* Mark as stable.

files and hard-links them to each other to save disk space.

  Currently it doesn't actually do the hard-linking, it just reports
  the amount of space saved if it did.

AUTHORS

@@ -0,0 +1,8 @@
+The following people contributed to Nix, in alphabetical order:
+
+Martin Bravenboer
+Eelco Dolstra
+Niels Janssen
+Armijn Hemel
+Rob Vermaas
+Eelco Visser

Makefile.am

@@ -1,3 +1,39 @@
-SUBDIRS = externals src scripts corepkgs doc
+SUBDIRS = externals src scripts corepkgs doc misc tests
+EXTRA_DIST = substitute.mk nix.spec nix.spec.in bootstrap.sh svn-revision
 
-EXTRA_DIST = substitute.mk
+include ./substitute.mk
+
+nix.spec: nix.spec.in
+
+rpm: nix.spec dist
+	rpm $(EXTRA_RPM_FLAGS) -ta $(distdir).tar.gz
+
+relname:
+	echo -n $(distdir) > relname
+
+install-data-local: init-state
+
+if INIT_STATE
+if SETUID_HACK
+INIT_FLAGS = -g @NIX_GROUP@ -o @NIX_USER@
+GROUP_WRITABLE = -m 775
+endif
+init-state:
+	$(INSTALL) $(INIT_FLAGS) -d $(DESTDIR)$(localstatedir)/nix
+	$(INSTALL) $(INIT_FLAGS) -d $(DESTDIR)$(localstatedir)/nix/db
+	$(INSTALL) $(INIT_FLAGS) -d $(DESTDIR)$(localstatedir)/log/nix
+	$(INSTALL) $(INIT_FLAGS) -d $(DESTDIR)$(localstatedir)/nix/profiles
+	$(INSTALL) $(INIT_FLAGS) -d $(DESTDIR)$(localstatedir)/nix/gcroots
+	$(INSTALL) $(INIT_FLAGS) $(GROUP_WRITABLE) -d $(DESTDIR)$(localstatedir)/nix/gcroots/tmp
+	$(INSTALL) $(INIT_FLAGS) $(GROUP_WRITABLE) -d $(DESTDIR)$(localstatedir)/nix/gcroots/channels
+	rm -f $(DESTDIR)$(localstatedir)/nix/gcroots/profiles
+	ln -s $(localstatedir)/nix/profiles $(DESTDIR)$(localstatedir)/nix/gcroots/profiles
+	$(INSTALL) $(INIT_FLAGS) -d $(DESTDIR)$(prefix)/store
+	$(INSTALL) $(INIT_FLAGS) $(GROUP_WRITABLE) -d $(DESTDIR)$(localstatedir)/nix/manifests
+#	$(bindir)/nix-store --init
+else
+init-state:
+endif
+
+svn-revision:
+	svnversion . > svn-revision

NEWS

@@ -0,0 +1,91 @@
+Version 0.7
+
+* Binary patching.  When upgrading components using pre-built binaries
+  (through nix-pull / nix-channel), Nix can automatically download and
+  apply binary patches to already installed components instead of full
+  downloads.  Patching is "smart": if there is a *sequence* of patches
+  to an installed component, Nix will use it.  Patches are currently
+  generated automatically between Nixpkgs (pre-)releases.
+
+* Simplifications to the substitute mechanism.
+
+* Nix-pull now stores downloaded manifests in /nix/var/nix/manifests.
+
+* Metadata on files in the Nix store is canonicalised after builds:
+  the last-modified timestamp is set to 0 (00:00:00 1/1/1970), the
+  mode is set to 0444 or 0555 (readable and possibly executable by
+  all; setuid/setgid bits are dropped), and the group is set to the
+  default.  This ensures that the result of a build and an
+  installation through a substitute is the same; and that timestamp
+  dependencies are revealed.
+
+
+Version 0.6
+
+Major changes include the following:
+
+* Rewrite of the normalisation engine.
+
+  * Multiple builds can now be performed in parallel (option `-j').
+
+  * Distributed builds.  Nix can now call a shell script to forward
+    builds to Nix installations on remote machines, which may or may
+    not be of the same platform type.
+
+  * Option `--fallback' allows recovery from broken substitutes.
+
+  * Option `--keep-going' causes building of other (unaffected)
+    derivations to continue if one failed.
+    
+* Improvements to the garbage collector (i.e., it should actually work
+  now).
+
+* Setuid Nix installations allow a Nix store to be shared among
+  multiple users.
+
+* Substitute registration is much faster now.
+
+* A utility `nix-build' to build a Nix expression and create a symlink
+  to the result int the current directory; useful for testing Nix
+  derivations.
+
+* Manual updates.
+
+* `nix-env' changes:
+
+  * Derivations for other platforms are filtered out (which can be
+    overriden using `--system-filter').
+
+  * `--install' by default now uninstall previous derivations with the
+    same name.
+
+  * `--upgrade' allows upgrading to a specific version.
+
+  * New operation `--delete-generations' to remove profile
+    generations (necessary for effective garbage collection).
+
+  * Nicer output (sorted, columnised).
+
+* More sensible verbosity levels all around (builder output is now
+  shown always, unless `-Q' is given).
+
+* Nix expression language changes:
+
+  * New language construct: `with E1; E2' brings all attributes
+    defined in the attribute set E1 in scope in E2.
+
+  * Added a `map' function.
+
+  * Various new operators (e.g., string concatenation).
+
+* Expression evaluation is much faster.
+
+* An Emacs mode for editing Nix expressions (with syntax highlighting
+  and indentation) has been added.
+
+* Many bug fixes.
+
+
+Version 0.5 and earlier
+
+Please refer to the Subversion commit log messages.

README

@@ -1,36 +1,5 @@
-Overview
-========
+                             *** Nix ***
 
-Nix is a package manager, deployment system, and component glue
-mechanism.
-
-
-Prerequisites
-=============
-
-* Berkeley DB 4.0.14
-* CWI ATerm 2.0
-
-
-Installation
-============
-
-* When building from the Subversion repository, first do:
-
-    autoreconf -i
-
-* To build, do:
-
-    ./configure
-    make
-    make install
-
-  Note that this will install to /nix, which is the default prefix.
-  You can specify another prefix, but this is not recommended if you
-  want to use prebuilt packages from other sources.
-
-
-Usage
-=====
-
-TODO
+For installation and usage instructions, please read the manual, which
+can be found in `docs/manual/manual.html', and additionally at the Nix
+website at <http://www.cs.uu.nl/groups/ST/Trace/Nix>.

bootstrap.sh

@@ -0,0 +1,5 @@
+#! /bin/sh -e
+aclocal
+autoheader
+automake --add-missing --copy
+autoconf

configure.ac

@@ -1,44 +1,205 @@
-AC_INIT(nix, "0.4")
+AC_INIT(nix, "0.7")
 AC_CONFIG_SRCDIR(README)
 AC_CONFIG_AUX_DIR(config)
 AM_INIT_AUTOMAKE
 
+# Change to `1' to produce a `stable' release (i.e., the `preREVISION'
+# suffix is not added).
+STABLE=1
+
 # Put the revision number in the version.
-if REVISION=`svnversion $srcdir 2> /dev/null`; then
-   if test "$REVISION" != "exported"; then
-      VERSION="$VERSION-r$REVISION"
-   fi
+if test "$STABLE" != "1"; then
+    if REVISION=`test -d $srcdir/.svn && svnversion $srcdir 2> /dev/null`; then
+        VERSION="${VERSION}pre${REVISION}"
+    elif REVISION=`cat $srcdir/svn-revision 2> /dev/null`; then
+        VERSION="${VERSION}pre${REVISION}"
+    fi
 fi
 
 AC_PREFIX_DEFAULT(/nix)
 
 AC_CANONICAL_HOST
 
+# Construct a Nix system name (like "i686-linux").
+AC_MSG_CHECKING([for the canonical Nix system name])
+cpu_name=$(uname -p | tr 'A-Z ' 'a-z_')
+machine_name=$(uname -m | tr 'A-Z ' 'a-z_')
+
+case $machine_name in
+    i*86)
+        machine_name=i686
+        ;;
+    *)
+        if test "$cpu_name" != "unknown"; then
+            machine_name=$cpu_name
+        fi
+        ;;
+esac
+
+sys_name=$(uname -s | tr 'A-Z ' 'a-z_')
+AC_ARG_WITH(system, AC_HELP_STRING([--with-system=SYSTEM],
+  [platform identifier (e.g., `i686-linux')]),
+  system=$withval, system="${machine_name}-${sys_name}")
+AC_MSG_RESULT($system)
+AC_SUBST(system)
+AC_DEFINE_UNQUOTED(SYSTEM, ["$system"], [platform identifier (`cpu-os')])
+
 AC_PROG_CC
 AC_PROG_CXX
 AC_PROG_RANLIB
 
-AC_PATH_PROG(wget, wget)
+# Check for pubsetbuf.
+AC_MSG_CHECKING([for pubsetbuf])
+AC_LANG_PUSH(C++)
+AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <iostream>
+using namespace std;
+static char buf[1024];]],
+    [[cerr.rdbuf()->pubsetbuf(buf, sizeof(buf));]])],
+    [AC_MSG_RESULT(yes) AC_DEFINE(HAVE_PUBSETBUF, 1, [whether pubsetbuf is available])],
+    AC_MSG_RESULT(no))
+AC_LANG_POP(C++)
+
+# Check for <locale>
+AC_LANG_PUSH(C++)
+AC_CHECK_HEADERS([locale])
+AC_LANG_POP(C++)
+
+AC_DEFUN([NEED_PROG],
+[
+AC_PATH_PROG($1, $2)
+if test -z "$$1"; then
+    AC_MSG_ERROR([$2 is required])
+fi
+])
+
+NEED_PROG(curl, curl)
+NEED_PROG(bzip2, bzip2)
+NEED_PROG(bunzip2, bunzip2)
+NEED_PROG(shell, sh)
+AC_PATH_PROG(xmllint, xmllint, false)
+AC_PATH_PROG(xsltproc, xsltproc, false)
+AC_PATH_PROG(flex, flex, false)
+AC_PATH_PROG(bison, bison, false)
+NEED_PROG(perl, perl)
+
+AC_ARG_WITH(docbook-catalog, AC_HELP_STRING([--with-docbook-catalog=PATH],
+  [path of the DocBook XML DTD]),
+  docbookcatalog=$withval, docbookcatalog=/docbook-dtd-missing)
+AC_SUBST(docbookcatalog)
+
+AC_ARG_WITH(docbook-ebnf-catalog, AC_HELP_STRING([--with-docbook-ebnf-catalog=PATH],
+  [path of the DocBook XML EBNF module DTD]),
+  docbookebnfcatalog=$withval, docbookcatalog=/docbook-ebnf-dtd-missing)
+AC_SUBST(docbookebnfcatalog)
+
+AC_ARG_WITH(docbook-xsl, AC_HELP_STRING([--with-docbook-xsl=PATH],
+  [path of the DocBook XSL stylesheets]),
+  docbookxsl=$withval, docbookxsl=/docbook-xsl-missing)
+AC_SUBST(docbookxsl)
+
+AC_ARG_WITH(xml-flags, AC_HELP_STRING([--with-xml-flags=FLAGS],
+  [extra flags to be passed to xmllint and xsltproc]),
+  xmlflags=$withval, xmlflags=)
+AC_SUBST(xmlflags)
+
+AC_ARG_WITH(store-dir, AC_HELP_STRING([--with-store-dir=PATH],
+  [path of the Nix store]),
+  storedir=$withval, storedir='${prefix}/store')
+AC_SUBST(storedir)
+
+AC_ARG_WITH(bdb, AC_HELP_STRING([--with-bdb=PATH],
+  [prefix of Berkeley DB]),
+  bdb=$withval, bdb=)
+AM_CONDITIONAL(HAVE_BDB, test -n "$bdb")
+if test -z "$bdb"; then
+  bdb_lib='-L${top_builddir}/externals/inst-bdb/lib -ldb_cxx'
+  bdb_include='-I${top_builddir}/externals/inst-bdb/include'
+else
+  bdb_lib="-L$bdb/lib -ldb_cxx"
+  bdb_include="-I$bdb/include"
+fi
+AC_SUBST(bdb_lib)
+AC_SUBST(bdb_include)
+
+AC_ARG_WITH(aterm, AC_HELP_STRING([--with-aterm=PATH],
+  [prefix of CWI ATerm library]),
+  aterm=$withval, aterm=)
+AM_CONDITIONAL(HAVE_ATERM, test -n "$aterm")
+if test -z "$aterm"; then
+  aterm_lib='-L${top_builddir}/externals/inst-aterm/lib -lATerm'
+  aterm_include='-I${top_builddir}/externals/inst-aterm/include'
+  aterm_bin='${top_builddir}/externals/inst-aterm/bin'
+else
+  aterm_lib="-L$aterm/lib -lATerm"
+  aterm_include="-I$aterm/include"
+  aterm_bin="$aterm/bin"
+fi
+AC_SUBST(aterm_lib)
+AC_SUBST(aterm_include)
+AC_SUBST(aterm_bin)
 
 AC_CHECK_LIB(pthread, pthread_mutex_init)
 
+AC_ARG_ENABLE(init-state, AC_HELP_STRING([--disable-init-state],
+  [do not initialise DB etc. in `make install']),
+  init_state=$enableval, init_state=yes)
+AM_CONDITIONAL(INIT_STATE, test "$init_state" = "yes")
+
+
+AC_ARG_ENABLE(setuid, AC_HELP_STRING([--enable-setuid],
+  [install Nix setuid]),
+  setuid_hack=$enableval, setuid_hack=no)
+AM_CONDITIONAL(SETUID_HACK, test "$setuid_hack" = "yes")
+if test "$setuid_hack" = "yes"; then
+    AC_DEFINE(SETUID_HACK, 1, [whether to install Nix setuid])
+fi
+
+AC_CHECK_FUNC(setresuid, [HAVE_SETRESUID=1], [HAVE_SETRESUID=])
+AM_CONDITIONAL(HAVE_SETRESUID, test "$HAVE_SETRESUID" = "1")
+if test "$HAVE_SETRESUID" = "1"; then
+    AC_DEFINE(HAVE_SETRESUID, 1, [whether we have setresuid()])
+fi
+
+AC_ARG_WITH(nix-user, AC_HELP_STRING([--with-nix-user=USER],
+  [user for Nix setuid binaries]),
+  NIX_USER=$withval, NIX_USER=nix)
+AC_SUBST(NIX_USER)
+AC_DEFINE_UNQUOTED(NIX_USER, ["$NIX_USER"], [Nix user])
+                                                      
+AC_ARG_WITH(nix-group, AC_HELP_STRING([--with-nix-group=USER],
+  [group for Nix setuid binaries]),
+  NIX_GROUP=$withval, NIX_GROUP=nix)
+AC_SUBST(NIX_GROUP)
+AC_DEFINE_UNQUOTED(NIX_GROUP, ["$NIX_GROUP"], [Nix group])
+
+                                                                                                            
 AM_CONFIG_HEADER([config.h])
 AC_CONFIG_FILES([Makefile
    externals/Makefile
    src/Makefile
+   src/bin2c/Makefile
    src/boost/Makefile
    src/boost/format/Makefile
-   src/libnix/Makefile
+   src/libutil/Makefile
+   src/libstore/Makefile
    src/libmain/Makefile
-   src/nix/Makefile
+   src/nix-store/Makefile
    src/nix-hash/Makefile
-   src/fix/Makefile
-   src/fix-ng/Makefile
+   src/libexpr/Makefile
+   src/nix-instantiate/Makefile
+   src/nix-env/Makefile
+   src/log2xml/Makefile
+   src/bsdiff-4.2/Makefile
    scripts/Makefile
    corepkgs/Makefile
    corepkgs/fetchurl/Makefile
    corepkgs/nar/Makefile
+   corepkgs/buildenv/Makefile
+   corepkgs/channels/Makefile
    doc/Makefile
    doc/manual/Makefile
+   misc/Makefile
+   misc/emacs/Makefile
+   tests/Makefile
   ])
 AC_OUTPUT

corepkgs/Makefile.am

@@ -1 +1 @@
-SUBDIRS = fetchurl nar
+SUBDIRS = fetchurl nar buildenv channels

corepkgs/buildenv/Makefile.am

@@ -0,0 +1,11 @@
+all-local: builder.pl
+
+install-exec-local:
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs/buildenv
+	$(INSTALL_DATA) default.nix $(DESTDIR)$(datadir)/nix/corepkgs/buildenv
+	$(INSTALL_PROGRAM) builder.pl $(DESTDIR)$(datadir)/nix/corepkgs/buildenv
+
+include ../../substitute.mk
+
+EXTRA_DIST = default.nix builder.pl.in

corepkgs/buildenv/builder.pl.in

@@ -0,0 +1,94 @@
+#! @perl@ -w
+
+use strict;
+use Cwd;
+use IO::Handle;
+
+STDOUT->autoflush(1);
+
+my $out = $ENV{"out"};
+mkdir "$out", 0755 || die "error creating $out";
+
+
+# For each activated package, create symlinks.
+
+sub createLinks {
+    my $srcDir = shift;
+    my $dstDir = shift;
+
+    my @srcFiles = glob("$srcDir/*");
+
+    foreach my $srcFile (@srcFiles) {
+        my $baseName = $srcFile;
+        $baseName =~ s/^.*\///g; # strip directory
+        my $dstFile = "$dstDir/$baseName";
+        
+	if ($srcFile =~ /\/propagated-build-inputs$/ ||
+            $srcFile =~ /\/nix-support$/ ||
+            $srcFile =~ /\/log$/)
+        {
+            # Do nothing.
+	}
+
+        elsif (-d $srcFile) {
+
+            lstat $dstFile;
+            
+            if (-d _) {
+                createLinks($srcFile, $dstFile);
+            }
+
+            elsif (-l _) {
+                my $target = readlink $dstFile or die;
+                if (!-d $target) {
+                    die "collission between directory `$srcFile' and non-directory `$target'";
+                }
+                unlink $dstFile or die "error unlinking `$dstFile': $!";
+                mkdir $dstFile, 0755 || 
+                    die "error creating directory `$dstFile': $!";
+                createLinks($target, $dstFile);
+                createLinks($srcFile, $dstFile);
+            }
+
+            else {
+                symlink($srcFile, $dstFile) ||
+                    die "error creating link `$dstFile': $!";
+            }
+        }
+
+        elsif (-l $dstFile) {
+            my $target = readlink $dstFile;
+            die "collission between `$srcFile' and `$target'";
+        }
+
+        else {
+#            print "linking $dstFile to $srcFile\n";
+            symlink($srcFile, $dstFile) ||
+                die "error creating link `$dstFile': $!";
+        }
+    }
+}
+
+
+my %done;
+
+sub addPkg {
+    my $pkgDir = shift;
+
+    return if (defined $done{$pkgDir});
+    $done{$pkgDir} = 1;
+
+    createLinks("$pkgDir", "$out");
+}
+
+
+my @args = split ' ', $ENV{"derivations"};
+
+while (scalar @args > 0) {
+    my $drvPath = shift @args;
+    print "adding $drvPath\n";
+    addPkg($drvPath);
+}
+
+
+symlink($ENV{"manifest"}, "$out/manifest") or die "cannot create manifest";

corepkgs/buildenv/default.nix

@@ -0,0 +1,9 @@
+{system, derivations, manifest}:
+
+derivation { 
+  name = "user-environment";
+  system = system;
+  builder = ./builder.pl;
+  derivations = derivations;
+  manifest = manifest;
+}

corepkgs/channels/Makefile.am

@@ -0,0 +1,11 @@
+all-local: unpack.sh
+
+install-exec-local:
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs/channels
+	$(INSTALL_DATA) unpack.nix $(DESTDIR)$(datadir)/nix/corepkgs/channels
+	$(INSTALL_PROGRAM) unpack.sh $(DESTDIR)$(datadir)/nix/corepkgs/channels
+
+include ../../substitute.mk
+
+EXTRA_DIST = unpack.nix unpack.sh.in

corepkgs/channels/unpack.nix

@@ -0,0 +1,7 @@
+{system, inputs}:
+
+derivation {
+  name = "channels";
+  builder = ./unpack.sh;
+  inherit system inputs;
+}

corepkgs/channels/unpack.sh.in

@@ -0,0 +1,24 @@
+#! @shell@ -e
+
+export PATH=/bin:/usr/bin # !!! impure
+
+mkdir $out
+mkdir $out/tmp
+cd $out/tmp
+
+expr=$out/default.nix
+echo '[' > $expr
+
+nr=0
+for i in $inputs; do
+    echo "unpacking $i"
+    @bunzip2@ < $i | tar xvf -
+    mv * ../$nr # !!! hacky
+    echo "(import ./$nr)" >> $expr
+    nr=$(($nr + 1))
+done
+
+echo ']' >> $expr
+
+cd ..
+rmdir tmp

corepkgs/fetchurl/Makefile.am

@@ -1,10 +1,11 @@
-all-local: fetchurl.sh
+all-local: builder.sh
 
 install-exec-local:
-	$(INSTALL) -d $(datadir)/fix/fetchurl
-	$(INSTALL_DATA) fetchurl.fix $(datadir)/fix/fetchurl
-	$(INSTALL_PROGRAM) fetchurl.sh $(datadir)/fix/fetchurl
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs/fetchurl
+	$(INSTALL_DATA) default.nix $(DESTDIR)$(datadir)/nix/corepkgs/fetchurl
+	$(INSTALL_PROGRAM) builder.sh $(DESTDIR)$(datadir)/nix/corepkgs/fetchurl
 
 include ../../substitute.mk
 
-EXTRA_DIST = fetchurl.fix fetchurl.sh.in
+EXTRA_DIST = default.nix builder.sh.in

corepkgs/fetchurl/builder.sh.in

@@ -1,15 +1,15 @@
-#! /bin/sh
+#! @shell@ -e
 
 export PATH=/bin:/usr/bin
 
-echo "downloading $url into $out..."
+echo "downloading $url into $out"
 
-prefetch=@prefix@/store/nix-prefetch-url-$md5
+prefetch=@storedir@/nix-prefetch-url-$md5
 if test -f "$prefetch"; then
     echo "using prefetched $prefetch";
-    mv $prefetch $out || exit 1
+    mv $prefetch $out
 else
-    @wget@ --passive-ftp "$url" -O "$out" || exit 1
+    @curl@ --fail --location --max-redirs 20 "$url" > "$out"
 fi
 
 actual=$(@bindir@/nix-hash --flat $out)

corepkgs/fetchurl/default.nix

@@ -0,0 +1,8 @@
+{system, url, md5}:
+
+derivation {
+  name = baseNameOf (toString url);
+  builder = ./builder.sh;
+  id = md5;
+  inherit system url md5;
+}

corepkgs/fetchurl/fetchurl.fix

@@ -1,10 +0,0 @@
-Function(["url", "md5"],
-  Package(
-    [ ("build", Relative("fetchurl/fetchurl.sh"))
-    , ("url", Var("url"))
-    , ("md5", Var("md5"))
-    , ("name", BaseName(Var("url")))
-    , ("id", Var("md5"))
-    ]
-  )
-)

corepkgs/nar/Makefile.am

@@ -1,12 +1,13 @@
 all-local: nar.sh unnar.sh
 
 install-exec-local:
-	$(INSTALL) -d $(datadir)/fix/nar
-	$(INSTALL_DATA) nar.fix $(datadir)/fix/nar
-	$(INSTALL_PROGRAM) nar.sh $(datadir)/fix/nar
-	$(INSTALL_DATA) unnar.fix $(datadir)/fix/nar
-	$(INSTALL_PROGRAM) unnar.sh $(datadir)/fix/nar
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/corepkgs/nar
+	$(INSTALL_DATA) nar.nix $(DESTDIR)$(datadir)/nix/corepkgs/nar
+	$(INSTALL_PROGRAM) nar.sh $(DESTDIR)$(datadir)/nix/corepkgs/nar
+	$(INSTALL_DATA) unnar.nix $(DESTDIR)$(datadir)/nix/corepkgs/nar
+	$(INSTALL_PROGRAM) unnar.sh $(DESTDIR)$(datadir)/nix/corepkgs/nar
 
 include ../../substitute.mk
 
-EXTRA_DIST = nar.fix nar.sh.in unnar.fix unnar.sh.in
+EXTRA_DIST = nar.nix nar.sh.in unnar.nix unnar.sh.in

corepkgs/nar/nar.fix

@@ -1,8 +0,0 @@
-Function(["path"],
-  Package(
-    [ ("name", "nar")
-    , ("build", Relative("nar/nar.sh"))
-    , ("path", Var("path"))
-    ]
-  )
-)

corepkgs/nar/nar.nix

@@ -0,0 +1,6 @@
+{system, path}: derivation {
+  name = "nar";
+  builder = ./nar.sh;
+  system = system;
+  path = path;
+}

corepkgs/nar/nar.sh.in

@@ -1,12 +1,19 @@
-#! /bin/sh
+#! @shell@ -e
 
+# !!! impure; fix this
 export PATH=/bin:/usr/bin
 
 echo "packing $path into $out..."
-mkdir $out || exit 1
-dst=$out/`basename $path`.nar.bz2
-@bindir@/nix --dump "$path" | bzip2 > $dst || exit 1
+mkdir $out
+dst=$out/$(basename $path).nar.bz2
+@bindir@/nix-store --dump "$path" > tmp
 
-md5=$(md5sum -b $dst | cut -c1-32)
+@bzip2@ < tmp > $dst
+
+narHash=$(md5sum -b tmp | cut -c1-32)
 if test $? != 0; then exit 1; fi
-echo $md5 > $out/md5 || exit 1
+echo $narHash > $out/nar-hash
+
+narbz2Hash=$(md5sum -b $dst | cut -c1-32)
+if test $? != 0; then exit 1; fi
+echo $narbz2Hash > $out/narbz2-hash

corepkgs/nar/unnar.fix

@@ -1,9 +0,0 @@
-Function(["nar", "outPath"],
-  Package(
-    [ ("name", "unnar")
-    , ("outPath", Var("outPath"))
-    , ("build", Relative("nar/unnar.sh"))
-    , ("nar", Var("nar"))
-    ]
-  )
-)

corepkgs/nar/unnar.nix

@@ -0,0 +1,7 @@
+{system, narFile, outPath}: derivation {
+  name = "unnar";
+  builder = ./unnar.sh;
+  system = system;
+  narFile = narFile;
+  outPath = outPath;
+}

corepkgs/nar/unnar.sh.in

@@ -1,6 +1,4 @@
-#! /bin/sh
+#! @shell@ -e
 
-export PATH=/bin:/usr/bin
-
-echo "unpacking $nar to $out..."
-bunzip2 < $nar | @bindir@/nix --restore "$out" || exit 1
+echo "unpacking $narFile to $out..."
+@bunzip2@ < $narFile | @bindir@/nix-store --restore "$out"

doc/dev/release-procedures.txt

@@ -0,0 +1,30 @@
+To produce a `stable' release from the trunk:
+
+0. Make sure that the trunk builds in the release supervisor.
+
+1. Branch the trunk, e.g., `svn cp .../trunk
+   .../branches/0.5-release'.
+
+2. Switch to the branch, e.g., `svn switch .../branches/0.5-release'.
+
+3. In `configure.ac', change `STABLE=0' into `STABLE=1' and commit.
+
+4. In the release supervisor, add a one-time job to build
+   `.../branches/0.5-release'.
+
+5. Make sure that the release succeeds.
+
+6. Move the branch to a tag, e.g., `svn mv .../branches/0.5-release
+   .../tags/0.5'.
+
+   Note that the branch should not be used for maintenance; it should
+   be deleted after the release has been created.  A maintenance
+   branch (e.g., `.../branches/0.5') should be created from the
+   original revision of the trunk (since maintenance releases should
+   also be tested first; hence, we cannot have `STABLE=1').  The same
+   procedure can then be followed to produce maintenance release; just
+   substitute `.../branches/VERSION' for the trunk.
+
+7. Switch back to the trunk.
+
+8. Bump the version number in `configure.ac' (in AC_INIT).

doc/manual/Makefile.am

@@ -1,30 +1,57 @@
-DOCBOOK_DTD = /nix/current/xml/dtd/docbook
-DOCBOOK_XSL = /nix/current/xml/xsl/docbook
+ENV = SGML_CATALOG_FILES=$(docbookcatalog):$(docbookebnfcatalog)
 
-ENV = SGML_CATALOG_FILES=$(DOCBOOK_DTD)/docbook.cat
+XMLLINT = $(ENV) $(xmllint) $(xmlflags) --catalogs
+XSLTPROC = $(ENV) $(xsltproc) $(xmlflags) --catalogs \
+ --param section.autolabel 1 \
+ --param section.label.includes.component.label 1 \
+ --param html.stylesheet \'style.css\' \
+ --param xref.with.number.and.title 0
 
-XMLLINT = $(ENV) xmllint --catalogs
-XSLTPROC = $(ENV) xsltproc --catalogs
+man1_MANS = nix-env.1 nix-store.1 nix-instantiate.1 \
+ nix-collect-garbage.1 nix-push.1 nix-pull.1 \
+ nix-prefetch-url.1
 
-SOURCES = book.xml introduction.xml installation.xml nix-reference.xml \
- troubleshooting.xml bugs.xml
+FIGURES = figures/user-environments.png
 
-book.is-valid: $(SOURCES)
-	$(XMLLINT) --noout --valid book.xml
+SOURCES = manual.xml introduction.xml installation.xml \
+ package-management.xml writing-nix-expressions.xml \
+ build-farm.xml \
+ $(man1_MANS:.1=.xml) \
+ troubleshooting.xml bugs.xml opt-common.xml opt-common-syn.xml \
+ quick-start.xml nix-lang-ref.xml style.css images
+
+manual.is-valid: $(SOURCES) version.xml
+	$(XMLLINT) --noout --valid manual.xml
 	touch $@
 
-man1_MANS = nix.1 fix.1
+version.xml:
+	echo -n $(VERSION) > version.xml
 
-man nix.1 fix.1: $(SOURCES) book.is-valid
-	$(XSLTPROC) $(DOCBOOK_XSL)/manpages/docbook.xsl book.xml
+man $(MANS): $(SOURCES) manual.is-valid
+	$(XSLTPROC) $(docbookxsl)/manpages/docbook.xsl manual.xml
 
-book.html: $(SOURCES) book.is-valid
-	$(XSLTPROC) --output book.html $(DOCBOOK_XSL)/html/docbook.xsl book.xml
+manual.html: $(SOURCES) manual.is-valid images
+	$(XSLTPROC) --output manual.html $(docbookxsl)/html/docbook.xsl manual.xml
 
-all-local: book.html
+all-local: manual.html
 
-install-data-local: book.html
-	$(INSTALL) -d $(datadir)/nix/manual
-	$(INSTALL_DATA) book.html $(datadir)/nix/manual
+install-data-local: manual.html
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/manual
+	$(INSTALL_DATA) manual.html $(DESTDIR)$(datadir)/nix/manual
+	$(INSTALL_DATA) style.css $(DESTDIR)$(datadir)/nix/manual
+	cp -r images $(DESTDIR)$(datadir)/nix/manual/images
+	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/manual/figures
+	$(INSTALL_DATA) $(FIGURES) $(DESTDIR)$(datadir)/nix/manual/figures
 
-EXTRA_DIST = $(SOURCES) book.html nix.1 fix.1 book.is-valid
+images:
+	mkdir images
+	cp $(docbookxsl)/images/*.png images
+	mkdir images/callouts
+	cp $(docbookxsl)/images/callouts/*.png images/callouts
+	chmod +w -R images
+
+KEEP = manual.html manual.is-valid version.xml $(MANS)
+
+EXTRA_DIST = $(SOURCES) $(FIGURES) $(KEEP)
+
+DISTCLEANFILES = $(KEEP)

doc/manual/book.xml

@@ -1,64 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE book
-    PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN"
-    "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd"
-[
-<!ENTITY introduction SYSTEM "introduction.xml">
-<!ENTITY installation SYSTEM "installation.xml">
-<!ENTITY nix-reference SYSTEM "nix-reference.xml">
-<!ENTITY fix-reference SYSTEM "fix-reference.xml">
-<!ENTITY troubleshooting SYSTEM "troubleshooting.xml">
-<!ENTITY bugs SYSTEM "bugs.xml">
-]>
-
-<book>
-  <title>Nix: The Manual</title>
-
-  <bookinfo>
-    <author>
-      <firstname>Eelco</firstname>
-      <surname>Dolstra</surname>
-    </author>
-    <copyright>
-      <year>2003</year>
-      <holder>Eelco Dolstra</holder>
-    </copyright>
-  </bookinfo>
-
-  &introduction;
-  &installation;
-
-  <chapter>
-    <title>A Guided Tour</title>
-    <para>
-    </para>
-  </chapter>
-
-  <chapter>
-    <title>Nix Syntax and Semantics</title>
-    <para>
-    </para>
-  </chapter>
-
-  <chapter>
-    <title>Fix Language Reference</title>
-    <para>
-    </para>
-  </chapter>
-
-  <chapter>
-    <title>Writing Builders</title>
-    <para>
-    </para>
-  </chapter>
-
-  <appendix>
-    <title>Command Reference</title>
-    &nix-reference;
-    &fix-reference;
-  </appendix>
-
-  &troubleshooting;
-  &bugs;
-
-</book>

doc/manual/bugs.xml

@@ -1,43 +1,108 @@
-<appendix>
-  <title>Bugs</title>
+<appendix><title>Bugs / To-Do</title>
 
-  <itemizedlist>
+<itemizedlist>
 
     <listitem>
       <para>
-	Nix should automatically recover the Berkeley DB database.
+        The man-pages generated from the DocBook documentation are ugly.
       </para>
     </listitem>
 
     <listitem>
       <para>
-	Nix should automatically remove Berkeley DB logfiles.
+        Generations properly form a tree.  E.g., if after switching to
+        generation 39, we perform an installation action, a generation
+        43 is created which is a descendant of 39, not 42.  So a
+        rollback from 43 ought to go back to 39.  This is not
+        currently implemented; generations form a linear sequence.
       </para>
     </listitem>
 
     <listitem>
       <para>
-	Unify the concepts of successors and substitutes into a general notion
-	of <emphasis>equivalent expressions</emphasis>.  Expressions are
-	equivalent if they have the same target paths with the same
-	identifiers.  However, even though they are functionally equivalent,
-	they may differ stronly with respect to their <emphasis>performance
-	  characteristics</emphasis>.  For example, realising a slice is more
-	efficient that realising the derivation from which that slice was
-	produced.  On the other hand, distributing sources may be more
-	efficient (storage- or bandwidth-wise) than distributing binaries.  So
-	we need to be able to attach weigths or priorities or performance
-	annotations to expressions; Nix can then choose the most efficient
-	expression dependent on the context.
+        Unify the concepts of successors and substitutes into a
+        general notion of <emphasis>equivalent expressions</emphasis>.
+        Expressions are equivalent if they have the same target paths
+        with the same identifiers.  However, even though they are
+        functionally equivalent, they may differ stronly with respect
+        to their <emphasis>performance characteristics</emphasis>.
+        For example, realising a closure expression is more efficient
+        that realising the derivation expression from which it was
+        produced.  On the other hand, distributing sources may be more
+        efficient (storage- or bandwidth-wise) than distributing
+        binaries.  So we need to be able to attach weigths or
+        priorities or performance annotations to expressions; Nix can
+        then choose the most efficient expression dependent on the
+        context.
       </para>
     </listitem>
 
-  </itemizedlist>
+    <listitem>
+      <para>
+        <emphasis>Build management.</emphasis>  In principle it is already
+        possible to do build management using Nix (by writing builders that
+        perform appropriate build steps), but the Nix expression language is
+        not yet powerful enough to make this pleasant (?).  The language should
+        be extended with features from the <ulink
+          url='http://www.cs.uu.nl/~eelco/maak/'>Maak build manager</ulink>.
+        Another interesting idea is to write a <command>make</command>
+        implementation that uses Nix as a back-end to support <ulink
+          url='http://www.research.att.com/~bs/bs_faq.html#legacy'>legacy</ulink> 
+        build files.
+      </para>
+    </listitem>
+
+    <listitem>
+      <para>
+        There are race conditions between the garbage collector and
+        other Nix tools.  For instance, when we run
+        <command>nix-env</command> to build and install a derivation
+        and run the garbage collector at the same time, the garbage
+        collector may kick in exactly between the build and
+        installation steps, i.e., before the newly built derivation
+        has become reachable from a root of the garbage collector.
+      </para>
+
+      <para>
+        One solution would be for these programs to properly register
+        temporary roots for the collector.  Another would be to use
+        stop-the-world garbage collection: if any tool is running, the
+        garbage collector blocks, and vice versa.  These solutions do
+        not solve the situation where multiple tools are involved,
+        e.g.,
+
+        <screen>
+$ nix-store -r $(nix-instantiate foo.nix)</screen>
+
+        since even if <command>nix-instantiate</command> where to
+        register a temporary root, it would be released by the time
+        <command>nix-store</command> is started.  A solution would be
+        to write the intermediate value to a file that is used as a
+        root to the collector, e.g.,
+        
+        <screen>
+$ nix-instantiate foo.nix > /nix/var/nix/roots/bla
+$ nix-store -r $(cat /nix/var/nix/roots/bla)</screen>
+
+      </para>
+    </listitem>
+
+<listitem><para>For security, <command>nix-push</command> manifests
+should be digitally signed, and <command>nix-pull</command> should
+verify the signatures.  The actual NAR archives in the cache do not
+need to be signed, since the manifest contains cryptographic hashes of
+these files (and <filename>fetchurl.nix</filename> checks
+them).</para></listitem>
+
+<listitem><para>We should switch away from MD5, since it has been
+more-or-less cracked.  We don't currently depend very much on the
+collision-resistance of MD5, but we will once we start sharing build
+results between users.</para></listitem>
+
+<listitem><para>It would be useful to have an option in
+<command>nix-env --delete-generations</command> to remove non-current
+generations older than a certain age.</para></listitem>
+
+</itemizedlist>
 
 </appendix>
-
-<!--
-local variables:
-sgml-parent-document: ("book.xml" "appendix")
-end:
--->

doc/manual/build-farm.xml

@@ -0,0 +1,129 @@
+<chapter id='chap-build-farm'><title>Setting up a Build Farm</title>
+
+<para>This chapter provides some sketchy information on how to set up
+a Nix-based build farm.  Nix is particularly suited as a basis for a
+build farm, since:
+
+<itemizedlist>
+
+  <listitem><para>Nix supports distributed builds: a local Nix
+  installation can forward Nix builds to other machines over the
+  network.  This allows multiple builds to be performed in parallel
+  (thus improving performance), but more in importantly, it allows Nix
+  to perform multi-platform builds in a semi-transparent way.  For
+  instance, if you perform a build for a
+  <literal>powerpc-darwin</literal> on an
+  <literal>i686-linux</literal> machine, Nix can automatically forward
+  the build to a <literal>powerpc-darwin</literal> machine, if
+  available.</para></listitem>
+
+  <listitem><para>The Nix expression language is ideal for describing
+  build jobs, plus all their dependencies.  For instance, if your
+  package has some dependency, you don't have to manually install it
+  on all the machines in the build farm; they will be built
+  automatically.</para></listitem>
+
+  <listitem><para>Proper release management requires that builds (if
+  deployed) are traceable: it should be possible to figure out from
+  exactly what sources they were built, in what configuration, etc.;
+  and it should be possible to reproduce the build, if necessary.  Nix
+  makes this possible since Nix's hashing scheme uniquely identifies
+  builds, and Nix expressions are self-contained.</para></listitem>
+
+  <listitem><para>Nix will only rebuild things that have actually
+  changed.  For instance, if the sources of a component haven't
+  changed between runs of the build farm, the component won't be
+  rebuild (unless it was garbage-collected).  Also, dependencies
+  typically don't change very often, so they only need to be built
+  once.</para></listitem>
+
+  <listitem><para>The results of a Nix build farm can be made
+  available through a channel, so successful builds can be deployed to
+  users immediately.</para></listitem>
+
+</itemizedlist>
+
+</para>
+
+
+<section><title>Overview</title>
+
+<para>TODO</para>
+
+<para>The sources of the Nix build farm are at <ulink
+url='https://svn.cs.uu.nl:12443/repos/trace/release/trunk' />.</para>
+
+</section>
+
+
+<section id='sec-distributed-builds'><title>Setting up distributed builds</title>
+
+<para>You can enable distributed builds by setting the environment
+variable <envar>NIX_BUILD_HOOK</envar> to point to a program that Nix
+will call whenever it wants to build a derivation.  The build hook
+(typically a shell or Perl script) can decline the build, in which Nix
+will perform it in the usual way if possible, or it can accept it, in
+which case it is responsible for somehow getting the inputs of the
+build to another machine, doing the build there, and getting the
+results back.</para>
+
+<example id='ex-remote-systems'><title>Remote machine configuration:
+<filename>remote-systems.conf</filename></title>
+<programlisting>
+nix@mcflurry.labs.cs.uu.nl  powerpc-darwin  /home/nix/.ssh/id_quarterpounder_auto  2
+nix@scratchy.labs.cs.uu.nl  i686-linux      /home/nix/.ssh/id_scratchy_auto        1
+</programlisting>
+</example>
+
+<para>An example build hook can be found in the Nix build farm
+sources: <ulink
+url='https://svn.cs.uu.nl:12443/repos/trace/release/trunk/common/distributed/build-remote.pl'
+/>.  It should be suitable for most purposes, with maybe some minor
+adjustments.  It uses <command>ssh</command> and
+<command>rsync</command> to copy the build inputs and outputs and
+perform the remote build.  You should define a list of available build
+machines and set the environment variable
+<envar>REMOTE_SYSTEMS</envar> to point to it.  An example
+configuration is shown in <xref linkend='ex-remote-systems' />.  Each
+line in the file specifies a machine, with the following bits of
+information:
+
+<orderedlist>
+  
+  <listitem><para>The name of the remote machine, with optionally the
+  user under which the remote build should be performed.  This is
+  actually passed as an argument to <command>ssh</command>, so it can
+  be an alias defined in your
+  <filename>~/.ssh/config</filename>.</para></listitem>
+
+  <listitem><para>The Nix platform type identifier, such as
+  <literal>powerpc-darwin</literal>.</para></listitem>
+
+  <listitem><para>The SSH private key to be used to log in to the
+  remote machine.  Since builds should be non-interactive, this key
+  should not have a passphrase!</para></listitem>
+
+  <listitem><para>The maximum <quote>load</quote> of the remote
+  machine.  This is just the maximum number of jobs that
+  <filename>build-remote.pl</filename> will execute in parallel on the
+  machine.  Typically this should be equal to the number of
+  CPUs.</para></listitem>
+
+</orderedlist>
+
+You should also set up the environment variable
+<envar>CURRENT_LOAD</envar> to point at a file that
+<filename>build-remote.pl</filename> uses to remember how many jobs it
+is currently executing remotely.  It doesn't look at the actual load
+on the remote machine, so if you have multiple instances of Nix
+running, they should use the same <envar>CURRENT_LOAD</envar>
+file<footnote><para>Although there are probably some race conditions
+in the script right now.</para></footnote>.  Maybe in the future
+<filename>build-remote.pl</filename> will look at the actual remote
+load.  The load file should exist, so you should just create it as an
+empty file initially.</para>
+  
+</section>
+
+
+</chapter>

doc/manual/fix-reference.xml

@@ -1,37 +0,0 @@
-<refentry>
-  <refnamediv>
-    <refname>fix</refname>
-    <refpurpose>generate Nix expressions from a high-level description</refpurpose>
-  </refnamediv>
-
-  <refsynopsisdiv>
-    <cmdsynopsis>
-      <command>fix</command>
-      <group choice='opt' rep='repeat'>
-	<arg><option>--verbose</option></arg>
-	<arg><option>-v</option></arg>
-      </group>
-      <arg rep='repeat'><replaceable>files</replaceable></arg>
-    </cmdsynopsis>
-  </refsynopsisdiv>
-
-  <refsect1>
-    <title>Description</title>
-
-    <para>
-      The command <command>fix</command> generates Nix expressions from
-      expressions is Fix's own high-level language.  While Nix expressions are
-      very primitive and not intended to be written directly, Fix expressions
-      are quite easy to write.
-    </para>
-
-  </refsect1>
-
-</refentry>
-
-
-<!--
-local variables:
-sgml-parent-document: ("book.xml" "refentry")
-end:
--->

doc/manual/installation.xml

@@ -1,80 +1,212 @@
-<chapter>
-  <title>Installation</title>
+<chapter id='chap-installation'><title>Installation</title>
 
-  <sect1>
-    <title>Prerequisites</title>
 
-    <para>
-      Nix uses Sleepycat's Berkeley DB and CWI's ATerm library.  However, these
-      are fetched automatically as part of the build process.
+<sect1><title>Obtaining Nix</title>
+
+<para>The easiest way to obtain Nix is to download a <ulink
+url='http://www.cs.uu.nl/groups/ST/Trace/Nix'>source
+distribution</ulink>.  RPMs for Red Hat 9 are also available.  These
+distributions are generated automatically.</para>
+
+<para>Alternatively, the most recent sources of Nix can be obtained
+from its <ulink
+url='https://svn.cs.uu.nl:12443/repos/trace/nix/trunk'>Subversion
+repository</ulink>.  For example, the following command will check out
+the latest revision into a directory called <filename>nix</filename>:</para>
+
+<screen>
+$ svn checkout https://svn.cs.uu.nl:12443/repos/trace/nix/trunk nix</screen>
+
+<para>Likewise, specific releases can be obtained from the <ulink
+url='https://svn.cs.uu.nl:12443/repos/trace/nix/tags'>tags
+directory</ulink> of the repository.  If you don't have Subversion,
+you can also download an automatically generated <ulink
+url='https://svn.cs.uu.nl:12443/dist/trace/'>compressed
+tar-file</ulink> of the head revision of the trunk.</para>
+
+</sect1>
+
+
+<sect1><title>Prerequisites</title>
+
+<para>The following prerequisites only apply when you build from
+source.  Binary releases (e.g., RPMs) have no prerequisites.</para>
+
+<para>A fairly recent version of GCC/G++ is required.  Version 2.95
+and higher should work.</para>
+
+<para>To build this manual and the man-pages you need the
+<command>xmllint</command> and <command>xsltproc</command> programs,
+which are part of the <literal>libxml2</literal> and
+<literal>libxslt</literal> packages, respectively.  You also need the
+<ulink url='http://docbook.sourceforge.net/projects/xsl/'>DocBook XSL
+stylesheets</ulink> and optionally the <ulink
+url='http://www.oasis-open.org/docbook/xml/4.2/docbook-xml-4.2.zip'>
+DocBook XML 4.2 DTD</ulink>.  Note that these are only required if you
+modify the manual sources or when you are building from the Subversion
+repository.</para>
+
+<para>To build the parser, very <emphasis>recent</emphasis> versions
+of Bison and Flex are required.  (This is because Nix needs GLR
+support in Bison and reentrancy support in Flex.)  For Bison, you need
+version 1.875c or higher (1.875 does <emphasis>not</emphasis> work),
+which can be obtained from the <ulink
+url='ftp://alpha.gnu.org/pub/gnu/bison'>GNU FTP server</ulink>.  For
+Flex, you need version 2.5.31, which is available on <ulink
+url='http://lex.sourceforge.net/'>SourceForge</ulink>.  Slightly older
+versions may also work, but ancient versions like the ubiquitous
+2.5.4a won't.  Note that these are only required if you modify the
+parser or when you are building from the Subversion repository.</para>
+
+<para>Nix uses Sleepycat's Berkeley DB and CWI's ATerm library.  These
+are included in the Nix source distribution.  If you build from the
+Subversion repository, you must download them yourself and place them
+in the <filename>externals/</filename> directory.  See
+<filename>externals/Makefile.am</filename> for the precise URLs of
+these packages.  Alternatively, if you already have them installed,
+you can use <command>configure</command>'s <option>--with-bdb</option>
+and <option>--with-aterm</option> options to point to their respective
+locations.  Note that Berkeley DB <emphasis>must</emphasis> be version
+4.2; other versions may not have compatible database formats.</para>
+
+</sect1>
+
+
+<sect1><title>Building Nix from source</title>
+
+<para>After unpacking or checking out the Nix sources, issue the
+following commands:
     </para>
 
-    <para>
-      Other than that, you need a good C++ compiler.  GCC 2.95 does not appear
-      to work; please use GCC 3.x.
-    </para>
-  </sect1>
-
-  <sect1>
-    <title>Obtaining Nix</title>
-
-    <para>
-      Nix can be obtained from its <ulink
-	url='http://losser.st-lab.cs.uu.nl:12080/repos/trace/nix/trunk'>Subversion 
-	repository</ulink>.  For example, the following command will check out
-      the latest revision into a directory called <filename>nix</filename>:
-    </para>
-
-    <screen>
-$ svn checkout http://losser.st-lab.cs.uu.nl:12080/repos/trace/nix/trunk nix</screen>
-
-    <para>
-      Likewise, specific releases can be obtained from the <ulink
-	url='http://losser.st-lab.cs.uu.nl:12080/repos/trace/nix/tags'>tags
-	directory</ulink> of the repository.  If you don't have Subversion, you
-      can download a <ulink
-	url='http://losser.st-lab.cs.uu.nl:12080/dist/trace/'>compressed
-	tar-file</ulink> of the latest revision of the repository.
-    </para>
-
-  </sect1>
-
-  <sect1>
-    <title>Building Nix</title>
-
-    <para>
-      To build Nix, do the following:
-    </para>
-
-    <screen>
-$ autoreconf -i
+<screen>
 $ ./configure <replaceable>options...</replaceable>
 $ make
 $ make install</screen>
 
-    <para>
-      Currently, the only useful switch for <command>configure</command> is
-      <option>--prefix=<replaceable>prefix</replaceable></option> to specify
-      where Nix is to be installed.  The default installation directory is
-      <filename>/nix</filename>.  You can change this to any location you like.
-      You should ensure that you have write permission to the installation
-      prefix. 
+<para>When building from the Subversion repository, these should be
+preceded by the command:
     </para>
 
-    <warning>
-      <para>
-	It is advisable <emphasis>not</emphasis> to change the installation
-	prefix, since doing so will in all likelihood make it impossible to use
-	derivates built on other systems.
-      </para>
-    </warning>
+<screen>
+$ autoreconf -i</screen>
+
+<para>The installation path can be specified by passing the
+<option>--prefix=<replaceable>prefix</replaceable></option> to
+<command>configure</command>.  The default installation directory is
+<filename>/nix</filename>.  You can change this to any location you
+like.  You must have write permission to the
+<replaceable>prefix</replaceable> path.</para>
+
+<warning><para>It is advisable <emphasis>not</emphasis> to change the
+installation prefix from its default, since doing so will in all
+likelihood make it impossible to use derivations built on other
+systems.</para></warning>
+
+<para>If you want to rebuilt the documentation, pass the full path to
+the DocBook XML catalog file (<filename>docbook.cat</filename>) and to
+the DocBook XSL stylesheets using the
+<option>--with-docbook-catalog=<replaceable>path</replaceable></option>
+and
+<option>--with-docbook-xsl=<replaceable>path</replaceable></option>
+options.</para>
+
+</sect1>
+
+
+<sect1><title>Installing from RPMs</title>
+
+<para>RPM packages of Nix can be downloaded from <ulink
+url='http://www.cs.uu.nl/groups/ST/Trace/Nix' />.  These RPMs should
+work for most fairly recent releases of SuSE and Red Hat Linux.  They
+have been known to work work on SuSE Linux 8.1 and 9.0, and Red Hat
+9.0.  In fact, it should work on any RPM-based Linux distribution
+based on <literal>glibc</literal> 2.3 or later.</para>
+
+<para>Once downloaded, the RPMs can be installed or upgraded using
+<command>rpm -U</command>.  For example,</para>
+
+<screen>
+$ rpm -U nix-0.5pre664-1.i386.rpm</screen>
+
+<para>The RPMs install into the directory <filename>/nix</filename>.
+Nix can be uninstalled using <command>rpm -e nix</command>.  After
+this it will be necessary to manually remove the Nix store and other
+auxiliary data:</para>
+
+<screen>
+$ rm -rf /nix/store
+$ rm -rf /nix/var</screen>
+
+</sect1>
+
+
+<sect1><title>Permissions</title>
+
+<para>All Nix operations must be performed under the user ID that owns
+the Nix store and database
+(<filename><replaceable>prefix</replaceable>/store</filename> and
+<filename><replaceable>prefix</replaceable>/var/nix/db</filename>,
+respectively).  When installed from the RPM packages, these
+directories are owned by <systemitem
+class='username'>root</systemitem>.</para>
+
+<sect2><title>Setuid installation</title>
+
+<para>As a somewhat <emphasis>ad hoc</emphasis> hack, you can also
+install the Nix binaries <quote>setuid</quote> so that a Nix store can
+be shared among several users.  To do this, configure Nix with the
+<emphasis>--enable-setuid</emphasis> option.  Nix will be installed as
+owned by a user and group specified by the
+<option>--with-nix-user=<parameter>user</parameter></option> and
+<option>--with-nix-group=<parameter>group</parameter></option>
+options.  E.g.,
+
+<screen>
+$ ./configure --enable-setuid --with-nix-user=my_nix_user --with-nix-group=my_nix_group</screen>
+
+The user and group default to <literal>nix</literal>.  You should make
+sure that both the user and the group exist.  Any <quote>real</quote>
+users that you want to allow access should be added to the Nix
+group.</para>
+
+<warning><para>A setuid installation should only by used if the users
+in the Nix group are mutually trusted, since any user in that group
+has the ability to change anything in the Nix store or database.  For
+instance, they could install a trojan horse in executables used by
+other users.</para></warning>
+
+<warning><para>On some platforms, the Nix binaries will be installed
+as setuid <literal>root</literal>.  They drop root privileges
+immediately after startup and switch to the Nix user.  The reason for
+this is that both the real and effective user must be set to the Nix
+user, and POSIX has no system call to do this.  This is not the case
+on systems that have the <function>setresuid()</function> system call
+(such as Linux and FreeBSD), so on those systems the binaries are
+simply owned by the Nix user.</para></warning>
+
+</sect2>
+
+</sect1>
+
+
+<sect1><title>Using Nix</title>
+
+<para>To use Nix, some environment variables should be set.  In
+particular, <envar>PATH</envar> should contain the directories
+<filename><replaceable>prefix</replaceable>/bin</filename> and
+<filename>~/.nix-profile/bin</filename>.  The first directory contains
+the Nix tools themselves, while <filename>~/.nix-profile</filename> is
+a symbolic link to the current <emphasis>user environment</emphasis>
+(an automatically generated package consisting of symlinks to
+installed packages).  The simplest way to set the required environment
+variables is to include the file
+<filename><replaceable>prefix</replaceable>/etc/profile.d/nix.sh</filename>
+in your <filename>~/.bashrc</filename> (or similar), like this:</para>
+
+<screen>
+source <replaceable>prefix</replaceable>/etc/profile.d/nix.sh</screen>
+
+</sect1>
 
-  </sect1>
 
 </chapter>
-
-<!--
-local variables:
-sgml-parent-document: ("book.xml" "chapter")
-end:
--->

doc/manual/introduction.xml

@@ -1,291 +1,150 @@
-<chapter>
-  <title>Introduction</title>
-
-  <sect1>
-    <title>The problem space</title>
-
-    <para>
-      Nix is a system for controlling the automatic creation and distribution
-      of data, such as computer programs and other software artifacts.  This is
-      a very general problem, and there are many applications that fall under
-      this description.
-    </para>
-
-    <sect2>
-      <title>Build management</title>
-
-      <para>
-	Build management tools are used to perform <emphasis>software
-	  builds</emphasis>, that is, the construction of derived products
-	(<emphasis>derivates)</emphasis>) such as executable programs from
-	source code.  A commonly used build tool is Make, which is a standard
-	tool on Unix systems. These tools have to deal with several issues:
-	<itemizedlist>
-
-	  <listitem>
-	    <para>
-	      <emphasis>Efficiency</emphasis>.  Since building large systems
-	      can take a substantial amount of time, it is desirable that build
-	      steps that have been performed in the past are not repeated
-	      unnecessarily, i.e., if a new build differs from a previous build
-	      only with respect to certain sources, then only the build steps
-	      that (directly or indirectly) <emphasis>depend</emphasis> on
-	      those sources should be redone.
-	    </para>
-	  </listitem>
-
-	  <listitem>
-	    <para>
-	      <emphasis>Correctness</emphasis> is this context means that the
-	      derivates produced by a build are always consistent with the
-	      sources, that is, they are equal to what we would get if we were
-	      to build the derivates from those sources.  This requirement is
-	      trivially met when we do a full, unconditional build, but is far
-	      from trivial under the requirement of efficiency, since it is not
-	      easy to determine which derivates are affected by a change to a
-	      source.
-	    </para>
-	  </listitem>
-
-	  <listitem>
-	    <para>
-	      <emphasis>Variability</emphasis> is the property that a software
-	      system can be built in a (potentially large) number of variants.
-	      Variation exists both in <emphasis>time</emphasis>---the
-	      evolution of different versions of an artifact---and in
-	      <emphasis>space</emphasis>---the artifact might have
-	      configuration options that lead to variants that differ in the
-	      features they support (for example, a system might be built with
-	      or without debugging information).
-	    </para>
-
-	    <para>
-	      Build managers historically have had good support for variation
-	      in time (rebuilding the system in an intelligent way when sources
-	      change is one of the primary reasons to use a build manager), but
-	      not always for variation in space.  For example,
-	      <command>make</command> will not automatically ensure that
-	      variant builds are properly isolated from each other (they will
-	      in fact overwrite each other unless special precautions are
-	      taken).
-	    </para>
-	  </listitem>
-
-	  <listitem>
-	    <para>
-	      <emphasis>High-level system modelling language</emphasis>.  The
-	      language in which one describes what and how derivates are to be
-	      produced should have sufficient abstraction facilities to make it
-	      easy to specify the derivation of even very large systems.  Also,
-	      the language should be <emphasis>modular</emphasis> to enable
-	      components from possible different sources to be easily combined.
-	    </para>
-	  </listitem>
-
-	</itemizedlist>
-      </para>
-
-    </sect2>
-
-    <sect2>
-      <title>Package management</title>
-
-      <para>
-	After software has been built, is must also be
-	<emphasis>deployed</emphasis> in the intended target environment, e.g.,
-	the user's workstation.  Examples include the Red Hat package manager
-	(RPM), Microsoft's MSI, and so on.  Here also we have several issues to
-	contend with:
-	<itemizedlist>
-	  <listitem>
-	    <para>
-	      The <emphasis>creation</emphasis> of packages from some formal
-	      description of what artifacts should be distributed in the
-	      package.
-	    </para>
-	  </listitem>
-	  <listitem>
-	    <para>
-	      The <emphasis>deployment</emphasis> of packages, that is, the
-	      mechanism by which we get them onto the intended target
-	      environment.  This can be as simple as copying a file, but
-	      complexity comes from the wide range of possible installation
-	      media (such as a network install), and the scalability of the
-	      process (if a program must be installed on a thousand systems, we
-	      do not want to visit each system and perform some manual steps to
-	      install the program on that system; that is, the complexity for
-	      the system administrator should be constant, not linear).
-	    </para>
-	  </listitem>
-	</itemizedlist>
-      </para>
-    </sect2>
-
-  </sect1>
-
-
-  <!--######################################################################-->
-
-  <sect1>
-    <title>What Nix provides</title>
-
-    <para>
-      Here is a summary of Nix's main features:
-    </para>
-
-    <itemizedlist>
-
-      <listitem>
-	<para>
-	  <emphasis>Reliable dependencies.</emphasis>  Builds of file system
-	  objects depend on other file system object, such as source files,
-	  tools, and so on.  We would like to ensure that a build does not
-	  refer to any objects that have not been declared as inputs for that
-	  build.  This is important for several reasons.  First, if any of the
-	  inputs change, we need to rebuild the things that depend on them to
-	  maintain consistency between sources and derivates.  Second, when we
-	  <emphasis>deploy</emphasis> file system objects (that is, copy them
-	  to a different system), we want to be certain that we copy everything
-	  that we need.
-	</para>
-
-	<para>
-	  Nix ensures this by building and storing file system objects in paths
-	  that are infeasible to predict in advance.  For example, the
-	  artifacts of a package <literal>X</literal> might be stored in
-	  <filename>/nix/store/d58a0606ed616820de291d594602665d-X</filename>,
-	  rather than in, say, <filename>/usr/lib</filename>.  The path
-	  component <filename>d58a...</filename> is actually a cryptographic
-	  hash of all the inputs (i.e., sources, requisites, and build flags)
-	  used in building <literal>X</literal>, and as such is very fragile:
-	  any change to the inputs will change the hash.  Therefore it is not
-	  sensible to <emphasis>hard-code</emphasis> such a path into the build
-	  scripts of a package <literal>Y</literal> that uses
-	  <literal>X</literal> (as does happen with <quote>fixed</quote> paths
-	  such as <filename>/usr/lib</filename>).  Rather, the build script of
-	  package <literal>Y</literal> is parameterised with the actual
-	  location of <literal>X</literal>, which is supplied by the Nix
-	  system.
-	</para>
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Support for variability.</emphasis>  
-	</para>
-	
-	<para>
-	  As stated above, the path name of a file system object contain a
-	  cryptographic hash of all inputs involved in building it.  A change to
-	  any of the inputs will cause the hash to change--and by extension,
-	  the path name.  These inputs include both sources (variation in time)
-	  and configuration options (variation in space).  Therefore variants
-	  of the same package don't clash---they can co-exist peacefully within
-	  the same file system.  So thanks to Nix's mechanism for reliably
-	  dealing with dependencies, we obtain management of variants for free
-	  (or, to quote Simon Peyton-Jone, it's not free, but it has already
-	  been paid for).
-	</para>
-
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Transparent source/binary deployment.</emphasis>
-	</para>
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Easy configuration duplication.</emphasis>
-	</para>
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Automatic storage management.</emphasis>
-	</para>
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Atomic upgrades and rollbacks.</emphasis>
-	</para>
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Support for many simultaneous configurations.</emphasis>
-	</para>
-      </listitem>
-
-      <listitem>
-	<para>
-	  <emphasis>Portability.</emphasis>  Nix is quite portable.  Contrary
-	  to build systems like those in, e.g., Vesta and ClearCase [sic?], it
-	  does not rely on operating system extensions.
-	</para>
-      </listitem>
-
-    </itemizedlist>
-
-    <para>
-      Here is what Nix doesn't yet provide, but will:
-    </para>
-
-    <itemizedlist>
-
-      <listitem>
-	<para>
-	  <emphasis>Build management.</emphasis>  In principle it is already
-	  possible to do build management using Fix (by writing builders that
-	  perform appropriate build steps), but the Fix language is not yet
-	  powerful enough to make this pleasant.  The <ulink
-	    url='http://www.cs.uu.nl/~eelco/maak/'>Maak build manager</ulink>
-	  should be retargeted to produce Nix expressions, or alternatively,
-	  extend Fix with Maak's semantics and concrete syntax (since Fix needs
-	  a concrete syntax anyway).  Another interesting idea is to write a
-	  <command>make</command> implementation that uses Nix as a back-end to
-	  support <ulink
-	    url='http://www.research.att.com/~bs/bs_faq.html#legacy'>legacy</ulink> 
-	  build files.
-	</para>
-      </listitem>
-
-    </itemizedlist>
-
-  </sect1>
-
-
-  <!--######################################################################-->
-
-  <sect1>
-    <title>The Nix system</title>
-
-    <para>
-      ...
-    </para>
-
-    <para>
-      Existing tools in this field generally both a underlying model (such as
-      the derivation graph of build tools, or the versioning scheme that
-      determines when two packages are <quote>compatible</quote> in a package
-      management system) and a formalism that allows ...
-    </para>
-
-    <para>
-      Following the principle of separation of mechanism and policy, the Nix
-      system separates the <emphasis>low-level aspect</emphasis> of file system
-      object management form the <emphasis>high-level aspect</emphasis> of the
-      ...
-    </para>
-
-  </sect1>
-
-</chapter>
+<chapter><title>Introduction</title>
 
 <!--
-local variables:
-sgml-parent-document: ("book.xml" "chapter")
-end:
+<epigraph><para><quote>The number of Nix installations in the world
+has grown to 5, with more expected.</quote></para></epigraph>
 -->
+
+<para>Nix is a system for the deployment of software.  Software
+deployment is concerned with the creation, distribution, and
+management of software components (<quote>packages</quote>).  Its main
+features are:
+
+<itemizedlist>
+
+<listitem><para>It helps you make sure that dependency specifications
+are complete.  In general in a deployment system you have to specify
+for each component what its dependencies are, but there are no
+guarantees that this specification is complete.  If you forget a
+dependency, then the component will build and work correctly on
+<emphasis>your</emphasis> machine if you have the dependency
+installed, but not on the end user's machine if it's not
+there.</para></listitem>
+
+<listitem><para>It is possible to have <emphasis>multiple versions or
+variants</emphasis> of a component installed at the same time.  In
+contrast, in systems such as RPM different versions of the same
+package tend to install to the same location in the file system, so
+installing one version will remove the other.  This is especially
+important if you want to use applications that have conflicting
+requirements on different versions of a component (e.g., application A
+requires version 1.0 of library X, while application B requires a
+non-backwards compatible version 1.1).</para></listitem>
+
+<listitem><para>Users can have different <quote>views</quote>
+(<quote>profiles</quote> in Nix parlance) on the set of installed
+applications in a system.  For instance, one user can have version 1.0
+of some package visible, while another is using version 1.1, and a
+third doesn't use it at all.</para></listitem>
+
+<listitem><para>It is possible to atomically
+<emphasis>upgrade</emphasis> software.  I.e., there is no time window
+during an upgrade in which part of the old version and part of the new
+version are simultaneously visible (which might well cause the
+component to fail).</para></listitem>
+
+<listitem><para>Likewise, it is possible to atomically roll back after
+an install, upgrade, or uninstall action.  That is, in a fast (O(1))
+operation the previous configuration of the system can be restored.
+This is because upgrade or uninstall actions don't actually remove
+components from the system.</para></listitem>
+
+<listitem><para>Unused components can be
+<emphasis>garbage-collected</emphasis> automatically and safely: when
+you remove an application from a profile, its dependencies will be
+deleted by the garbage collector only if there are no other active
+applications using them.</para></listitem>
+
+<listitem><para>Nix supports both source-based deployment models
+(where you distribute <emphasis>Nix expressions</emphasis> that tell
+Nix how to build software from source) and binary-based deployment
+models.  The latter is more-or-less transparent: installation of
+components is always based on Nix expressions, but if the expressions
+have been built before and Nix knows that the resulting binaries are
+available somewhere, it will use those instead.</para></listitem>
+
+<listitem><para>Nix is flexible in the deployment policies that it
+supports.  There is a clear separation between the tools that
+implement basic Nix <emphasis>mechanisms</emphasis> (e.g., building
+Nix expressions), and the tools that implement various deployment
+<emphasis>policies</emphasis>.  For instance, there is a concept of
+<quote>Nix channels</quote> that can be used to keep software
+installations up-to-date automatically from a network source.  This is
+a policy that is implemented by a fairly short Perl script, which can
+be adapted easily to achieve similar policies.</para></listitem>
+
+<listitem><para>Nix component builds aim to be <quote>pure</quote>;
+that is, unaffected by anything other than the declared dependencies.
+This means that if a component was built successfully once, it can be
+rebuilt again on another machine and the result will be the same.  We
+cannot <emphasis>guarantee</emphasis> this (e.g., if the build depends
+on the time-of-day), but Nix (and the tools in the Nix Packages
+collection) takes special care to help achieve this.</para></listitem>
+
+<listitem><para>Nix expressions (the things that tell Nix how to build
+components) are self-contained: they describe not just components but
+complete compositions.  In other words, Nix expressions also describe
+how to build all the dependencies.  This is in contrast to component
+specification languages like RPM spec files, which might say that a
+component X depends on some other component Y, but since it does not
+describe <emphasis>exactly</emphasis> what Y is, the result of
+building or running X might be different on different machines.
+Combined with purity, self-containedness ensures that a component that
+<quote>works</quote> on one machine also works on another, when
+deployed using Nix.</para></listitem>
+
+<listitem><para>The Nix expression language makes it easy to describe
+variability in components (e.g., optional features or
+dependencies).</para></listitem>
+
+<listitem><para>Nix is ideal for building build farms that do
+continuous builds of software from a version management system, since
+it can take care of building all the dependencies as well.  Also, Nix
+only rebuilds components that have changed, so there are no
+unnecessary builds.  In addition, Nix can transparently distribute
+build jobs over different machines, including different
+platforms.</para></listitem>
+
+<listitem><para>Nix can be used not only for software deployment, but
+also for <emphasis>service deployment</emphasis>, such as the
+deployment of a complete web server with all its configuration files,
+static pages, software dependencies, and so on.  Nix's advantages for
+software deployment also apply here: for instance, the ability
+trivially to have multiple configurations at the same time, or the
+ability to do rollbacks.</para></listitem>
+
+<listitem><para>Nix can efficiently upgrade between different versions
+of a component through <emphasis>binary patching</emphasis>.  If
+patches are available on a server, and you try to install a new
+version of some component, Nix will automatically apply a patch (or
+sequence of patches), if available, to transform the installed
+component into the new version.</para></listitem> 
+
+</itemizedlist>
+
+</para>
+
+<para>This manual tells you how to install and use Nix and how to
+write Nix expressions for software not already in the Nix Packages
+collection.  It also discusses some advanced topics, such as setting
+up a Nix-based build farm, and doing service deployment using
+Nix.</para>
+
+<warning><para>This manual is a work in progress.  It's quite likely
+to be incomplete, inconsistent with the current implementation, or
+simply wrong.</para></warning>
+
+<note><para>Some background information on Nix can be found in two
+papers.  The ICSE 2004 paper <ulink
+url='http://www.cs.uu.nl/~eelco/pubs/immdsd-icse2004-final.pdf'><citetitle>Imposing
+a Memory Management Discipline on Software
+Deployment</citetitle></ulink> discusses the hashing mechanism used to
+ensure reliable dependency identification and non-interference between
+different versions and variants of packages.  The LISA 2004 paper
+<ulink
+url='http://www.cs.uu.nl/~eelco/pubs/nspfssd-lisa2004-final.pdf'><citetitle>Nix:
+A Safe and Policy-Free System for Software
+Deployment</citetitle></ulink> gives a more general discussion of Nix
+from a system-administration perspective.</para></note>
+
+</chapter>

doc/manual/manual.xml

@@ -0,0 +1,87 @@
+<?xml version="1.0"?>
+<!DOCTYPE book
+    PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
+    "http://www.docbook.org/xml/4.3/docbook-xml-4.3.zip"
+[
+<!ENTITY introduction SYSTEM "introduction.xml">
+<!ENTITY quick-start SYSTEM "quick-start.xml">
+<!ENTITY installation SYSTEM "installation.xml">
+<!ENTITY package-management SYSTEM "package-management.xml">
+<!ENTITY writing-nix-expressions SYSTEM "writing-nix-expressions.xml">
+<!ENTITY build-farm SYSTEM "build-farm.xml">
+<!ENTITY opt-common SYSTEM "opt-common.xml">
+<!ENTITY opt-common-syn SYSTEM "opt-common-syn.xml">
+<!ENTITY nix-env SYSTEM "nix-env.xml">
+<!ENTITY nix-store SYSTEM "nix-store.xml">
+<!ENTITY nix-instantiate SYSTEM "nix-instantiate.xml">
+<!ENTITY nix-collect-garbage SYSTEM "nix-collect-garbage.xml">
+<!ENTITY nix-push SYSTEM "nix-push.xml">
+<!ENTITY nix-pull SYSTEM "nix-pull.xml">
+<!ENTITY nix-prefetch-url SYSTEM "nix-prefetch-url.xml">
+<!-- <!ENTITY nix-lang-ref SYSTEM "nix-lang-ref.xml"> -->
+<!ENTITY troubleshooting SYSTEM "troubleshooting.xml">
+<!ENTITY bugs SYSTEM "bugs.xml">
+<!ENTITY version SYSTEM "version.xml">
+]>
+
+<book>
+  <title>Nix User's Guide</title>
+
+  <subtitle>Draft (Version &version;)</subtitle>
+  
+  <bookinfo>
+    <author>
+      <firstname>Eelco</firstname>
+      <surname>Dolstra</surname>
+    </author>
+    <copyright>
+      <year>2004</year>
+      <holder>Eelco Dolstra</holder>
+    </copyright>
+  </bookinfo>
+
+  &introduction;
+  &quick-start;
+  &installation;
+  &package-management;
+  &writing-nix-expressions;
+  &build-farm;
+
+  <appendix>
+    <title>Command Reference</title>
+    <sect1>
+      <title>nix-env</title>
+      &nix-env;
+    </sect1>
+    <sect1>
+      <title>nix-store</title>
+      &nix-store;
+    </sect1>
+    <sect1>
+      <title>nix-instantiate</title>
+      &nix-instantiate;
+    </sect1>
+    <sect1>
+      <title>nix-collect-garbage</title>
+      &nix-collect-garbage;
+    </sect1>
+    <sect1>
+      <title>nix-push</title>
+      &nix-push;
+    </sect1>
+    <sect1>
+      <title>nix-pull</title>
+      &nix-pull;
+    </sect1>
+    <sect1>
+      <title>nix-prefetch-url</title>
+      &nix-prefetch-url;
+    </sect1>
+  </appendix>
+
+<!--  &nix-lang-ref; -->
+
+  &troubleshooting;
+  &bugs;
+
+</book>

doc/manual/nix-collect-garbage.xml

@@ -0,0 +1,87 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-collect-garbage</refname>
+    <refpurpose>remove unreachable store paths</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-collect-garbage</command>
+      <group choice='opt'>
+        <arg choice='plain'><option>--print-live</option></arg>
+        <arg choice='plain'><option>--print-dead</option></arg>
+      </group>
+      <arg><option>--min-age</option> <replaceable>age</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-collect-garbage</command> performs a
+      garbage collection on the Nix store: any paths in the Nix store
+      that are garbage (not reachable from a set of root store
+      expressions) are deleted.
+    </para>
+
+    <para>
+      The roots of the garbage collector are the store expressions
+      mentioned in the files in the directory
+      <filename><replaceable>prefix</replaceable>/var/nix/gcroots</filename>.
+      By default, the roots are all user environments in
+      <filename><replaceable>prefix</replaceable>/var/nix/profiles</filename>.
+      You can register other store expressions as roots by writing the
+      full path of the store expression to an arbitrary file in the
+      <filename>gcroots</filename> directory (or a subdirectory
+      thereof).
+    </para>
+
+  </refsection>
+
+  <refsection>
+    <title>Options</title>
+
+    <variablelist>
+
+      <varlistentry>
+        <term><option>--print-live</option> / <option>--print-dead</option></term>
+        <listitem>
+          <para>
+            These options cause the set of live or dead paths to be
+            printed, respectively, rather than performing an actual
+            garbage collector.  They correspond exactly with the
+            sub-operations in <command>nix-store
+            <option>--gc</option></command>.
+          </para>
+        </listitem>
+      </varlistentry>
+      
+      <varlistentry>
+        <term><option>--min-age</option> <replaceable>age</replaceable></term>
+        <listitem>
+          <para>
+            This option corresponds to the <option>--min-age</option>
+            option in <command>nix-store <option>--gc</option></command>.
+          </para>
+        </listitem>
+      </varlistentry>
+      
+    </variablelist>
+
+  </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <para>
+      To delete all unreachable paths, just do:
+    
+      <screen>
+$ nix-collect-garbage</screen>
+
+    </para>
+
+  </refsection>
+    
+</refentry>

doc/manual/nix-env.xml

@@ -0,0 +1,937 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-env</refname>
+    <refpurpose>manipulate or query Nix user environments</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-env</command>
+      &opt-common-syn;
+      <arg>
+        <group choice='req'>
+          <arg choice='plain'><option>--file</option></arg>
+          <arg choice='plain'><option>-f</option></arg>
+        </group>
+        <replaceable>path</replaceable>
+      </arg>
+      <arg>
+        <group choice='req'>
+          <arg choice='plain'><option>--profile</option></arg>
+          <arg choice='plain'><option>-p</option></arg>
+        </group>
+        <replaceable>path</replaceable>
+      </arg>
+      <arg><option>--preserve-installed</option></arg>
+      <arg>
+        <arg choice='plain'><option>--system-filter</option></arg>
+        <replaceable>system</replaceable>
+      </arg>
+      <arg><option>--dry-run</option></arg>
+      <arg choice='plain'><replaceable>operation</replaceable></arg>
+      <arg rep='repeat'><replaceable>options</replaceable></arg>
+      <arg rep='repeat'><replaceable>arguments</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-env</command> is used to manipulate Nix
+      user environments.  User environments are sets of software
+      components available to a user at some point in time.  In other
+      words, they are a synthesised view of the programs available in
+      the Nix store.  There may be many user environments: different
+      users can have different environments, and individual users can
+      switch between different environments.
+    </para>
+
+<!--    <para>
+      Environments are manipulated by operations such as the
+      installation and removal of components (hereafter called
+      <emphasis>derivations</emphasis>).  These operations are not
+      destructive: rather than overwrite the current environment, they
+      create a new environment to which we can then atomically
+      <emphasis>switch</emphasis> by flipping a symlink.
+    </para> -->
+
+    <para>
+      <command>nix-env</command> takes exactly one
+      <emphasis>operation</emphasis> flag which indicates the
+      subcommand to be performed.  These are documented below.
+    </para>
+    
+  </refsection>
+
+
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Common options</title>
+
+    <para>
+      This section lists the options that are common to all
+      operations.  These options are allowed for every subcommand,
+      though they may not always have an effect.
+    </para>
+
+    <variablelist>
+
+      &opt-common;
+
+      <varlistentry>
+        <term><option>--file</option> / <option>-f</option></term>
+        <listitem>
+          <para>
+            Specifies the Nix expression (designated below as the
+            <emphasis>active Nix expression</emphasis>) used by the
+            <option>--install</option>, <option>--upgrade</option>,
+            and <option>--query --available</option> operations to
+            obtain derivations.  The default is
+            <filename>~/.nix-defexpr</filename>.
+          </para>
+        </listitem>
+      </varlistentry>
+      
+      <varlistentry>
+        <term><option>--profile</option> / <option>-p</option></term>
+        <listitem>
+          <para>
+            Specifies the profile to be used by those operations that
+            operate on a profile (designated below as the
+            <emphasis>active profile</emphasis>).  A profile is
+            sequence of user environments called
+            <emphasis>generations</emphasis>, one of which is the
+            <emphasis>current generation</emphasis>.  The default
+            profile is the target of the symbolic link
+            <filename>~/.nix-profile</filename> (see below).
+          </para>
+        </listitem>
+      </varlistentry>
+      
+      <varlistentry>
+        <term><option>--dry-run</option></term>
+        <listitem>
+          <para>
+            For the <option>--install</option>,
+            <option>--upgrade</option>, <option>--uninstall</option>,
+            <option>--switch-generation</option> and
+            <option>--rollback</option> operations, this flag will
+            cause <command>nix-env</command> to print what
+            <emphasis>would</emphasis> be done if this flag had not
+            been specified, without actually doing it.
+          </para>
+        </listitem>
+      </varlistentry>
+      
+      <varlistentry>
+        <term><option>--preserve-installed</option></term>
+        <listitem>
+          <para>
+            By default, when you install a derivation with the
+            <option>--install</option> operation, it will replace
+            previously installed versions with the same derivation
+            name (regardless of the version number).  This option
+            causes those previously installed versions to be kept in
+            the new generation of the profile.  Note that this will
+            generally cause conflicts in the creation of the user
+            environment (since multiple versions of a package
+            typically contain the same programs).
+          </para>
+        </listitem>
+      </varlistentry>
+      
+      <varlistentry>
+        <term><option>--system-filter</option> <replaceable>system</replaceable></term>
+        <listitem>
+          <para>
+            By default, operations such as <option>--query
+            --available</option> only include derivations matching the
+            current platform.  This option allows you to use
+            derivations for the specified platform
+            <replaceable>system</replaceable>.  The special value
+            <literal>*</literal> causes derivations for any platform
+            to be included.
+          </para>
+        </listitem>
+      </varlistentry>
+      
+    </variablelist>
+
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Files</title>
+
+    <variablelist>
+
+      <varlistentry>
+        <term><filename>~/.nix-defexpr</filename></term>
+        <listitem>
+          <para>
+            The default Nix expression used by the
+            <option>--install</option>, <option>--upgrade</option>,
+            and <option>--query --available</option> operations to
+            obtain derivations.  It is generally a symbolic link to
+            some other location set using the
+            <option>--import</option> operation.  The
+            <option>--file</option> option may be used to override
+            this default.
+          </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><filename>~/.nix-profile</filename></term>
+        <listitem>
+          <para>
+            A symbolic link to the user's current profile.  By
+            default, this symlink points to
+            <filename><replaceable>prefix</replaceable>/var/nix/profiles/default</filename>.
+            The <envar>PATH</envar> environment variable should
+            include <filename>~/.nix-profile/bin</filename> for the
+            user environment to be visible to the user.
+          </para>
+        </listitem>
+      </varlistentry>
+
+    </variablelist>
+        
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--install</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--install</option></arg>
+          <arg choice='plain'><option>-i</option></arg>
+        </group>
+        <group choice='opt'>
+          <arg choice='plain'><option>--preserve-installed</option></arg>
+          <arg choice='plain'><option>-P</option></arg>
+        </group>
+        <arg choice='plain' rep='repeat'><replaceable>drvnames</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The install operation creates a new user environment, based on
+        the current generation of the active profile, to which the
+        derivations designated by <replaceable>drvnames</replaceable>
+        in the active Nix expression are added.
+      </para>
+
+      <para>
+        Currently installed derivations with a name equal to the name
+        of a derivation being added are removed unless the option
+        <option>--preserve-installed</option> is specified.
+      </para>
+
+    </refsection>
+
+    <refsection>
+      <title>Flags</title>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--preserve-installed</option> / <option>-P</option></term>
+          <listitem>
+            <para>
+              Do not remove derivations with a name matching one of
+              the derivations being installed.  Usually, trying to
+              have two versions of the same package installed in the
+              same generation of a profile will lead to an error in
+              building the generation, due to file name clashes
+              between the two versions.  However, this is not the case
+              for all packages.
+            </para>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env --install gcc-3.3.2 <lineannotation>(install specific version)</lineannotation>
+installing `gcc-3.3.2'
+uninstalling `gcc-3.1' <lineannotation>(previously installed version is removed)</lineannotation>
+
+$ nix-env --install gcc <lineannotation>(just pick any version)</lineannotation>
+
+$ nix-env -f ~/foo.nix -i '*' <lineannotation>(install everything in <filename>foo.nix</filename>)</lineannotation></screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--upgrade</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--upgrade</option></arg>
+          <arg choice='plain'><option>-u</option></arg>
+        </group>
+        <group choice='opt'>
+          <arg choice='plain'><option>--lt</option></arg>
+          <arg choice='plain'><option>--leq</option></arg>
+          <arg choice='plain'><option>--always</option></arg>
+        </group>
+        <arg choice='plain' rep='repeat'><replaceable>drvnames</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The upgrade operation creates a new user environment, based on
+        the current generation of the active profile, in which all
+        derivations designated by <replaceable>drvnames</replaceable>
+        for which there are newer versions in the active Nix
+        expression are replaced by those newer versions.  Matching
+        derivations for which there are no newer versions are left
+        untouched; this is not an error.  It is also not an error if
+        an element of <replaceable>drvnames</replaceable> matches no
+        installed derivations.
+      </para>
+
+      <para>
+        If multiple derivations in the active Nix expression match an
+        installed derivation, the one with the highest version is
+        selected.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Flags</title>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--lt</option></term>
+          <listitem>
+            <para>
+              Only upgrade a derivation to newer versions.  This is
+              the default.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--leq</option></term>
+          <listitem>
+            <para>
+              In addition to upgrading to newer versions, also
+              <quote>upgrade</quote> to derivations that have the same
+              version.  Version are not a unique identification of a
+              derivation, so there may be many derivations that have
+              the same version.  This flag may be useful to force
+              <quote>synchronisation</quote> between the installed and
+              available derivations.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--always</option></term>
+          <listitem>
+            <para>
+              In addition to upgrading to newer versions, also
+              <quote>upgrade</quote> to derivations that have the same
+              or a lower version.  I.e., derivations may actually be
+              downgraded depending on what is available in the active
+              Nix expression.
+            </para>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+
+    </refsection>
+
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env --upgrade gcc
+upgrading `gcc-3.3.1' to `gcc-3.4'
+
+$ nix-env -u gcc-3.3.2 --always <lineannotation>(switch to a specific version)</lineannotation>
+upgrading `gcc-3.4' to `gcc-3.3.2'
+
+$ nix-env --upgrade pan
+<lineannotation>(no upgrades available, so nothing happens)</lineannotation>
+
+$ nix-env -u '*' <lineannotation>(try to upgrade everything)</lineannotation>
+upgrading `hello-2.1.2' to `hello-2.1.3'
+upgrading `mozilla-1.2' to `mozilla-1.4'</screen>        
+
+    </refsection>
+    
+    <refsection>
+      <title>Versions</title>
+
+      <para>
+        The upgrade operation determines whether a derivation
+        <varname>y</varname> is an upgrade of a derivation
+        <varname>x</varname> by looking at their respective
+        <literal>name</literal> attributes.  The names (e.g.,
+        <literal>gcc-3.3.1</literal> are split into two parts: the
+        package name (<literal>gcc</literal>), and the version
+        (<literal>3.3.1</literal>).  The version part starts after the
+        first dash not following by a letter.  <varname>x</varname> is
+        considered an upgrade of <varname>y</varname> if their package
+        names match, and the version of <varname>y</varname> is higher
+        that that of <varname>x</varname>.
+      </para>
+
+      <para>
+        The versions are compared by splitting them into contiguous
+        components of numbers and letters.  E.g.,
+        <literal>3.3.1pre5</literal> is split into <literal>[3, 3, 1,
+        "pre", 5]</literal>.  These lists are then compared
+        lexicographically (from left to right).  Corresponding
+        components <varname>a</varname> and <varname>b</varname> are
+        compared as follows.  If they are both numbers, integer
+        comparison is used.  If <varname>a</varname> is an empty
+        string and <varname>b</varname> is a number,
+        <varname>a</varname> is considered less than
+        <varname>b</varname>.  The special string component
+        <literal>pre</literal> (for <emphasis>pre-release</emphasis>)
+        is considered to be less than other components.  String
+        components are considered less than number components.
+        Otherwise, they are compared lexicographically (i.e., using
+        case-sensitive string comparison).
+      </para>
+
+      <para>
+        This is illustrated by the following examples:
+
+        <screen>
+1.0 &lt; 2.3
+2.1 &lt; 2.3
+2.3 = 2.3
+2.5 > 2.3
+3.1 > 2.3
+2.3.1 > 2.3
+2.3.1 > 2.3a
+2.3pre1 &lt; 2.3
+2.3pre3 &lt; 2.3pre12
+2.3a &lt; 2.3c
+2.3pre1 &lt; 2.3c
+2.3pre1 &lt; 2.3q</screen>
+        
+      </para>
+
+    </refsection>
+            
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--uninstall</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--uninstall</option></arg>
+          <arg choice='plain'><option>-e</option></arg>
+        </group>
+        <arg choice='plain' rep='repeat'><replaceable>drvnames</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The uninstall operation creates a new user environment, based
+        on the current generation of the active profile, from which the
+        derivations designated by <replaceable>drvnames</replaceable>
+        are removed.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env --uninstall gcc
+$ nix-env -e '*' <lineannotation>(remove everything)</lineannotation></screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--query</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--query</option></arg>
+          <arg choice='plain'><option>-q</option></arg>
+        </group>
+        <group choice='opt'>
+          <arg choice='plain'><option>--installed</option></arg>
+          <arg choice='plain'><option>--available</option></arg>
+          <arg choice='plain'><option>-a</option></arg>
+        </group>
+        <group choice='req'>
+          <arg choice='plain'><option>--name</option></arg>
+          <arg choice='plain'><option>--expr</option></arg>
+          <arg choice='plain'><option>--status</option></arg>
+          <arg choice='plain'><option>-s</option></arg>
+        </group>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The query operation displays information about either the
+        derivations that are installed in the current generation of
+        the active profile (<option>--installed</option>), or the
+        derivations that are available for installation in the active
+        Nix expression (<option>--available</option>).
+      </para>
+
+      <para>
+        The derivations are sorted by their <literal>name</literal>
+        attributes.
+      </para>
+
+    </refsection>
+
+    <refsection>
+      <title>Source selection</title>
+
+      <para>
+        The following flags specify the set of derivations on which
+        the query operates.
+      </para>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--installed</option></term>
+          <listitem>
+            <para>
+              The query operates on the derivations that are installed
+              in the current generation of the active profile.  This
+              is the default
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--available</option> / <option>-a</option></term>
+          <listitem>
+            <para>
+              The query operates on the derivations that are available
+              in the active Nix expression.
+            </para>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+            
+    </refsection>
+
+    <refsection>
+      <title>Queries</title>
+
+      <para>
+        The following flags specify what information to display about
+        the selected derivations.  Only one type of query may be
+        specified.
+      </para>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--name</option></term>
+          <listitem>
+            <para>
+              Prints the <literal>name</literal> attribute of each
+              derivation.  This is the default.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--expr</option></term>
+          <listitem>
+            <para>
+              Prints the store expression in the Nix store that
+              described the derivation.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--status</option> / <option>-s</option></term>
+          <listitem>
+            <para>
+              Prints the <emphasis>status</emphasis> of each
+              derivation, followed by its <literal>name</literal>
+              attribute.  The status consists of three characters.
+              The first is <literal>I</literal> or
+              <literal>-</literal>, indicating whether the derivation
+              is currently installed in the current generation of the
+              active profile.  This is by definition the case for
+              <option>--installed</option>, but not for
+              <option>--available</option>.  The second is
+              <literal>P</literal> or <literal>-</literal>, indicating
+              whether the derivation is present on the system.  This
+              indicates whether installation of an available
+              derivation will require the derivation to be built.  The
+              third is <literal>S</literal> or <literal>-</literal>,
+              indicating whether a substitute is available for the
+              derivation.
+            </para>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+              
+    </refsection>
+
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env -q <lineannotation>(show installed derivations)</lineannotation>
+MozillaFirebird-0.7
+bison-1.875c
+docbook-xml-4.2
+...
+
+$ nix-env -qa <lineannotation>(show available derivations)</lineannotation>
+GConf-2.4.0.1
+MPlayer-1.0pre3
+MozillaFirebird-0.7
+ORBit2-2.8.3
+...
+
+$ nix-env -qas <lineannotation>(show status of available derivations)</lineannotation>
+-P- GConf-2.4.0.1 <lineannotation>(not installed but present)</lineannotation>
+--S MPlayer-1.0pre3 <lineannotation>(not present, but there is a substitute for fast installation)</lineannotation>
+--S MozillaFirebird-0.7 <lineannotation>(i.e., this is not the installed Firebird, even though the version is the same!)</lineannotation>
+IP- bison-1.875c <lineannotation>(installed and by definition present)</lineannotation>
+...
+
+$ nix-env -f ./foo.nix -qa <lineannotation>(show available derivations in the Nix expression <filename>foo.nix</filename>)</lineannotation>
+foo-1.2.3</screen>
+
+    </refsection>
+    
+  </refsection>
+  
+    
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--switch-profile</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--switch-profile</option></arg>
+          <arg choice='plain'><option>-S</option></arg>
+        </group>
+        <arg choice='req'><replaceable>path</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        This operation makes <replaceable>path</replaceable> the
+        current profile for the user.  That is, the symlink
+        <filename>~/.nix-profile</filename> is made to point to
+        <replaceable>path</replaceable>.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env -S ~/my-profile</screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--list-generations</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <arg choice='req'><option>--list-generations</option></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        This operation print a list of all the currently existing
+        generations for the active profile.  These may be switched to
+        using the <option>--switch-generation</option> operation.  It
+        also prints the creation date of the generation, and indicates
+        the current generation.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env --list-generations
+  95   2004-02-06 11:48:24
+  96   2004-02-06 11:49:01
+  97   2004-02-06 16:22:45
+  98   2004-02-06 16:24:33   (current)</screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--delete-generations</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <arg choice='req'><option>--delete-generations</option></arg>
+        <arg choice='plain' rep='repeat'><replaceable>generations</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        This operation deletes the specified generations of the
+        current profile.  The generations can be a list of generation
+        numbers, or the special value <literal>old</literal> to delete
+        all non-current generations.  Periodically deleting old
+        generations is important to make garbage collection effective.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env --delete-generations 3 4 8
+
+$ nix-env -p other_profile --delete-generations old</screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--switch-generation</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--switch-generation</option></arg>
+          <arg choice='plain'><option>-G</option></arg>
+        </group>
+        <arg choice='req'><replaceable>generation</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        This operation makes generation number
+        <replaceable>generation</replaceable> the current generation
+        of the active profile.  That is, if the
+        <filename><replaceable>profile</replaceable></filename> is the
+        path to the active profile, then the symlink
+        <filename><replaceable>profile</replaceable></filename> is
+        made to point to
+        <filename><replaceable>profile</replaceable>-<replaceable>generation</replaceable>-link</filename>,
+        which is in turn a symlink to the actual user environment in
+        the Nix store.
+      </para>
+
+      <para>
+        Switching will fail if the specified generation does not
+        exist.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env -G 42
+switching from generation 50 to 42</screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--rollback</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <arg choice='req'><option>--rollback</option></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        This operation switches to the <quote>previous</quote>
+        generation of the active profile, that is, the highest
+        numbered generation lower than the current generation, if it
+        exists.  It is just a convenience wrapper around
+        <option>--list-generations</option> and
+        <option>--switch-generation</option>.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env --rollback
+switching from generation 92 to 91
+
+$ nix-env --rolback
+error: no generation older than the current (91) exists</screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--import</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-env</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--import</option></arg>
+          <arg choice='plain'><option>-I</option></arg>
+        </group>
+        <arg choice='req'><replaceable>path</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        This operation makes <replaceable>path</replaceable> the
+        default active Nix expression for the user.  That is, the
+        symlink <filename>~/.nix-userenv</filename> is made to point
+        to <replaceable>path</replaceable>.
+      </para>
+
+    </refsection>
+            
+    <refsection>
+      <title>Examples</title>
+
+      <screen>
+$ nix-env -I ~/nixpkgs-0.5/</screen>
+
+    </refsection>
+    
+  </refsection>
+
+
+  
+</refentry>

doc/manual/nix-instantiate.xml

@@ -0,0 +1,90 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-instantiate</refname>
+    <refpurpose>instantiate store expressions from Nix expressions</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-instantiate</command>
+      &opt-common-syn;
+      <group choice='opt'>
+        <arg choice='plain'><option>--parse-only</option></arg>
+        <arg choice='plain'><option>--eval-only</option></arg>
+      </group>
+      <arg choice='plain' rep='repeat'><replaceable>files</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-instantiate</command> generates
+      (low-level) store expressions from (high-level) Nix expressions.
+      It loads and evaluates the Nix expressions in each of
+      <replaceable>files</replaceable>.  Each top-level expression
+      should evaluate to a derivation, a list of derivations, or a set
+      of derivations.  The paths of the resulting store expressions
+      are printed on standard output.
+    </para>
+
+    <para>
+      This command is generally used for testing Nix expression before
+      they are used with <command>nix-env</command>.
+    </para>
+
+  </refsection>
+
+  <refsection>
+    <title>Options</title>
+
+    <variablelist>
+
+      &opt-common;
+
+      <varlistentry>
+        <term><option>--parse-only</option></term>
+        <listitem>
+          <para>
+            Just parse the input files, and print their abstract
+            syntax trees on standard output in ATerm format.
+          </para>
+        </listitem>
+      </varlistentry>
+      
+      <varlistentry>
+        <term><option>--eval-only</option></term>
+        <listitem>
+          <para>
+            Just parse and evaluate the input files, and print the
+            resulting values on standard output.  No instantiation of
+            store expressions takes place.
+          </para>
+        </listitem>
+      </varlistentry>
+
+    </variablelist>
+
+  </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <screen>
+$ nix-instantiate gcc.nix <lineannotation>(instantiate)</lineannotation>
+/nix/store/468abdcb93aa22bb721142615b97698b-d-gcc-3.3.2.store
+
+$ nix-store -r $(nix-instantiate gcc.nix) <lineannotation>(build)</lineannotation>
+
+$ nix-store -r $(nix-instantiate gcc.nix) <lineannotation>(print output path)</lineannotation>
+/nix/store/9afa718cddfdfe94b5b9303d0430ceb1-gcc-3.3.2
+
+$ ls -l /nix/store/9afa718cddfdfe94b5b9303d0430ceb1-gcc-3.3.2
+dr-xr-xr-x    2 eelco    users         360 2003-12-01 16:12 bin
+dr-xr-xr-x    3 eelco    users          72 2003-12-01 16:12 include
+...</screen>
+
+  </refsection>
+    
+</refentry>

doc/manual/nix-lang-ref.xml

@@ -0,0 +1,277 @@
+<appendix>
+  <title>Nix Language Reference</title>
+
+  <sect1>
+    <title>Grammar</title>
+
+    <productionset>
+      <title>Expressions</title>
+      
+      <production id="nix.expr">
+        <lhs>Expr</lhs>
+        <rhs>
+          <nonterminal def="#nix.expr_function" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_function">
+        <lhs>ExprFunction</lhs>
+        <rhs>
+          '{' <nonterminal def="#nix.formals" /> '}' ':' <nonterminal def="#nix.expr_function" />
+          <sbr />|
+          <nonterminal def="#nix.expr_assert" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_assert">
+        <lhs>ExprAssert</lhs>
+        <rhs>
+          'assert' <nonterminal def="#nix.expr" /> ';' <nonterminal def="#nix.expr_assert" />
+          <sbr />|
+          <nonterminal def="#nix.expr_if" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_if">
+        <lhs>ExprIf</lhs>
+        <rhs>
+          'if' <nonterminal def="#nix.expr" /> 'then' <nonterminal def="#nix.expr" />
+          'else' <nonterminal def="#nix.expr" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_op">
+        <lhs>ExprOp</lhs>
+        <rhs>
+          '!' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '==' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '!=' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '&amp;&amp;' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '||' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '->' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '//' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '~' <nonterminal def="#nix.expr_op" />
+          <sbr />|
+          <nonterminal def="#nix.expr_op" /> '?' <nonterminal def="#nix.id" />
+          <sbr />|
+          <nonterminal def="#nix.expr_app" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_app">
+        <lhs>ExprApp</lhs>
+        <rhs>
+          <nonterminal def="#nix.expr_app" /> '.' <nonterminal def="#nix.expr_select" />
+          <sbr />|
+          <nonterminal def="#nix.expr_select" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_select">
+        <lhs>ExprSelect</lhs>
+        <rhs>
+          <nonterminal def="#nix.expr_select" /> <nonterminal def="#nix.id" />
+          <sbr />|
+          <nonterminal def="#nix.expr_simple" />
+        </rhs>
+      </production>
+      
+      <production id="nix.expr_simple">
+        <lhs>ExprSimple</lhs>
+        <rhs>
+          <nonterminal def="#nix.id" /> |
+          <nonterminal def="#nix.int" /> |
+          <nonterminal def="#nix.str" /> |
+          <nonterminal def="#nix.path" /> |
+          <nonterminal def="#nix.uri" />
+          <sbr />|
+          'true' | 'false' | 'null'
+          <sbr />|
+          '(' <nonterminal def="#nix.expr" /> ')'
+          <sbr />|
+          '{' <nonterminal def="#nix.bind" />* '}'
+          <sbr />|
+          'let' '{' <nonterminal def="#nix.bind" />* '}'
+          <sbr />|
+          'rec' '{' <nonterminal def="#nix.bind" />* '}'
+          <sbr />|
+          '[' <nonterminal def="#nix.expr_select" />* ']'
+        </rhs>
+      </production>
+
+      <production id="nix.bind">
+        <lhs>Bind</lhs>
+        <rhs>
+          <nonterminal def="#nix.id" /> '=' <nonterminal def="#nix.expr" /> ';'
+          <sbr />|
+          'inherit' ('(' <nonterminal def="#nix.expr" /> ')')? <nonterminal def="#nix.id" />* ';'
+        </rhs>
+      </production>
+
+      <production id="nix.formals">
+        <lhs>Formals</lhs>
+        <rhs>
+          <nonterminal def="#nix.formal" /> ',' <nonterminal def="#nix.formals" />
+          | <nonterminal def="#nix.formal" />
+        </rhs>
+      </production>
+          
+      <production id="nix.formal">
+        <lhs>Formal</lhs>
+        <rhs>
+          <nonterminal def="#nix.id" />
+          <sbr />|
+          <nonterminal def="#nix.id" /> '?' <nonterminal def="#nix.expr" />
+        </rhs>
+      </production>
+          
+    </productionset>
+
+    <productionset>
+      <title>Terminals</title>
+
+      <production id="nix.id">
+        <lhs>Id</lhs>
+        <rhs>[a-zA-Z\_][a-zA-Z0-9\_\']*</rhs>
+      </production>
+    
+      <production id="nix.int">
+        <lhs>Int</lhs>
+        <rhs>[0-9]+</rhs>
+      </production>
+    
+      <production id="nix.str">
+        <lhs>Str</lhs>
+        <rhs>\"[^\n\"]*\"</rhs>
+      </production>
+
+      <production id="nix.path">
+        <lhs>Path</lhs>
+        <rhs>[a-zA-Z0-9\.\_\-\+]*(\/[a-zA-Z0-9\.\_\-\+]+)+</rhs>
+      </production>
+    
+      <production id="nix.uri">
+        <lhs>Uri</lhs>
+        <rhs>[a-zA-Z][a-zA-Z0-9\+\-\.]*\:[a-zA-Z0-9\%\/\?\:\@\&amp;\=\+\$\,\-\_\.\!\~\*\']+</rhs>
+      </production>
+
+      <production id="nix.ws">
+        <lhs>Whitespace</lhs>
+        <rhs>
+          [ \t\n]+
+          <sbr />|
+          \#[^\n]*
+          <sbr />|
+          \/\*(.|\n)*\*\/
+        </rhs>
+      </production>
+
+    </productionset>
+    
+  </sect1>
+  
+
+
+  <sect1>
+    <title>Semantics</title>
+
+
+    
+    <sect2>
+      <title>Built-in functions</title>
+
+      <para>
+        The Nix language provides the following built-in function
+        (<quote>primops</quote>):
+      </para>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><function>import</function>
+          <replaceable>e</replaceable></term>
+          <listitem>
+            <para>
+              Evaluates the expression <replaceable>e</replaceable>,
+              which must yield a path value.  The Nix expression
+              stored at this path in the file system is then read,
+              parsed, and evaluated.  Returns the result of the
+              evaluation of the Nix expression just read.
+            </para>
+
+            <para>
+              Example: <literal>import ./foo.nix</literal> evaluates
+              the expression stored in <filename>foo.nix</filename>
+              (in the directory containing the expression in which the
+              <function>import</function> occurs).
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><function>derivation</function>
+          <replaceable>e</replaceable></term>
+          <listitem>
+            <para>
+              Evaluates the expression <replaceable>e</replaceable>,
+              which must yield an attribute set.  [...]
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><function>baseNameOf</function>
+          <replaceable>e</replaceable></term>
+          <listitem>
+            <para>
+              Evaluates the expression <replaceable>e</replaceable>,
+              which must yield a string value, and returns a string
+              representing its <emphasis>base name</emphasis>.  This
+              is the substring following the last path separator
+              (<literal>/</literal>).
+            </para>
+
+            <para>
+              Example: <literal>baseNameOf "/foo/bar"</literal>
+              returns <literal>"bar"</literal>, and
+              <literal>baseNameOf "/foo/bar/"</literal> returns
+              <literal>""</literal>.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><function>toString</function>
+          <replaceable>e</replaceable></term>
+          <listitem>
+            <para>
+              Evaluates the expression <replaceable>e</replaceable>
+              and coerces it into a string, if possible.  Only
+              strings, paths, and URIs can be so coerced.
+            </para>
+
+            <para>
+              Example: <literal>toString
+              http://www.cs.uu.nl/</literal> returns
+              <literal>"http://www.cs.uu.nl/"</literal>.
+            </para>
+          </listitem>
+        </varlistentry>
+            
+      </variablelist>
+
+    </sect2>
+
+  </sect1>
+  
+
+</appendix>

doc/manual/nix-prefetch-url.xml

@@ -0,0 +1,54 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-prefetch-url</refname>
+    <refpurpose>copy a file from a URL into the store and print its MD5 hash</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-prefetch-url</command>
+      <arg choice='plain'><replaceable>url</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-prefetch-url</command> downloads the
+      file referenced by the URL <replaceable>url</replaceable>,
+      prints its MD5 cryptographic hash code, and copies it into the
+      Nix store.  The file name in the store is
+      <filename><replaceable>hash</replaceable>-<replaceable>basename</replaceable></filename>,
+      where <replaceable>basename</replaceable> is everything
+      following the final slash in <replaceable>url</replaceable>.
+    </para>
+
+    <para>
+      This command is just a convenience to Nix expression writers.
+      Often a Nix expressions fetch some source distribution from the
+      network using the <literal>fetchurl</literal> expression
+      contained in <literal>nixpkgs</literal>.  However,
+      <literal>fetchurl</literal> requires an MD5 hash.  If you don't
+      know the hash, you would have to download the file first, and
+      then <literal>fetchurl</literal> would download it again when
+      you build your Nix expression.  Since
+      <literal>fetchurl</literal> uses the same name for the
+      downloaded file as <command>nix-prefetch-url</command>, the
+      redundant download can be avoided.
+    </para>
+
+  </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <screen>
+$ nix-prefetch-url ftp://ftp.nluug.nl/pub/gnu/make/make-3.80.tar.bz2
+...
+file has hash 0bbd1df101bc0294d440471e50feca71
+...</screen>
+
+  </refsection>
+    
+</refentry>

doc/manual/nix-pull.xml

@@ -0,0 +1,43 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-pull</refname>
+    <refpurpose>pull substitutes from a network cache</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-pull</command>
+      <arg choice='plain'><replaceable>url</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-pull</command> obtains a list of
+      pre-built store paths from the URL
+      <replaceable>url</replaceable>, and for each of these store
+      paths, registers a substitute derivation that downloads and
+      unpacks it into the Nix store.  This is used to speed up
+      installations: if you attempt to install something that has
+      already been built and stored into the network cache, Nix can
+      transparently re-use the pre-built store paths.
+    </para>
+
+    <para>
+      The file at <replaceable>url</replaceable> must be compatible
+      with the files created by <replaceable>nix-push</replaceable>.
+    </para>
+
+  </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <screen>
+$ nix-pull http://catamaran.labs.cs.uu.nl/dist/nix/nixpkgs-0.5pre753/MANIFEST</screen>
+
+  </refsection>
+    
+</refentry>

doc/manual/nix-push.xml

@@ -0,0 +1,138 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-push</refname>
+    <refpurpose>push store paths onto a network cache</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-push</command>
+      <arg choice='plain'><replaceable>archives-put-url</replaceable></arg>
+      <arg choice='plain'><replaceable>archives-get-url</replaceable></arg>
+      <arg choice='plain'><replaceable>manifest-put-url</replaceable></arg>
+      <arg choice='plain' rep='repeat'><replaceable>paths</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-push</command> builds a set of store
+      expressions (if necessary), and then packages and uploads all
+      store paths in the resulting closures to a server.  A network
+      cache thus populated can subsequently be used to speed up
+      software deployment on other machines using the
+      <command>nix-pull</command> command.
+    </para>
+
+    <para>
+      <command>nix-push</command> performs the following actions.
+      
+      <orderedlist>
+
+        <listitem>
+          <para>
+            The store expressions stored in
+            <replaceable>paths</replaceable> are realised (using
+            <literal>nix-store --realise</literal>).
+          </para>
+        </listitem>
+
+        <listitem>
+          <para>
+            All paths in the closure of the store expressions stored
+            in <replaceable>paths</replaceable> are determined (using
+            <literal>nix-store --query --requisites
+            --include-successors</literal>).  It should be noted that
+            since the <option>--include-successors</option> flag is
+            used, if you specify a derivation store expression, you
+            get a combined source/binary distribution.  If you only
+            want a binary distribution, you should specify the closure
+            store expression that result from realising these (see
+            below).
+          </para>
+        </listitem>
+
+        <listitem>
+          <para>
+            All store paths determined in the previous step are
+            packaged and compressed into a <command>bzip</command>ped
+            NAR archive (extension <filename>.nar.bz2</filename>).
+          </para>
+        </listitem>
+
+        <listitem>
+          <para>
+            A <emphasis>manifest</emphasis> is created that contains
+            information on the store paths, their eventual URLs in the
+            cache, and cryptographic hashes of the contents of the NAR
+            archives.
+          </para>
+        </listitem>
+
+        <listitem>
+          <para>
+            Each store path is uploaded to the remote directory
+            specified by <replaceable>archives-put-url</replaceable>.
+            HTTP PUT requests are used to do this.  However, before a
+            file <varname>x</varname> is uploaded to
+            <literal><replaceable>archives-put-url</replaceable>/<varname>x</varname></literal>,
+            <command>nix-push</command> first determines whether this
+            upload is unnecessary by issuing a HTTP HEAD request on
+            <literal><replaceable>archives-get-url</replaceable>/<varname>x</varname></literal>.
+            This allows a cache to be shared between many partially
+            overlapping <command>nix-push</command> invocations.
+            (We use two URLs because the upload URL typically
+            refers to a CGI script, while the download URL just refers
+            to a file system directory on the server.)
+          </para>
+        </listitem>
+
+        <listitem>
+          <para>
+            The manifest is uploaded using an HTTP PUT request to
+            <replaceable>manifest-put-url</replaceable>.  The
+            corresponding URL to download the manifest can then be
+            used by <command>nix-pull</command>.
+          </para>
+        </listitem>
+        
+      </orderedlist>
+    </para>
+            
+  </refsection>
+
+  <refsection>
+    <title>Examples</title>
+
+    <para>
+      To upload files there typically is some CGI script on the server
+      side.  This script should be be protected with a password.  The
+      following example uploads the store paths resulting from
+      building the Nix expressions in <filename>foo.nix</filename>,
+      passing appropriate authentication information:
+    
+      <screen>
+$ nix-push \
+    http://foo@bar:server.domain/cgi-bin/upload.pl/cache \
+    http://server.domain/cache \
+    http://foo@bar:server.domain/cgi-bin/upload.pl/MANIFEST \
+    $(nix-instantiate foo.nix)</screen>
+
+    This will push both sources and binaries (and any build-time
+    dependencies used in the build, such as compilers).
+    </para>
+
+    <para>
+      If we just want to push binaries, not sources and build-time
+      dependencies, we can do:
+      
+      <screen>
+$ nix-push <replaceable>urls</replaceable> $(nix-instantiate $(nix-store -r foo.nix))</screen>
+    
+    </para>
+
+  </refsection>
+    
+</refentry>

doc/manual/nix-reference.xml

@@ -1,444 +0,0 @@
-<refentry>
-  <refnamediv>
-    <refname>nix</refname>
-    <refpurpose>manipulate or query the Nix store</refpurpose>
-  </refnamediv>
-
-  <refsynopsisdiv>
-    <cmdsynopsis>
-      <command>nix</command>
-      <group choice='opt'>
-	<arg><option>--path</option></arg>
-	<arg><option>-p</option></arg>
-      </group>
-      <group choice='opt' rep='repeat'>
-	<arg><option>--verbose</option></arg>
-	<arg><option>-v</option></arg>
-      </group>
-      <group choice='opt' rep='repeat'>
-	<arg><option>--keep-failed</option></arg>
-	<arg><option>-K</option></arg>
-      </group>
-      <arg choice='plain'><replaceable>operation</replaceable></arg>
-      <arg rep='repeat'><replaceable>options</replaceable></arg>
-      <arg rep='repeat'><replaceable>arguments</replaceable></arg>
-    </cmdsynopsis>
-  </refsynopsisdiv>
-
-  <refsect1>
-    <title>Description</title>
-
-    <para>
-      The command <command>nix</command> provides access to the Nix store. This
-      is the (set of) path(s) where Nix expressions and the file system objects
-      built by them are stored.
-    </para>
-
-    <para>
-      <command>nix</command> has many subcommands called
-      <emphasis>operations</emphasis>.  These are individually documented
-      below.  Exactly one operation must always be provided.
-    </para>
-
-  </refsect1>
-
-  <refsect1>
-    <title>Common Options</title>
-
-    <para>
-      In this section the options that are common to all Nix operations are
-      listed.  These options are allowed for every subcommand (although they
-      may not always have an effect).
-    </para>
-
-    <variablelist>
-
-      <varlistentry>
-	<term><option>--path</option></term>
-	<listitem>
-	  <para>
-	    Indicates that any identifier arguments to the operation are paths
-	    in the store rather than identifiers.
-	  </para>
-	</listitem>
-      </varlistentry>
-
-      <varlistentry>
-	<term><option>--verbose</option></term>
-	<listitem>
-	  <para>
-	    Increases the level of verbosity of diagnostic messages printed on
-	    standard error.  For each Nix operation, the information printed on
-	    standard output is well-defined and specified below in the
-	    respective sections.  Any diagnostic information is printed on
-	    standard error, never on standard output.
-	  </para>
-
-	  <para>
-	    This option may be specified repeatedly.  Currently, the following
-	    verbosity levels exist:
-	  </para>
-
-	  <variablelist>
-	    <varlistentry>
-	      <term>0</term>
-	      <listitem>
-		<para>
-		  Print error messages only.
-		</para>
-	      </listitem>
-	    </varlistentry>
-	    <varlistentry>
-	      <term>1</term>
-	      <listitem>
-		<para>
-		  Print informational messages.
-		</para>
-	      </listitem>
-	    </varlistentry>
-	    <varlistentry>
-	      <term>2</term>
-	      <listitem>
-		<para>
-		  Print even more informational messages.
-		</para>
-	      </listitem>
-	    </varlistentry>
-	    <varlistentry>
-	      <term>3</term>
-	      <listitem>
-		<para>
-		  Print messages that should only be useful for debugging.
-		</para>
-	      </listitem>
-	    </varlistentry>
-	    <varlistentry>
-	      <term>4</term>
-	      <listitem>
-		<para>
-		  <quote>Vomit mode</quote>: print vast amounts of debug
-		  information.
-		</para>
-	      </listitem>
-	    </varlistentry>
-	  </variablelist>
-
-	</listitem>
-      </varlistentry>
-
-      <varlistentry>
-	<term><option>--keep-failed</option></term>
-	<listitem>
-	  <para>
-	    Specifies that in case of a build failure, the temporary directory
-            (usually in <filename>/tmp</filename>) in which the build takes
-            place should not be deleted.  The path of the build directory is
-            printed as an informational message.
-	  </para>
-	</listitem>
-      </varlistentry>
-
-    </variablelist>
-
-  </refsect1>
-
-
-  <!--######################################################################-->
-
-  <refsect1>
-    <title>Operation <option>--install</option></title>
-
-    <refsect2>
-      <title>Synopsis</title>
-      <cmdsynopsis>
-	<command>nix</command>
-	<group>
-	  <arg><option>--install</option></arg>
-	  <arg><option>-i</option></arg>
-	</group>
-	<arg choice='plain' rep='repeat'><replaceable>ids</replaceable></arg>
-      </cmdsynopsis>
-    </refsect2>
-
-    <refsect2>
-      <title>Description</title>
-	    
-      <para>
-	The operation <option>--install</option> realises the Nix expressions
-	identified by <replaceable>ids</replaceable> in the file system.  If
-	these expressions are derivation expressions, they are first
-	normalised.  That is, their target paths are are built, unless a normal
-	form is already known.
-      </para>
-
-      <para>
-	The identifiers of the normal forms of the given Nix expressions are
-	printed on standard output.
-      </para>
-
-    </refsect2>
-	    
-  </refsect1>
-
-
-  <!--######################################################################-->
-
-  <refsect1>
-    <title>Operation <option>--delete</option></title>
-
-    <refsect2>
-      <title>Synopsis</title>
-      <cmdsynopsis>
-	<command>nix</command>
-	<group>
-	  <arg><option>--delete</option></arg>
-	  <arg><option>-d</option></arg>
-	</group>
-	<arg choice='plain' rep='repeat'><replaceable>paths</replaceable></arg>
-      </cmdsynopsis>
-    </refsect2>
-
-    <refsect2>
-      <title>Description</title>
-	    
-      <para>
-	The operation <option>--delete</option> unconditionally deletes the
-	paths <replaceable>paths</replaceable> from the Nix store. It is an
-	error to attempt to delete paths outside of the store.
-      </para>
-
-      <warning>
-	<para>
-	  This operation should almost never be called directly, since no
-	  attempt is made to verify that no references exist to the paths to
-	  be deleted.  Therefore, careless deletion can result in an
-	  inconsistent system. Deletion of paths in the store is done by the
-	  garbage collector (which uses <option>--delete</option> to delete
-	  unreferenced paths).
-	  
-	</para>
-      </warning>
-
-    </refsect2>
-	    
-  </refsect1>
-
-
-  <!--######################################################################-->
-
-  <refsect1>
-    <title>Operation <option>--query</option></title>
-
-    <refsect2>
-      <title>Synopsis</title>
-      <cmdsynopsis>
-	<command>nix</command>
-	<group>
-	  <arg><option>--query</option></arg>
-	  <arg><option>-q</option></arg>
-	</group>
-	<group>
-	  <group>
-	    <arg><option>--list</option></arg>
-	    <arg><option>-l</option></arg>
-	  </group>
-	  <group>
-	    <arg><option>--requisites</option></arg>
-	    <arg><option>-r</option></arg>
-	  </group>
-	  <group>
-	    <arg><option>--expansion</option></arg>
-	    <arg><option>-e</option></arg>
-	  </group>
-	  <group>
-	    <arg><option>--graph</option></arg>
-	    <arg><option>-g</option></arg>
-	  </group>
-	</group>
-	<arg choice='plain' rep='repeat'><replaceable>args</replaceable></arg>
-      </cmdsynopsis>
-    </refsect2>
-
-    <refsect2>
-      <title>Description</title>
-	    
-      <para>
-	The operation <option>--query</option> displays various bits of
-	information about Nix expressions or paths in the store.  The queries
-	are described in <xref linkend='nixref-queries' />.  At most one query
-	can be specified; the default query is <option>--list</option>.
-      </para>
-
-    </refsect2>
-
-    <refsect2 id='nixref-queries'>
-      <title>Queries</title>
-	    
-      <variablelist>
-
-	<varlistentry>
-	  <term><option>--list</option></term>
-	  <listitem>
-	    <para>
-	      Prints out the target paths of the Nix expressions indicated by
-	      the identifiers <replaceable>args</replaceable>.  In the case of
-	      a derivation expression, these are the paths that will be
-	      produced by the builder of the expression.  In the case of a
-	      slice expression, these are the root paths (which are generally
-	      the paths that were produced by the builder of the derivation
-	      expression of which the slice is a normal form).
-	    </para>
-
-	    <para>
-	      This query has one option:
-	    </para>
-
-	    <variablelist>
-
-	      <varlistentry>
-		<term><option>--normalise</option></term>
-		<listitem>
-		  <para>
-		    Causes the target paths of the <emphasis>normal
-		      forms</emphasis> of the expressions to be printed, rather
-		    than the target paths of the expressions themselves.
-		  </para>
-		</listitem>
-	      </varlistentry>
-
-	    </variablelist>
-	    
-	  </listitem>
-	</varlistentry>
-
-	<varlistentry>
-	  <term><option>--requisites</option></term>
-	  <listitem>
-	    <para>
-	      Prints out the requisite paths of the Nix expressions indicated
-	      by the identifiers <replaceable>args</replaceable>.  The
-	      requisite paths of a Nix expression are the paths that need to be
-	      present in the system to be able to realise the expression.  That
-	      is, they form the <emphasis>closure</emphasis> of the expression
-	      in the file system (i.e., no path in the set of requisite paths
-	      points to anything outside the set of requisite paths).
-	    </para>
-
-	    <para>
-	      The notion of requisite paths is very useful when one wants to
-	      distribute Nix expressions.  Since they form a closure, they are
-	      the only paths one needs to distribute to another system to be
-	      able to realise the expression on the other system.
-	    </para>
-
-	    <para>
-	      This query is generally used to implement various kinds of
-	      distribution.  A <emphasis>source distribution</emphasis> is
-	      obtained by distributing the requisite paths of a derivation
-	      expression.  A <emphasis>binary distribution</emphasis> is
-	      obtained by distributing the requisite paths of a slice
-	      expression (i.e., the normal form of a derivation expression; you
-	      can directly specify the identifier of the slice expression, or
-	      use <option>--normalise</option> and specify the identifier of a
-	      derivation expression).  A <emphasis>cache
-		distribution</emphasis> is obtained by distributing the
-	      requisite paths of a derivation expression and specifying the
-	      option <option>--include-successors</option>.  This will include
-	      not just the paths of a source and binary distribution, but also
-	      all expressions and paths of subterms of the source.  This is
-	      useful if one wants to realise on the target system a Nix
-	      expression that is similar but not quite the same as the one
-	      being distributed, since any common subterms will be reused.
-	    </para>
-
-	    <para>
-	      This query has a number of options:
-	    </para> 
-
-	    <variablelist>
-
-	      <varlistentry>
-		<term><option>--normalise</option></term>
-		<listitem>
-		  <para>
-		    Causes the requisite paths of the <emphasis>normal
-		      forms</emphasis> of the expressions to be printed, rather
-		    than the requisite paths of the expressions themselves.
-		  </para>
-		</listitem>
-	      </varlistentry>
-
-	      <varlistentry>
-		<term><option>--exclude-exprs</option></term>
-		<listitem>
-		  <para>
-		    Excludes the paths of Nix expressions.  This causes the
-		    closure property to be lost, that is, the resulting set of
-		    paths is not enough to ensure realisibility.
-		  </para>
-		</listitem>
-	      </varlistentry>
-
-	      <varlistentry>
-		<term><option>--include-successors</option></term>
-		<listitem>
-		  <para>
-		    Also include the requisites of successors (normal forms).
-		    Only the requisites of <emphasis>known</emphasis>
-		    successors are included, i.e., the normal forms of
-		    derivation expressions that have never been normalised will
-		    not be included.
-		  </para>
-
-		  <para>
-		    Note that not just the successor of a derivation expression
-		    will be included, but also the successors of all input
-		    expressions of that derivation expression.  I.e., all
-		    normal forms of subterms involved in the normalisation of
-		    the top-level term are included.
-		  </para>
-		</listitem>
-	      </varlistentry>
-
-	    </variablelist>
-
-	  </listitem>
-	</varlistentry>
-
-	<varlistentry>
-	  <term><option>--expansion</option></term>
-	  <listitem>
-	    <para>
-	      For each identifier in <replaceable>args</replaceable>, prints
-	      all expansions of that identifier, that is, all paths whose
-	      current content matches the identifier.
-	    </para>
-	  </listitem>
-	</varlistentry>
-
-	<varlistentry>
-	  <term><option>--graph</option></term>
-	  <listitem>
-	    <para>
-	      Prints a graph of the closure of the expressions identified by
-	      <replaceable>args</replaceable> in the format of the
-	      <command>dot</command> tool of AT&amp;T's GraphViz package.
-	    </para>
-	  </listitem>
-	</varlistentry>
-
-      </variablelist>
-
-    </refsect2>
-
-  </refsect1>
-
-
-</refentry>
-
-
-<!--
-local variables:
-sgml-parent-document: ("book.xml" "refentry")
-end:
--->

doc/manual/nix-store.xml

@@ -0,0 +1,563 @@
+<refentry>
+  <refnamediv>
+    <refname>nix-store</refname>
+    <refpurpose>manipulate or query the Nix store</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>nix-store</command>
+      &opt-common-syn;
+      <arg choice='plain'><replaceable>operation</replaceable></arg>
+      <arg rep='repeat'><replaceable>options</replaceable></arg>
+      <arg rep='repeat'><replaceable>arguments</replaceable></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>
+      The command <command>nix-store</command> performs primitive
+      operations on the Nix store.  You generally do not need to run
+      this command manually.
+    </para>
+
+    <para>
+      <command>nix-store</command> takes exactly one
+      <emphasis>operation</emphasis> flag which indicates the
+      subcommand to be performed.  These are documented below.
+    </para>
+
+  </refsection>
+
+
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Common options</title>
+
+    <para>
+      This section lists the options that are common to all
+      operations.  These options are allowed for every subcommand,
+      though they may not always have an effect.
+    </para>
+
+    <variablelist>
+
+      &opt-common;
+
+    </variablelist>
+
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Environment variables</title>
+
+    <para>
+      The following environment variables affect the behaviour of
+      <command>nix-store</command>.
+    </para>
+    
+    <variablelist>
+
+      <varlistentry>
+        <term><envar>TMPDIR</envar>=<replaceable>path</replaceable></term>
+        <listitem>
+          <para>
+            Use the directory <replaceable>path</replaceable> to store
+            temporary files.  In particular, this includes temporary
+            build directories; these can take up substantial amounts
+            of disk space.  The default is <filename>/tmp</filename>.
+          </para>
+        </listitem>
+      </varlistentry>
+
+    </variablelist>
+        
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--realise</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-store</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--realise</option></arg>
+          <arg choice='plain'><option>-r</option></arg>
+        </group>
+        <arg choice='plain' rep='repeat'><replaceable>paths</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The operation <option>--install</option> realises in the file
+        system the store expressions stored in
+        <replaceable>paths</replaceable>.  If these expressions are
+        derivation expressions, they are first
+        <emphasis>normalised</emphasis> into a closure expression.
+        This may happen in two ways.  First, the corresponding closure
+        expression (the <emphasis>successor</emphasis>) may already
+        known (either because the build has already been performed, or
+        because a successor was explicitly registered through the
+        <option>--successor</option> operation).  Otherwise, the build
+        action described by the derivation is performed, and a closure
+        expression is computed by scanning the result of the build for
+        references to other paths in the store.
+      </para>
+
+      <para>
+        The paths of the closure expression corresponding to each
+        expression in <replaceable>paths</replaceable> is printed on
+        standard output.
+      </para>
+
+    </refsection>
+            
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--gc</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-store</command>
+        <arg choice='plain'><option>--gc</option></arg>
+        <group choice='req'>
+          <arg choice='plain'><option>--print-live</option></arg>
+          <arg choice='plain'><option>--print-dead</option></arg>
+          <arg choice='plain'><option>--delete</option></arg>
+        </group>
+        <arg><option>--min-age</option> <replaceable>age</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The operation <option>--gc</option> performs a garbage
+        collection on the Nix store.  What it does specifically is
+        determined by the sub-operation, which is one of the
+        following:
+      </para>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--print-live</option></term>
+          <listitem>
+            <para>
+              This operation prints on standard output the set of
+              <quote>live</quote> store paths, which are all the store
+              paths reachable from a set of <quote>root</quote> store
+              expressions read from standard input.  Live paths should
+              never be deleted, since that would break consistency —
+              it would become possible that applications are installed
+              that reference things that are no longer present in the
+              store.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--print-dead</option></term>
+          <listitem>
+            <para>
+              This operation prints out on standard output the set of
+              <quote>dead</quote> store paths, which is just the
+              opposite of the set of live paths: any path in the store
+              that is not live (with respect to the roots) is dead.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--delete</option></term>
+          <listitem>
+            <para>
+              This operation performs an actual garbage collection.
+              All dead paths are removed from the store.
+            </para>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+
+      <para>
+        The set of root store expressions is read from standard input.
+        Each line should contain exactly one store path.
+      </para>
+
+      <para>
+        The option <option>--min-age</option> specifies a minimum time
+        in hours that an unreachable store path must not have been
+        used before it is considered dead.  The default is 0 (consider
+        all unreachable store paths dead).  Whether a store path has
+        been used is determined by looking at its access time
+        (<literal>atime</literal>), so this does not work if the store
+        is located on a file system that has the
+        <literal>noatime</literal> option set.
+      </para>
+
+      <warning>
+        <para>
+          You generally will want to use the command
+          <command>nix-collect-garbage</command>, which figures out
+          the roots and then calls this command automatically.
+        </para>
+      </warning>
+
+    </refsection>
+            
+  </refsection>
+
+
+  
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--query</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-store</command>
+        <group choice='req'>
+          <arg choice='plain'><option>--query</option></arg>
+          <arg choice='plain'><option>-q</option></arg>
+        </group>
+        <group choice='req'>
+          <arg choice='plain'><option>--list</option></arg>
+          <arg choice='plain'><option>-l</option></arg>
+          <arg choice='plain'><option>--requisites</option></arg>
+          <arg choice='plain'><option>-R</option></arg>
+          <arg choice='plain'><option>--predecessors</option></arg>
+          <arg choice='plain'><option>--graph</option></arg>
+        </group>
+        <arg><option>--normalise</option></arg>
+        <arg><option>-n</option></arg>
+        <arg><option>--force-realise</option></arg>
+        <arg><option>-f</option></arg>
+        <arg choice='plain' rep='repeat'><replaceable>args</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The operation <option>--query</option> displays various bits
+        of information about store expressions or store paths.  The
+        queries are described below.  At most one query can be
+        specified.  The default query is <option>--list</option>.
+      </para>
+
+    </refsection>
+
+
+    <refsection>
+      <title>Common query options</title>
+
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--normalise</option> / <option>-n</option></term>
+          <listitem>
+            <para>
+              For those queries that take a Nix store expression, this
+              option causes those expressions to be normalised first.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--force-realise</option> / <option>-f</option></term>
+          <listitem>
+            <para>
+              For those queries that take a Nix store expression, this
+              option causes those expressions to be realised first.
+              This is just a short-cut for the common idiom
+            </para>
+            <screen>
+nix-store --realise /nix/store/bla.store
+x=`nix-store --query --normalise /nix/store/bla.store`
+<emphasis>(do something with the path $x</emphasis></screen>
+            <para>
+              which using this flag can be written as
+            </para>
+            <screen>
+x=`nix-store --query --normalise --force-realise /nix/store/bla.store`
+<emphasis>(do something with the path $x</emphasis></screen>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+        
+    </refsection>
+    
+
+    <refsection id='nixref-queries'>
+      <title>Queries</title>
+            
+      <variablelist>
+
+        <varlistentry>
+          <term><option>--list</option> / <option>-l</option></term>
+          <listitem>
+            <para>
+              Prints out the <emphasis>output paths</emphasis> of the
+              store expressions indicated by the identifiers
+              <replaceable>args</replaceable>.  In the case of a
+              derivation expression, these are the paths that will be
+              produced when the derivation is realised.  In the case
+              of a closure expression, these are the paths that were
+              produced the derivation expression of which the closure
+              expression is a successor.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--requisites</option> / <option>-R</option></term>
+          <listitem>
+            <para>
+              Prints out the requisite paths of the store expressions
+              indicated by the identifiers
+              <replaceable>args</replaceable>.  The requisite paths of
+              a Nix expression are the paths that need to be present
+              in the system to be able to realise the expression.
+              That is, they form the <emphasis>closure</emphasis> of
+              the expression in the file system (i.e., no path in the
+              set of requisite paths points to anything outside the
+              set of requisite paths).
+            </para>
+
+            <para>
+              The notion of requisite paths is very useful when one
+              wants to distribute store expressions.  Since they form a
+              closure, they are the only paths one needs to distribute
+              to another system to be able to realise the expression
+              on the other system.
+            </para>
+
+            <para>
+              This query is generally used to implement various kinds
+              of deployment.  A <emphasis>source deployment</emphasis>
+              is obtained by distributing the requisite paths of a
+              derivation expression.  A <emphasis>binary
+              deployment</emphasis> is obtained by distributing the
+              requisite paths of a closure expression.  A
+              <emphasis>cache deployment</emphasis> is obtained by
+              distributing the requisite paths of a derivation
+              expression and specifying the option
+              <option>--include-successors</option>.  This will
+              include not just the paths of a source and binary
+              deployment, but also all expressions and paths of
+              subterms of the source.  This is useful if one wants to
+              realise on the target system a Nix expression that is
+              similar but not quite the same as the one being
+              distributed, since any common subterms will be reused.
+            </para>
+
+            <para>
+              This query has a number of options:
+            </para> 
+
+            <variablelist>
+
+              <varlistentry>
+                <term><option>--exclude-exprs</option></term>
+                <listitem>
+                  <para>
+                    Excludes the paths of store expressions.  This
+                    causes the closure property to be lost, that is,
+                    the resulting set of paths is not enough to ensure
+                    realisibility.
+                  </para>
+                </listitem>
+              </varlistentry>
+
+              <varlistentry>
+                <term><option>--include-successors</option></term>
+                <listitem>
+                  <para>
+                    Also include the requisites of successors (normal forms).
+                    Only the requisites of <emphasis>known</emphasis>
+                    successors are included, i.e., the normal forms of
+                    derivation expressions that have never been normalised will
+                    not be included.
+                  </para>
+
+                  <para>
+                    Note that not just the successor of a derivation expression
+                    will be included, but also the successors of all input
+                    expressions of that derivation expression.  I.e., all
+                    normal forms of subterms involved in the normalisation of
+                    the top-level term are included.
+                  </para>
+                </listitem>
+              </varlistentry>
+
+            </variablelist>
+
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--predecessors</option></term>
+          <listitem>
+            <para>
+              For each store expression stored at paths
+              <replaceable>args</replaceable>, prints its
+              <emphasis>predecessors</emphasis>.  A derivation
+              expression <varname>p</varname> is a predecessor of a
+              store expression <varname>q</varname> iff
+              <varname>q</varname> is a successor of
+              <varname>p</varname>.
+            </para>
+          </listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term><option>--graph</option></term>
+          <listitem>
+            <para>
+              Prints a graph of the closure of the store expressions
+              identified by <replaceable>args</replaceable> in the
+              format of the <command>dot</command> tool of AT&amp;T's
+              GraphViz package.
+            </para>
+          </listitem>
+        </varlistentry>
+
+      </variablelist>
+
+    </refsection>
+
+  </refsection>
+
+  
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--successor</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-store</command>
+        <arg choice='req'><option>--successor</option></arg>
+        <arg choice='plain'
+        rep='repeat'><replaceable>srcpath</replaceable> <replaceable>sucpath</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The operation <option>--successor</option> registers that the
+        closure expression in <replaceable>sucpath</replaceable> is a
+        successor of the derivation expression in
+        <replaceable>srcpath</replaceable>.  This is used to implement
+        binary deployment.
+      </para>
+
+    </refsection>
+            
+  </refsection>
+
+
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--substitute</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-store</command>
+        <arg choice='req'><option>--substitute</option></arg>
+        <arg choice='plain'
+        rep='repeat'><replaceable>srcpath</replaceable> <replaceable>subpath</replaceable></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The operation <option>--substitute</option> registers that the
+        store path <replaceable>srcpath</replaceable> can be built by
+        realising the derivation expression in
+        <replaceable>subpath</replaceable>.  This is used to implement
+        binary deployment.
+      </para>
+
+    </refsection>
+            
+  </refsection>
+
+
+
+  <!--######################################################################-->
+
+  <refsection>
+    <title>Operation <option>--verify</option></title>
+
+    <refsection>
+      <title>Synopsis</title>
+      <cmdsynopsis>
+        <command>nix-store</command>
+        <arg choice='req'><option>--verify</option></arg>
+      </cmdsynopsis>
+    </refsection>
+
+    <refsection>
+      <title>Description</title>
+            
+      <para>
+        The operation <option>--verify</option> verifies the internal
+        consistency of the Nix database, and the consistency between
+        the Nix database and the Nix store.  Any inconsistencies
+        encountered are automatically repaired.  Inconsistencies are
+        generally the result of the Nix store or database being
+        modified by non-Nix tools, or of bugs in Nix itself.
+      </para>
+
+    </refsection>
+            
+  </refsection>
+
+
+
+</refentry>
+
+
+<!--
+local variables:
+sgml-parent-document: ("book.xml" "refentry")
+end:
+-->

doc/manual/opt-common-syn.xml

@@ -0,0 +1,19 @@
+<arg><option>--help</option></arg>
+<arg><option>--version</option></arg>
+<arg rep='repeat'><option>--verbose</option></arg>
+<arg rep='repeat'><option>-v</option></arg>
+<arg><option>--no-build-output</option></arg>
+<arg><option>-Q</option></arg>
+<arg>
+  <group choice='req'>
+    <arg choice='plain'><option>--max-jobs</option></arg>
+    <arg choice='plain'><option>-j</option></arg>
+  </group>
+  <replaceable>number</replaceable>
+</arg>
+<arg><option>--keep-going</option></arg>
+<arg><option>-k</option></arg>
+<arg><option>--keep-failed</option></arg>
+<arg><option>-K</option></arg>
+<arg><option>--fallback</option></arg>
+<arg><option>--readonly-mode</option></arg>

doc/manual/opt-common.xml

@@ -0,0 +1,184 @@
+<varlistentry>
+  <term><option>--help</option></term>
+  <listitem>
+    <para>
+      Prints out a summary of the command syntax and exits.
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--version</option></term>
+  <listitem>
+    <para>
+      Prints out the Nix version number on standard output and exits.
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--verbose</option> / <option>-v</option></term>
+  <listitem>
+    <para>
+      Increases the level of verbosity of diagnostic messages printed
+      on standard error.  For each Nix operation, the information
+      printed on standard output is well-defined; any diagnostic
+      information is printed on standard error, never on standard
+      output.
+    </para>
+
+    <para>
+      This option may be specified repeatedly.  Currently, the
+      following verbosity levels exist:
+    </para>
+
+    <variablelist>
+      <varlistentry>
+        <term>0</term>
+        <listitem>
+          <para>
+            <quote>Errors only</quote>: only print messages explaining
+            why the Nix invocation failed.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>1</term>
+        <listitem>
+          <para>
+            <quote>Informational</quote>: print
+            <emphasis>useful</emphasis> messages about what Nix is
+            doing.  This is the default.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>2</term>
+        <listitem>
+          <para>
+            <quote>Talkative</quote>: print more informational messages.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>3</term>
+        <listitem>
+          <para>
+            <quote>Chatty</quote>: print even more informational messages.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>4</term>
+        <listitem>
+          <para>
+            <quote>Debug</quote>: print debug information:
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>5</term>
+        <listitem>
+          <para>
+            <quote>Vomit</quote>: print vast amounts of debug
+            information.
+          </para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--no-build-output</option> / <option>-Q</option></term>
+  <listitem>
+    <para>
+      By default, output written by builders to standard output and
+      standard error is echoed to the Nix command's standard error.
+      This option suppresses this behaviour.  Note that the builder's
+      standard output and error are always written to a log file in
+      <filename><replaceable>prefix</replaceable>/nix/var/log/nix</filename>.
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--max-jobs</option> / <option>-j</option></term>
+  <listitem>
+    <para>
+      Sets the maximum number of build jobs that Nix will perform in
+      parallel to the specified number.  The default is 1.  A higher
+      value is useful on SMP systems or to exploit I/O latency.
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--keep-going</option> / <option>-k</option></term>
+  <listitem>
+    <para>
+      Keep going in case of failed builds, to the greatest extent
+      possible.  That is, if building an input of some derivation
+      fails, Nix will still build the other inputs, but not the
+      derivation itself.  Without this option, Nix stops if any build
+      fails (except for builds of substitutes), possibly killing
+      builds in progress (in case of parallel or distributed builds).
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--keep-failed</option> / <option>-K</option></term>
+  <listitem>
+    <para>
+      Specifies that in case of a build failure, the temporary
+      directory (usually in <filename>/tmp</filename>) in which the
+      build takes place should not be deleted.  The path of the build
+      directory is printed as an informational message.
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--fallback</option></term>
+  <listitem>
+    <para>
+      Whenever Nix attempts to realise a derivation for which a
+      closure is already known, but this closure cannot be realised,
+      fall back on normalising the derivation.
+    </para>
+
+    <para>
+      The most common scenario in which this is useful is when we have
+      registered substitutes in order to perform binary distribution
+      from, say, a network repository.  If the repository is down, the
+      realisation of the derivation will fail.  When this option is
+      specified, Nix will build the derivation instead.  Thus,
+      binary installation falls back on a source installation.  This
+      option is not the default since it is generally not desirable
+      for a transient failure in obtaining the substitutes to lead to
+      a full build from source (with the related consumption of
+      resources).
+    </para>
+  </listitem>
+</varlistentry>
+
+
+<varlistentry>
+  <term><option>--readonly-mode</option></term>
+  <listitem>
+    <para>
+      When this option is used, no attempt is made to open the Nix
+      database.  Most Nix operations do need database access, so those
+      operations will fail.
+    </para>
+  </listitem>
+</varlistentry>

doc/manual/package-management.xml

@@ -0,0 +1,455 @@
+<chapter id='chap-package-management'><title>Package Management</title>
+
+<para>This chapter discusses how to do package management with Nix,
+i.e., how to obtain, install, upgrade, and erase components.  This is
+the <quote>user's</quote> perspective of the Nix system — people
+who want to <emphasis>create</emphasis> components should consult
+<xref linkend='chap-writing-nix-expressions' />.</para>
+
+
+<sect1><title>Basic package management</title>
+
+<para>The main command for package management is
+<command>nix-env</command>.  You can use it to install, upgrade, and
+erase components, and to query what components are installed or are
+available for installation.</para>
+
+<para>In Nix, different users can have different <quote>views</quote>
+on the set of installed applications.  That is, there might be lots of
+applications present on the system (possibly in many different
+versions), but users can have a specific selection of those active —
+where <quote>active</quote> just means that it appears in a directory
+in the user's <envar>PATH</envar>.  Such a view on the set of
+installed applications is called a <emphasis>user
+environment</emphasis>, which is just a directory tree consisting of
+symlinks to the files of the active applications.  </para>
+
+<para>Components are installed from a set of <emphasis>Nix
+expressions</emphasis> that tell Nix how to build those components,
+including, if necessary, their dependencies.  There is a collection of
+Nix expressions called the Nix Package collection that contains
+components ranging from basic development stuff such as GCC and Glibc,
+to end-user applications like Mozilla Firefox.  (Nix is however not
+tied to the Nix Package collection; you could write your own Nix
+expression based on it, or completely new ones.)  You can download the
+latest version from <ulink
+url='http://catamaran.labs.cs.uu.nl/dist/nix' />.  You probably want
+the latest unstable release; currently the stable releases tend to lag
+behind quite a bit.</para>
+
+<para>Assuming that you have downloaded and unpacked a release of Nix
+Packages, you can view the set of available components in the release:
+
+<screen>
+$ nix-env -qaf nixpkgs-<replaceable>version</replaceable>
+ant-blackdown-1.4.2
+aterm-2.2
+bash-3.0
+binutils-2.15
+bison-1.875d
+blackdown-1.4.2
+bzip2-1.0.2
+...</screen>
+
+where <literal>nixpkgs-<replaceable>version</replaceable></literal> is
+where you've unpacked the release.</para>
+
+<para>It is also possible to see the <emphasis>status</emphasis> of
+available components, i.e., whether they are installed into the user
+environment and/or present in the system:
+
+<screen>
+$ nix-env -qasf nixpkgs-<replaceable>version</replaceable>
+...
+-PS bash-3.0
+--S binutils-2.15
+IPS bison-1.875d
+...</screen>
+
+The first character (<literal>I</literal>) indicates whether the
+component is installed in your current user environment.  The second
+(<literal>P</literal>) indicates whether it is present on your system
+(in which case installing it into your user environment would be a
+very quick operation).  The last one (<literal>S</literal>) indicates
+whether there is a so-called <emphasis>substitute</emphasis> for the
+component, which is Nix's mechanism for doing binary deployment.  It
+just means that Nix know that it can fetch a pre-built component from
+somewhere (typically a network server) instead of building it
+locally.</para>
+
+<para>So now that we have a set of Nix expressions we can build the
+components contained in them.  This is done using <literal>nix-env
+-i</literal>.  For instance,
+
+<screen>
+$ nix-env -f nixpkgs-<replaceable>version</replaceable> -i subversion</screen>
+
+will install the component called <literal>subversion</literal> (which
+is, of course, the <ulink
+url='http://subversion.tigris.org/'>Subversion version management
+system</ulink>).</para>
+
+<para>When you do this for the first time, Nix will start building
+Subversion and all its dependencies.  This will take quite a while —
+typically an hour or two on modern machines.  Fortunately, there is a
+faster way (so do a Ctrl-C on that install operation!): you just need
+to tell Nix that pre-built binaries of all those components are
+available somewhere.  This is done using the
+<command>nix-pull</command> command, which must be supplied with a URL
+containing a <emphasis>manifest</emphasis> describing what binaries
+are available.  This URL should correspond to the Nix Packages release
+that you're using.  For instance, if you obtained a release from
+<ulink
+url='http://catamaran.labs.cs.uu.nl/dist/nix/nixpkgs-0.6pre1554/' />,
+then you should do:
+
+<screen>
+$ nix-pull http://catamaran.labs.cs.uu.nl/dist/nix/nixpkgs-0.6pre1554/MANIFEST</screen>
+
+If you then issue the installation command, it should start
+downloading binaries from <systemitem
+class='fqdomainname'>catamaran.labs.cs.uu.nl</systemitem>, instead of
+building them from source.  This might still take a while since all
+dependencies must be downloaded, but on a reasonably fast connection
+such as an DSL line it's on the order of a few minutes.</para>
+
+<para>Naturally, packages can also be uninstalled:
+
+<screen>
+$ nix-env -e subversion</screen>
+
+</para>
+
+<para>Upgrading to a new version is just as easy.  If you have a new
+release of Nix Packages, you can do:
+
+<screen>
+$ nix-env -f nixpkgs-<replaceable>version</replaceable> -u subversion</screen>
+
+This will <emphasis>only</emphasis> upgrade Subversion if there is a
+<quote>newer</quote> version in the new set of Nix expressions, as
+defined by some pretty arbitrary rules regarding ordering of version
+numbers (which generally do what you'd expect of them).  To just
+unconditionally replace Subversion with whatever version is in the Nix
+expressions, use <parameter>-i</parameter> instead of
+<parameter>-u</parameter>; <parameter>-i</parameter> will remove
+whatever version is already installed.</para>
+
+<para>You can also upgrade all components for which there are newer
+versions:
+
+<screen>
+$ nix-env -f nixpkgs-<replaceable>version</replaceable> -u '*'</screen>
+
+</para>
+
+<para>Sometimes it's useful to be able to ask what
+<command>nix-env</command> would do, without actually doing it.  For
+instance, to find out what packages would be upgraded by
+<literal>nix-env -u '*'</literal>, you can do
+
+<screen>
+$ nix-env ... -u '*' --dry-run
+(dry run; not doing anything)
+upgrading `libxslt-1.1.0' to `libxslt-1.1.10'
+upgrading `graphviz-1.10' to `graphviz-1.12'
+upgrading `coreutils-5.0' to `coreutils-5.2.1'</screen>
+
+</para>
+
+<para>If you grow bored of specifying the Nix expressions using
+<parameter>-f</parameter> all the time, you can set a default
+location:
+
+<screen>
+$ nix-env -I nixpkgs-<replaceable>version</replaceable></screen>
+
+After this you can just say, for instance, <literal>nix-env -u
+'*'</literal>.<footnote><para>Setting a default using
+<parameter>-I</parameter> currently clashes with using Nix channels,
+since <literal>nix-channel --update</literal> calls <literal>nix-env
+-I</literal> to set the default to the Nix expressions it downloaded
+from the channel, replacing whatever default you had
+set.</para></footnote></para>
+
+</sect1>
+
+
+<sect1><title>Profiles</title>
+
+<para>Profiles and user environments are Nix's mechanism for
+implementing the ability to allow differens users to have different
+configurations, and to do atomic upgrades and rollbacks.  To
+understand how they work, it's useful to know a bit about how Nix
+works.  In Nix, components are stored in unique locations in the
+<emphasis>Nix store</emphasis> (typically,
+<filename>/nix/store</filename>).  For instance, a particular version
+of the Subversion component might be stored in a directory
+<filename>/nix/store/eeeeaf42e56b...-subversion-0.32.1/</filename>,
+while another version might be stored in
+<filename>/nix/store/58823d558a6a...-subversion-0.34/</filename>.  The
+long hexadecimal numbers prefixed to the directory names are
+cryptographic hashes<footnote><para>128 bit MD5 hashes, to be
+precise.</para></footnote> of <emphasis>all</emphasis> inputs involved
+in building the component — sources, dependencies, compiler flags, and
+so on.  So if two components differ in any way, they end up in
+different locations in the file system, so they don't interfere with
+each other.  <xref linkend='fig-user-environments'
+/><footnote><para>TODO: the figure isn't entirely up to date.  It
+should show multiple profiles and
+<filename>~/.nix-profile</filename>.</para></footnote> shows a part of
+a typical Nix store.</para>
+
+<figure id='fig-user-environments'><title>User environments</title>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref='figures/user-environments.png' format='PNG' />
+    </imageobject>
+  </mediaobject>
+</figure>
+
+<para>Of course, you wouldn't want to type
+
+<screen>
+$ /nix/store/eeeeaf42e56b...-subversion-0.32.1/bin/svn</screen>
+
+every time you want to run Subversion.  Of course we could set up the
+<envar>PATH</envar> environment variable to include the
+<filename>bin</filename> directory of every component we want to use,
+but this is not very convenient since changing <envar>PATH</envar>
+doesn't take effect for already existing processes.  The solution Nix
+uses is to create directory trees of symlinks to
+<emphasis>activated</emphasis> components.  These are called
+<emphasis>user environments</emphasis> and they are components
+themselves (though automatically generated by
+<command>nix-env</command>), so they too reside in the Nix store.  For
+instance, in <xref linkend='fig-user-environments' /> the user
+environment <filename>/nix/store/068150f63831...-user-env</filename>
+contains a symlink to just Subversion 0.32.1 (arrows in the figure
+indicate symlinks).  This would be what we would obtain if we had done
+
+<screen>
+$ nix-env -i subversion</screen>
+
+on a set of Nix expressions that contained Subversion 0.32.1.</para>
+
+<para>This doesn't in itself solve the problem, of course; you
+wouldn't want to type
+<filename>/nix/store/068150f63831...-user-env/bin/svn</filename>
+either.  Therefore there are symlinks outside of the store that point
+to the user environments in the store; for instance, the symlinks
+<filename>42</filename> and <filename>43</filename> in the example.
+These are called <emphasis>generations</emphasis> since every time you
+perform a <command>nix-env</command> operation, a new user environment
+is generated based on the current one.  For instance, generation 43
+was created from generation 42 when we did
+
+<screen>
+$ nix-env -i subversion mozilla</screen>
+
+on a set of Nix expressions that contained Mozilla and a new version
+of Subversion.</para>
+
+<para>Generations are grouped together into
+<emphasis>profiles</emphasis> so that different users don't interfere
+with each other if they don't want to.  For example:
+
+<screen>
+$ ls -l /nix/var/nix/profiles/
+...
+lrwxrwxrwx  1 eelco ... default-42-link -> /nix/store/068150f63831...-user-env
+lrwxrwxrwx  1 eelco ... default-43-link -> /nix/store/84c85f89ddbf...-user-env
+lrwxrwxrwx  1 eelco ... default -> default-43-link</screen>
+
+This shows a profile called <filename>default</filename>.  The file
+<filename>default</filename> itself is actually a symlink that points
+to the current generation.  When we do a <command>nix-env</command>
+operation, a new user environment and generation link are created
+based on the current one, and finally the <filename>default</filename>
+symlink is made to point at the new generation.  This last step is
+atomic on Unix, which explains how we can do atomic upgrades.  (Note
+that the building/installing of new components doesn't interfere in
+any way with old components, since they are stored in different
+locations in the Nix store.)</para>
+
+<para>If you find that you want to undo a <command>nix-env</command>
+operation, you can just do
+
+<screen>
+$ nix-env --rollback</screen>
+
+which will just make the current generation link point at the previous
+link.  E.g., <filename>default</filename> would be made to point at
+<filename>default-42-link</filename>.  You can also switch to a
+specific generation:
+
+<screen>
+$ nix-env --switch-generation 43</screen>
+
+which in this example would roll forward to generation 43 again.  You
+can also see all available generations:
+
+<screen>
+$ nix-env --list-generations</screen></para>
+
+<para>Actually, there is another level of indirection not shown in the
+figure above.  You generally wouldn't have
+<filename>/nix/var/nix/profiles/<replaceable>some-profile</replaceable>/bin</filename>
+in your <envar>PATH</envar>.  Rather, there is a symlink
+<filename>~/.nix-profile</filename> that points to your current
+profile.  This means that you should put
+<filename>~/.nix-profile/bin</filename> in your <envar>PATH</envar>
+(and indeed, that's what the initialisation script
+<filename>/nix/etc/profile.d/nix.sh</filename> does).  This makes it
+easier to switch to a different profile.  You can do that using the
+command <command>nix-env --switch-profile</command>:
+
+<screen>
+$ nix-env --switch-profile /nix/var/nix/profiles/my-profile
+
+$ nix-env --switch-profile /nix/var/nix/profiles/default</screen>
+
+These commands switch to the <filename>my-profile</filename> and
+default profile, respectively.  If the profile doesn't exist, it will
+be created automatically.  You should be careful about storing a
+profile in another location than the <filename>profiles</filename>
+directory, since otherwise it might not be used as a root of the
+garbage collector (see section <xref linkend='sec-garbage-collection'
+/>).</para>
+
+<para>All <command>nix-env</command> operations work on the profile
+pointed to by <command>~/.nix-profile</command>, but you can override
+this using the <option>--profile</option> option (abbreviation
+<option>-p</option>):
+
+<screen>
+$ nix-env -p /nix/var/nix/profiles/other-profile -i subversion</screen>
+
+This will <emphasis>not</emphasis> change the
+<command>~/.nix-profile</command> symlink.</para>
+
+</sect1>
+
+
+<sect1 id='sec-garbage-collection'><title>Garbage collection</title>
+
+<para><command>nix-env</command> operations such as upgrades
+(<option>-u</option>) and uninstall (<option>-e</option>) never
+actually delete components from the system.  All they do (as shown
+above) is to create a new user environment that no longer contains
+symlinks to the <quote>deleted</quote> components.</para>
+
+<para>Of course, since disk space is not infinite, unused components
+should be removed at some point.  You can do this by running the Nix
+garbage collector.  It will remove from the Nix store any component
+not used (directly or indirectly) by any generation of any
+profile.</para>
+
+<para>Note however that as long as old generations reference a
+component, it will not be deleted.  After all, we wouldn't be able to
+do a rollback otherwise.  So in order for garbage collection to be
+effective, you should also delete (some) old generations.  Of course,
+this should only be done if you are certain that you will not need to
+roll back.</para>
+
+<para>To delete all old (non-current) generations of your current
+profile:
+
+<screen>
+$ nix-env --delete-generations old</screen>
+
+Instead of <literal>old</literal> you can also specify a list of
+generations, e.g.,
+
+<screen>
+$ nix-env --delete-generations 10 11 14</screen>
+
+</para>
+
+<para>After removing appropriate old generations you can run the
+garbage collector as follows:
+
+<screen>
+$ nix-collect-garbage</screen>
+
+You can alo first view what files would be deleted:
+
+<screen>
+$ nix-collect-garbage --print-dead</screen>
+
+Likewise, the option <option>--print-live</option> will show the paths
+that <emphasis>won't</emphasis> be deleted.</para>
+
+<sect2><title>Garbage collector roots</title>
+
+<para>TODO</para>
+
+<para>The garbage collector uses as roots all store expressions
+mentioned in all files with extension <filename>.gcroot</filename> in
+the directory
+<filename><replaceable>prefix</replaceable>/var/nix/gcroots/</filename>,
+or in any file or directory symlinked to from that directory.  E.g.,
+by default,
+<filename><replaceable>prefix</replaceable>/var/nix/gcroots/</filename>
+contains a symlink to
+<filename><replaceable>prefix</replaceable>/var/nix/profiles/</filename>,
+so all generations of all profiles are also roots of the collector.</para>
+
+</sect2>
+
+</sect1>
+
+
+<sect1><title>Channels</title>
+
+<para>If you want to stay up to date with a set of packages, it's not
+very convenient to manually download the latest set of Nix expressions
+for those packages, use <command>nix-pull</command> to register
+pre-built binaries (if available), and upgrade using
+<command>nix-env</command>.  Fortunately, there's a better way:
+<emphasis>Nix channels</emphasis>.</para>
+
+<para>A Nix channel is just a URL that points to a place that contains
+a set of Nix expressions and a manifest.  Using the command
+<command>nix-channel</command> you can automatically stay up to date
+with whatever is available at that URL.</para>
+
+<para>You can <quote>subscribe</quote> to a channel using
+<command>nix-channel --add</command>, e.g.,
+
+<screen>
+$ nix-channel --add http://catamaran.labs.cs.uu.nl/dist/nix/channels/nixpkgs-unstable</screen>
+
+subscribes you to a channel that always contains that latest version
+of the Nix Packages collection.  (Instead of
+<literal>nixpkgs-unstable</literal> you could also subscribe to
+<literal>nixpkgs-stable</literal>, which should have a higher level of
+stability, but right now is just outdated.)  Subscribing really just
+means that the URL is added to the file
+<filename>~/.nix-channels</filename>.  Right now there is no command
+to <quote>unsubscribe</quote>; you should just edit that file manually
+and delete the offending URL.</para>
+
+<para>To obtain the latest Nix expressions available in a channel, do
+
+<screen>
+$ nix-channel --update</screen>
+
+This downloads the Nix expressions in every channel (downloaded from
+<literal><replaceable>url</replaceable>/nixexprs.tar.bz2</literal>)
+and registers any available pre-built binaries in every channel
+(by <command>nix-pull</command>ing
+<literal><replaceable>url</replaceable>/MANIFEST</literal>).  It also
+makes the union of each channel's Nix expressions the default for
+<command>nix-env</command> operations.  Consequently, you can then say
+
+<screen>
+$ nix-env -u '*'</screen>
+
+to upgrade all components in your profile to the latest versions
+available in the subscribed channels.</para>
+
+</sect1>
+
+
+</chapter>

doc/manual/quick-start.xml

@@ -0,0 +1,118 @@
+<chapter><title>Quick Start</title>
+
+<para>This chapter is for impatient people who don't like reading
+documentation.  For more in-depth information you are kindly referred
+to the following chapters.</para>
+
+<orderedlist>
+
+<listitem><para>Download a source tarball or RPM from <ulink
+url='http://www.cs.uu.nl/groups/ST/Trace/Nix'/>.  Build source
+distributions using the regular sequence:
+        
+<screen>
+$ tar xvfj nix-<replaceable>version</replaceable>.tar.bz2
+$ ./configure
+$ make
+$ make install <lineannotation>(as root)</lineannotation></screen>
+
+This will install Nix in <filename>/nix</filename>.  You shouldn't
+change the prefix if at all possible since that will make it
+impossible to use our pre-built components.  Alternatively, you could
+grab an RPM if you're on an RPM-based system.  You should also add
+<filename>/nix/etc/profile.d/nix.sh</filename> to your
+<filename>~/.bashrc</filename> (or some other login
+file).</para></listitem>
+
+<listitem><para>Subscribe to the Nix Packages channel.
+
+<screen>
+$ nix-channel --add http://catamaran.labs.cs.uu.nl/dist/nix/channels/nixpkgs-unstable</screen>
+
+</para></listitem>
+
+<listitem><para>Download the latest Nix expressions available in the channel.
+<screen>
+$ nix-channel --update</screen>
+
+Note that this in itself doesn't download any components, it just
+downloads the Nix expressions that build them and stores them
+somewhere (under <filename>~/.nix-defexpr</filename>, in case you're
+curious).  Also, it registers the fact that pre-built binaries are
+available remotely.</para></listitem>
+
+<listitem><para>See what installable components are currently
+available in the channel:
+
+<screen>
+$ nix-env -qa
+docbook-xml-4.2
+firefox-1.0pre-PR-0.10.1
+hello-2.1.1
+libxslt-1.1.0
+<replaceable>...</replaceable></screen>
+
+</para></listitem>
+
+<listitem><para>Install some components from the channel:
+        
+<screen>
+$ nix-env -i hello firefox <replaceable>...</replaceable> </screen>
+
+This should download the pre-built components; it should not build
+them locally (if it does, something went wrong).</para></listitem>
+
+<listitem><para>Test that they work:
+
+<screen>
+$ which hello
+/home/eelco/.nix-profile/bin/hello
+$ hello
+Hello, world!
+$ firefox
+<lineannotation>(read Slashdot or something)</lineannotation></screen>
+
+</para></listitem>
+    
+<listitem><para>Uninstall a package:
+
+<screen>
+$ nix-env -e hello</screen>
+
+</para></listitem>
+
+<listitem><para>To keep up-to-date with the channel, do:
+
+<screen>
+$ nix-channel --update
+$ nix-env -u '*'</screen>
+
+The latter command will upgrade each installed component for which
+there is a <quote>newer</quote> version (as determined by comparing
+the version numbers).</para></listitem>
+
+<listitem><para>If you're unhappy with the result of a
+<command>nix-env</command> action (e.g., an upgraded component turned
+out not to work properly), you can go back:
+
+<screen>
+$ nix-env --rollback</screen>
+
+</para></listitem>
+
+<listitem><para>You should periodically run the Nix garbage collector
+to get rid of unused packages, since uninstalls or upgrades don't
+actually delete them:
+
+<screen>
+$ nix-env --delete-generations old
+$ nix-collect-garbage</screen>
+
+The first command deletes old <quote>generations</quote> of your
+profile (making rollbacks impossible, but also making the components
+in those old generations available for garbage collection), while the
+second command actually deletes them.</para></listitem>
+
+</orderedlist>
+
+</chapter>

doc/manual/schemas.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<locatingRules xmlns="http://thaiopensource.com/ns/locating-rules/1.0">
+  <uri pattern="*.xml" typeId="DocBook"/>
+</locatingRules>

doc/manual/style.css

@@ -0,0 +1,232 @@
+/* Copied from http://bakefile.sourceforge.net/, which appears
+   licensed under the GNU GPL. */
+
+
+/***************************************************************************
+                             Basic headers and text:
+ ***************************************************************************/
+
+body
+{
+    font-family: sans-serif;
+    background: white;
+  
+    margin: 2em 1em 2em 1em;
+}
+
+h1,h2,h3
+{
+    color: #005aa0;
+    text-align: left;
+}
+
+h1 /* title */
+{
+    font-size: 200%;
+}
+
+h2 /* chapters, appendices, subtitle */
+{
+    font-size: 180%;
+}
+
+/* Extra space between chapters, appendices. */
+div.chapter > div.titlepage h2, div.appendix > div.titlepage h2 
+{ 
+    margin-top: 1.5em;
+/*    border-top: solid #005aa0; */
+}
+
+div.sect1 h2 /* sections */
+{
+    font-size: 150%;
+}
+
+div.refnamediv h2, div.refsynopsisdiv h2, div.refsection h2 /* refentry parts */
+{
+    font-size: 125%;
+}
+
+div.refsection h3
+{
+    font-size: 110%;
+}
+
+h3 /* subsections */
+{
+    font-size: 125%;
+}
+
+
+
+/***************************************************************************
+                               Program listings:
+ ***************************************************************************/
+
+div.example
+{
+    border: 1px solid #6185a0;
+    padding: 6px 6px;
+    margin-left: 3em;
+    margin-right: 3em;
+    background: #eeeeee;
+}
+
+pre.programlisting
+{
+    color: #600000;
+    font-family: monospace;
+}
+
+
+/***************************************************************************
+                            Screen dumps:
+ ***************************************************************************/
+
+pre.screen
+{
+    border: 1px solid #6185a0;
+    padding: 6px 6px;
+    margin-left: 3em;
+    margin-right: 3em;
+    color: #600000;
+    background: #eeeeee;
+    font-family: monospace;
+    /* font-size: 90%; */
+}
+
+
+/***************************************************************************
+                               Notes, warnings etc:
+ ***************************************************************************/
+
+.note,.warning
+{
+    border: 1px solid #6185a0;
+    padding: 0px 1em;
+    background: #fffff5;
+}
+
+div.note,div.warning
+{
+    font-style: italic;
+}
+
+div.warning h3
+{
+    color: red;
+    font-size: 100%;
+}
+
+div.note h3
+{
+    color: blue;
+    font-size: 100%;
+}
+
+div.navfooter *
+{
+    font-size: 90%;
+}
+
+
+/***************************************************************************
+                        Links colors and highlighting: 
+ ***************************************************************************/
+
+a:link { color: #0048b3; }
+a:visited { color: #002a6a; }
+a:hover { background: #ffffcd; }
+
+
+/***************************************************************************
+                              Table of contents:
+ ***************************************************************************/
+
+.toc
+{
+    font-size: 90%;
+}
+
+
+
+/***************************************************************************
+                               Special elements:
+ ***************************************************************************/
+
+tt
+{
+    color: #400000;
+}
+
+.term
+{
+    font-weight: bold;
+    
+}
+
+div.variablelist dd
+{
+    margin-bottom: 1em;
+}
+
+.default
+{
+    font-style: italic;
+}
+
+.availability
+{
+    font-style: italic;
+}
+
+.varname
+{
+    color: #400000;
+}
+
+
+div.informaltable table
+{
+  border: 1px solid #6185a0;
+  width: 100%;
+}
+
+div.informaltable td
+{
+  border: 0;
+  padding: 5px;
+}
+
+div.informaltable td.default
+{
+  text-align: right;
+}
+
+div.informaltable th
+{
+  text-align: left;
+  color: #005aa0;
+  border: 0;
+  padding: 5px;
+  background: #fffff5;
+  font-weight: normal;
+  font-style: italic;
+}
+
+td.varname, td.tagname, td.paramname
+{
+  font-weight: bold;
+  vertical-align: top;
+}
+
+div.epigraph
+{
+    font-style: italic;
+    text-align: right;
+}
+
+table.productionset table.productionset
+{
+    font-family: monospace;
+}

doc/manual/troubleshooting.xml

@@ -1,43 +1,9 @@
 <appendix>
   <title>Troubleshooting</title>
 
-  <sect1>
-    <title>Database hangs</title>
-
-    <para>
-      If Nix or Fix appear to hang immediately after they are started, Nix's
-      database is probably <quote>wedged</quote>, i.e., some process died while
-      it held a lock on the database.  The solution is to ensure that no other
-      processes are accessing the database and then run the following command:
-    </para>
-
-    <screen>
-      $ db_recover -e -h <replaceable>prefix</replaceable>/var/nix/db</screen>
-
-    <para>
-      Here, <replaceable>prefix</replaceable> should be replaced by Nix's
-      installation prefix.
-    </para>
-
-  </sect1>
-
-
-  <sect1>
-    <title>Database logfile removal</title>
-
-    <para>
-      Every time a Nix database transaction takes place, Nix writes a record of
-      this transaction to a <emphasis>log</emphasis> in its database directory
-      to ensure that the operation can be replayed in case of a application or
-      system crash.  However, without manual intervention, the log grows
-      indefinitely.  Hence, unused log files should be deleted periodically.
-      This can be accomplished using the following command:
-    </para>
-
-    <screen>
-      $ rm `db_archive -a -h <replaceable>prefix</replaceable>/var/nix/db`</screen>
-
-  </sect1>
+  <para>
+    (Nothing.)
+  </para>
 	
 </appendix>
 

externals/Makefile.am

@@ -1,11 +1,11 @@
 # Berkeley DB
 
-DB = db-4.1.25
+DB = db-4.2.52
 
 $(DB).tar.gz:
 	@echo "Nix requires Berkeley DB to build."
-	@echo "Please download version 4.1.25 from"
-	@echo "  http://www.sleepycat.com/update/snapshot/db-4.1.25.tar.gz"
+	@echo "Please download version 4.2.52 from"
+	@echo "  http://www.sleepycat.com/update/snapshot/db-4.2.52.tar.gz"
 	@echo "and place it in the externals/ directory."
 	false
 
@@ -16,25 +16,30 @@ have-db:
 	$(MAKE) $(DB)
 	touch have-db
 
+if HAVE_BDB
+build-db:
+else
 build-db: have-db
 	(pfx=`pwd` && \
 	cd $(DB)/build_unix && \
 	CC="$(CC)" CXX="$(CXX)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" \
-     ../dist/configure --prefix=$$pfx/inst \
-	 --enable-cxx --disable-shared && \
+	 ../dist/configure --prefix=$$pfx/inst-bdb \
+	 --enable-cxx --disable-shared --disable-cryptography \
+         --disable-replication --disable-verify && \
 	make && \
 	make install)
 	touch build-db
+endif
 
 
 # CWI ATerm
 
-ATERM = aterm-2.0.5
+ATERM = aterm-2.3.1
 
 $(ATERM).tar.gz:
 	@echo "Nix requires the CWI ATerm library to build."
-	@echo "Please download version 2.0.5 from"
-	@echo "  http://www.cwi.nl/projects/MetaEnv/aterm/aterm-2.0.5.tar.gz"
+	@echo "Please download version 2.3.1 from"
+	@echo "  http://www.cwi.nl/projects/MetaEnv/aterm/aterm-2.3.1.tar.gz"
 	@echo "and place it in the externals/ directory."
 	false
 
@@ -45,47 +50,23 @@ have-aterm:
 	$(MAKE) $(ATERM)
 	touch have-aterm
 
+if HAVE_ATERM
+build-aterm:
+else
 build-aterm: have-aterm
 	(pfx=`pwd` && \
 	cd $(ATERM) && \
-	CC="$(CC)" ./configure --prefix=$$pfx/inst \
-     --with-cflags="-DNDEBUG -DXGC_VERBOSE -DXHASHPEM -DWITH_STATS $(CFLAGS)" && \
+	CC="$(CC)" ./configure --prefix=$$pfx/inst-aterm && \
 	make && \
 	make install)
 	touch build-aterm
+endif
 
 
-# SDF bundle
+all: build-db build-aterm
 
-SDF2 = sdf2-bundle-1.6
-
-$(SDF2).tar.gz:
-	@echo "Nix requires the SDF2 bundle to build."
-	@echo "Please download version 1.6 from"
-	@echo "  ftp://ftp.stratego-language.org/pub/stratego/sdf2/sdf2-bundle-1.6.tar.gz"
-	@echo "and place it in the externals/ directory."
-	false
-
-$(SDF2): $(SDF2).tar.gz
-	gunzip < $(SDF2).tar.gz | tar xvf -
-
-have-sdf2:
-	$(MAKE) $(SDF2)
-	touch have-sdf2
-
-build-sdf2: have-sdf2
-	(pfx=`pwd` && \
-	cd $(SDF2) && \
-	CC="$(CC) -pg" ./configure --prefix=$$pfx/inst --with-cflags="$(CFLAGS)" && \
-	make && \
-	make install)
-	touch build-sdf2
-
-
-all: build-db build-aterm build-sdf2
-
-EXTRA_DIST = $(DB).tar.gz $(ATERM).tar.gz $(SDF2).tar.gz
+EXTRA_DIST = $(DB).tar.gz $(ATERM).tar.gz
 
 ext-clean:
-	$(RM) -f have-db build-db have-aterm build-aterm have-sdf2 build-sdf2
-	$(RM) -rf $(DB) $(ATERM) $(SDF2)
+	$(RM) -f have-db build-db have-aterm build-aterm
+	$(RM) -rf $(DB) $(ATERM)

misc/Makefile.am

@@ -0,0 +1 @@
+SUBDIRS = emacs

misc/emacs/Makefile.am

@@ -0,0 +1,5 @@
+EXTRA_DIST = nix-mode.el
+
+install-data-local:
+	$(INSTALL) -d $(DESTDIR)$(datadir)/emacs/site-lisp
+	$(INSTALL_DATA) nix-mode.el $(DESTDIR)$(datadir)/emacs/site-lisp

misc/emacs/README

@@ -0,0 +1,10 @@
+The Nix Emacs mode supports syntax highlighting, somewhat sensible
+indenting, and refilling of comments.
+
+To enable Nix mode in Emacs, add something like this to your ~/.emacs
+file:
+
+  (load "/nix/share/emacs/site-lisp/nix-mode.el")
+
+This automatically causes Nix mode to be activated for all files with
+extension `.nix'.

misc/emacs/nix-mode.el

@@ -0,0 +1,109 @@
+(defun nix-mode ()
+  "Major mode for editing Nix expressions.
+
+The following commands may be useful:
+
+  '\\[newline-and-indent]'
+    Insert a newline and move the cursor to align with the previous
+    non-empty line.
+
+  '\\[fill-paragraph]'
+    Refill a paragraph so that all lines are at most `fill-column'
+    lines long.  This should do the right thing for comments beginning
+    with `#'.  However, this command doesn't work properly yet if the
+    comment is adjacent to code (i.e., no intervening empty lines).
+    In that case, select the text to be refilled and use
+    `\\[fill-region]' instead.
+
+The hook `nix-mode-hook' is run when Nix mode is started.
+
+\\{nix-mode-map}
+"
+
+  (interactive)
+  
+  (kill-all-local-variables)
+  
+  (setq major-mode 'nix-mode)
+  (setq mode-name "Nix")
+
+  (use-local-map nix-mode-map)
+
+  (set-syntax-table nix-mode-syntax-table)
+
+  ;; Font lock support.
+  (setq font-lock-defaults '(nix-keywords nil nil nil nil))
+
+  ;; Automatic indentation [C-j].
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'nix-indent-line)
+
+  ;; Indenting of comments.
+  (make-local-variable 'comment-start)
+  (setq comment-start "# ")
+  (make-local-variable 'comment-end)
+  (setq comment-end "")
+  (make-local-variable 'comment-start-skip)
+  (setq comment-start-skip "\\(^\\|\\s-\\);?#+ *")
+
+  ;; Filling of comments.
+  (make-local-variable 'adaptive-fill-mode)
+  (setq adaptive-fill-mode t)
+  (make-local-variable 'paragraph-start)
+  (setq paragraph-start "[ \t]*\\(#+[ \t]*\\)?$")
+  (make-local-variable 'paragraph-separate)
+  (setq paragraph-separate paragraph-start)
+  
+  (run-hooks 'nix-mode-hook)
+  )
+
+
+(defvar nix-mode-map nil
+  "Keymap for Nix mode.")
+
+(setq nix-mode-map (make-sparse-keymap))
+;(define-key nix-mode-map [tab] 'tab-to-tab-stop)
+
+
+(defvar nix-keywords
+  '("\\<if\\>" "\\<then\\>" "\\<else\\>" "\\<assert\\>"
+    "\\<let\\>" "\\<rec\\>" "\\<inherit\\>"
+    ("\\<true\\>" . font-lock-builtin-face)
+    ("\\<false\\>" . font-lock-builtin-face)
+    ("\\<null\\>" . font-lock-builtin-face)
+    ("\\<import\\>" . font-lock-builtin-face)
+    ("\\<derivation\\>" . font-lock-builtin-face)
+    ("\\<baseNameOf\\>" . font-lock-builtin-face)
+    ("\\<toString\\>" . font-lock-builtin-face)
+    ("\\<isNull\\>" . font-lock-builtin-face)
+    ("\\<\\([a-zA-Z_][a-zA-Z0-9_']*\\)[ \t]*="
+     (1 font-lock-variable-name-face nil nil))
+    ("[a-zA-Z][a-zA-Z0-9\\+-\\.]*:[a-zA-Z0-9%/\\?:@&=\\+\\$,_\\.!~\\*'-]+"
+     . font-lock-constant-face)
+    ("[a-zA-Z0-9._\\+-]*\\(/[a-zA-Z0-9._\\+-]+\\)+"
+     . font-lock-constant-face)
+    ))
+
+
+(defvar nix-mode-syntax-table nil
+  "Syntax table for Nix mode.")
+
+(if nix-mode-syntax-table
+    nil
+    (progn
+      (setq nix-mode-syntax-table (make-syntax-table))
+      (modify-syntax-entry ?/ ". 14" nix-mode-syntax-table)
+      (modify-syntax-entry ?* ". 23" nix-mode-syntax-table)
+      (modify-syntax-entry ?# "< b" nix-mode-syntax-table)
+      (modify-syntax-entry ?\n "> b" nix-mode-syntax-table)
+      ))
+
+
+(defun nix-indent-line ()
+  "Indent current line in a Nix expression."
+  (interactive)
+  (indent-relative-maybe))
+
+
+(setq auto-mode-alist (cons '("\\.nix\\'" . nix-mode) auto-mode-alist))
+(setq auto-mode-alist (cons '("\\.nix.in\\'" . nix-mode) auto-mode-alist))

nix.spec.in

@@ -0,0 +1,77 @@
+%define enable_setuid ""
+%define nix_user "nix"
+%define nix_group "nix"
+
+# If set, the Nix user and group will be created by the RPM
+# pre-install script.
+%define nix_user_uid ""
+%define nix_group_gid ""
+
+Summary: The Nix software deployment system
+Name: nix
+Version: @version@
+Release: 1
+License: GPL
+Group: Software Deployment
+URL: http://www.cs.uu.nl/groups/ST/Trace/Nix
+Source0: %{name}-@version@.tar.gz
+BuildRoot: %{_tmppath}/%{name}-%{version}-buildroot
+%define _prefix /nix
+Prefix: %{_prefix}
+Requires: /usr/bin/perl
+
+# Hack to make that shitty RPM scanning hack shut up.
+Provides: perl(readmanifest)
+                                                               
+%description
+
+Nix is a system for software deployment.
+
+%prep
+%setup -q
+
+%build
+extraFlags=
+if test -n "%{enable_setuid}"; then
+    extraFlags="$extraFlags --enable-setuid"
+    if test -n "%{nix_user}"; then
+        extraFlags="$extraFlags --with-nix-user=%{nix_user}"
+    fi
+    if test -n "%{nix_group}"; then
+        extraFlags="$extraFlags --with-nix-group=%{nix_group}"
+    fi
+fi
+./configure --prefix=%{_prefix} $extraFlags
+make
+make check
+
+%install
+rm -rf $RPM_BUILD_ROOT
+make DESTDIR=$RPM_BUILD_ROOT install
+strip $RPM_BUILD_ROOT/%{_prefix}/bin/* || true
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%pre
+if test -n "%{nix_group_gid}"; then
+    /usr/sbin/groupadd -g %{nix_group_gid} %{nix_group} || true
+fi
+if test -n "%{nix_user_uid}"; then
+    /usr/sbin/useradd -c "Nix" -u %{nix_user_uid} \
+        -s /sbin/nologin -r -d /var/empty %{nix_user} \
+        -g %{nix_group} || true
+fi
+
+%files
+#%defattr(-,root,root)
+%{_prefix}/bin
+%{_prefix}/libexec
+%{_prefix}/var
+%{_prefix}/share
+%{_prefix}/man
+%{_prefix}/store
+%config
+%{_prefix}/etc
+#%doc
+#%{_prefix}/share/nix/manual

scripts/Makefile.am

@@ -1,19 +1,25 @@
-bin_SCRIPTS = nix-switch nix-collect-garbage \
- nix-pull nix-push nix-prefetch-url
+bin_SCRIPTS = nix-collect-garbage \
+  nix-pull nix-push nix-prefetch-url \
+  nix-install-package nix-channel nix-build
 
 noinst_SCRIPTS = nix-profile.sh
 
-install-exec-local:
-	$(INSTALL) -d $(sysconfdir)/profile.d
-	$(INSTALL_PROGRAM) nix-profile.sh $(sysconfdir)/profile.d/nix.sh
-	$(INSTALL) -d $(sysconfdir)/nix
-# !!! don't overwrite local modifications
-	$(INSTALL_DATA) prebuilts.conf $(sysconfdir)/nix/prebuilts.conf
+nix-pull nix-push: readmanifest.pm download-using-manifests.pl
+
+install-exec-local: readmanifest.pm download-using-manifests.pl
+	$(INSTALL) -d $(DESTDIR)$(sysconfdir)/profile.d
+	$(INSTALL_PROGRAM) nix-profile.sh $(DESTDIR)$(sysconfdir)/profile.d/nix.sh
+	$(INSTALL) -d $(DESTDIR)$(libexecdir)/nix
+	$(INSTALL_DATA) readmanifest.pm $(DESTDIR)$(libexecdir)/nix 
+	$(INSTALL_PROGRAM) download-using-manifests.pl $(DESTDIR)$(libexecdir)/nix 
+	$(INSTALL) -d $(DESTDIR)$(sysconfdir)/nix
 
 include ../substitute.mk
 
-EXTRA_DIST = nix-switch.in nix-collect-garbage.in \
- nix-pull.in nix-push.in nix-profile.sh.in \
- nix-prefetch-url.in \
- prebuilts.conf
-
+EXTRA_DIST = nix-collect-garbage.in \
+  nix-pull.in nix-push.in nix-profile.sh.in \
+  nix-prefetch-url.in nix-install-package.in \
+  nix-channel.in \
+  readmanifest.pm.in \
+  nix-build.in \
+  download-using-manifests.pl.in

scripts/download-using-manifests.pl.in

@@ -0,0 +1,246 @@
+#! @perl@ -w -I@libexecdir@/nix
+
+use strict;
+use readmanifest;
+
+my $manifestDir = "@localstatedir@/nix/manifests";
+my $logFile = "@localstatedir@/log/nix/downloads";
+
+open LOGFILE, ">>$logFile" or die "cannot open log file $logFile";
+
+
+# Check the arguments.
+die unless scalar @ARGV == 1;
+my $targetPath = $ARGV[0];
+
+my $date = `date`;
+chomp $date;
+print LOGFILE "$$ get $targetPath $date\n";
+
+print "\n*** Trying to download/patch `$targetPath'\n";
+
+
+# Load all manifests.
+my %narFiles;
+my %patches;
+my %successors;
+
+for my $manifest (glob "$manifestDir/*.nixmanifest") {
+#    print STDERR "reading $manifest\n";
+    readManifest $manifest, \%narFiles, \%patches, \%successors;
+}
+
+
+# Build a graph of all store paths that might contribute to the
+# construction of $targetPath, and the special node "start".  The
+# edges are either patch operations, or downloads of full NAR files.
+# The latter edges only occur between "start" and a store path.
+
+my %graph;
+
+$graph{"start"} = {d => 0, pred => undef, edges => []};
+
+my @queue = ();
+my $queueFront = 0;
+my %done;
+
+sub addToQueue {
+    my $v = shift;
+    return if defined $done{$v};
+    $done{$v} = 1;
+    push @queue, $v;
+}
+
+sub addNode {
+    my $u = shift;
+    $graph{$u} = {d => 999999999999, pred => undef, edges => []}
+        unless defined $graph{$u};
+}
+
+sub addEdge {
+    my $u = shift;
+    my $v = shift;
+    my $w = shift;
+    my $type = shift;
+    my $info = shift;
+    addNode $u;
+    push @{$graph{$u}->{edges}},
+        {weight => $w, start => $u, end => $v, type => $type, info => $info};
+    my $n = scalar @{$graph{$u}->{edges}};
+}
+
+addToQueue $targetPath;
+
+sub isValidPath {
+    my $p = shift;
+    system "nix-store --isvalid '$p' 2> /dev/null";
+    return $? == 0;
+}
+
+while ($queueFront < scalar @queue) {
+    my $u = $queue[$queueFront++];
+#    print "$u\n";
+
+    addNode $u;
+
+    # If the path already exists, it has distance 0 from the "start"
+    # node.
+    if (isValidPath($u)) {
+        addEdge "start", $u, 0, "present", undef;
+    }
+
+    else {
+
+        # Add patch edges.
+        my $patchList = $patches{$u};
+        foreach my $patch (@{$patchList}) {
+            if (isValidPath($patch->{basePath})) {
+                # !!! this should be cached
+                my $hash = `nix-hash "$patch->{basePath}"`;
+                chomp $hash;
+#                print "  MY HASH is $hash\n";
+                if ($hash ne $patch->{baseHash}) {
+                    print LOGFILE "$$ rejecting $patch->{basePath}\n";
+                    next;
+                }
+            }
+#            print "  PATCH from $patch->{basePath}\n";
+            addToQueue $patch->{basePath};
+            addEdge $patch->{basePath}, $u, $patch->{size}, "patch", $patch;
+        }
+
+        # Add NAR file edges to the start node.
+        my $narFileList = $narFiles{$u};
+        foreach my $narFile (@{$narFileList}) {
+#            print "  NAR from $narFile->{url}\n";
+            addEdge "start", $u, $narFile->{size}, "narfile", $narFile;
+            if ($u eq $targetPath) {
+                print LOGFILE "$$ full-download-would-be $narFile->{size}\n";
+            }
+        }
+
+    }
+}
+
+
+# Run Dijkstra's shortest path algorithm to determine the shortest
+# sequence of download and/or patch actions that will produce
+# $targetPath.
+
+sub byDistance { # sort by distance, reversed
+    return -($graph{$a}->{d} <=> $graph{$b}->{d});
+}
+
+my @todo = keys %graph;
+
+while (scalar @todo > 0) {
+
+    # Remove the closest element from the todo list.
+    @todo = sort byDistance @todo;
+    my $u = pop @todo;
+
+    my $u_ = $graph{$u};
+
+#    print "IN $u $u_->{d}\n";
+
+    foreach my $edge (@{$u_->{edges}}) {
+        my $v_ = $graph{$edge->{end}};
+        if ($v_->{d} > $u_->{d} + $edge->{weight}) {
+            $v_->{d} = $u_->{d} + $edge->{weight};
+            # Store the edge; to edge->start is actually the
+            # predecessor.
+            $v_->{pred} = $edge; 
+#            print "  RELAX $edge->{end} $v_->{d}\n";
+        }
+    }
+}
+
+
+# Retrieve the shortest path from "start" to $targetPath.
+my @path = ();
+my $cur = $targetPath;
+die "don't know how to produce $targetPath\n"
+    unless defined $graph{$targetPath}->{pred};
+while ($cur ne "start") {
+    push @path, $graph{$cur}->{pred};
+    $cur = $graph{$cur}->{pred}->{start};
+}
+
+
+# Traverse the shortest path, perform the actions described by the
+# edges.
+my $curStep = 1;
+my $maxStep = scalar @path;
+
+sub downloadFile {
+    my $url = shift;
+    my $hash = shift;
+    $ENV{"PRINT_PATH"} = 1;
+    $ENV{"QUIET"} = 1;
+    my ($hash2, $path) = `nix-prefetch-url '$url' '$hash'`;
+    chomp $hash2;
+    chomp $path;
+    die "hash mismatch" if $hash ne $hash2;
+    return $path;
+}
+
+while (scalar @path > 0) {
+    my $edge = pop @path;
+    my $u = $edge->{start};
+    my $v = $edge->{end};
+
+    print "\n*** Step $curStep/$maxStep: ";
+    $curStep++;
+
+    if ($edge->{type} eq "present") {
+        print "using already present path `$v'\n";
+        print LOGFILE "$$ present $v\n";
+    }
+
+    elsif ($edge->{type} eq "patch") {
+        my $patch = $edge->{info};
+        print "applying patch `$patch->{url}' to `$u' to create `$v'\n";
+
+        print LOGFILE "$$ patch $patch->{url} $patch->{size} $patch->{baseHash} $u $v\n";
+
+        # Download the patch.
+        print "  downloading patch...\n";
+        my $patchPath = downloadFile "$patch->{url}", "$patch->{hash}";
+
+        # Turn the base path into a NAR archive, to which we can
+        # actually apply the patch.
+        print "  packing base path...\n";
+        system "nix-store --dump $patch->{basePath} > /tmp/nar";
+        die "cannot dump `$patch->{basePath}'" if ($? != 0);
+
+        # Apply the patch.
+        print "  applying patch...\n";
+        system "@libexecdir@/bspatch /tmp/nar /tmp/nar2 $patchPath";
+        die "cannot apply patch `$patchPath' to /tmp/nar" if ($? != 0);
+
+        # Unpack the resulting NAR archive into the target path.
+        print "  unpacking patched archive...\n";
+        system "nix-store --restore $v < /tmp/nar2";
+        die "cannot unpack /tmp/nar2 into `$v'" if ($? != 0);
+    }
+
+    elsif ($edge->{type} eq "narfile") {
+        my $narFile = $edge->{info};
+        print "downloading `$narFile->{url}' into `$v'\n";
+
+        print LOGFILE "$$ narfile $narFile->{url} $narFile->{size} $v\n";
+        
+        # Download the archive.
+        print "  downloading archive...\n";
+        my $narFilePath = downloadFile "$narFile->{url}", "$narFile->{hash}";
+
+        # Unpack the archive into the target path.
+        print "  unpacking archive...\n";
+        system "bunzip2 < '$narFilePath' | nix-store --restore '$v'";
+        die "cannot unpack `$narFilePath' into `$v'" if ($? != 0);
+    }
+}
+
+
+print LOGFILE "$$ success\n";
+close LOGFILE;

scripts/generate-patches.pl

@@ -0,0 +1,285 @@
+#! /usr/bin/perl -w -I/home/eelco/nix/scripts
+
+use strict;
+use POSIX qw(tmpnam);
+use readmanifest;
+
+die unless scalar @ARGV == 5;
+
+my $cacheDir = $ARGV[0];
+my $patchesDir = $ARGV[1];
+my $patchesURL = $ARGV[2];
+my $srcDir = $ARGV[3];
+my $dstDir = $ARGV[4];
+
+my $tmpdir;
+do { $tmpdir = tmpnam(); }
+until mkdir $tmpdir, 0777;
+
+print "TEMP = $tmpdir\n";
+
+#END { rmdir $tmpdir; }
+
+my %srcNarFiles;
+my %srcPatches;
+my %srcSuccessors;
+
+my %dstNarFiles;
+my %dstPatches;
+my %dstSuccessors;
+
+readManifest "$srcDir/MANIFEST",
+    \%srcNarFiles, \%srcPatches, \%srcSuccessors;
+
+readManifest "$dstDir/MANIFEST",
+    \%dstNarFiles, \%dstPatches, \%dstSuccessors;
+
+
+sub findOutputPaths {
+    my $narFiles = shift;
+    my $successors = shift;
+
+    my %outPaths;
+    
+    foreach my $p (keys %{$narFiles}) {
+
+        # Ignore store expressions.
+        next if ($p =~ /\.store$/);
+        
+        # Ignore builders (too much ambiguity -- they're all called
+        # `builder.sh').
+        next if ($p =~ /\.sh$/);
+        next if ($p =~ /\.patch$/);
+        
+        # Don't bother including tar files etc.
+        next if ($p =~ /\.tar\.(gz|bz2)$/ || $p =~ /\.zip$/ || $p =~ /\.bin$/);
+
+        $outPaths{$p} = 1;
+    }
+
+    return %outPaths;
+}
+
+print "finding src output paths...\n";
+my %srcOutPaths = findOutputPaths \%srcNarFiles, \%srcSuccessors;
+
+print "finding dst output paths...\n";
+my %dstOutPaths = findOutputPaths \%dstNarFiles, \%dstSuccessors;
+
+
+sub getNameVersion {
+    my $p = shift;
+    $p =~ /\/[0-9a-f]+((?:-[a-zA-Z][^\/-]*)+)([^\/]*)$/;
+    my $name = $1;
+    my $version = $2;
+    $name =~ s/^-//;
+    $version =~ s/^-//;
+    return ($name, $version);
+}
+
+
+# A quick hack to get a measure of the `distance' between two
+# versions: it's just the position of the first character that differs
+# (or 999 if they are the same).
+sub versionDiff {
+    my $s = shift;
+    my $t = shift;
+    my $i;
+    return 999 if $s eq $t;
+    for ($i = 0; $i < length $s; $i++) {
+        return $i if $i >= length $t or
+            substr($s, $i, 1) ne substr($t, $i, 1);
+    }
+    return $i;
+}
+
+
+sub getNarBz2 {
+    my $narFiles = shift;
+    my $storePath = shift;
+    
+    my $narFileList = $$narFiles{$storePath};
+    die "missing store expression $storePath" unless defined $narFileList;
+
+    my $narFile = @{$narFileList}[0];
+    die unless defined $narFile;
+
+    $narFile->{url} =~ /\/([^\/]+)$/;
+    die unless defined $1;
+    return "$cacheDir/$1";
+}
+
+
+sub containsPatch {
+    my $patches = shift;
+    my $storePath = shift;
+    my $basePath = shift;
+    my $patchList = $$patches{$storePath};
+    return 0 if !defined $patchList;
+    my $found = 0;
+    foreach my $patch (@{$patchList}) {
+        # !!! baseHash might differ
+        return 1 if $patch->{basePath} eq $basePath;
+    }
+    return 0;
+}
+
+
+# For each output path in the destination, see if we need to / can
+# create a patch.
+
+print "creating patches...\n";
+
+foreach my $p (keys %dstOutPaths) {
+
+    # If exactly the same path already exists in the source, skip it.
+    next if defined $srcOutPaths{$p};
+    
+#    print "  $p\n";
+
+    # If not, then we should find the path in the source that is
+    # `most' likely to be present on a system that wants to install
+    # this path.
+
+    (my $name, my $version) = getNameVersion $p;
+
+    my @closest = ();
+    my $closestVersion;
+    my $minDist = -1; # actually, larger means closer
+
+    # Find all source paths with the same name.
+
+    foreach my $q (keys %srcOutPaths) {
+        (my $name2, my $version2) = getNameVersion $q;
+        if ($name eq $name2) {
+            my $dist = versionDiff $version, $version2;
+            if ($dist > $minDist) {
+                $minDist = $dist;
+                @closest = ($q);
+                $closestVersion = $version2;
+            } elsif ($dist == $minDist) {
+                push @closest, $q;
+            }
+        }
+    }
+
+    if (scalar(@closest) == 0) {
+        print "  NO BASE: $p\n";
+        next;
+    }
+
+    foreach my $closest (@closest) {
+
+        # Generate a patch between $closest and $p.
+        print "  $p <- $closest\n";
+
+        # If the patch already exists, skip it.
+        if (containsPatch(\%srcPatches, $p, $closest) ||
+            containsPatch(\%dstPatches, $p, $closest))
+        {
+            print "    skipping, already exists\n";
+            next;
+        }
+
+#        next;
+        
+        my $srcNarBz2 = getNarBz2 \%srcNarFiles, $closest;
+        my $dstNarBz2 = getNarBz2 \%dstNarFiles, $p;
+        
+        system("bunzip2 < $srcNarBz2 > $tmpdir/A") == 0
+            or die "cannot unpack $srcNarBz2";
+
+        system("bunzip2 < $dstNarBz2 > $tmpdir/B") == 0
+            or die "cannot unpack $dstNarBz2";
+
+        system("bsdiff $tmpdir/A $tmpdir/B $tmpdir/DIFF") == 0
+            or die "cannot compute binary diff";
+
+        my $baseHash = `nix-hash --flat $tmpdir/A` or die;
+        chomp $baseHash;
+
+        my $narHash = `nix-hash --flat $tmpdir/B` or die;
+        chomp $narHash;
+
+        my $narDiffHash = `nix-hash --flat $tmpdir/DIFF` or die;
+        chomp $narDiffHash;
+
+        my $narDiffSize = (stat "$tmpdir/DIFF")[7];
+        my $dstNarBz2Size = (stat $dstNarBz2)[7];
+
+        if ($narDiffSize >= $dstNarBz2Size) {
+            print "    rejecting; patch bigger than full archive\n";
+            next;
+        }
+    
+        my $finalName =
+            "$narDiffHash-$name-$closestVersion-to-$version.nar-bsdiff";
+
+        print "    size $narDiffSize; full size $dstNarBz2Size\n";
+        
+        if (-e "$patchesDir/$finalName") {
+            print "    not copying, already exists\n";
+        }
+
+        else {
+
+            system("cp '$tmpdir/DIFF' '$patchesDir/$finalName.tmp'") == 0
+                or die "cannot copy diff";
+            
+            rename("$patchesDir/$finalName.tmp", "$patchesDir/$finalName")
+                or die "cannot rename $patchesDir/$finalName.tmp";
+            
+        }
+        
+        # Add the patch to the manifest.
+        addPatch \%dstPatches, $p,
+            { url => "$patchesURL/$finalName", hash => $narDiffHash
+            , size => $narDiffSize
+            , basePath => $closest, baseHash => $baseHash
+            , narHash => $narHash, patchType => "nar-bsdiff"
+            };
+    }
+}
+
+
+# Add in any potentially useful patches in the source (namely, those
+# patches that produce either paths in the destination or paths that
+# can be used as the base for other useful patches).
+
+my $changed;
+do {
+    # !!! we repeat this to reach the transitive closure; inefficient
+    $changed = 0;
+
+    foreach my $p (keys %srcPatches) {
+        my $patchList = $srcPatches{$p};
+
+        my $include = 0;
+
+        # Is path $p included in the destination?  If so, include
+        # patches that produce it.
+        $include = 1 if (defined $dstNarFiles{$p});
+
+        # Is path $p a path that serves as a base for paths in the
+        # destination?  If so, include patches that produce it.
+        foreach my $q (keys %dstPatches) {
+            foreach my $patch (@{$dstPatches{$q}}) {
+                # !!! check baseHash
+                $include = 1 if ($p eq $patch->{basePath});
+            }
+        }
+
+        if ($include) {
+            foreach my $patch (@{$patchList}) {
+                $changed = 1 if addPatch \%dstPatches, $p, $patch;
+            }
+        }            
+        
+    }
+    
+} while $changed;
+
+
+# Rewrite the manifest of the destination (with the new patches).
+writeManifest "$dstDir/MANIFEST",
+    \%dstNarFiles, \%dstPatches, \%dstSuccessors;

scripts/nix-build.in

@@ -0,0 +1,41 @@
+#! @shell@ -e
+
+nixExpr=$1
+
+if test -z "$nixExpr"; then
+    echo "syntax: $0 NIX-EXPR..." >&2
+    exit 1
+fi
+
+extraArgs=
+noLink=
+
+for i in "$@"; do
+    case "$i" in
+        --no-link)
+            noLink=1
+            ;;
+        -*)
+            extraArgs="$extraArgs $i"
+            ;;
+        *)
+            storeExprs=$(nix-instantiate "$i")
+            for j in $storeExprs; do
+                echo "store expression is $j" >&2
+            done
+            outPaths=$(nix-store -qnfv $extraArgs $storeExprs)
+            for j in $outPaths; do
+                echo "$j"
+                if test -z "$noLink"; then
+                    if test -L result; then
+                        rm result
+                    elif test -e result; then
+                        echo "cannot remove \`result' (not a symlink)"
+                        exit 1
+                    fi
+                    ln -s "$j" result
+                fi
+            done
+            ;;
+    esac
+done

scripts/nix-channel.in

@@ -0,0 +1,136 @@
+#! @perl@ -w
+
+use strict;
+
+my $rootsDir = "@localstatedir@/nix/gcroots/channels";
+
+
+# Figure out the name of the `.nix-channels' file to use.
+my $home = $ENV{"HOME"};
+die '$HOME not set' unless defined $home;
+my $channelsList = "$home/.nix-channels";
+    
+
+my @channels;
+
+
+# Reads the list of channels from the file $channelsList;
+sub readChannels {
+    return if (!-f $channelsList);
+    open CHANNELS, "<$channelsList" or die "cannot open `$channelsList': $!";
+    while (<CHANNELS>) {
+        chomp;
+        push @channels, $_;
+    }
+    close CHANNELS;
+}
+
+
+# Writes the list of channels to the file $channelsList;
+sub writeChannels {
+    open CHANNELS, ">$channelsList" or die "cannot open `$channelsList': $!";
+    foreach my $url (@channels) {
+        print CHANNELS "$url\n";
+    }
+    close CHANNELS;
+}
+
+
+# Adds a channel to the file $channelsList;
+sub addChannel {
+    my $url = shift;
+    readChannels;
+    foreach my $url2 (@channels) {
+        return if $url eq $url2;
+    }
+    push @channels, $url;
+    writeChannels;
+}
+
+
+# Fetch Nix expressions and pull cache manifests from the subscribed
+# channels.
+sub update {
+    readChannels;
+
+    # Get rid of all the old substitutes.
+    system "@bindir@/nix-store --clear-substitutes";
+    die "cannot clear substitutes" if ($? != 0);
+
+    # Pull cache manifests.
+    foreach my $url (@channels) {
+        print "pulling cache manifest from `$url'\n";
+        system "@bindir@/nix-pull '$url'/MANIFEST";
+        die "cannot pull cache manifest from `$url'" if ($? != 0);
+    }
+
+    # Create a Nix expression that fetches and unpacks the channel Nix
+    # expressions.
+
+    my $nixExpr = "[";
+    
+    foreach my $url (@channels) {
+        my $fullURL = "$url/nixexprs.tar.bz2";
+        my $hash = `@bindir@/nix-prefetch-url '$fullURL' 2> /dev/null`
+            or die "cannot fetch `$fullURL'";
+        chomp $hash;
+        # !!! escaping
+        $nixExpr .= "((import @datadir@/nix/corepkgs/fetchurl) " .
+            "{url = $fullURL; md5 = \"$hash\"; system = \"@system@\";}) "
+    }
+
+    $nixExpr .= "]";
+
+    $nixExpr =
+        "(import @datadir@/nix/corepkgs/channels/unpack.nix) " .
+        "{inputs = $nixExpr; system = \"@system@\";}";
+
+    # Instantiate the Nix expression.
+    my $storeExpr = `echo '$nixExpr' | @bindir@/nix-instantiate -`
+        or die "cannot instantiate Nix expression";
+    chomp $storeExpr;
+
+    # Register the store expression as a root of the garbage
+    # collector.
+    my $userName = getpwuid($<);
+    die "who ARE you? go away" unless defined $userName;
+
+    my $rootFile = "$rootsDir/$userName.gcroot";
+    my $tmpRootFile = "$rootsDir/$userName-tmp.gcroot";
+    
+    open ROOT, ">$tmpRootFile" or die "cannot create `$tmpRootFile': $!";
+    print ROOT "$storeExpr";
+    close ROOT;
+
+    # Realise the store expression.
+    my $outPath = `nix-store -qnf '$storeExpr'`
+        or die "cannot realise store expression";
+    chomp $outPath;
+
+    # Make it the default Nix expression for `nix-env'.
+    system "@bindir@/nix-env --import '$outPath'";
+    die "cannot pull set default Nix expression to `$outPath'" if ($? != 0);
+
+    rename $tmpRootFile, $rootFile or die "cannot rename `$tmpRootFile' to `$rootFile': $!";
+}
+
+
+while (scalar @ARGV) {
+    my $arg = shift @ARGV;
+
+    if ($arg eq "--add") {
+        die "syntax: nix-channel --add URL" if (scalar @ARGV != 1);
+        addChannel (shift @ARGV);
+        last;
+    }
+
+    elsif ($arg eq "--update") {
+        die "syntax: nix-channel --update" if (scalar @ARGV != 0);
+        update;
+        last;
+    }
+
+    else {
+        die "unknown argument `$arg'";
+    }
+}

scripts/nix-collect-garbage.in

@@ -1,47 +1,90 @@
-#! /usr/bin/perl -w
+#! @perl@ -w
 
 use strict;
 use IPC::Open2;
 
-my $linkdir = "@localstatedir@/nix/links";
-my $storedir = "@prefix@/store";
+my $rootsDir = "@localstatedir@/nix/gcroots";
+my $storeDir = "@storedir@";
 
 my %alive;
 
-my $keepsuccessors = 1;
-my $invert = 0;
+my $gcOper = "--delete";
+my $minAge = 0;
 
-foreach my $arg (@ARGV) {
-    if ($arg eq "--no-successors") { $keepsuccessors = 0; }
-    elsif ($arg eq "--invert") { $invert = 1; }
+my @roots = ();
+
+
+# Parse the command line.
+for (my $i = 0; $i < scalar @ARGV; $i++) {
+    my $arg = $ARGV[$i];
+    if ($arg eq "--delete" || $arg eq "--print-live" || $arg eq "--print-dead") {
+        $gcOper = $arg;
+    }
+    elsif ($arg eq "--min-age") {
+        $i++;
+        $minAge = undef;
+        $minAge = $ARGV[$i];
+        die "invalid minimum age" unless defined $minAge && $minAge =~ /^\d*$/;
+    }
     else { die "unknown argument `$arg'" };
 }
 
-my $extraarg = "";
-if ($keepsuccessors) { $extraarg = "--include-successors"; };
-my $pid = open2(\*READ, \*WRITE, "nix --query --requisites $extraarg \$(cat $linkdir/*.id)") 
-    or die "determining live paths";
-close WRITE;
-while (<READ>) {
-	chomp;
-	$alive{$_} = 1;
-	if ($invert) { print "$_\n"; };
+
+# Read all GC roots from the given file.
+sub readRoots {
+    my $fileName = shift;
+    open ROOT, "<$fileName" or die "cannot open `$fileName': $!";
+    while (<ROOT>) {
+        chomp;
+        foreach my $root (split ' ') {
+            die "bad root `$root' in file `$fileName'"
+                unless $root =~ /^\S+$/;
+            push @roots, $root;
+        }
+    }
+    close ROOT;
 }
-close READ;
+
+
+# Recursively finds all *.gcroot files in the given directory.
+sub findRoots;
+sub findRoots {
+    my $followSymlinks = shift;
+    my $dir = shift;
+
+    opendir(DIR, $dir) or die "cannot open directory `$dir': $!";
+    my @names = readdir DIR or die "cannot read directory `$dir': $!";
+    closedir DIR;
+
+    foreach my $name (@names) {
+        next if $name eq "." || $name eq "..";
+        $name = $dir . "/" . $name;
+        if ($name =~ /.gcroot$/ && -f $name) {
+            readRoots $name;
+        }
+        elsif (-d $name) {
+            if ($followSymlinks || !-l $name) {
+                findRoots 0, $name;
+            }
+        }
+    }
+    
+}
+
+
+# Find GC roots, starting at $rootsDir.
+findRoots 1, $rootsDir;
+
+
+# Run the collector with the roots we found.
+my $pid = open2(">&1", \*WRITE, "@bindir@/nix-store --gc $gcOper --min-age $minAge")
+    or die "cannot run `nix-store --gc'";
+
+foreach my $root (@roots) {
+    print WRITE "$root\n";
+}
+
+close WRITE;
 
 waitpid $pid, 0;
-$? == 0 or die "determining live paths";
-
-exit 0 if ($invert);
-
-opendir(DIR, $storedir) or die "cannot opendir $storedir: $!";
-my @names = readdir(DIR);
-closedir DIR;
-
-foreach my $name (@names) {
-    next if ($name eq "." || $name eq "..");
-    $name = "$storedir/$name";
-    if (!$alive{$name}) {
-        print "$name\n";
-    }
-}
+$? == 0 or die "`nix-store --gc' failed";

scripts/nix-install-package.in

@@ -0,0 +1,37 @@
+#! @perl@ -w
+
+use strict;
+use POSIX qw(tmpnam);
+
+my $pkgfile = $ARGV[0];
+die unless defined $pkgfile;
+
+my $tmpdir;
+do { $tmpdir = tmpnam(); }
+until mkdir $tmpdir, 0777;
+
+# !!! remove tmpdir on exit
+
+print "Unpacking $pkgfile in $tmpdir...\n";
+system "bunzip2 < $pkgfile | (cd $tmpdir && tar xf -)";
+die if $?;
+
+print "This package contains the following derivations:\n";
+system "@bindir@/nix-env -qasf $tmpdir/default.nix";
+die if $?;
+
+print "Do you wish to install these (Y/N)? ";
+my $reply = <STDIN>;
+chomp $reply;
+exit if (!($reply eq "y"));
+
+print "Pulling caches...\n";
+system "@bindir@/nix-pull `cat $tmpdir/caches`";
+die if $?;
+
+print "Installing package...\n";
+system "@bindir@/nix-env -if $tmpdir/default.nix '*'";
+die if $?;
+
+print "Installation succeeded! Press Enter to continue.\n";
+<STDIN>;

scripts/nix-prefetch-url.in

@@ -1,48 +1,60 @@
-#! /usr/bin/perl -w
+#! @shell@ -e
 
-use strict;
-use IPC::Open2;
+url=$1
+hash=$2
 
-my $url = shift @ARGV;
-defined $url or die;
+if test -z "$url"; then
+    echo "syntax: nix-prefetch-url URL" >&2
+    exit 1
+fi
 
-print "fetching $url...\n";
+# Determine the hash, unless it was given.
+if test -z "$hash"; then
 
-my $out = "@prefix@/store/nix-prefetch-url-$$";
+    # !!! race
+    tmpPath1=@storedir@/nix-prefetch-url-$$
 
-system "@wget@ --passive-ftp '$url' -O '$out'";
-$? == 0 or die "unable to fetch $url";
+    # Test whether we have write permission in the store.  If not,
+    # fetch to /tmp and don't copy to the store.  This is a hack to
+    # make this script at least work somewhat in setuid installations.
+    if ! touch $tmpPath1 2> /dev/null; then
+        echo "(cannot write to the store, result won't be cached)" >&2
+        dummyMode=1
+        tmpPath1=/tmp/nix-prefetch-url-$$ # !!! security?
+    fi
 
-my $hash=`@bindir@/nix-hash --flat $out`;
-$? == 0 or die "unable to hash $out";
-chomp $hash;
+    # Perform the checkout.
+    @curl@ --fail --location --max-redirs 20 "$url" > $tmpPath1
 
-print "file has hash $hash\n";
+    # Compute the hash.
+    hash=$(@bindir@/nix-hash --flat $tmpPath1)
+    if ! test -n "$QUIET"; then echo "hash is $hash" >&2; fi
 
-my $out2 = "@prefix@/store/nix-prefetch-url-$hash";
-rename $out, $out2;
+    # Rename it so that the fetchurl builder can find it.
+    if test "$dummyMode" != 1; then
+        tmpPath2=@storedir@/nix-prefetch-url-$hash
+        test -e $tmpPath2 || mv $tmpPath1 $tmpPath2 # !!! race
+    fi
 
-# Create a Fix expression.
-my $fixexpr = 
-    "App(IncludeFix(\"fetchurl/fetchurl.fix\"), " .
-    "[(\"url\", \"$url\"), (\"md5\", \"$hash\")])";
+fi
 
-# Instantiate a Nix expression.
-print STDERR "running fix...\n";
-my $pid = open2(\*READ, \*WRITE, "fix -") or die "cannot run fix";
+# Create a Nix expression that does a fetchurl.
+storeExpr=$( \
+    echo "(import @datadir@/nix/corepkgs/fetchurl) \
+        {url = $url; md5 = \"$hash\"; system = \"@system@\";}" \
+    | @bindir@/nix-instantiate -)
 
-print WRITE $fixexpr;
-close WRITE;
+# Realise it.
+finalPath=$(@bindir@/nix-store -qnB --force-realise $storeExpr)
+    
+if ! test -n "$QUIET"; then echo "path is $finalPath" >&2; fi
 
-my $id = <READ>;
-chomp $id;
+if test -n "$tmpPath1" -o -n "$tmpPath2"; then
+    rm -rf $tmpPath1 $tmpPath2 || true
+fi
 
-waitpid $pid, 0;
-$? == 0 or die "fix failed";
+echo $hash
 
-# Run Nix.
-print STDERR "running nix...\n";
-system "nix --install $id > /dev/null";
-$? == 0 or die "`nix --install' failed";
-
-unlink $out2;
+if test -n "$PRINT_PATH"; then
+    echo $finalPath
+fi

scripts/nix-profile.sh.in

@@ -1,20 +1,11 @@
-#if test -z "$NIX_SET"; then
+if test -n "$HOME"; then
+    NIX_LINK="$HOME/.nix-profile"
 
-#    export NIX_SET=1
+    if ! test -L "$NIX_LINK"; then
+        echo "creating $NIX_LINK"
+        _NIX_DEF_LINK=@localstatedir@/nix/profiles/default
+        ln -s "$_NIX_DEF_LINK" "$NIX_LINK"
+    fi
 
-    NIX_LINKS=@localstatedir@/nix/links/current
-
-    export PATH=$NIX_LINKS/bin:@prefix@/bin:$PATH
-
-#    export LD_LIBRARY_PATH=$NIX_LINKS/lib:$LD_LIBRARY_PATH
-
-    export LIBRARY_PATH=$NIX_LINKS/lib:$LIBRARY_PATH
-
-    export C_INCLUDE_PATH=$NIX_LINKS/include:$C_INCLUDE_PATH
-    export CPLUS_INCLUDE_PATH=$NIX_LINKS/include:$CPLUS_INCLUDE_PATH
-
-    export PKG_CONFIG_PATH=$NIX_LINKS/lib/pkgconfig:$PKG_CONFIG_PATH
-
-#    export MANPATH=$NIX_LINKS/man:$MANPATH
-
-#fi
+    export PATH=$NIX_LINK/bin:@prefix@/bin:$PATH
+fi

scripts/nix-pull.in

@@ -1,143 +1,92 @@
-#! /usr/bin/perl -w
+#! @perl@ -w -I@libexecdir@/nix
 
 use strict;
 use IPC::Open2;
 use POSIX qw(tmpnam);
+use readmanifest;
 
 my $tmpdir;
 do { $tmpdir = tmpnam(); }
 until mkdir $tmpdir, 0777;
 
 my $manifest = "$tmpdir/manifest";
-my $conffile = "@sysconfdir@/nix/prebuilts.conf";
 
-#END { unlink $manifest; rmdir $tmpdir; }
+END { unlink $manifest; rmdir $tmpdir; }
 
-my @srcpaths;
-my @subs;
-my @sucs;
 
-my $fullexpr = "[";
-my $first = 1;
+# Obtain URLs either from the command line or from a configuration file.
+my %narFiles;
+my %patches;
+my %successors;
 
-open CONFFILE, "<$conffile";
+sub processURL {
+    my $url = shift;
 
-while (<CONFFILE>) {
+    $url =~ s/\/$//;
+    print "obtaining list of Nix archives at $url...\n";
 
-    chomp;
-    if (/^\s*(\S+)\s*(\#.*)?$/) {
-        my $url = $1;
-	$url =~ s/\/$//;
+    system("@curl@ --fail --silent --show-error --location --max-redirs 20 " .
+           "'$url' > '$manifest'") == 0
+           or die "curl failed: $?";
 
-        print "obtaining list of Nix archives at $url...\n";
+    readManifest $manifest, \%narFiles, \%patches, \%successors;
 
-        system "wget --cache=off '$url'/MANIFEST -O '$manifest' 2> /dev/null"; # !!! escape
-        if ($?) { die "`wget' failed"; }
-        
-        open MANIFEST, "<$manifest";
-
-	my $inside = 0;
-
-	my $storepath;
-	my $narname;
-	my $hash;
-	my @preds;
-
-        while (<MANIFEST>) {
-	    chomp;
-	    s/\#.*$//g;
-	    next if (/^$/);
-
-	    if (!$inside) {
-		if (/^\{$/) { 
-		    $inside = 1;
-		    undef $storepath;
-		    undef $narname;
-		    undef $hash;
-		    @preds = ();
-		}
-		else { die "bad line: $_"; }
-	    } else {
-		if (/^\}$/) {
-		    $inside = 0;
-		    my $fullurl = "$url/$narname";
-		    print "$storepath\n";
-
-		    # Construct a Fix expression that fetches and unpacks a
-		    # Nix archive from the network.
-		    my $fetch =
-			"App(IncludeFix(\"fetchurl/fetchurl.fix\"), " .
-			"[(\"url\", \"$fullurl\"), (\"md5\", \"$hash\")])";
-		    my $fixexpr = 
-			"App(IncludeFix(\"nar/unnar.fix\"), " .
-			"[ (\"nar\", $fetch)" .
-			", (\"outPath\", \"$storepath\")" .
-			"])";
-		    
-		    if (!$first) { $fullexpr .= "," };
-		    $first = 0;
-		    $fullexpr .= $fixexpr; # !!! O(n^2)?
-
-		    push @srcpaths, $storepath;
-
-		    foreach my $p (@preds) {
-			push @sucs, $p;
-			push @sucs, $storepath;
-		    }
-
-		}
-		elsif (/^\s*StorePath:\s*(\/\S+)\s*$/) {
-		    $storepath = $1;
-		}
-		elsif (/^\s*NarName:\s*(\S+)\s*$/) {
-		    $narname = $1;
-		}
-		elsif (/^\s*MD5:\s*(\S+)\s*$/) {
-		    $hash = $1;
-		}
-		elsif (/^\s*SuccOf:\s*(\/\S+)\s*$/) {
-		    push @preds, $1;
-		}
-		else { die "bad line: $_"; }
-	    }
-        }
-
-        close MANIFEST;
+    my $baseName = "unnamed";
+    if ($url =~ /\/([^\/]+)\/[^\/]+$/) { # get the forelast component
+        $baseName = $1;
     }
 
+    my $hash = `@bindir@/nix-hash --flat '$manifest'`
+        or die "cannot hash `$manifest'";
+    chomp $hash;
+    
+    my $finalPath = "@localstatedir@/nix/manifests/$baseName-$hash.nixmanifest";
+    
+    system("mv '$manifest' '$finalPath'") == 0
+        or die "cannot move `$manifest' to `$finalPath";
 }
 
-$fullexpr .= "]";
-
-
-# Instantiate Nix expressions from the Fix expressions we created above.
-print STDERR "running fix...\n";
-my $pid = open2(\*READ, \*WRITE, "fix -") or die "cannot run fix";
-
-print WRITE $fullexpr;
-close WRITE;
-my $i = 0;
-while (<READ>) {
-    chomp;
-    die unless /^\//;
-    my $subpath = $_;
-    die unless ($i < scalar @srcpaths);
-    my $srcpath = $srcpaths[$i++];
-    push @subs, $srcpath;
-    push @subs, $subpath;
+while (@ARGV) {
+    my $url = shift @ARGV;
+    processURL $url;
 }
 
-waitpid $pid, 0;
-$? == 0 or die "fix failed";
+
+my $size = scalar (keys %narFiles);
+print "$size store paths in manifest\n";
 
 
 # Register all substitutes.
 print STDERR "registering substitutes...\n";
-system "nix --substitute @subs";
-if ($?) { die "`nix --substitute' failed"; }
+
+my $pid = open2(\*READ, \*WRITE, "@bindir@/nix-store --substitute")
+    or die "cannot run nix-store";
+
+close READ;
+
+foreach my $storePath (keys %narFiles) {
+    my $narFileList = $narFiles{$storePath};
+    foreach my $narFile (@{$narFileList}) {
+        print WRITE "$storePath\n";
+        print WRITE "@libexecdir@/nix/download-using-manifests.pl\n";
+        print WRITE "0\n";
+    }
+}
+
+close WRITE;
+
+waitpid $pid, 0;
+$? == 0 or die "nix-store failed";
 
 
 # Register all successors.
 print STDERR "registering successors...\n";
-system "nix --successor @sucs";
-if ($?) { die "`nix --successor' failed"; }
+my @sucs = %successors;
+while (scalar @sucs > 0) {
+    my $n = scalar @sucs;
+    if ($n > 256) { $n = 256 };
+    my @sucs2 = @sucs[0..$n - 1];
+    @sucs = @sucs[$n..scalar @sucs - 1];
+    system "@bindir@/nix-store --successor @sucs2";
+    if ($?) { die "`nix-store --successor' failed"; }
+}

scripts/nix-push.in

@@ -1,142 +1,193 @@
-#! /usr/bin/perl -w
+#! @perl@ -w
 
 use strict;
 use POSIX qw(tmpnam);
+use readmanifest;
 
 my $tmpdir;
 do { $tmpdir = tmpnam(); }
 until mkdir $tmpdir, 0777;
 
-my $fixfile = "$tmpdir/create-nars.fix";
+my $nixfile = "$tmpdir/create-nars.nix";
 my $manifest = "$tmpdir/MANIFEST";
 
-END { unlink $manifest; unlink $fixfile; rmdir $tmpdir; }
+END { unlink $manifest; unlink $nixfile; rmdir $tmpdir; }
 
-open FIX, ">$fixfile";
-print FIX "[";
-my $first = 1;
+my $curl = "@curl@ --fail --silent";
+my $extraCurlFlags = ${ENV{'CURL_FLAGS'}};
+$curl = "$curl $extraCurlFlags" if defined $extraCurlFlags;
 
-my @paths;
 
-foreach my $id (@ARGV) {
+# Parse the command line.
+my $archives_put_url = shift @ARGV;
+my $archives_get_url = shift @ARGV;
+my $manifest_put_url = shift @ARGV;
 
-    die unless $id =~ /^\//;
+
+# From the given store expressions, determine the requisite store
+# paths.
+my %storePaths;
+
+foreach my $storeexpr (@ARGV) {
+    die unless $storeexpr =~ /^\//;
 
     # Get all paths referenced by the normalisation of the given 
     # Nix expression.
-    system "nix --install $id > /dev/null";
-    if ($?) { die "`nix --install' failed"; }
+    system "@bindir@/nix-store --realise $storeexpr > /dev/null";
+    die if ($?);
 
-    open PATHS, "nix --query --requisites --include-successors $id 2> /dev/null |" or die "nix -qr";
+    open PATHS, "@bindir@/nix-store --query --requisites --include-successors $storeexpr 2> /dev/null |" or die;
     while (<PATHS>) {
         chomp;
         die "bad: $_" unless /^\//;
-        push @paths, $_;
+        $storePaths{$_} = "";
     }
     close PATHS;
-
-    # For each path, create a Fix expression that turns the path into
-    # a Nix archive.
-    foreach my $path (@paths) {
-
-	die unless ($path =~ /\/[0-9a-z]{32}.*$/);
-	print "$path\n";
-
-        # Construct a Fix expression that creates a Nix archive.
-        my $fixexpr = 
-          "Call(IncludeFix(\"nar/nar.fix\"), " .
-          "[ (\"path\", Closure([\"$path\"], [(\"$path\", [])]))" .
-          "])";
-	
-	print FIX "," unless ($first);
-	$first = 0;
-        print FIX $fixexpr;
-
-    }
 }
 
-print FIX "]";
-close FIX;
+my @storePaths = keys %storePaths;
 
 
-# Instantiate a Nix expression from the Fix expression.
-my @nids;
-print STDERR "running fix...\n";
-open NIDS, "fix $fixfile |" or die "cannot run fix";
-while (<NIDS>) {
+# For each path, create a Nix expression that turns the path into
+# a Nix archive.
+open NIX, ">$nixfile";
+print NIX "[";
+
+foreach my $storePath (@storePaths) {
+    die unless ($storePath =~ /\/[0-9a-z]{32}.*$/);
+
+    # Construct a Nix expression that creates a Nix archive.
+    my $nixexpr = 
+        "((import @datadir@/nix/corepkgs/nar/nar.nix) " .
+        # !!! $storePath should be represented as a closure
+        "{path = \"$storePath\"; system = \"@system@\";}) ";
+    
+    print NIX $nixexpr;
+}
+
+print NIX "]";
+close NIX;
+
+
+# Instantiate store expressions from the Nix expression.
+my @storeexprs;
+print STDERR "instantiating store expressions...\n";
+open STOREEXPRS, "@bindir@/nix-instantiate $nixfile |" or die "cannot run nix-instantiate";
+while (<STOREEXPRS>) {
     chomp;
     die unless /^\//;
-    push @nids, $_;
+    push @storeexprs, $_;
 }
-close NIDS;
+close STOREEXPRS;
 
 
-# Realise the Nix expression.
+# Realise the store expressions.
 print STDERR "creating archives...\n";
-system "nix --install -v @nids > /dev/null";
-if ($?) { die "`nix --install' failed"; }
 
 my @narpaths;
-open NIDS, "nix --query --list @nids |" or die "cannot run nix";
-while (<NIDS>) {
-    chomp;
-    die unless (/^\//);
-    push @narpaths, "$_";
-}
-close NIDS;
 
-    
+my @tmp = @storeexprs;
+while (scalar @tmp > 0) {
+    my $n = scalar @tmp;
+    if ($n > 256) { $n = 256 };
+    my @tmp2 = @tmp[0..$n - 1];
+    @tmp = @tmp[$n..scalar @tmp - 1];
+
+    system "@bindir@/nix-store --realise @tmp2 > /dev/null";
+    if ($?) { die "`nix-store --realise' failed"; }
+
+    open NARPATHS, "@bindir@/nix-store --query --list @tmp2 |" or die "cannot run nix";
+    while (<NARPATHS>) {
+        chomp;
+        die unless (/^\//);
+        push @narpaths, "$_";
+    }
+    close NARPATHS;
+}
+
+
 # Create the manifest.
 print STDERR "creating manifest...\n";
 
-open MANIFEST, ">$manifest";
+my %narFiles;
+my %patches;
+my %successors;
 
-my @pushlist;
-push @pushlist, $manifest;
-
-for (my $n = 0; $n < scalar @paths; $n++) {
-    my $storepath = $paths[$n];
+my @nararchives;
+for (my $n = 0; $n < scalar @storePaths; $n++) {
+    my $storePath = $storePaths[$n];
     my $nardir = $narpaths[$n];
     
-    $storepath =~ /\/([^\/]*)$/;
+    $storePath =~ /\/([^\/]*)$/;
     my $basename = $1;
     defined $basename or die;
 
     my $narname = "$basename.nar.bz2";
 
     my $narfile = "$nardir/$narname";
-    (-f $narfile) or die "narfile for $storepath not found";
-    push @pushlist, $narfile;
+    (-f $narfile) or die "narfile for $storePath not found";
+    push @nararchives, $narfile;
 
-    open MD5, "$nardir/md5" or die "cannot open hash";
-    my $hash = <MD5>;
-    chomp $hash;
-    $hash =~ /^[0-9a-z]{32}$/ or die "invalid hash";
+    open MD5, "$nardir/narbz2-hash" or die "cannot open narbz2-hash";
+    my $narbz2Hash = <MD5>;
+    chomp $narbz2Hash;
+    $narbz2Hash =~ /^[0-9a-z]{32}$/ or die "invalid hash";
     close MD5;
 
-    print MANIFEST "{\n";
-    print MANIFEST "  StorePath: $storepath\n";
-    print MANIFEST "  NarName: $narname\n";
-    print MANIFEST "  MD5: $hash\n";
+    open MD5, "$nardir/nar-hash" or die "cannot open nar-hash";
+    my $narHash = <MD5>;
+    chomp $narHash;
+    $narHash =~ /^[0-9a-z]{32}$/ or die "invalid hash";
+    close MD5;
+    
+    my $narbz2Size = (stat $narfile)[7];
 
-    if ($storepath =~ /\.nix$/) {
-	open PREDS, "nix --query --predecessors $storepath |" or die "cannot run nix";
-	while (<PREDS>) {
-	    chomp;
-	    die unless (/^\//);
-	    print MANIFEST "  SuccOf: $_\n";
-	}
-	close PREDS;
+    $narFiles{$storePath} = [
+        { url => $archives_get_url/$narname
+        , hash => $narbz2Hash
+        , size => $narbz2Size
+        , narHash => $narHash
+        }
+    ];
+                            
+    if ($storePath =~ /\.store$/) {
+        open PREDS, "@bindir@/nix-store --query --predecessors $storePath |" or die "cannot run nix";
+        while (<PREDS>) {
+            chomp;
+            die unless (/^\//);
+            my $pred = $_;
+            # Only include predecessors that are themselves being
+            # pushed.
+            if (defined $storePaths{$pred}) {
+                $successors{$pred} = $storePath;
+            }
+        }
+        close PREDS;
     }
 
-    print MANIFEST "}\n";
 }
 
-close MANIFEST;
+writeManifest $manifest, \%narFiles, \%patches, \%successors;
 
 
-# Push the prebuilts to the server. !!! FIXME
-print STDERR "pushing to server...\n";
-if (scalar @pushlist > 0) {
-    system "rsync -av -e ssh @pushlist eelco\@losser.st-lab.cs.uu.nl:/home/eelco/public_html/nix-dist/";
+# Upload the archives.
+print STDERR "uploading archives...\n";
+foreach my $nararchive (@nararchives) {
+
+    $nararchive =~ /\/([^\/]*)$/;
+    my $basename = $1;
+
+    if (system("$curl --head $archives_get_url/$basename > /dev/null") != 0) {
+        print STDERR "  $nararchive\n";
+        system("$curl --show-error --upload-file " .
+               "'$nararchive' '$archives_put_url/$basename' > /dev/null") == 0 or
+            die "curl failed on $nararchive: $?";
+    }
 }
+
+
+# Upload the manifest.
+print STDERR "uploading manifest...\n";
+system("$curl  --show-error --upload-file " .
+       "'$manifest' '$manifest_put_url' > /dev/null") == 0 or
+    die "curl failed on $manifest: $?";

scripts/nix-switch.in

@@ -1,86 +0,0 @@
-#! /usr/bin/perl -w
-
-use strict;
-
-my $keep = 0;
-my $sourceroot = 1;
-my $name = "current";
-my $srcid;
-
-my $argnr = 0;
-while ($argnr < scalar @ARGV) {
-    my $arg = $ARGV[$argnr++];
-    if ($arg eq "--keep") { $keep = 1; }
-    elsif ($arg eq "--no-source") { $sourceroot = 0; }
-    elsif ($arg eq "--name") { $name = $ARGV[$argnr++]; }
-    elsif ($arg =~ /^\//) { $srcid = $arg; }
-    else { die "unknown argument `$arg'" };
-}
-
-my $linkdir = "@localstatedir@/nix/links";
-
-# Build the specified package, and all its dependencies.
-my $nfid = `nix --install $srcid`;
-if ($?) { die "`nix --install' failed"; }
-chomp $nfid;
-die unless $nfid =~ /^\//;
-
-my $pkgdir = `nix --query --list $nfid`;
-if ($?) { die "`nix --query --list' failed"; }
-chomp $pkgdir;
-
-# Figure out a generation number.
-opendir(DIR, $linkdir);
-my $nr = 0;
-foreach my $n (sort(readdir(DIR))) {
-    next if (!($n =~ /^\d+$/));
-    $nr = $n + 1 if ($n >= $nr);
-}
-closedir(DIR);
-
-my $link = "$linkdir/$nr";
-
-# Create a symlink from $link to $pkgdir.
-symlink($pkgdir, $link) or die "cannot create $link: $!";
-
-# Store the id of the normal form.  This is useful for garbage
-# collection and the like.
-my $idfile = "$linkdir/$nr.id";
-open ID, "> $idfile" or die "cannot create $idfile";
-print ID "$nfid\n";
-close ID;
-
-# Optionally store the source id.
-if ($sourceroot) {
-    $idfile = "$linkdir/$nr-src.id";
-    open ID, "> $idfile" or die "cannot create $idfile";
-    print ID "$srcid\n";
-    close ID;
-}
-
-my $current = "$linkdir/$name";
-
-# Read the current generation so that we can delete it (if --keep
-# wasn't specified).
-my $oldlink = readlink($current);
-
-# Make $link the current generation by pointing $linkdir/current to
-# it.  The rename() system call is supposed to be essentially atomic
-# on Unix.  That is, if we have links `current -> X' and `new_current
-# -> Y', and we rename new_current to current, a process accessing
-# current will see X or Y, but never a file-not-found or other error
-# condition.  This is sufficient to atomically switch the current link
-# tree.
-
-print "switching $current to $link\n";
-
-my $tmplink = "$linkdir/.new_$name";
-symlink($link, $tmplink) or die "cannot create $tmplink";
-rename($tmplink, $current) or die "cannot rename $tmplink";
-
-if (!$keep && defined $oldlink) {
-    print "deleting old $oldlink\n";
-    unlink($oldlink) == 1 or print "cannot delete $oldlink\n";
-    unlink("$oldlink.id") == 1 or print "cannot delete $oldlink.id\n";
-    unlink("$oldlink-src.id");
-}

scripts/optimise-store.pl

@@ -0,0 +1,69 @@
+#! /usr/bin/perl -w
+
+use strict;
+
+{ my $ofh = select STDOUT;
+  $| = 1;
+  select $ofh;
+}
+
+#my @paths = ("/nix/store/caef3a49150506d233f474322a824e50-glibc-2.3.3", "/nix/store/a8a9d585d1ad4b1bc911be7743b3b996-glibc-2.3.3");
+my @paths = ("/nix/store");
+
+my $tmpfile = "/tmp/nix-optimise-hash-list";
+#my $tmpfile = "/data/nix-optimise-hash-list";
+
+system("find @paths -type f -print0 | xargs -0 md5sum -- > $tmpfile") == 0
+    or die "cannot hash store files";
+
+system("sort $tmpfile > $tmpfile.sorted") == 0
+    or die "cannot sort list";
+
+open LIST, "<$tmpfile.sorted" or die;
+
+my $prevFile;
+my $prevHash;
+
+my $totalSpace = 0;
+my $savedSpace = 0;
+
+my $files = 0;
+
+while (<LIST>) {
+#    print "D";
+    /^([0-9a-f]*)\s+(.*)$/ or die;
+    my $curFile = $2;
+    my $curHash = $1;
+
+#    print "A";
+    my $fileSize = (stat $curFile)[7];
+#    print "B";
+#    my $fileSize = 1;
+    $totalSpace += $fileSize;
+
+    if (defined $prevHash && $curHash eq $prevHash) {
+        
+#        print "$curFile = $prevFile\n";
+
+        $savedSpace += $fileSize;
+        
+    } else {
+        $prevFile = $curFile;
+        $prevHash = $curHash;
+    }
+
+    print "." if ($files++ % 100 == 0);
+    #print ".";
+
+#    print "C";
+}
+
+print "\n";
+
+print "total space = $totalSpace\n";
+print "saved space = $savedSpace\n";
+my $savings = ($savedSpace / $totalSpace) * 100.0;
+print "savings = $savings %\n";
+
+
+close LIST;

scripts/prebuilts.conf

@@ -1,2 +1,2 @@
-# A list of URLs from where we obtain Nix archives.
-http://losser.st-lab.cs.uu.nl/~eelco/nix-dist/
+# A list of URLs from where `nix-pull' obtain Nix archives if
+# no URL is specified on the command line.

scripts/readmanifest.pm.in

@@ -0,0 +1,193 @@
+use strict;
+
+
+sub addPatch {
+    my $patches = shift;
+    my $storePath = shift;
+    my $patch = shift;
+
+    $$patches{$storePath} = []
+        unless defined $$patches{$storePath};
+
+    my $patchList = $$patches{$storePath};
+
+    my $found = 0;
+    foreach my $patch2 (@{$patchList}) {
+        if ($patch2->{url} eq $patch->{url}) {
+            if ($patch2->{hash} eq $patch->{hash}) {
+                $found = 1 if ($patch2->{basePath} eq $patch->{basePath});
+            } else {
+                die "conflicting hashes for URL $patch->{url}, " .
+                    "namely $patch2->{hash} and $patch->{hash}";
+            }
+        }
+    }
+    
+    push @{$patchList}, $patch if !$found;
+
+    return !$found;
+}
+
+
+sub readManifest {
+    my $manifest = shift;
+    my $narFiles = shift;
+    my $patches = shift;
+    my $successors = shift;
+
+    open MANIFEST, "<$manifest";
+
+    my $inside = 0;
+    my $type;
+
+    my $storePath;
+    my $url;
+    my $hash;
+    my $size;
+    my @preds;
+    my $basePath;
+    my $baseHash;
+    my $patchType;
+    my $narHash;
+
+    while (<MANIFEST>) {
+        chomp;
+        s/\#.*$//g;
+        next if (/^$/);
+
+        if (!$inside) {
+
+            if (/^\s*(\w*)\s*\{$/) {
+                $type = $1;
+                $type = "narfile" if $type eq "";
+                $inside = 1;
+                undef $storePath;
+                undef $url;
+                undef $hash;
+                undef $size;
+                @preds = ();
+                undef $narHash;
+                undef $basePath;
+                undef $baseHash;
+                undef $patchType;
+	    }
+
+        } else {
+            
+            if (/^\}$/) {
+                $inside = 0;
+
+                if ($type eq "narfile") {
+
+                    $$narFiles{$storePath} = []
+                        unless defined $$narFiles{$storePath};
+
+                    my $narFileList = $$narFiles{$storePath};
+
+                    my $found = 0;
+                    foreach my $narFile (@{$narFileList}) {
+                        if ($narFile->{url} eq $url) {
+                            if ($narFile->{hash} eq $hash) {
+                                $found = 1;
+                            } else {
+                                die "conflicting hashes for URL $url, " .
+                                    "namely $narFile->{hash} and $hash";
+                            }
+                        }
+                    }
+                    if (!$found) {
+                        push @{$narFileList},
+                            { url => $url, hash => $hash, size => $size
+                            , narHash => $narHash
+                            };
+                    }
+                
+                    foreach my $p (@preds) {
+                        $$successors{$p} = $storePath;
+                    }
+
+                }
+
+                elsif ($type eq "patch") {
+                    addPatch $patches, $storePath,
+                        { url => $url, hash => $hash, size => $size
+                        , basePath => $basePath, baseHash => $baseHash
+                        , narHash => $narHash, patchType => $patchType
+                        };
+                }
+
+            }
+            
+            elsif (/^\s*StorePath:\s*(\/\S+)\s*$/) { $storePath = $1; }
+            elsif (/^\s*Hash:\s*(\S+)\s*$/) { $hash = $1; }
+            elsif (/^\s*URL:\s*(\S+)\s*$/) { $url = $1; }
+            elsif (/^\s*Size:\s*(\d+)\s*$/) { $size = $1; }
+            elsif (/^\s*SuccOf:\s*(\/\S+)\s*$/) { push @preds, $1; }
+            elsif (/^\s*BasePath:\s*(\/\S+)\s*$/) { $basePath = $1; }
+            elsif (/^\s*BaseHash:\s*(\S+)\s*$/) { $baseHash = $1; }
+            elsif (/^\s*Type:\s*(\S+)\s*$/) { $patchType = $1; }
+            elsif (/^\s*NarHash:\s*(\S+)\s*$/) { $narHash = $1; }
+
+            # Compatibility;
+            elsif (/^\s*NarURL:\s*(\S+)\s*$/) { $url = $1; }
+            elsif (/^\s*MD5:\s*(\S+)\s*$/) { $hash = $1; }
+
+        }
+    }
+
+    close MANIFEST;
+}
+
+
+sub writeManifest
+{
+    my $manifest = shift;
+    my $narFiles = shift;
+    my $patches = shift;
+    my $successors = shift;
+
+    open MANIFEST, ">$manifest.tmp"; # !!! check exclusive
+
+    foreach my $storePath (keys %{$narFiles}) {
+        my $narFileList = $$narFiles{$storePath};
+        foreach my $narFile (@{$narFileList}) {
+            print MANIFEST "{\n";
+            print MANIFEST "  StorePath: $storePath\n";
+            print MANIFEST "  NarURL: $narFile->{url}\n";
+            print MANIFEST "  MD5: $narFile->{hash}\n";
+            print MANIFEST "  NarHash: $narFile->{narHash}\n";
+            print MANIFEST "  Size: $narFile->{size}\n";
+            foreach my $p (keys %{$successors}) { # !!! quadratic
+                if ($$successors{$p} eq $storePath) {
+                    print MANIFEST "  SuccOf: $p\n";
+                }
+            }
+            print MANIFEST "}\n";
+        }
+    }
+    
+    foreach my $storePath (keys %{$patches}) {
+        my $patchList = $$patches{$storePath};
+        foreach my $patch (@{$patchList}) {
+            print MANIFEST "patch {\n";
+            print MANIFEST "  StorePath: $storePath\n";
+            print MANIFEST "  NarURL: $patch->{url}\n";
+            print MANIFEST "  MD5: $patch->{hash}\n";
+            print MANIFEST "  NarHash: $patch->{narHash}\n";
+            print MANIFEST "  Size: $patch->{size}\n";
+            print MANIFEST "  BasePath: $patch->{basePath}\n";
+            print MANIFEST "  BaseHash: $patch->{baseHash}\n";
+            print MANIFEST "  Type: $patch->{patchType}\n";
+            print MANIFEST "}\n";
+        }
+    }
+    
+    
+    close MANIFEST;
+
+    rename("$manifest.tmp", $manifest)
+        or die "cannot rename $manifest.tmp: $!";
+}
+
+
+return 1;

scripts/remove-patches.pl

@@ -0,0 +1,19 @@
+#! /usr/bin/perl -w -I/home/eelco/nix/scripts
+
+use strict;
+use readmanifest;
+
+for my $p (@ARGV) {
+
+    my %narFiles;
+    my %patches;
+    my %successors;
+
+    readManifest $p,
+        \%narFiles, \%patches, \%successors;
+
+    %patches = ();
+    
+    writeManifest $p,
+        \%narFiles, \%patches, \%successors;
+}

scripts/update-manifest.pl

@@ -0,0 +1,53 @@
+#! /usr/bin/perl -w -I.
+
+use strict;
+use readmanifest;
+
+die unless scalar @ARGV == 2;
+
+my $cache = $ARGV[0];
+my $manifest = $ARGV[1];
+my %narFiles;
+my %patches;
+my %successors;
+
+readManifest $manifest, \%narFiles, \%patches, \%successors;
+
+foreach my $storePath (keys %narFiles) {
+    my $narFileList = $narFiles{$storePath};
+
+    foreach my $narFile (@{$narFileList}) {
+        if (!defined $narFile->{size} or
+            !defined $narFile->{narHash})
+        {
+            $narFile->{url} =~ /\/([^\/]+)$/;
+            die unless defined $1;
+            my $fn = "$cache/$1";
+            
+            my @info = stat $fn or die;
+            $narFile->{size} = $info[7];
+
+            my $narHash;
+            my $hashFile = "$fn.NARHASH";
+            if (-e $hashFile) {
+                open HASH, "<$hashFile" or die;
+                $narHash = <HASH>;
+                close HASH;
+            } else {
+                print "$fn\n";
+                $narHash = `bunzip2 < '$fn' | nix-hash --flat /dev/stdin` or die;
+                open HASH, ">$hashFile" or die;
+                print HASH $narHash;
+                close HASH;
+            }
+            chomp $narHash;
+            $narFile->{narHash} = $narHash;
+        }
+    }
+}
+
+if (! -e "$manifest.backup") {
+    system "mv --reply=no '$manifest' '$manifest.backup'";
+}
+
+writeManifest $manifest, \%narFiles, \%patches, \%successors;

src/Makefile.am

@@ -1 +1,15 @@
-SUBDIRS = boost libnix libmain nix nix-hash fix fix-ng
+SUBDIRS = bin2c boost libutil libstore libmain nix-store nix-hash \
+ libexpr nix-instantiate nix-env log2xml bsdiff-4.2
+
+EXTRA_DIST = aterm-helper.pl
+
+SETUID_PROGS = nix-store nix-instantiate nix-env
+install-exec-hook:
+if SETUID_HACK
+if HAVE_SETRESUID
+	cd $(DESTDIR)$(bindir) && chown @NIX_USER@ $(SETUID_PROGS) \
+	  && chgrp @NIX_GROUP@ $(SETUID_PROGS) && chmod ug+s $(SETUID_PROGS)
+else
+	cd $(DESTDIR)$(bindir) && chown root $(SETUID_PROGS) && chmod u+s $(SETUID_PROGS)
+endif
+endif

src/aterm-helper.pl

@@ -0,0 +1,143 @@
+#! /usr/bin/perl -w
+
+# This program generates C/C++ code for efficiently manipulating
+# ATerms.  It generates functions to build and match ATerms according
+# to a set of constructor definitions defined in a file read from
+# standard input.  A constructor is defined by a line with the
+# following format:
+#
+#   SYM | ARGS | TYPE | FUN?
+#
+# where SYM is the name of the constructor, ARGS is a
+# whitespace-separated list of argument types, TYPE is the type of the
+# resulting ATerm (which should be `ATerm' or a type synonym for
+# `ATerm'), and the optional FUN is used to construct the names of the
+# build and match functions (it defaults to SYM; overriding it is
+# useful if there are overloaded constructors, e.g., with different
+# arities).  Note that SYM may be empty.
+#
+# A line of the form
+#
+#   VAR = EXPR
+#
+# causes a ATerm variable to be generated that is initialised to the
+# value EXPR.
+#
+# Finally, a line of the form
+#
+#   init NAME
+#
+# causes the initialisation function to be called `NAME'.  This
+# function must be called before any of the build/match functions or
+# the generated variables are used.
+
+die if scalar @ARGV != 2;
+
+my $syms = "";
+my $init = "";
+my $initFun = "init";
+
+open HEADER, ">$ARGV[0]";
+open IMPL, ">$ARGV[1]";
+
+while (<STDIN>) {
+    next if (/^\s*$/);
+    
+    if (/^\s*(\w*)\s*\|([^\|]*)\|\s*(\w+)\s*\|\s*(\w+)?/) {
+        my $const = $1;
+        my @types = split ' ', $2;
+        my $result = $3;
+        my $funname = $4;
+        $funname = $const unless defined $funname;
+
+        my $formals = "";
+        my $formals2 = "";
+        my $args = "";
+        my $unpack = "";
+        my $n = 1;
+        foreach my $type (@types) {
+            $args .= ", ";
+            if ($type eq "string") {
+#                $args .= "(ATerm) ATmakeAppl0(ATmakeAFun((char *) e$n, 0, ATtrue))";
+#                $type = "const char *";
+                $type = "ATerm";
+                $args .= "e$n";
+                # !!! in the matcher, we should check that the
+                # argument is a string (i.e., a nullary application).
+            } elsif ($type eq "int") {
+                $args .= "(ATerm) ATmakeInt(e$n)";
+            } elsif ($type eq "ATermList" || $type eq "ATermBlob") {
+                $args .= "(ATerm) e$n";
+            } else {
+                $args .= "e$n";
+            }
+            $formals .= ", " if $formals ne "";
+            $formals .= "$type e$n";
+            $formals2 .= ", ";
+            $formals2 .= "$type & e$n";
+            my $m = $n - 1;
+            # !!! more checks here
+            if ($type eq "int") {
+                $unpack .= "    e$n = ATgetInt((ATermInt) ATgetArgument(e, $m));\n";
+            } elsif ($type eq "ATermList") {
+                $unpack .= "    e$n = (ATermList) ATgetArgument(e, $m);\n";
+            } elsif ($type eq "ATermBlob") {
+                $unpack .= "    e$n = (ATermBlob) ATgetArgument(e, $m);\n";
+            } else {
+                $unpack .= "    e$n = ATgetArgument(e, $m);\n";
+            }
+            $n++;
+        }
+
+        my $arity = scalar @types;
+
+        print HEADER "extern AFun sym$funname;\n\n";
+        
+        print IMPL "AFun sym$funname = 0;\n";
+        
+        print HEADER "static inline $result make$funname($formals) {\n";
+        print HEADER "    return (ATerm) ATmakeAppl$arity(sym$funname$args);\n";
+        print HEADER "}\n\n";
+
+        print HEADER "#ifdef __cplusplus\n";
+        print HEADER "static inline bool match$funname(ATerm e$formals2) {\n";
+        print HEADER "    if (ATgetType(e) != AT_APPL || ATgetAFun(e) != sym$funname) return false;\n";
+        print HEADER "$unpack";
+        print HEADER "    return true;\n";
+        print HEADER "}\n";
+        print HEADER "#endif\n\n\n";
+
+        $init .= "    sym$funname = ATmakeAFun(\"$const\", $arity, ATfalse);\n";
+        $init .= "    ATprotectAFun(sym$funname);\n";
+    }
+
+    elsif (/^\s*(\w+)\s*=\s*(.*)$/) {
+        my $name = $1;
+        my $value = $2;
+        print HEADER "extern ATerm $name;\n";
+        print IMPL "ATerm $name = 0;\n";
+        $init .= "    $name = $value;\n";
+    }
+
+    elsif (/^\s*init\s+(\w+)\s*$/) {
+        $initFun = $1;
+    }
+
+    else {
+        die "bad line: `$_'";
+    }
+}
+
+print HEADER "void $initFun();\n\n";
+
+print HEADER "static inline const char * aterm2String(ATerm t) {\n";
+print HEADER "    return (const char *) ATgetName(ATgetAFun(t));\n";
+print HEADER "}\n\n";
+
+print IMPL "\n";
+print IMPL "void $initFun() {\n";
+print IMPL "$init";
+print IMPL "}\n";
+
+close HEADER;
+close IMPL;

src/bin2c/Makefile.am

@@ -0,0 +1,3 @@
+noinst_PROGRAMS = bin2c
+
+bin2c_SOURCES = bin2c.c

src/boost/Makefile.am

@@ -1,3 +1,6 @@
 SUBDIRS = format
 
-EXTRA_DIST = format.hpp
+EXTRA_DIST = assert.hpp checked_delete.hpp format.hpp \
+ shared_ptr.hpp weak_ptr.hpp throw_exception.hpp \
+ enable_shared_from_this.hpp \
+ detail/shared_count.hpp detail/workaround.hpp

src/boost/assert.hpp

@@ -0,0 +1,38 @@
+//
+//  boost/assert.hpp - BOOST_ASSERT(expr)
+//
+//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  Note: There are no include guards. This is intentional.
+//
+//  See http://www.boost.org/libs/utility/assert.html for documentation.
+//
+
+#undef BOOST_ASSERT
+
+#if defined(BOOST_DISABLE_ASSERTS)
+
+# define BOOST_ASSERT(expr) ((void)0)
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+
+#include <boost/current_function.hpp>
+
+namespace boost
+{
+
+void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
+
+} // namespace boost
+
+#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+# include <assert.h>
+# define BOOST_ASSERT(expr) assert(expr)
+#endif

src/boost/checked_delete.hpp

@@ -0,0 +1,71 @@
+#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
+#define BOOST_CHECKED_DELETE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/checked_delete.hpp
+//
+//  Copyright (c) 1999, 2000, 2001, 2002 boost.org
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) 2003 Daniel Frey
+//  Copyright (c) 2003 Howard Hinnant
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org/libs/utility/checked_delete.html for documentation.
+//
+
+namespace boost
+{
+
+// verify that types are complete for increased safety
+
+template<class T> inline void checked_delete(T * x)
+{
+    // intentionally complex - simplification causes regressions
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        // boost:: disables ADL
+        boost::checked_delete(x);
+    }
+};
+
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED

src/boost/detail/shared_count.hpp

@@ -0,0 +1,555 @@
+#ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  detail/shared_count.hpp
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+
+//#include <boost/config.hpp>
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
+#endif
+
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+//#include <boost/detail/lightweight_mutex.hpp>
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include <boost/detail/quick_allocator.hpp>
+#endif
+
+#include <memory>           // std::auto_ptr, std::allocator
+#include <functional>       // std::less
+#include <exception>        // std::exception
+#include <new>              // std::bad_alloc
+#include <typeinfo>         // std::type_info in get_deleter
+#include <cstddef>          // std::size_t
+
+#ifdef __BORLANDC__
+# pragma warn -8026     // Functions with excep. spec. are not expanded inline
+# pragma warn -8027     // Functions containing try are not expanded inline
+#endif
+
+namespace boost
+{
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
+// The standard library that comes with Borland C++ 5.5.1
+// defines std::exception and its members as having C calling
+// convention (-pc). When the definition of bad_weak_ptr
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below. The version
+// check is deliberately conservative.
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option push -pc
+#endif
+
+class bad_weak_ptr: public std::exception
+{
+public:
+
+    virtual char const * what() const throw()
+    {
+        return "boost::bad_weak_ptr";
+    }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option pop
+#endif
+
+namespace detail
+{
+
+class sp_counted_base
+{
+private:
+
+    //    typedef detail::lightweight_mutex mutex_type;
+
+public:
+
+    sp_counted_base(): use_count_(1), weak_count_(1)
+    {
+    }
+
+    virtual ~sp_counted_base() // nothrow
+    {
+    }
+
+    // dispose() is called when use_count_ drops to zero, to release
+    // the resources managed by *this.
+
+    virtual void dispose() = 0; // nothrow
+
+    // destruct() is called when weak_count_ drops to zero.
+
+    virtual void destruct() // nothrow
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter(std::type_info const & ti) = 0;
+
+    void add_ref_copy()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++use_count_;
+    }
+
+    void add_ref_lock()
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        if(use_count_ == 0) boost::throw_exception(boost::bad_weak_ptr());
+        ++use_count_;
+    }
+
+    void release() // nothrow
+    {
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            long new_use_count = --use_count_;
+
+            if(new_use_count != 0) return;
+        }
+
+        dispose();
+        weak_release();
+    }
+
+    void weak_add_ref() // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        ++weak_count_;
+    }
+
+    void weak_release() // nothrow
+    {
+        long new_weak_count;
+
+        {
+#if defined(BOOST_HAS_THREADS)
+            mutex_type::scoped_lock lock(mtx_);
+#endif
+            new_weak_count = --weak_count_;
+        }
+
+        if(new_weak_count == 0)
+        {
+            destruct();
+        }
+    }
+
+    long use_count() const // nothrow
+    {
+#if defined(BOOST_HAS_THREADS)
+        mutex_type::scoped_lock lock(mtx_);
+#endif
+        return use_count_;
+    }
+
+private:
+
+    sp_counted_base(sp_counted_base const &);
+    sp_counted_base & operator= (sp_counted_base const &);
+
+    long use_count_;        // #shared
+    long weak_count_;       // #weak + (#shared != 0)
+
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
+    mutable mutex_type mtx_;
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_constructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+    boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+    boost::sp_array_destructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#endif
+
+//
+// Borland's Codeguard trips up over the -Vx- option here:
+//
+#ifdef __CODEGUARD__
+# pragma option push -Vx-
+#endif
+
+template<class P, class D> class sp_counted_base_impl: public sp_counted_base
+{
+private:
+
+    P ptr; // copy constructor must not throw
+    D del; // copy constructor must not throw
+
+    sp_counted_base_impl(sp_counted_base_impl const &);
+    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+    typedef sp_counted_base_impl<P, D> this_type;
+
+public:
+
+    // pre: initial_use_count <= initial_weak_count, d(p) must not throw
+
+    sp_counted_base_impl(P p, D d): ptr(p), del(d)
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
+    }
+
+    virtual void dispose() // nothrow
+    {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
+        del(ptr);
+    }
+
+    virtual void * get_deleter(std::type_info const & ti)
+    {
+        return ti == typeid(D)? &del: 0;
+    }
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
+    }
+
+    void operator delete(void * p)
+    {
+        std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
+    }
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+    void * operator new(std::size_t)
+    {
+        return quick_allocator<this_type>::alloc();
+    }
+
+    void operator delete(void * p)
+    {
+        quick_allocator<this_type>::dealloc(p);
+    }
+
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+int const shared_count_id = 0x2C35F101;
+int const   weak_count_id = 0x298C38A4;
+
+#endif
+
+class weak_count;
+
+class shared_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+    int id_;
+#endif
+
+    friend class weak_count;
+
+public:
+
+    shared_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+    }
+
+    template<class P, class D> shared_count(P p, D d): pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+#ifndef BOOST_NO_EXCEPTIONS
+
+        try
+        {
+            pi_ = new sp_counted_base_impl<P, D>(p, d);
+        }
+        catch(...)
+        {
+            d(p); // delete p
+            throw;
+        }
+
+#else
+
+        pi_ = new sp_counted_base_impl<P, D>(p, d);
+
+        if(pi_ == 0)
+        {
+            d(p); // delete p
+            boost::throw_exception(std::bad_alloc());
+        }
+
+#endif
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    // auto_ptr<Y> is special cased to provide the strong guarantee
+
+    template<class Y>
+    explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>()))
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        r.release();
+    }
+
+#endif 
+
+    ~shared_count() // nothrow
+    {
+        if(pi_ != 0) pi_->release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        id_ = 0;
+#endif
+    }
+
+    shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->add_ref_copy();
+    }
+
+    explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
+
+    shared_count & operator= (shared_count const & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->add_ref_copy();
+        if(pi_ != 0) pi_->release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    void swap(shared_count & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const // nothrow
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    bool unique() const // nothrow
+    {
+        return use_count() == 1;
+    }
+
+    friend inline bool operator==(shared_count const & a, shared_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(shared_count const & a, shared_count const & b)
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+
+    void * get_deleter(std::type_info const & ti) const
+    {
+        return pi_? pi_->get_deleter(ti): 0;
+    }
+};
+
+#ifdef __CODEGUARD__
+# pragma option pop
+#endif
+
+
+class weak_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+    int id_;
+#endif
+
+    friend class shared_count;
+
+public:
+
+    weak_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(weak_count_id)
+#endif
+    {
+    }
+
+    weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    ~weak_count() // nothrow
+    {
+        if(pi_ != 0) pi_->weak_release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        id_ = 0;
+#endif
+    }
+
+    weak_count & operator= (shared_count const & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->weak_add_ref();
+        if(pi_ != 0) pi_->weak_release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    weak_count & operator= (weak_count const & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        if(tmp != 0) tmp->weak_add_ref();
+        if(pi_ != 0) pi_->weak_release();
+        pi_ = tmp;
+
+        return *this;
+    }
+
+    void swap(weak_count & r) // nothrow
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const // nothrow
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    friend inline bool operator==(weak_count const & a, weak_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(weak_count const & a, weak_count const & b)
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+};
+
+inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+{
+    if(pi_ != 0)
+    {
+        pi_->add_ref_lock();
+    }
+    else
+    {
+        boost::throw_exception(boost::bad_weak_ptr());
+    }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#ifdef __BORLANDC__
+# pragma warn .8027     // Functions containing try are not expanded inline
+# pragma warn .8026     // Functions with excep. spec. are not expanded inline
+#endif
+
+#endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED

src/boost/detail/workaround.hpp

@@ -0,0 +1,74 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef WORKAROUND_DWA2002126_HPP
+# define WORKAROUND_DWA2002126_HPP
+
+// Compiler/library version workaround macro
+//
+// Usage:
+//
+//     #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+//        ... // workaround code here
+//     #endif
+//
+// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
+// first argument must be undefined or expand to a numeric
+// value. The above expands to:
+//
+//     (BOOST_MSVC) != 0 && (BOOST_MSVC) <= 1200
+//
+// When used for workarounds that apply to the latest known version 
+// and all earlier versions of a compiler, the following convention 
+// should be observed:
+//
+//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
+//
+// The version number in this case corresponds to the last version in
+// which the workaround was known to have been required. When
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
+// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
+// the workaround for any version of the compiler. When
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
+// error will be issued if the compiler version exceeds the argument
+// to BOOST_TESTED_AT().  This can be used to locate workarounds which
+// may be obsoleted by newer versions.
+
+# ifndef BOOST_STRICT_CONFIG
+
+#  define BOOST_WORKAROUND(symbol, test)                \
+        ((symbol != 0) && (1 % (( (symbol test) ) + 1)))
+//                              ^ ^           ^ ^
+// The extra level of parenthesis nesting above, along with the
+// BOOST_OPEN_PAREN indirection below, is required to satisfy the
+// broken preprocessor in MWCW 8.3 and earlier.
+//
+// The basic mechanism works as follows:
+//      (symbol test) + 1        =>   if (symbol test) then 2 else 1
+//      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
+//
+// The complication with % is for cooperation with BOOST_TESTED_AT().
+// When "test" is BOOST_TESTED_AT(x) and
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
+//
+//      symbol test              =>   if (symbol <= x) then 1 else -1
+//      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
+//      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
+//
+
+#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
+#   define BOOST_OPEN_PAREN (
+#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
+#  else
+#   define BOOST_TESTED_AT(value) != ((value)-(value))
+#  endif
+
+# else
+
+#  define BOOST_WORKAROUND(symbol, test) 0
+
+# endif 
+
+#endif // WORKAROUND_DWA2002126_HPP

src/boost/enable_shared_from_this.hpp

@@ -0,0 +1,68 @@
+#ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+#define BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+
+//
+//  enable_shared_from_this.hpp
+//
+//  Copyright (c) 2002 Peter Dimov
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//
+
+#include <boost/weak_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/assert.hpp>
+//#include <boost/config.hpp>
+
+namespace boost
+{
+
+template<class T> class enable_shared_from_this
+{
+protected:
+
+    enable_shared_from_this()
+    {
+    }
+
+    enable_shared_from_this(enable_shared_from_this const &)
+    {
+    }
+
+    enable_shared_from_this & operator=(enable_shared_from_this const &)
+    {
+        return *this;
+    }
+
+    ~enable_shared_from_this()
+    {
+    }
+
+public:
+
+    shared_ptr<T> shared_from_this()
+    {
+        shared_ptr<T> p(_internal_weak_this);
+        BOOST_ASSERT(p.get() == this);
+        return p;
+    }
+
+    shared_ptr<T const> shared_from_this() const
+    {
+        shared_ptr<T const> p(_internal_weak_this);
+        BOOST_ASSERT(p.get() == this);
+        return p;
+    }
+
+    typedef T _internal_element_type; // for bcc 5.5.1
+    weak_ptr<_internal_element_type> _internal_weak_this;
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED

src/boost/format.hpp

@@ -24,23 +24,16 @@
 #include <sstream>
 #include <cassert>
 
+#if HAVE_LOCALE
 #include <locale>
-//#define BOOST_NO_STD_LOCALE
-//#define BOOST_NO_LOCALE_ISIDIGIT
-//#include <cctype>
+#else
+#define BOOST_NO_STD_LOCALE
+#define BOOST_NO_LOCALE_ISIDIGIT
+#include <cctype>
+#endif
 
 #include <boost/format/macros_default.hpp>
 
-namespace boost 
-{
-    template<class E> void throw_exception(E const & e)
-    {
-        throw e;
-    }
-}
-
-#define BOOST_ASSERT(expr) assert(expr)
-
 
 // ****  Forward declarations ----------------------------------
 #include <boost/format/format_fwd.hpp>           // basic_format<Ch,Tr>, and other frontends

src/boost/format/Makefile.am

@@ -1,8 +1,8 @@
 noinst_LIBRARIES = libformat.a
 
-libformat_a_SOURCES = format_implementation.cc free_funcs.cc parsing.cc
+libformat_a_SOURCES = format_implementation.cc free_funcs.cc \
+ parsing.cc exceptions.hpp feed_args.hpp format_class.hpp \
+ format_fwd.hpp group.hpp internals.hpp internals_fwd.hpp \
+ macros_default.hpp
 
 AM_CXXFLAGS = -Wall -I../..
-
-EXTRA_DIST = exceptions.hpp feed_args.hpp format_class.hpp format_fwd.hpp \
- group.hpp internals.hpp internals_fwd.hpp macros_default.hpp

src/boost/format/feed_args.hpp

@@ -24,7 +24,7 @@
 #include "boost/format/format_class.hpp"
 #include "boost/format/group.hpp"
 
-//#include "boost/throw_exception.hpp"
+#include "boost/throw_exception.hpp"
 
 namespace boost {
 namespace io {

src/boost/format/format_implementation.cc

@@ -20,8 +20,8 @@
 #ifndef BOOST_FORMAT_IMPLEMENTATION_HPP
 #define BOOST_FORMAT_IMPLEMENTATION_HPP
 
-//#include <boost/throw_exception.hpp>
-//#include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
 #include <boost/format.hpp>
 
 namespace boost {

src/boost/format/free_funcs.cc

@@ -20,7 +20,7 @@
 #define BOOST_FORMAT_FUNCS_HPP
 
 #include "boost/format.hpp"
-//#include "boost/throw_exception.hpp"
+#include "boost/throw_exception.hpp"
 
 namespace boost {
 

src/boost/format/parsing.cc

@@ -23,8 +23,8 @@
 
 
 #include <boost/format.hpp>
-//#include <boost/throw_exception.hpp>
-//#include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
 
 
 namespace boost {

src/boost/shared_ptr.hpp

@@ -0,0 +1,474 @@
+#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SHARED_PTR_HPP_INCLUDED
+
+//
+//  shared_ptr.hpp
+//
+//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+//#include <boost/config.hpp>   // for broken compiler workarounds
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/detail/shared_ptr_nmt.hpp>
+#else
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/shared_count.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <memory>               // for std::auto_ptr
+#include <algorithm>            // for std::swap
+#include <functional>           // for std::less
+#include <typeinfo>             // for std::bad_cast
+#include <iosfwd>               // for std::basic_ostream
+
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+
+namespace boost
+{
+
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+
+namespace detail
+{
+
+struct static_cast_tag {};
+struct const_cast_tag {};
+struct dynamic_cast_tag {};
+struct polymorphic_cast_tag {};
+
+template<class T> struct shared_ptr_traits
+{
+    typedef T & reference;
+};
+
+template<> struct shared_ptr_traits<void>
+{
+    typedef void reference;
+};
+
+#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
+
+template<> struct shared_ptr_traits<void const>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void volatile>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void const volatile>
+{
+    typedef void reference;
+};
+
+#endif
+
+// enable_shared_from_this support
+
+template<class T, class Y> void sp_enable_shared_from_this(boost::enable_shared_from_this<T> * pe, Y * px, shared_count const & pn)
+{
+    if(pe != 0) pe->_internal_weak_this._internal_assign(px, pn);
+}
+
+inline void sp_enable_shared_from_this(void const volatile *, void const volatile *, shared_count const &)
+{
+}
+
+} // namespace detail
+
+
+//
+//  shared_ptr
+//
+//  An enhanced relative of scoped_ptr with reference counted copy semantics.
+//  The object pointed to is deleted when the last shared_ptr pointing to it
+//  is destroyed or reset.
+//
+
+template<class T> class shared_ptr
+{
+private:
+
+    // Borland 5.5.1 specific workaround
+    typedef shared_ptr<T> this_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+    typedef T * pointer;
+    typedef typename detail::shared_ptr_traits<T>::reference reference;
+
+    shared_ptr(): px(0), pn() // never throws in 1.30+
+    {
+    }
+
+    template<class Y>
+    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete
+    {
+        detail::sp_enable_shared_from_this(p, p, pn);
+    }
+
+    //
+    // Requirements: D's copy constructor must not throw
+    //
+    // shared_ptr will release p by calling d(p)
+    //
+
+    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+    {
+        detail::sp_enable_shared_from_this(p, p, pn);
+    }
+
+//  generated copy constructor, assignment, destructor are fine...
+
+//  except that Borland C++ has a bug, and g++ with -Wsynth warns
+#if defined(__BORLANDC__) || defined(__GNUC__)
+
+    shared_ptr & operator=(shared_ptr const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
+    }
+
+#endif
+
+    template<class Y>
+    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
+    {
+        // it is now safe to copy r.px, as pn(r.pn) did not throw
+        px = r.px;
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0) // need to allocate new counter -- the cast failed
+        {
+            pn = detail::shared_count();
+        }
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0)
+        {
+            boost::throw_exception(std::bad_cast());
+        }
+    }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    template<class Y>
+    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
+    {
+        Y * tmp = r.get();
+        pn = detail::shared_count(r);
+        detail::sp_enable_shared_from_this(tmp, tmp, pn);
+    }
+
+#endif
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
+
+    template<class Y>
+    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn; // shared_count::op= doesn't throw
+        return *this;
+    }
+
+#endif
+
+#ifndef BOOST_NO_AUTO_PTR
+
+    template<class Y>
+    shared_ptr & operator=(std::auto_ptr<Y> & r)
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+#endif
+
+    void reset() // never throws in 1.30+
+    {
+        this_type().swap(*this);
+    }
+
+    template<class Y> void reset(Y * p) // Y must be complete
+    {
+        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
+        this_type(p).swap(*this);
+    }
+
+    template<class Y, class D> void reset(Y * p, D d)
+    {
+        this_type(p, d).swap(*this);
+    }
+
+    reference operator* () const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return *px;
+    }
+
+    T * operator-> () const // never throws
+    {
+        BOOST_ASSERT(px != 0);
+        return px;
+    }
+    
+    T * get() const // never throws
+    {
+        return px;
+    }
+
+    // implicit conversion to "bool"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+    operator bool () const
+    {
+        return px != 0;
+    }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+    typedef T * (this_type::*unspecified_bool_type)() const;
+    
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::get;
+    }
+
+#else 
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+#endif
+
+    // operator! is redundant, but some compilers need it
+
+    bool operator! () const // never throws
+    {
+        return px == 0;
+    }
+
+    bool unique() const // never throws
+    {
+        return pn.unique();
+    }
+
+    long use_count() const // never throws
+    {
+        return pn.use_count();
+    }
+
+    void swap(shared_ptr<T> & other) // never throws
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
+    {
+        return pn < rhs.pn;
+    }
+
+    void * _internal_get_deleter(std::type_info const & ti) const
+    {
+        return pn.get_deleter(ti);
+    }
+
+// Tasteless as this may seem, making all members public allows member templates
+// to work in the absence of member template friends. (Matthew Langston)
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+private:
+
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+
+
+#endif
+
+    T * px;                     // contained pointer
+    detail::shared_count pn;    // reference counter
+
+};  // shared_ptr
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+
+#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
+
+// Resolve the ambiguity between our op!= and the one in rel_ops
+
+template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
+{
+    return a.get() != b.get();
+}
+
+#endif
+
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a._internal_less(b);
+}
+
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::const_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::dynamic_cast_tag());
+}
+
+// shared_*_cast names are deprecated. Use *_pointer_cast instead.
+
+template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::dynamic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, detail::polymorphic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+{
+    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
+    return shared_static_cast<T>(r);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+    return p.get();
+}
+
+// operator<<
+
+#if defined(__GNUC__) &&  (__GNUC__ < 3)
+
+template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
+{
+    os << p.get();
+    return os;
+}
+
+#else
+
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT)
+// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
+using std::basic_ostream;
+template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+# else
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+# endif 
+{
+    os << p.get();
+    return os;
+}
+
+#endif
+
+// get_deleter (experimental)
+
+#if (defined(__GNUC__) &&  (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238))
+
+// g++ 2.9x doesn't allow static_cast<X const *>(void *)
+// apparently EDG 2.38 also doesn't accept it
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+    void const * q = p._internal_get_deleter(typeid(D));
+    return const_cast<D *>(static_cast<D const *>(q));
+}
+
+#else
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
+}
+
+#endif
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
+#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+#endif  // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED

src/boost/throw_exception.hpp

@@ -0,0 +1,47 @@
+#ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED
+#define BOOST_THROW_EXCEPTION_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/throw_exception.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  http://www.boost.org/libs/utility/throw_exception.html
+//
+
+//#include <boost/config.hpp>
+
+#ifdef BOOST_NO_EXCEPTIONS
+# include <exception>
+#endif
+
+namespace boost
+{
+
+#ifdef BOOST_NO_EXCEPTIONS
+
+void throw_exception(std::exception const & e); // user defined
+
+#else
+
+template<class E> void throw_exception(E const & e)
+{
+    throw e;
+}
+
+#endif
+
+} // namespace boost
+
+#endif // #ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED

src/boost/weak_ptr.hpp

@@ -0,0 +1,193 @@
+#ifndef BOOST_WEAK_PTR_HPP_INCLUDED
+#define BOOST_WEAK_PTR_HPP_INCLUDED
+
+//
+//  weak_ptr.hpp
+//
+//  Copyright (c) 2001, 2002, 2003 Peter Dimov
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
+//
+
+#include <boost/shared_ptr.hpp>
+
+#ifdef BOOST_MSVC  // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+
+namespace boost
+{
+
+template<class T> class weak_ptr
+{
+private:
+
+    // Borland 5.5.1 specific workarounds
+    typedef weak_ptr<T> this_type;
+
+public:
+
+    typedef T element_type;
+
+    weak_ptr(): px(0), pn() // never throws in 1.30+
+    {
+    }
+
+//  generated copy constructor, assignment, destructor are fine
+
+
+//
+//  The "obvious" converting constructor implementation:
+//
+//  template<class Y>
+//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+//  {
+//  }
+//
+//  has a serious problem.
+//
+//  r.px may already have been invalidated. The px(r.px)
+//  conversion may require access to *r.px (virtual inheritance).
+//
+//  It is not possible to avoid spurious access violations since
+//  in multithreaded programs r.px may be invalidated at any point.
+//
+
+    template<class Y>
+    weak_ptr(weak_ptr<Y> const & r): pn(r.pn) // never throws
+    {
+        px = r.lock().get();
+    }
+
+    template<class Y>
+    weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+    {
+    }
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
+
+    template<class Y>
+    weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
+    {
+        px = r.lock().get();
+        pn = r.pn;
+        return *this;
+    }
+
+    template<class Y>
+    weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
+    {
+        px = r.px;
+        pn = r.pn;
+        return *this;
+    }
+
+#endif
+
+    shared_ptr<T> lock() const // never throws
+    {
+#if defined(BOOST_HAS_THREADS)
+
+        // optimization: avoid throw overhead
+        if(expired())
+        {
+            return shared_ptr<element_type>();
+        }
+
+        try
+        {
+            return shared_ptr<element_type>(*this);
+        }
+        catch(bad_weak_ptr const &)
+        {
+            // Q: how can we get here?
+            // A: another thread may have invalidated r after the use_count test above.
+            return shared_ptr<element_type>();
+        }
+
+#else
+
+        // optimization: avoid try/catch overhead when single threaded
+        return expired()? shared_ptr<element_type>(): shared_ptr<element_type>(*this);
+
+#endif
+    }
+
+    long use_count() const // never throws
+    {
+        return pn.use_count();
+    }
+
+    bool expired() const // never throws
+    {
+        return pn.use_count() == 0;
+    }
+
+    void reset() // never throws in 1.30+
+    {
+        this_type().swap(*this);
+    }
+
+    void swap(this_type & other) // never throws
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+    void _internal_assign(T * px2, detail::shared_count const & pn2)
+    {
+        px = px2;
+        pn = pn2;
+    }
+
+    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
+    {
+        return pn < rhs.pn;
+    }
+
+// Tasteless as this may seem, making all members public allows member templates
+// to work in the absence of member template friends. (Matthew Langston)
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+private:
+
+    template<class Y> friend class weak_ptr;
+    template<class Y> friend class shared_ptr;
+
+#endif
+
+    T * px;                     // contained pointer
+    detail::weak_count pn;      // reference counter
+
+};  // weak_ptr
+
+template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
+{
+    return a._internal_less(b);
+}
+
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+// deprecated, provided for backward compatibility
+template<class T> shared_ptr<T> make_shared(weak_ptr<T> const & r)
+{
+    return r.lock();
+}
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif    
+
+#endif  // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED

src/bsdiff-4.2/LICENSE

@@ -0,0 +1,121 @@
+BSD Protection License
+February 2002
+
+Preamble
+--------
+
+The Berkeley Software Distribution ("BSD") license has proven very effective
+over the years at allowing for a wide spread of work throughout both
+commercial and non-commercial products.  For programmers whose primary
+intention is to improve the general quality of available software, it is
+arguable that there is no better license than the BSD license, as it
+permits improvements to be used wherever they will help, without idealogical
+or metallic constraint.
+
+This is of particular value to those who produce reference implementations
+of proposed standards: The case of TCP/IP clearly illustrates that freely
+and universally available implementations leads the rapid acceptance of
+standards -- often even being used instead of a de jure standard (eg, OSI
+network models).
+
+With the rapid proliferation of software licensed under the GNU General
+Public License, however, the continued success of this role is called into
+question.  Given that the inclusion of a few lines of "GPL-tainted" work
+into a larger body of work will result in restricted distribution -- and
+given that further work will likely build upon the "tainted" portions,
+making them difficult to remove at a future date -- there are inevitable
+circumstances where authors would, in order to protect their goal of
+providing for the widespread usage of their work, wish to guard against
+such "GPL-taint".
+
+In addition, one can imagine that companies which operate by producing and
+selling (possibly closed-source) code would wish to protect themselves
+against the rise of a GPL-licensed competitor.  While under existing
+licenses this would mean not releasing their code under any form of open
+license, if a license existed under which they could incorporate any
+improvements back into their own (commercial) products then they might be
+far more willing to provide for non-closed distribution.
+
+For the above reasons, we put forth this "BSD Protection License": A
+license designed to retain the freedom granted by the BSD license to use
+licensed works in a wide variety of settings, both non-commercial and
+commercial, while protecting the work from having future contributors
+restrict that freedom.
+
+The precise terms and conditions for copying, distribution, and
+modification follow.
+
+BSD PROTECTION LICENSE
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION, AND MODIFICATION
+----------------------------------------------------------------
+
+0. Definitions.
+   a) "Program", below, refers to any program or work distributed under
+      the terms of this license.
+   b) A "work based on the Program", below, refers to either the Program
+      or any derivative work under copyright law.
+   c) "Modification", below, refers to the act of creating derivative works.
+   d) "You", below, refers to each licensee.
+
+1. Scope.
+   This license governs the copying, distribution, and modification of the
+   Program.  Other activities are outside the scope of this license; The
+   act of running the Program is not restricted, and the output from the
+   Program is covered only if its contents constitute a work based on the
+   Program.
+
+2. Verbatim copies.
+   You may copy and distribute verbatim copies of the Program as you
+   receive it, in any medium, provided that you conspicuously and
+   appropriately publish on each copy an appropriate copyright notice; keep
+   intact all the notices that refer to this License and to the absence of
+   any warranty; and give any other recipients of the Program a copy of this
+   License along with the Program.
+
+3. Modification and redistribution under closed license.
+   You may modify your copy or copies of the Program, and distribute
+   the resulting derivative works, provided that you meet the
+   following conditions:
+   a) The copyright notice and disclaimer on the Program must be reproduced
+      and included in the source code, documentation, and/or other materials
+      provided in a manner in which such notices are normally distributed.
+   b) The derivative work must be clearly identified as such, in order that
+      it may not be confused with the original work.
+   c) The license under which the derivative work is distributed must
+      expressly prohibit the distribution of further derivative works.
+
+4. Modification and redistribution under open license.
+   You may modify your copy or copies of the Program, and distribute
+   the resulting derivative works, provided that you meet the
+   following conditions:
+   a) The copyright notice and disclaimer on the Program must be reproduced
+      and included in the source code, documentation, and/or other materials
+      provided in a manner in which such notices are normally distributed.
+   b) You must clearly indicate the nature and date of any changes made
+      to the Program.  The full details need not necessarily be included in
+      the individual modified files, provided that each modified file is
+      clearly marked as such and instructions are included on where the
+      full details of the modifications may be found.
+   c) You must cause any work that you distribute or publish, that in whole
+      or in part contains or is derived from the Program or any part
+      thereof, to be licensed as a whole at no charge to all third
+      parties under the terms of this License.
+
+5. Implied acceptance.
+   You may not copy or distribute the Program or any derivative works except
+   as expressly provided under this license.  Consequently, any such action
+   will be taken as implied acceptance of the terms of this license.
+
+6. NO WARRANTY.
+   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+   THE COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+   REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE FOR ANY DIRECT,
+   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING, BUT
+   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+   TORT, EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGES.

src/bsdiff-4.2/Makefile.am

@@ -0,0 +1,7 @@
+libexec_PROGRAMS = bsdiff bspatch
+
+bsdiff_SOURCES = bsdiff.c
+
+bspatch_SOURCES = bspatch.c
+
+AM_CFLAGS = -O3 -DBZIP2=\"$(bzip2)\"

src/bsdiff-4.2/Makefile.old

@@ -0,0 +1,18 @@
+CFLAGS		+=	-O3
+.ifdef BZIP2
+CFLAGS		+=	-DBZIP2=\"${BZIP2}\"
+.endif
+
+PREFIX		?=	/usr/local
+INSTALL_PROGRAM	?=	${INSTALL} -c -s -m 555
+INSTALL_MAN	?=	${INSTALL} -c -m 444
+
+all:		bsdiff bspatch
+bsdiff:		bsdiff.c
+bspatch:	bspatch.c
+
+install:
+	${INSTALL_PROGRAM} bsdiff bspatch ${PREFIX}/bin
+.ifndef WITHOUT_MAN
+	${INSTALL_MAN} bsdiff.1 bspatch.1 ${PREFIX}/man/man1
+.endif

src/bsdiff-4.2/bsdiff.1

@@ -0,0 +1,36 @@
+.Dd May 18, 2003
+.Dt BSDIFF 1
+.Os FreeBSD
+.Sh NAME
+.Nm bsdiff
+.Nd generate a patch between two binary files
+.Sh SYNOPSIS
+.Nm
+.Ao Ar oldfile Ac Ao Ar newfile Ac Ao Ar patchfile Ac
+.Sh DESCRIPTION
+.Nm
+compares
+.Ao Ar oldfile Ac
+to
+.Ao Ar newfile Ac
+and writes to
+.Ao Ar patchfile Ac
+a binary patch suitable for use by bspatch(1).
+When
+.Ao Ar oldfile Ac
+and
+.Ao Ar newfile Ac
+are two versions of an executable program, the
+patches produced are on average a factor of five smaller
+than those produced by any other binary patch tool known
+to the author.
+.Pp
+.Nm
+uses memory equal to 17 times the size of 
+.Ao Ar oldfile Ac ,
+and requires
+an absolute minimum working set size of 8 times the size of oldfile.
+.Sh SEE ALSO
+.Xr bspatch 1
+.Sh AUTHORS
+.An Colin Percival Aq cperciva@daemonology.net

src/bsdiff-4.2/bsdiff.c

@@ -0,0 +1,385 @@
+/*
+  bsdiff.c -- Binary patch generator.
+
+  Copyright 2003 Colin Percival
+
+  For the terms under which this work may be distributed, please see
+  the adjoining file "LICENSE".
+*/
+
+#ifndef BZIP2
+#define BZIP2 "/usr/bin/bzip2"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <err.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+
+#define MIN(x,y) (((x)<(y)) ? (x) : (y))
+
+void split(off_t *I,off_t *V,off_t start,off_t len,off_t h)
+{
+	off_t i,j,k,x,tmp,jj,kk;
+
+	if(len<16) {
+		for(k=start;k<start+len;k+=j) {
+			j=1;x=V[I[k]+h];
+			for(i=1;k+i<start+len;i++) {
+				if(V[I[k+i]+h]<x) {
+					x=V[I[k+i]+h];
+					j=0;
+				};
+				if(V[I[k+i]+h]==x) {
+					tmp=I[k+j];I[k+j]=I[k+i];I[k+i]=tmp;
+					j++;
+				};
+			};
+			for(i=0;i<j;i++) V[I[k+i]]=k+j-1;
+			if(j==1) I[k]=-1;
+		};
+		return;
+	};
+
+	x=V[I[start+len/2]+h];
+	jj=0;kk=0;
+	for(i=start;i<start+len;i++) {
+		if(V[I[i]+h]<x) jj++;
+		if(V[I[i]+h]==x) kk++;
+	};
+	jj+=start;kk+=jj;
+
+	i=start;j=0;k=0;
+	while(i<jj) {
+		if(V[I[i]+h]<x) {
+			i++;
+		} else if(V[I[i]+h]==x) {
+			tmp=I[i];I[i]=I[jj+j];I[jj+j]=tmp;
+			j++;
+		} else {
+			tmp=I[i];I[i]=I[kk+k];I[kk+k]=tmp;
+			k++;
+		};
+	};
+
+	while(jj+j<kk) {
+		if(V[I[jj+j]+h]==x) {
+			j++;
+		} else {
+			tmp=I[jj+j];I[jj+j]=I[kk+k];I[kk+k]=tmp;
+			k++;
+		};
+	};
+
+	if(jj>start) split(I,V,start,jj-start,h);
+
+	for(i=0;i<kk-jj;i++) V[I[jj+i]]=kk-1;
+	if(jj==kk-1) I[jj]=-1;
+
+	if(start+len>kk) split(I,V,kk,start+len-kk,h);
+}
+
+void qsufsort(off_t *I,off_t *V,u_char *old,off_t oldsize)
+{
+	off_t buckets[256];
+	off_t i,h,len;
+
+	for(i=0;i<256;i++) buckets[i]=0;
+	for(i=0;i<oldsize;i++) buckets[old[i]]++;
+	for(i=1;i<256;i++) buckets[i]+=buckets[i-1];
+	for(i=255;i>0;i--) buckets[i]=buckets[i-1];
+	buckets[0]=0;
+
+	for(i=0;i<oldsize;i++) I[++buckets[old[i]]]=i;
+	I[0]=oldsize;
+	for(i=0;i<oldsize;i++) V[i]=buckets[old[i]];
+	V[oldsize]=0;
+	for(i=1;i<256;i++) if(buckets[i]==buckets[i-1]+1) I[buckets[i]]=-1;
+	I[0]=-1;
+
+	for(h=1;I[0]!=-(oldsize+1);h+=h) {
+		len=0;
+		for(i=0;i<oldsize+1;) {
+			if(I[i]<0) {
+				len-=I[i];
+				i-=I[i];
+			} else {
+				if(len) I[i-len]=-len;
+				len=V[I[i]]+1-i;
+				split(I,V,i,len,h);
+				i+=len;
+				len=0;
+			};
+		};
+		if(len) I[i-len]=-len;
+	};
+
+	for(i=0;i<oldsize+1;i++) I[V[i]]=i;
+}
+
+off_t matchlen(u_char *old,off_t oldsize,u_char *new,off_t newsize)
+{
+	off_t i;
+
+	for(i=0;(i<oldsize)&&(i<newsize);i++)
+		if(old[i]!=new[i]) break;
+
+	return i;
+}
+
+off_t search(off_t *I,u_char *old,off_t oldsize,
+		u_char *new,off_t newsize,off_t st,off_t en,off_t *pos)
+{
+	off_t x,y;
+
+	if(en-st<2) {
+		x=matchlen(old+I[st],oldsize-I[st],new,newsize);
+		y=matchlen(old+I[en],oldsize-I[en],new,newsize);
+
+		if(x>y) {
+			*pos=I[st];
+			return x;
+		} else {
+			*pos=I[en];
+			return y;
+		}
+	};
+
+	x=st+(en-st)/2;
+	if(memcmp(old+I[x],new,MIN(oldsize-I[x],newsize))<0) {
+		return search(I,old,oldsize,new,newsize,x,en,pos);
+	} else {
+		return search(I,old,oldsize,new,newsize,st,x,pos);
+	};
+}
+
+void offtout(off_t x,u_char *buf)
+{
+	off_t y;
+
+	if(x<0) y=-x; else y=x;
+
+		buf[0]=y%256;y-=buf[0];
+	y=y/256;buf[1]=y%256;y-=buf[1];
+	y=y/256;buf[2]=y%256;y-=buf[2];
+	y=y/256;buf[3]=y%256;y-=buf[3];
+	y=y/256;buf[4]=y%256;y-=buf[4];
+	y=y/256;buf[5]=y%256;y-=buf[5];
+	y=y/256;buf[6]=y%256;y-=buf[6];
+	y=y/256;buf[7]=y%256;
+
+	if(x<0) buf[7]|=0x80;
+}
+
+int main(int argc,char *argv[])
+{
+	int fd,p[2];
+	pid_t pid;
+	u_char *old,*new;
+	off_t oldsize,newsize;
+	off_t *I,*V;
+
+	off_t scan,pos,len;
+	off_t lastscan,lastpos,lastoffset;
+	off_t oldscore,scsc;
+
+	off_t s,Sf,lenf,Sb,lenb;
+	off_t overlap,Ss,lens;
+	off_t i;
+
+	off_t dblen,eblen;
+	u_char *db,*eb;
+
+	u_char buf[8];
+	u_char header[32];
+
+	if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);
+
+	/* Allocate oldsize+1 bytes instead of oldsize bytes to ensure
+		that we never try to malloc(0) and get a NULL pointer */
+	if(((fd=open(argv[1],O_RDONLY,0))<0) ||
+		((oldsize=lseek(fd,0,SEEK_END))==-1) ||
+		((old=malloc(oldsize+1))==NULL) ||
+		(lseek(fd,0,SEEK_SET)!=0) ||
+		(read(fd,old,oldsize)!=oldsize) ||
+		(close(fd)==-1)) err(1,"%s",argv[1]);
+
+	if(((I=malloc((oldsize+1)*sizeof(off_t)))==NULL) ||
+		((V=malloc((oldsize+1)*sizeof(off_t)))==NULL)) err(1,NULL);
+
+	qsufsort(I,V,old,oldsize);
+
+	free(V);
+
+	/* Allocate newsize+1 bytes instead of newsize bytes to ensure
+		that we never try to malloc(0) and get a NULL pointer */
+	if(((fd=open(argv[2],O_RDONLY,0))<0) ||
+		((newsize=lseek(fd,0,SEEK_END))==-1) ||
+		((new=malloc(newsize+1))==NULL) ||
+		(lseek(fd,0,SEEK_SET)!=0) ||
+		(read(fd,new,newsize)!=newsize) ||
+		(close(fd)==-1)) err(1,"%s",argv[2]);
+
+	if(((db=malloc(newsize+1))==NULL) ||
+		((eb=malloc(newsize+1))==NULL)) err(1,NULL);
+	dblen=0;
+	eblen=0;
+
+	if((fd=open(argv[3],O_CREAT|O_TRUNC|O_WRONLY,0666))<0)
+		err(1,"%s",argv[3]);
+
+	/* Header is
+		0	8	 "BSDIFF40"
+		8	8	length of bzip2ed ctrl block
+		16	8	length of bzip2ed diff block
+		24	8	length of new file */
+	/* File is
+		0	32	Header
+		32	??	Bzip2ed ctrl block
+		??	??	Bzip2ed diff block
+		??	??	Bzip2ed extra block */
+	memcpy(header,"BSDIFF40",8);
+	memset(header+8,0,24);
+	if(write(fd,header,32)!=32) err(1,"%s",argv[3]);
+
+	if((pipe(p)==-1) || ((pid=fork())==-1)) err(1,NULL);
+	if(pid==0) {
+		if((close(0)==-1) || (close(1)==-1) || (dup2(fd,1)==-1) ||
+			(dup2(p[0],0)==-1) || (close(fd)==-1) ||
+			(close(p[0])==-1) || (close(p[1])==-1))
+			err(1,NULL);
+		execl(BZIP2,BZIP2,"-zc",NULL);
+		err(1,"%s",BZIP2);
+	};
+	if(close(p[0])==-1) err(1,NULL);
+
+	scan=0;len=0;
+	lastscan=0;lastpos=0;lastoffset=0;
+	while(scan<newsize) {
+		oldscore=0;
+
+		for(scsc=scan+=len;scan<newsize;scan++) {
+			len=search(I,old,oldsize,new+scan,newsize-scan,
+					0,oldsize,&pos);
+
+			for(;scsc<scan+len;scsc++)
+			if((scsc+lastoffset<oldsize) &&
+				(old[scsc+lastoffset] == new[scsc]))
+				oldscore++;
+
+			if(((len==oldscore) && (len!=0)) || 
+				(len>oldscore+8)) break;
+
+			if((scan+lastoffset<oldsize) &&
+				(old[scan+lastoffset] == new[scan]))
+				oldscore--;
+		};
+
+		if((len!=oldscore) || (scan==newsize)) {
+			s=0;Sf=0;lenf=0;
+			for(i=0;(lastscan+i<scan)&&(lastpos+i<oldsize);) {
+				if(old[lastpos+i]==new[lastscan+i]) s++;
+				i++;
+				if(s*2-i>Sf*2-lenf) { Sf=s; lenf=i; };
+			};
+
+			lenb=0;
+			if(scan<newsize) {
+				s=0;Sb=0;
+				for(i=1;(scan>=lastscan+i)&&(pos>=i);i++) {
+					if(old[pos-i]==new[scan-i]) s++;
+					if(s*2-i>Sb*2-lenb) { Sb=s; lenb=i; };
+				};
+			};
+
+			if(lastscan+lenf>scan-lenb) {
+				overlap=(lastscan+lenf)-(scan-lenb);
+				s=0;Ss=0;lens=0;
+				for(i=0;i<overlap;i++) {
+					if(new[lastscan+lenf-overlap+i]==
+					   old[lastpos+lenf-overlap+i]) s++;
+					if(new[scan-lenb+i]==
+					   old[pos-lenb+i]) s--;
+					if(s>Ss) { Ss=s; lens=i+1; };
+				};
+
+				lenf+=lens-overlap;
+				lenb-=lens;
+			};
+
+			for(i=0;i<lenf;i++)
+				db[dblen+i]=new[lastscan+i]-old[lastpos+i];
+			for(i=0;i<(scan-lenb)-(lastscan+lenf);i++)
+				eb[eblen+i]=new[lastscan+lenf+i];
+
+			dblen+=lenf;
+			eblen+=(scan-lenb)-(lastscan+lenf);
+
+			offtout(lenf,buf);
+			if(write(p[1],buf,8)!=8) err(1,NULL);
+			offtout((scan-lenb)-(lastscan+lenf),buf);
+			if(write(p[1],buf,8)!=8) err(1,NULL);
+			offtout((pos-lenb)-(lastpos+lenf),buf);
+			if(write(p[1],buf,8)!=8) err(1,NULL);
+
+			lastscan=scan-lenb;
+			lastpos=pos-lenb;
+			lastoffset=pos-scan;
+		};
+	};
+
+	if((close(p[1])==-1) || (waitpid(pid,NULL,0)!=pid)) err(1,NULL);
+
+	if((len=lseek(fd,0,SEEK_END))==-1) err(1,"%s",argv[3]);
+	offtout(len-32,buf);
+	if((lseek(fd,8,SEEK_SET)!=8) || (write(fd,buf,8)!=8))
+		err(1,"%s",argv[3]);
+	offtout(newsize,buf);
+	if((lseek(fd,24,SEEK_SET)!=24) || (write(fd,buf,8)!=8))
+		err(1,"%s",argv[3]);
+
+	if(lseek(fd,0,SEEK_END)==-1) err(1,"%s",argv[3]);
+	if((pipe(p)==-1) || ((pid=fork())==-1)) err(1,NULL);
+	if(pid==0) {
+		if((close(0)==-1) || (close(1)==-1) || (dup2(fd,1)==-1) ||
+			(dup2(p[0],0)==-1) || (close(fd)==-1) ||
+			(close(p[0])==-1) || (close(p[1])==-1))
+			err(1,NULL);
+		execl(BZIP2,BZIP2,"-zc",NULL);
+		err(1,"%s",BZIP2);
+	};
+	if(close(p[0])==-1) err(1,NULL);
+	if(write(p[1],db,dblen)!=dblen) err(1,NULL);
+	if((close(p[1])==-1) || (waitpid(pid,NULL,0)!=pid)) err(1,NULL);
+
+	if((newsize=lseek(fd,0,SEEK_END))==-1) err(1,"%s",argv[3]);
+	offtout(newsize-len,buf);
+	if((lseek(fd,16,SEEK_SET)!=16) || (write(fd,buf,8)!=8))
+		err(1,"%s",argv[3]);
+
+	if(lseek(fd,0,SEEK_END)==-1) err(1,"%s",argv[3]);
+	if((pipe(p)==-1) || ((pid=fork())==-1)) err(1,NULL);
+	if(pid==0) {
+		if((close(0)==-1) || (close(1)==-1) || (dup2(fd,1)==-1) ||
+			(dup2(p[0],0)==-1) || (close(fd)==-1) ||
+			(close(p[0])==-1) || (close(p[1])==-1))
+			err(1,NULL);
+		execl(BZIP2,BZIP2,"-zc",NULL);
+		err(1,"%s",BZIP2);
+	};
+	if(close(p[0])==-1) err(1,NULL);
+	if(write(p[1],eb,eblen)!=eblen) err(1,NULL);
+	if((close(p[1])==-1) || (waitpid(pid,NULL,0)!=pid)) err(1,NULL);
+	if(close(fd)==-1) err(1,"%s",argv[3]);
+
+	free(db);
+	free(eb);
+	free(I);
+	free(old);
+	free(new);
+
+	return 0;
+}

src/bsdiff-4.2/bspatch.1

@@ -0,0 +1,32 @@
+.Dd May 18, 2003
+.Dt BSPATCH 1
+.Os FreeBSD
+.Sh NAME
+.Nm bspatch
+.Nd apply a patch built with bsdiff(1)
+.Sh SYNOPSIS
+.Nm
+.Ao Ar oldfile Ac Ao Ar newfile Ac Ao Ar patchfile Ac
+.Sh DESCRIPTION
+.Nm
+generates
+.Ao Ar newfile Ac
+from
+.Ao Ar oldfile Ac
+and
+.Ao Ar patchfile Ac
+where
+.Ao Ar patchfile Ac
+is a binary patch built by bsdiff(1).
+.Pp
+.Nm
+uses memory equal to the size of 
+.Ao Ar oldfile Ac
+plus the size of 
+.Ao Ar newfile Ac ,
+but can tolerate a very small working set without a dramatic loss
+of performance.
+.Sh SEE ALSO
+.Xr bsdiff 1
+.Sh AUTHORS
+.An Colin Percival Aq cperciva@daemonology.net

src/bsdiff-4.2/bspatch.c

@@ -0,0 +1,216 @@
+/*
+  .c -- Binary patcher
+
+  Copyright 2003,2004 Colin Percival
+
+  For the terms under which this work may be distributed, please see
+  the adjoining file "LICENSE".
+*/
+
+#ifndef BZIP2
+#define BZIP2 "/usr/bin/bzip2"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <err.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+
+ssize_t loopread(int d,void *buf,size_t nbytes)
+{
+	ssize_t ptr,lenread;
+
+	for(ptr=0;ptr<nbytes;ptr+=lenread) {
+		lenread=read(d,buf+ptr,nbytes-ptr);
+		if(lenread==0) return ptr;
+		if(lenread==-1) return -1;
+	};
+	return ptr;
+}
+
+int bz2read(int fd,off_t offset,off_t len,char * fname,pid_t * pids)
+{
+	int p0[2],p1[2];
+	u_char * data;
+
+	if((pipe(p0)==-1) || (pipe(p1)==-1)) err(1,NULL);
+
+	if((pids[0]=fork())==-1) err(1,NULL);
+	if(pids[0]==0) {
+		if(close(0) || close(1) || close(p0[0]) ||
+			close(p1[0]) || close(p1[1])) err(1,NULL);
+		if((data=malloc(len+1))==NULL) err(1,NULL);
+		if((pread(fd,data,len,offset)!=len) || close(fd))
+			err(1,"%s",fname);
+		if((write(p0[1],data,len)!=len) || close(p0[1]))
+			err(1,NULL);
+		free(data);
+		_exit(0);
+	};
+
+	if((pids[1]=fork())==-1) err(1,NULL);
+	if(pids[1]==0) {
+		if(close(0) || close(1) || close(p0[1]) ||
+			close(p1[0])) err(1,NULL);
+		if((dup2(p0[0],0)==-1) || close(p0[0])) err(1,NULL);
+		if((dup2(p1[1],1)==-1) || close(p1[1])) err(1,NULL);
+		if(close(fd)==-1) err(1,"%s",fname);
+
+		execl(BZIP2,BZIP2,"-dc",NULL);
+		err(1,"%s",BZIP2);
+	};
+
+	if(close(p0[0]) || close(p0[1]) || close(p1[1])) err(1,NULL);
+
+	return p1[0];
+}
+
+off_t offtin(u_char *buf)
+{
+	off_t y;
+
+	y=buf[7]&0x7F;
+	y=y*256;y+=buf[6];
+	y=y*256;y+=buf[5];
+	y=y*256;y+=buf[4];
+	y=y*256;y+=buf[3];
+	y=y*256;y+=buf[2];
+	y=y*256;y+=buf[1];
+	y=y*256;y+=buf[0];
+
+	if(buf[7]&0x80) y=-y;
+
+	return y;
+}
+
+int main(int argc,char * argv[])
+{
+	int fd,ctrlpipe,diffpipe,extrapipe;
+	pid_t pids[6];
+	ssize_t patchsize,oldsize,newsize;
+	ssize_t bzctrllen,bzdatalen;
+	u_char header[32],buf[8];
+	int version=0;
+	u_char *old, *new;
+	off_t oldpos,newpos;
+	off_t ctrl[3];
+	off_t lenread;
+	off_t i;
+
+	if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);
+
+	if(((fd=open(argv[3],O_RDONLY,0))<0) ||
+		((patchsize=lseek(fd,0,SEEK_END))==-1) ||
+		(lseek(fd,0,SEEK_SET)!=0)) err(1,"%s",argv[3]);
+	if(patchsize<32) errx(1,"Corrupt patch\n");
+
+	/*
+	  Ok, this is going to be messy.  There are two different patch
+	formats which we need to support.
+
+	  The old format (pre-4.0) is:
+		0	8	"QSUFDIFF" or "BSDIFF30"
+		8	8	X
+		16	8	Y
+		24	8	sizeof(newfile)
+		32	X	bzip2(control block)
+		32+X	Y	bzip2(data block)
+	with control block a set of pairs (x,y) meaning "seek forward
+	in oldfile by y bytes, and add the next x bytes to x bytes from
+	the data block".
+
+	  The new format (4.0) is:
+		0	8	"BSDIFF40"
+		8	8	X
+		16	8	Y
+		24	8	sizeof(newfile)
+		32	X	bzip2(control block)
+		32+X	Y	bzip2(diff block)
+		32+X+Y	???	bzip2(extra block)
+	with control block a set of triples (x,y,z) meaning "add x bytes
+	from oldfile to x bytes from the diff block; copy y bytes from the
+	extra block; seek forwards in oldfile by z bytes".
+	*/
+
+	if(read(fd,header,32)!=32) err(1,"%s",argv[3]);
+	if(memcmp(header,"QSUFDIFF",8)==0) version=1;
+	if(memcmp(header,"BSDIFF30",8)==0) version=1;
+	if(memcmp(header,"BSDIFF40",8)==0) version=2;
+
+	if(!version) errx(1,"Corrupt patch\n");
+
+	bzctrllen=offtin(header+8);
+	bzdatalen=offtin(header+16);
+	newsize=offtin(header+24);
+	if((bzctrllen<0) || (bzdatalen<0) || (newsize<0) ||
+		((version==1) && (32+bzctrllen+bzdatalen!=patchsize)))
+		errx(1,"Corrupt patch\n");
+
+	ctrlpipe=bz2read(fd,32,bzctrllen,argv[3],pids);
+	diffpipe=bz2read(fd,32+bzctrllen,bzdatalen,argv[3],pids+2);
+	if(version==2) {
+		extrapipe=bz2read(fd,32+bzctrllen+bzdatalen,
+			patchsize-(32+bzctrllen+bzdatalen),argv[3],pids+4);
+	};
+
+	if(close(fd)==-1) err(1,"%s",argv[3]);
+	if(((fd=open(argv[1],O_RDONLY,0))<0) ||
+		((oldsize=lseek(fd,0,SEEK_END))==-1) ||
+		((old=malloc(oldsize+1))==NULL) ||
+		(lseek(fd,0,SEEK_SET)!=0) ||
+		(read(fd,old,oldsize)!=oldsize) ||
+		(close(fd)==-1)) err(1,"%s",argv[1]);
+	if((new=malloc(newsize+1))==NULL) err(1,NULL);
+
+	oldpos=0;newpos=0;
+	while(newpos<newsize) {
+		for(i=0;i<=version;i++) {
+			if((lenread=loopread(ctrlpipe,buf,8))<0) err(1,NULL);
+			if(lenread<8) errx(1,"Corrupt patch\n");
+			ctrl[i]=offtin(buf);
+		};
+
+		if(version==1) oldpos+=ctrl[1];
+
+		if(newpos+ctrl[0]>newsize) errx(1,"Corrupt patch\n");
+		if((lenread=loopread(diffpipe,new+newpos,ctrl[0]))<0)
+			err(1,NULL);
+		if(lenread!=ctrl[0]) errx(1,"Corrupt patch\n");
+		for(i=0;i<ctrl[0];i++)
+			if((oldpos+i>=0) && (oldpos+i<oldsize))
+				new[newpos+i]+=old[oldpos+i];
+		newpos+=ctrl[0];
+		oldpos+=ctrl[0];
+
+		if(version==2) {
+			if(newpos+ctrl[1]>newsize) errx(1,"Corrupt patch\n");
+			if((lenread=loopread(extrapipe,new+newpos,ctrl[1]))<0)
+				err(1,NULL);
+			if(lenread!=ctrl[1]) errx(1,"Corrupt patch\n");
+
+			newpos+=ctrl[1];
+			oldpos+=ctrl[2];
+		};
+	};
+
+	if(loopread(ctrlpipe,buf,1)!=0) errx(1,"Corrupt patch\n");
+	if(loopread(diffpipe,buf,1)!=0) errx(1,"Corrupt patch\n");
+	if(version==2)
+		if(loopread(extrapipe,buf,1)!=0) errx(1,"Corrupt patch\n");
+
+	if(close(ctrlpipe) || close(diffpipe) || 
+		((version==2) && close(extrapipe)))
+		err(1,NULL);
+	for(i=0;i<(version+1)*2;i++) waitpid(pids[i],NULL,0);
+
+	if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0666))<0) ||
+		(write(fd,new,newsize)!=newsize) || (close(fd)==-1))
+		err(1,"%s",argv[2]);
+
+	free(new);
+	free(old);
+
+	return 0;
+}