* Document Boehm GC support.

* Use pkgconfig to locate the Boehm GC (as suggested by Ludo), if
--enable-gc is given.
2010-10-29 14:44:02 +00:00 · 2010-10-29 14:00:47 +00:00 · 2010-10-29 13:11:50 +00:00 · 2010-10-28 12:50:01 +00:00 · 2010-10-28 12:29:40 +00:00 · 2010-10-26 10:47:02 +00:00
65 changed files with 1120 additions and 560 deletions
--- a/Makefile.am
+++ b/Makefile.am
@@ -2,6 +2,8 @@ SUBDIRS = externals src scripts corepkgs doc misc tests
 EXTRA_DIST = substitute.mk nix.spec nix.spec.in bootstrap.sh \
  nix.conf.example NEWS version

+pkginclude_HEADERS = config.h
+
 include ./substitute.mk

 nix.spec: nix.spec.in
--- a/configure.ac
+++ b/configure.ac
@@ -10,8 +10,8 @@ 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_')
+cpu_name=$(uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ' 'abcdefghijklmnopqrstuvwxyz_')
+machine_name=$(uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ' 'abcdefghijklmnopqrstuvwxyz_')

 case $machine_name in
    i*86)
@@ -30,7 +30,7 @@ case $machine_name in
        ;;
 esac

-sys_name=$(uname -s | tr 'A-Z ' 'a-z_')
+sys_name=$(uname -s | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ' 'abcdefghijklmnopqrstuvwxyz_')

 case $sys_name in
    cygwin*)
@@ -136,11 +136,22 @@ AC_CHECK_HEADERS([locale], [], [], [])
 AC_LANG_POP(C++)


+# Check for <err.h>.
+AC_CHECK_HEADER([err.h], [], [bsddiff_compat_include="-Icompat-include"])
+AC_SUBST([bsddiff_compat_include])
+
+
 # Check whether we have the personality() syscall, which allows us to
 # do i686-linux builds on x86_64-linux machines.
 AC_CHECK_HEADERS([sys/personality.h])


+# Check for tr1/unordered_set.
+AC_LANG_PUSH(C++)
+AC_CHECK_HEADERS([tr1/unordered_set], [], [], [])
+AC_LANG_POP(C++)
+
+
 AC_DEFUN([NEED_PROG],
 [
 AC_PATH_PROG($1, $2)
@@ -239,7 +250,17 @@ AC_SUBST(bzip2_bin)
 AC_SUBST(bzip2_bin_test)


-AC_CHECK_LIB(pthread, pthread_mutex_init)
+# Whether to use the Boehm garbage collector.
+AC_ARG_ENABLE(gc, AC_HELP_STRING([--enable-gc],
+  [enable garbage collection in the Nix expression evaluator (requires Boehm GC)]),
+  gc=$enableval, gc=)
+if test -n "$gc"; then
+  PKG_CHECK_MODULES([BDW_GC], [bdw-gc])
+  boehmgc_lib="-L$boehmgc/lib -lgc"
+  CXXFLAGS="$BDW_GC_CFLAGS $CXXFLAGS"
+  AC_DEFINE(HAVE_BOEHMGC, 1, [Whether to use the Boehm garbage collector.])
+fi
+AC_SUBST(boehmgc_lib)


 AC_ARG_ENABLE(init-state, AC_HELP_STRING([--disable-init-state],
--- a/doc/manual/conf-file.xml
+++ b/doc/manual/conf-file.xml
@@ -97,6 +97,25 @@ env-keep-derivations = false
  </varlistentry>


+  <varlistentry xml:id="conf-build-cores"><term><literal>build-cores</literal></term>
+
+    <listitem><para>Sets the value of the
+    <envar>NIX_BUILD_CORES</envar> environment variable in the
+    invocation of builders.  Builders can use this variable at their
+    discretion to control the maximum amount of parallelism.  For
+    instance, in Nixpkgs, if the derivation attribute
+    <varname>enableParallelBuilding</varname> is set to
+    <literal>true</literal>, the builder passes the
+    <option>-j<replaceable>N</replaceable></option> flag to GNU Make.
+    It can be overriden using the <option
+    linkend='opt-cores'>--cores</option> command line switch and
+    defaults to <literal>1</literal>.  The value <literal>0</literal>
+    means that the builder should use all available CPU cores in the
+    system.</para></listitem>
+
+  </varlistentry>
+
+
  <varlistentry xml:id="conf-build-max-silent-time"><term><literal>build-max-silent-time</literal></term>

    <listitem>
--- a/doc/manual/env-common.xml
+++ b/doc/manual/env-common.xml
@@ -271,6 +271,17 @@ $ mount -o bind /mnt/otherdisk/nix /nix</screen>

 </varlistentry>

+
+<varlistentry><term><envar>GC_INITIAL_HEAP_SIZE</envar></term>
+
+  <listitem><para>If Nix has been configured to use the Boehm garbage
+  collector, this variable sets the initial size of the heap in bytes.
+  It defaults to 384 MiB.  Setting it to a low value reduces memory
+  consumption, but will increase runtime due to the overhead of
+  garbage collection.</para></listitem>
+
+</varlistentry>
+
    
 </variablelist>

--- a/doc/manual/installation.xml
+++ b/doc/manual/installation.xml
@@ -105,6 +105,13 @@ this packages.  Alternatively, if you already have it installed, you
 can use <command>configure</command>'s <option>--with-bzip2</option>
 options to point to their respective locations.</para>

+<para>Nix can optionally use the <link
+xlink:href="http://www.hpl.hp.com/personal/Hans_Boehm/gc/">Boehm
+garbage collector</link> to reduce the evaluator’s memory consumption.
+To enable it, install <literal>pkgconfig</literal> and the Boehm
+garbage collector, and pass the flag <option>--enable-gc</option> to
+<command>configure</command>.</para>
+
 </section>


--- a/doc/manual/introduction.xml
+++ b/doc/manual/introduction.xml
@@ -113,7 +113,7 @@ $ nix-env --rollback

 <simplesect><title>Garbage collection</title>

-<para>When you install a package like this…
+<para>When you uninstall a package like this…

 <screen>
 $ nix-env --uninstall firefox
--- a/doc/manual/manual.xml
+++ b/doc/manual/manual.xml
@@ -27,10 +27,11 @@
      <year>2007</year>
      <year>2008</year>
      <year>2009</year>
+      <year>2010</year>
      <holder>Eelco Dolstra</holder>
    </copyright>

-    <date>September 2009</date>
+    <date>August 2010</date>
    
  </info>

--- a/doc/manual/nix-push.xml
+++ b/doc/manual/nix-push.xml
@@ -120,7 +120,7 @@ dependencies used in the build, such as compilers).</para>
 dependencies, we can do:
      
 <screen>
-$ nix-push <replaceable>urls</replaceable> $(nix-instantiate $(nix-store -r foo.nix))</screen>
+$ nix-push <replaceable>urls</replaceable> $(nix-store -r $(nix-instantiate foo.nix))</screen>
    
 </para>

--- a/doc/manual/opt-common-syn.xml
+++ b/doc/manual/opt-common-syn.xml
@@ -13,6 +13,10 @@
  </group>
  <replaceable>number</replaceable>
 </arg>
+<arg>
+  <arg><option>--cores</option></arg>
+  <replaceable>number</replaceable>
+</arg>
 <arg>
  <arg><option>--max-silent-time</option></arg>
  <replaceable>number</replaceable>
--- a/doc/manual/opt-common.xml
+++ b/doc/manual/opt-common.xml
@@ -98,7 +98,25 @@
  linkend='conf-build-max-jobs'><literal>build-max-jobs</literal></link>
  configuration setting, which itself defaults to
  <literal>1</literal>.  A higher value is useful on SMP systems or to
-  exploit I/O latency.  </para></listitem>
+  exploit I/O latency.</para></listitem>
+  
+</varlistentry>
+
+
+<varlistentry xml:id="opt-cores"><term><option>--cores</option></term>
+
+  <listitem><para>Sets the value of the <envar>NIX_BUILD_CORES</envar>
+  environment variable in the invocation of builders.  Builders can
+  use this variable at their discretion to control the maximum amount
+  of parallelism.  For instance, in Nixpkgs, if the derivation
+  attribute <varname>enableParallelBuilding</varname> is set to
+  <literal>true</literal>, the builder passes the
+  <option>-j<replaceable>N</replaceable></option> flag to GNU Make.
+  It defaults to the value of the <link
+  linkend='conf-build-cores'><literal>build-cores</literal></link>
+  configuration setting, if set, or <literal>1</literal> otherwise.
+  The value <literal>0</literal> means that the builder should use all
+  available CPU cores in the system.</para></listitem>
  
 </varlistentry>

--- a/doc/manual/release-notes.xml
+++ b/doc/manual/release-notes.xml
@@ -6,6 +6,80 @@



+<!--==================================================================-->
+
+<section xml:id="ssec-relnotes-1.0"><title>Release 1.0 (TBA)</title>
+
+<para>This release has the following improvements:</para>
+
+<itemizedlist>
+
+  <listitem>
+    <para>Nix can now optionally use the Boehm garbage collector.
+    This significantly reduces the Nix evaluator’s memory footprint,
+    especially when evaluating large NixOS system configurations.  It
+    can be enabled using the <option>--enable-gc</option> configure
+    option.</para>
+  </listitem>
+
+</itemizedlist>
+
+</section>
+
+
+<!--==================================================================-->
+
+<section xml:id="ssec-relnotes-0.16"><title>Release 0.16 (August 17, 2010)</title>
+
+<para>This release has the following improvements:</para>
+
+<itemizedlist>
+
+  <listitem>
+    <para>The Nix expression evaluator is now much faster in most
+    cases: typically, <link
+    xlink:href="http://www.mail-archive.com/nix-dev@cs.uu.nl/msg04113.html">3
+    to 8 times compared to the old implementation</link>.  It also
+    uses less memory.  It no longer depends on the ATerm
+    library.</para>
+  </listitem>
+
+  <listitem>
+    <para>
+      Support for configurable parallelism inside builders.  Build
+      scripts have always had the ability to perform multiple build
+      actions in parallel (for instance, by running <command>make -j
+      2</command>), but this was not desirable because the number of
+      actions to be performed in parallel was not configurable.  Nix
+      now has an option <option>--cores
+      <replaceable>N</replaceable></option> as well as a configuration
+      setting <varname>build-cores =
+      <replaceable>N</replaceable></varname> that causes the
+      environment variable <envar>NIX_BUILD_CORES</envar> to be set to
+      <replaceable>N</replaceable> when the builder is invoked.  The
+      builder can use this at its discretion to perform a parallel
+      build, e.g., by calling <command>make -j
+      <replaceable>N</replaceable></command>.  In Nixpkgs, this can be
+      enabled on a per-package basis by setting the derivation
+      attribute <varname>enableParallelBuilding</varname> to
+      <literal>true</literal>.
+    </para>
+  </listitem>
+
+  <listitem>
+    <para><command>nix-store -q</command> now supports XML output
+    through the <option>--xml</option> flag.</para>
+  </listitem>
+
+  <listitem>
+    <para>Several bug fixes.</para>
+  </listitem>
+
+</itemizedlist>
+
+</section>
+
+
 <!--==================================================================-->

 <section xml:id="ssec-relnotes-0.15"><title>Release 0.15 (March 17, 2010)</title>
--- a/nix.conf.example
+++ b/nix.conf.example
@@ -59,6 +59,17 @@
 #build-max-jobs = 1


+### Option `build-cores'
+#
+# This option defines the number of CPU cores to utilize in parallel
+# within a build job, i.e. by passing an appropriate `-jN' flag to GNU
+# Make. The default is 1, meaning that parallel building within jobs
+# is disabled.  Passing the special value `0' causes Nix to try and
+# auto-detect the number of available cores on the local host.  This
+# setting can be overridden using the `--cores' command line switch.
+#build-cores = 1
+
+
 ### Option `build-max-silent-time'
 #
 # This option defines the maximum number of seconds that a builder can
--- a/release.nix
+++ b/release.nix
@@ -1,4 +1,7 @@
-{ nixpkgs ? ../nixpkgs }:
+{ nixpkgs ? ../nixpkgs
+, nix ? { outPath = ./.; rev = 1234; }
+, officialRelease ? false
+}:

 let

@@ -6,10 +9,6 @@ let


    tarball =
-      { nix ? {outPath = ./.; rev = 1234;}
-      , officialRelease ? false
-      }:
-
      with import nixpkgs {};

      releaseTools.sourceTarball {
@@ -19,8 +18,8 @@ let
        inherit officialRelease;

        buildInputs =
-          [ curl bison flex2533 perl libxml2 libxslt w3m bzip2
-            tetex dblatex nukeReferences
+          [ curl bison24 flex2535 perl libxml2 libxslt w3m bzip2
+            tetex dblatex nukeReferences pkgconfig
          ];

        configureFlags = ''
@@ -60,63 +59,36 @@ let


    build =
-      { tarball ? jobs.tarball {}
-      , system ? "i686-linux"
-      }:
+      { system ? "i686-linux" }:

-      with import nixpkgs {inherit system;};
+      with import nixpkgs { inherit system; };

      releaseTools.nixBuild {
        name = "nix";
        src = tarball;

-        buildInputs = [curl perl bzip2 openssl];
+        buildInputs = [ curl perl bzip2 openssl pkgconfig boehmgc ];

        configureFlags = ''
          --disable-init-state
          --with-bzip2=${bzip2}
+          --enable-gc
        '';
      };


-    /*
-    static =
-      { tarball ? jobs.tarball {}
-      , system ? "i686-linux"
-      }:
-
-      with import nixpkgs {inherit system;};
-
-      releaseTools.binaryTarball {
-        name = "nix-static-tarball";
-        src = tarball;
-
-        buildInputs = [curl perl bzip2];
-
-        configureFlags = ''
-          --disable-init-state
-          --with-bzip2=${bzip2}
-          --enable-static-nix
-        '';
-      };
-    */
-
-      
    coverage =
-      { tarball ? jobs.tarball {}
-      }:
-
-      with import nixpkgs {};
+      with import nixpkgs { system = "x86_64-linux"; };

      releaseTools.coverageAnalysis {
        name = "nix-build";
        src = tarball;

-        buildInputs = [
-          curl perl bzip2 openssl
-          # These are for "make check" only:
-          graphviz libxml2 libxslt
-        ];
+        buildInputs =
+          [ curl perl bzip2 openssl
+            # These are for "make check" only:
+            graphviz libxml2 libxslt
+          ];

        configureFlags = ''
          --disable-init-state --disable-shared
@@ -168,17 +140,15 @@ let

  makeRPM = 
    system: diskImageFun: prio:
-    { tarball ? jobs.tarball {}
-    }:

-    with import nixpkgs {inherit system;};
+    with import nixpkgs { inherit system; };

    releaseTools.rpmBuild rec {
-      name = "nix-rpm-${diskImage.name}";
-      src = tarball;
+      name = "nix-rpm";
+      src = jobs.tarball;
      diskImage = diskImageFun vmTools.diskImages;
      memSize = 1024;
-      meta = { schedulingPriority = toString prio; };
+      meta = { schedulingPriority = prio; };
    };


@@ -187,19 +157,17 @@ let
  
  makeDeb =
    system: diskImageFun: prio:
-    { tarball ? jobs.tarball {}
-    }:

-    with import nixpkgs {inherit system;};
+    with import nixpkgs { inherit system; };

    releaseTools.debBuild {
      name = "nix-deb";
-      src = tarball;
+      src = jobs.tarball;
      diskImage = diskImageFun vmTools.diskImages;
      memSize = 1024;
-      meta = { schedulingPriority = toString prio; };
+      meta = { schedulingPriority = prio; };
      configureFlags = "--sysconfdir=/etc";
-      debRequires = ["curl"];
+      debRequires = [ "curl" ];
    };


--- a/scripts/build-remote.pl.in
+++ b/scripts/build-remote.pl.in
@@ -211,14 +211,14 @@ system("NIX_SSHOPTS=\"@sshOpts\" @bindir@/nix-copy-closure $hostName $maybeSign

 print "building...\n";

-my $buildFlags = "--max-silent-time $maxSilentTime";
+my $buildFlags = "--max-silent-time $maxSilentTime --fallback";

 # `-tt' forces allocation of a pseudo-terminal.  This is required to
 # make the remote nix-store process receive a signal when the
 # connection dies.  Without it, the remote process might continue to
 # run indefinitely (that is, until it next tries to write to
 # stdout/stderr).
-if (system("ssh $hostName @sshOpts -tt 'nix-store --realise $buildFlags $drvPath > /dev/null'") != 0) {
+if (system("ssh $hostName @sshOpts -tt 'nix-store -r $drvPath $buildFlags > /dev/null'") != 0) {
    # If we couldn't run ssh or there was an ssh problem (indicated by
    # exit code 255), then we return exit code 1; otherwise we assume
    # that the builder failed, which we indicate to Nix using exit
--- a/scripts/generate-patches.pl.in
+++ b/scripts/generate-patches.pl.in
@@ -20,11 +20,11 @@ die unless scalar @ARGV == 5;

 my $hashAlgo = "sha256";

-my $cacheDir = $ARGV[0];
+my $narDir = $ARGV[0];
 my $patchesDir = $ARGV[1];
 my $patchesURL = $ARGV[2];
-my $srcDir = $ARGV[3];
-my $dstDir = $ARGV[4];
+my $srcManifest = $ARGV[3];
+my $dstManifest = $ARGV[4];

 my $tmpDir = tempdir("nix-generate-patches.XXXXXX", CLEANUP => 1, TMPDIR => 1)
    or die "cannot create a temporary directory";
@@ -41,10 +41,10 @@ my %dstNarFiles;
 my %dstLocalPaths;
 my %dstPatches;

-readManifest "$srcDir/MANIFEST",
+readManifest "$srcManifest",
    \%srcNarFiles, \%srcLocalPaths, \%srcPatches;

-readManifest "$dstDir/MANIFEST",
+readManifest "$dstManifest",
    \%dstNarFiles, \%dstLocalPaths, \%dstPatches;


@@ -55,8 +55,7 @@ sub findOutputPaths {
    
    foreach my $p (keys %{$narFiles}) {

-        # Ignore store expressions.
-        next if ($p =~ /\.store$/);
+        # Ignore derivations.
        next if ($p =~ /\.drv$/);
        
        # Ignore builders (too much ambiguity -- they're all called
@@ -65,7 +64,7 @@ sub findOutputPaths {
        next if ($p =~ /\.patch$/);
        
        # Don't bother including tar files etc.
-        next if ($p =~ /\.tar\.(gz|bz2)$/ || $p =~ /\.zip$/ || $p =~ /\.bin$/);
+        next if ($p =~ /\.tar$/ || $p =~ /\.tar\.(gz|bz2|Z|lzma|xz)$/ || $p =~ /\.zip$/ || $p =~ /\.bin$/ || $p =~ /\.tgz$/ || $p =~ /\.rpm$/ || $p =~ /cvs-export$/ || $p =~ /fetchhg$/);

        $outPaths{$p} = 1;
    }
@@ -85,6 +84,7 @@ sub getNameVersion {
    $p =~ /\/[0-9a-z]+((?:-[a-zA-Z][^\/-]*)+)([^\/]*)$/;
    my $name = $1;
    my $version = $2;
+    return undef unless defined $name && defined $version;
    $name =~ s/^-//;
    $version =~ s/^-//;
    return ($name, $version);
@@ -112,14 +112,14 @@ sub getNarBz2 {
    my $storePath = shift;
    
    my $narFileList = $$narFiles{$storePath};
-    die "missing store expression $storePath" unless defined $narFileList;
+    die "missing path $storePath" unless defined $narFileList;

    my $narFile = @{$narFileList}[0];
    die unless defined $narFile;

    $narFile->{url} =~ /\/([^\/]+)$/;
    die unless defined $1;
-    return "$cacheDir/$1";
+    return "$narDir/$1";
 }


@@ -213,6 +213,7 @@ foreach my $p (keys %dstOutPaths) {
    # this path.

    (my $name, my $version) = getNameVersion $p;
+    next unless defined $name && defined $version;

    my @closest = ();
    my $closestVersion;
@@ -222,6 +223,8 @@ foreach my $p (keys %dstOutPaths) {

    foreach my $q (keys %srcOutPaths) {
        (my $name2, my $version2) = getNameVersion $q;
+	next unless defined $name2 && defined $version2;
+
        if ($name eq $name2) {

            # If the sizes differ too much, then skip.  This
@@ -241,11 +244,11 @@ foreach my $p (keys %dstOutPaths) {
            # If the numbers of weighted uses differ too much, then
            # skip.  This disambiguates between, e.g., the bootstrap
            # GCC and the final GCC in Nixpkgs.
-            my $srcUses = computeUses \%srcNarFiles, $q;
-            my $dstUses = computeUses \%dstNarFiles, $p;
-            $ratio = $srcUses / $dstUses;
-            $ratio = 1 / $ratio if $ratio < 1;
-            print "  USE $srcUses $dstUses $ratio $q\n";
+#            my $srcUses = computeUses \%srcNarFiles, $q;
+#            my $dstUses = computeUses \%dstNarFiles, $p;
+#            $ratio = $srcUses / $dstUses;
+#            $ratio = 1 / $ratio if $ratio < 1;
+#            print "  USE $srcUses $dstUses $ratio $q\n";
            
 #            if ($ratio >= 2) {
 #                print "  SKIPPING $q due to use ratio $ratio ($srcUses $dstUses)\n";
@@ -288,6 +291,11 @@ foreach my $p (keys %dstOutPaths) {
        my $srcNarBz2 = getNarBz2 \%srcNarFiles, $closest;
        my $dstNarBz2 = getNarBz2 \%dstNarFiles, $p;

+        if (! -f $srcNarBz2) {
+            warn "patch source archive $srcNarBz2 is missing\n";
+            next;
+        }
+
        system("@bunzip2@ < $srcNarBz2 > $tmpDir/A") == 0
            or die "cannot unpack $srcNarBz2";

@@ -404,5 +412,5 @@ do {


 # Rewrite the manifest of the destination (with the new patches).
-writeManifest "$dstDir/MANIFEST",
+writeManifest "${dstManifest}",
    \%dstNarFiles, \%dstPatches;
--- a/scripts/nix-build.in
+++ b/scripts/nix-build.in
@@ -102,7 +102,7 @@ EOF
        $n += 2;
    }

-    elsif ($arg eq "--max-jobs" or $arg eq "-j" or $arg eq "--max-silent-time" or $arg eq "--log-type") {
+    elsif ($arg eq "--max-jobs" or $arg eq "-j" or $arg eq "--max-silent-time" or $arg eq "--log-type" or $arg eq "--cores") {
        $n++;
        die "$0: `$arg' requires an argument\n" unless $n < scalar @ARGV;
        push @buildArgs, ($arg, $ARGV[$n]);
--- a/src/bsdiff-4.3/Makefile.am
+++ b/src/bsdiff-4.3/Makefile.am
@@ -1,3 +1,5 @@
+EXTRA_DIST = compat-include
+
 libexec_PROGRAMS = bsdiff bspatch

 bsdiff_SOURCES = bsdiff.c
@@ -8,4 +10,4 @@ bspatch_SOURCES = bspatch.c

 bspatch_LDADD = ${bzip2_lib}

-AM_CFLAGS = -O3 ${bzip2_include}
+AM_CFLAGS = -O3 ${bzip2_include} ${bsddiff_compat_include}
--- a/src/bsdiff-4.3/compat-include/err.h
+++ b/src/bsdiff-4.3/compat-include/err.h
@@ -0,0 +1,12 @@
+/* Simulate BSD's <err.h> functionality. */
+
+#ifndef COMPAT_ERR_H_INCLUDED
+#define COMPAT_ERR_H_INCLUDED 1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define err(rc,...)  do { fprintf(stderr,__VA_ARGS__); exit(rc); } while(0)
+#define errx(rc,...) do { fprintf(stderr,__VA_ARGS__); exit(rc); } while(0)
+
+#endif
--- a/src/libexpr/Makefile.am
+++ b/src/libexpr/Makefile.am
@@ -11,7 +11,7 @@ pkginclude_HEADERS = \
 names.hh symbol-table.hh

 libexpr_la_LIBADD = ../libutil/libutil.la ../libstore/libstore.la \
- ../boost/format/libformat.la
+ ../boost/format/libformat.la @boehmgc_lib@

 BUILT_SOURCES = \
 parser-tab.hh lexer-tab.hh parser-tab.cc lexer-tab.cc
--- a/src/libexpr/attr-path.cc
+++ b/src/libexpr/attr-path.cc
@@ -5,8 +5,9 @@
 namespace nix {


+// !!! Shouldn't we return a pointer to a Value?
 void findAlongAttrPath(EvalState & state, const string & attrPath,
-    const Bindings & autoArgs, Expr * e, Value & v)
+    Bindings & autoArgs, Expr * e, Value & v)
 {
    Strings tokens = tokenizeString(attrPath, ".");

@@ -48,7 +49,7 @@ void findAlongAttrPath(EvalState & state, const string & attrPath,
            Bindings::iterator a = v.attrs->find(state.symbols.create(attr));
            if (a == v.attrs->end())
                throw Error(format("attribute `%1%' in selection path `%2%' not found") % attr % curPath);
-            v = a->second.value;
+            v = *a->value;
        }

        else if (apType == apIndex) {
--- a/src/libexpr/attr-path.hh
+++ b/src/libexpr/attr-path.hh
@@ -1,17 +1,17 @@
 #ifndef __ATTR_PATH_H
 #define __ATTR_PATH_H

+#include "eval.hh"
+
 #include <string>
 #include <map>

-#include "eval.hh"
-

 namespace nix {

    
 void findAlongAttrPath(EvalState & state, const string & attrPath,
-    const Bindings & autoArgs, Expr * e, Value & v);
+    Bindings & autoArgs, Expr * e, Value & v);

    
 }
--- a/src/libexpr/common-opts.cc
+++ b/src/libexpr/common-opts.cc
@@ -20,13 +20,17 @@ bool parseOptionArg(const string & arg, Strings::iterator & i,
    if (i == argsEnd) throw error;
    string value = *i++;

-    Value & v(autoArgs[state.symbols.create(name)].value);
+    /* !!! check for duplicates! */
+    Value * v = state.allocValue();
+    autoArgs.push_back(Attr(state.symbols.create(name), v));

    if (arg == "--arg")
-        state.mkThunk_( v, parseExprFromString(state, value, absPath(".")));
+        state.mkThunk_(*v, parseExprFromString(state, value, absPath(".")));
    else
-        mkString(v, value);
-    
+        mkString(*v, value);
+
+    autoArgs.sort(); // !!! inefficient
+
    return true;
 }

--- a/src/libexpr/eval.cc
+++ b/src/libexpr/eval.cc
@@ -8,15 +8,46 @@

 #include <cstring>

+#if HAVE_BOEHMGC
+
+#include <gc/gc.h>
+#include <gc/gc_cpp.h>
+
+#define NEW new (UseGC)
+
+#else
+
+#define GC_STRDUP strdup
+#define GC_MALLOC malloc
+
+#define NEW new
+
+#endif
+

 #define LocalNoInline(f) static f __attribute__((noinline)); f
 #define LocalNoInlineNoReturn(f) static f __attribute__((noinline, noreturn)); f


 namespace nix {
+
+
+Bindings::iterator Bindings::find(const Symbol & name)
+{
+    Attr key(name, 0);
+    iterator i = lower_bound(begin(), end(), key);
+    if (i != end() && i->name == name) return i;
+    return end();
+}
+
+
+void Bindings::sort()
+{
+    std::sort(begin(), end());
+}
    

-std::ostream & operator << (std::ostream & str, Value & v)
+std::ostream & operator << (std::ostream & str, const Value & v)
 {
    switch (v.type) {
    case tInt:
@@ -39,14 +70,14 @@ std::ostream & operator << (std::ostream & str, Value & v)
        str << v.path; // !!! escaping?
        break;
    case tNull:
-        str << "true";
+        str << "null";
        break;
    case tAttrs: {
        str << "{ ";
        typedef std::map<string, Value *> Sorted;
        Sorted sorted;
        foreach (Bindings::iterator, i, *v.attrs)
-            sorted[i->first] = &i->second.value;
+            sorted[i->name] = i->value;
        foreach (Sorted::iterator, i, sorted)
            str << i->first << " = " << *i->second << "; ";
        str << "}";
@@ -59,7 +90,7 @@ std::ostream & operator << (std::ostream & str, Value & v)
        str << "]";
        break;
    case tThunk:
-    case tCopy:
+    case tApp:
        str << "<CODE>";
        break;
    case tLambda:
@@ -91,7 +122,6 @@ string showType(const Value & v)
        case tThunk: return "a thunk";
        case tApp: return "a function application";
        case tLambda: return "a function";
-        case tCopy: return "a copy";
        case tBlackhole: return "a black hole";
        case tPrimOp: return "a built-in function";
        case tPrimOpApp: return "a partially applied built-in function";
@@ -108,12 +138,14 @@ EvalState::EvalState()
    , sMeta(symbols.create("meta"))
    , sName(symbols.create("name"))
    , sSystem(symbols.create("system"))
+    , sOverrides(symbols.create("__overrides"))
    , baseEnv(allocEnv(128))
    , baseEnvDispl(0)
    , staticBaseEnv(false, 0)
 {
    nrEnvs = nrValuesInEnvs = nrValues = nrListElems = 0;
    nrEvaluated = recursionDepth = maxRecursionDepth = 0;
+    nrAttrsets = nrOpUpdates = nrOpUpdateValuesCopied = 0;
    deepestStack = (char *) -1;

    createBaseEnv();
@@ -130,25 +162,26 @@ EvalState::~EvalState()

 void EvalState::addConstant(const string & name, Value & v)
 {
+    Value * v2 = allocValue();
+    *v2 = v;
    staticBaseEnv.vars[symbols.create(name)] = baseEnvDispl;
-    baseEnv.values[baseEnvDispl++] = v;
+    baseEnv.values[baseEnvDispl++] = v2;
    string name2 = string(name, 0, 2) == "__" ? string(name, 2) : name;
-    (*baseEnv.values[0].attrs)[symbols.create(name2)].value = v;
+    baseEnv.values[0]->attrs->push_back(Attr(symbols.create(name2), v2));
 }


 void EvalState::addPrimOp(const string & name,
-    unsigned int arity, PrimOp primOp)
+    unsigned int arity, PrimOpFun primOp)
 {
-    Value v;
+    Value * v = allocValue();
    string name2 = string(name, 0, 2) == "__" ? string(name, 2) : name;
-    v.type = tPrimOp;
-    v.primOp.arity = arity;
-    v.primOp.fun = primOp;
-    v.primOp.name = strdup(name2.c_str());
+    Symbol sym = symbols.create(name2);
+    v->type = tPrimOp;
+    v->primOp = NEW PrimOp(primOp, arity, sym);
    staticBaseEnv.vars[symbols.create(name)] = baseEnvDispl;
    baseEnv.values[baseEnvDispl++] = v;
-    (*baseEnv.values[0].attrs)[symbols.create(name2)].value = v;
+    baseEnv.values[0]->attrs->push_back(Attr(sym, v));
 }


@@ -216,7 +249,7 @@ LocalNoInline(void addErrorPrefix(Error & e, const char * s, const string & s2,
 void mkString(Value & v, const char * s)
 {
    v.type = tString;
-    v.string.s = strdup(s);
+    v.string.s = GC_STRDUP(s);
    v.string.context = 0;
 }

@@ -226,18 +259,28 @@ void mkString(Value & v, const string & s, const PathSet & context)
    mkString(v, s.c_str());
    if (!context.empty()) {
        unsigned int n = 0;
-        v.string.context = new const char *[context.size() + 1];
-        foreach (PathSet::const_iterator, i, context) 
-            v.string.context[n++] = strdup(i->c_str());
+        v.string.context = (const char * *)
+            GC_MALLOC((context.size() + 1) * sizeof(char *));
+        foreach (PathSet::const_iterator, i, context)  
+            v.string.context[n++] = GC_STRDUP(i->c_str());
        v.string.context[n] = 0;
    }
 }


+void mkString(Value & v, const Symbol & s)
+{
+    v.type = tString;
+    v.string.s = ((string) s).c_str();
+    v.string.context = 0;
+}
+
+
 void mkPath(Value & v, const char * s)
 {
+    clearValue(v);
    v.type = tPath;
-    v.path = strdup(s);
+    v.path = GC_STRDUP(s);
 }


@@ -247,22 +290,22 @@ Value * EvalState::lookupVar(Env * env, const VarRef & var)
    
    if (var.fromWith) {
        while (1) {
-            Bindings::iterator j = env->values[0].attrs->find(var.name);
-            if (j != env->values[0].attrs->end())
-                return &j->second.value;
+            Bindings::iterator j = env->values[0]->attrs->find(var.name);
+            if (j != env->values[0]->attrs->end())
+                return j->value;
            if (env->prevWith == 0)
                throwEvalError("undefined variable `%1%'", var.name);
            for (unsigned int l = env->prevWith; l; --l, env = env->up) ;
        }
    } else
-        return &env->values[var.displ];
+        return env->values[var.displ];
 }


-Value * EvalState::allocValues(unsigned int count)
+Value * EvalState::allocValue()
 {
-    nrValues += count;
-    return new Value[count]; // !!! check destructor
+    nrValues++;
+    return (Value *) GC_MALLOC(sizeof(Value));
 }


@@ -270,24 +313,51 @@ Env & EvalState::allocEnv(unsigned int size)
 {
    nrEnvs++;
    nrValuesInEnvs += size;
-    Env * env = (Env *) malloc(sizeof(Env) + size * sizeof(Value));
+    Env * env = (Env *) GC_MALLOC(sizeof(Env) + size * sizeof(Value *));
+
+    /* Clear the values because maybeThunk() expects this. */
+    for (unsigned i = 0; i < size; ++i)
+        env->values[i] = 0;
+    
    return *env;
 }


+Value * EvalState::allocAttr(Value & vAttrs, const Symbol & name)
+{
+    Value * v = allocValue();
+    vAttrs.attrs->push_back(Attr(name, v));
+    return v;
+}
+
+    
 void EvalState::mkList(Value & v, unsigned int length)
 {
    v.type = tList;
    v.list.length = length;
-    v.list.elems = new Value *[length];
+    v.list.elems = (Value * *) GC_MALLOC(length * sizeof(Value *));
    nrListElems += length;
 }


-void EvalState::mkAttrs(Value & v)
+void EvalState::mkAttrs(Value & v, unsigned int expected)
 {
+    clearValue(v);
    v.type = tAttrs;
-    v.attrs = new Bindings;
+    v.attrs = NEW Bindings;
+    v.attrs->reserve(expected);
+    nrAttrsets++;
+}
+
+
+unsigned long nrThunks = 0;
+
+static inline void mkThunk(Value & v, Env & env, Expr * expr)
+{
+    v.type = tThunk;
+    v.thunk.env = &env;
+    v.thunk.expr = expr;
+    nrThunks++;
 }


@@ -297,14 +367,28 @@ void EvalState::mkThunk_(Value & v, Expr * expr)
 }


-void EvalState::cloneAttrs(Value & src, Value & dst)
+unsigned long nrAvoided = 0;
+
+/* Create a thunk for the delayed computation of the given expression
+   in the given environment.  But if the expression is a variable,
+   then look it up right away.  This significantly reduces the number
+   of thunks allocated. */
+Value * EvalState::maybeThunk(Env & env, Expr * expr)
 {
-    mkAttrs(dst);
-    foreach (Bindings::iterator, i, *src.attrs) {
-        Attr & a = (*dst.attrs)[i->first];
-        mkCopy(a.value, i->second.value);
-        a.pos = i->second.pos;
+    ExprVar * var;
+    /* Ignore variables from `withs' because they can throw an
+       exception. */
+    if ((var = dynamic_cast<ExprVar *>(expr))) {
+        Value * v = lookupVar(&env, var->info);
+        /* The value might not be initialised in the environment yet.
+           In that case, ignore it. */
+        if (v) { nrAvoided++; return v; }
    }
+
+    Value * v = allocValue();
+    mkThunk(*v, env, expr);
+
+    return v;
 }


@@ -402,7 +486,7 @@ void ExprInt::eval(EvalState & state, Env & env, Value & v)

 void ExprString::eval(EvalState & state, Env & env, Value & v)
 {
-    mkString(v, s.c_str());
+    mkString(v, s);
 }


@@ -414,49 +498,67 @@ void ExprPath::eval(EvalState & state, Env & env, Value & v)

 void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
 {
-    state.mkAttrs(v);
+    state.mkAttrs(v, attrs.size());

    if (recursive) {
        /* Create a new environment that contains the attributes in
           this `rec'. */
-        Env & env2(state.allocEnv(attrs.size() + inherited.size()));
+        Env & env2(state.allocEnv(attrs.size()));
        env2.up = &env;

-        unsigned int displ = 0;
-        
+        AttrDefs::iterator overrides = attrs.find(state.sOverrides);
+        bool hasOverrides = overrides != attrs.end();
+
        /* The recursive attributes are evaluated in the new
-           environment. */
-        foreach (Attrs::iterator, i, attrs) {
-            nix::Attr & a = (*v.attrs)[i->first];
-            mkCopy(a.value, env2.values[displ]);
-            mkThunk(env2.values[displ++], env2, i->second.first);
-            a.pos = &i->second.second;
+           environment, while the inherited attributes are evaluated
+           in the original environment. */
+        unsigned int displ = 0;
+        foreach (AttrDefs::iterator, i, attrs)
+            if (i->second.inherited) {
+                /* !!! handle overrides? */
+                Value * vAttr = state.lookupVar(&env, i->second.var);
+                env2.values[displ++] = vAttr;
+                v.attrs->push_back(Attr(i->first, vAttr, &i->second.pos));
+            } else {
+                Value * vAttr;
+                if (hasOverrides) {
+                    vAttr = state.allocValue();
+                    mkThunk(*vAttr, env2, i->second.e);
+                } else
+                    vAttr = state.maybeThunk(env2, i->second.e);
+                env2.values[displ++] = vAttr;
+                v.attrs->push_back(Attr(i->first, vAttr, &i->second.pos));
+            }
+        
+        /* If the rec contains an attribute called `__overrides', then
+           evaluate it, and add the attributes in that set to the rec.
+           This allows overriding of recursive attributes, which is
+           otherwise not possible.  (You can use the // operator to
+           replace an attribute, but other attributes in the rec will
+           still reference the original value, because that value has
+           been substituted into the bodies of the other attributes.
+           Hence we need __overrides.) */
+        if (hasOverrides) {
+            Value * vOverrides = (*v.attrs)[overrides->second.displ].value;
+            state.forceAttrs(*vOverrides);
+            foreach (Bindings::iterator, i, *vOverrides->attrs) {
+                AttrDefs::iterator j = attrs.find(i->name);
+                if (j != attrs.end()) {
+                    (*v.attrs)[j->second.displ] = *i;
+                    env2.values[j->second.displ] = i->value;
+                } else
+                    v.attrs->push_back(*i);
+            }
+            v.attrs->sort();
        }
-
-        /* The inherited attributes, on the other hand, are
-           evaluated in the original environment. */
-        foreach (list<Inherited>::iterator, i, inherited) {
-            nix::Attr & a = (*v.attrs)[i->first.name];
-            Value * v2 = state.lookupVar(&env, i->first);
-            mkCopy(a.value, *v2);
-            mkCopy(env2.values[displ++], *v2);
-            a.pos = &i->second;
-        }
-
    }

    else {
-        foreach (Attrs::iterator, i, attrs) {
-            nix::Attr & a = (*v.attrs)[i->first];
-            mkThunk(a.value, env, i->second.first);
-            a.pos = &i->second.second;
-        }
-
-        foreach (list<Inherited>::iterator, i, inherited) {
-            nix::Attr & a = (*v.attrs)[i->first.name];
-            mkCopy(a.value, *state.lookupVar(&env, i->first));
-            a.pos = &i->second;
-        }
+        foreach (AttrDefs::iterator, i, attrs)
+            if (i->second.inherited)
+                v.attrs->push_back(Attr(i->first, state.lookupVar(&env, i->second.var), &i->second.pos));
+            else
+                v.attrs->push_back(Attr(i->first, state.maybeThunk(env, i->second.e), &i->second.pos));
    }
 }

@@ -465,20 +567,18 @@ void ExprLet::eval(EvalState & state, Env & env, Value & v)
 {
    /* Create a new environment that contains the attributes in this
       `let'. */
-    Env & env2(state.allocEnv(attrs->attrs.size() + attrs->inherited.size()));
+    Env & env2(state.allocEnv(attrs->attrs.size()));
    env2.up = &env;

-    unsigned int displ = 0;
-
-    /* The recursive attributes are evaluated in the new
+    /* The recursive attributes are evaluated in the new environment,
+       while the inherited attributes are evaluated in the original
       environment. */
-    foreach (ExprAttrs::Attrs::iterator, i, attrs->attrs)
-        mkThunk(env2.values[displ++], env2, i->second.first);
-
-    /* The inherited attributes, on the other hand, are evaluated in
-       the original environment. */
-    foreach (list<ExprAttrs::Inherited>::iterator, i, attrs->inherited)
-        mkCopy(env2.values[displ++], *state.lookupVar(&env, i->first));
+    unsigned int displ = 0;
+    foreach (ExprAttrs::AttrDefs::iterator, i, attrs->attrs)
+        if (i->second.inherited)
+            env2.values[displ++] = state.lookupVar(&env, i->second.var);
+        else
+            env2.values[displ++] = state.maybeThunk(env2, i->second.e);

    state.eval(env2, body, v);
 }
@@ -487,11 +587,8 @@ void ExprLet::eval(EvalState & state, Env & env, Value & v)
 void ExprList::eval(EvalState & state, Env & env, Value & v)
 {
    state.mkList(v, elems.size());
-    Value * vs = state.allocValues(v.list.length);
-    for (unsigned int n = 0; n < v.list.length; ++n) {
-        v.list.elems[n] = &vs[n];
-        mkThunk(vs[n], env, elems[n]);
-    }
+    for (unsigned int n = 0; n < v.list.length; ++n)
+        v.list.elems[n] = state.maybeThunk(env, elems[n]);
 }


@@ -503,21 +600,26 @@ void ExprVar::eval(EvalState & state, Env & env, Value & v)
 }


+unsigned long nrLookups = 0;
+unsigned long nrLookupSize = 0;
+
 void ExprSelect::eval(EvalState & state, Env & env, Value & v)
 {
+    nrLookups++;
    Value v2;
    state.evalAttrs(env, e, v2);
+    nrLookupSize += v2.attrs->size();
    Bindings::iterator i = v2.attrs->find(name);
    if (i == v2.attrs->end())
        throwEvalError("attribute `%1%' missing", name);
    try {            
-        state.forceValue(i->second.value);
+        state.forceValue(*i->value);
    } catch (Error & e) {
        addErrorPrefix(e, "while evaluating the attribute `%1%' at %2%:\n",
-            name, *i->second.pos);
+            name, *i->pos);
        throw;
    }
-    v = i->second.value;
+    v = *i->value;
 }


@@ -541,24 +643,27 @@ void ExprApp::eval(EvalState & state, Env & env, Value & v)
 {
    Value vFun;
    state.eval(env, e1, vFun);
-    Value vArg;
-    mkThunk(vArg, env, e2); // !!! should this be on the heap?
-    state.callFunction(vFun, vArg, v);
+    state.callFunction(vFun, *state.maybeThunk(env, e2), v);
 }


 void EvalState::callFunction(Value & fun, Value & arg, Value & v)
 {
    if (fun.type == tPrimOp || fun.type == tPrimOpApp) {
-        unsigned int argsLeft =
-            fun.type == tPrimOp ? fun.primOp.arity : fun.primOpApp.argsLeft;
+
+        /* Figure out the number of arguments still needed. */
+        unsigned int argsDone = 0;
+        Value * primOp = &fun;
+        while (primOp->type == tPrimOpApp) {
+            argsDone++;
+            primOp = primOp->primOpApp.left;
+        }
+        assert(primOp->type == tPrimOp);
+        unsigned int arity = primOp->primOp->arity;
+        unsigned int argsLeft = arity - argsDone;
+        
        if (argsLeft == 1) {
-            /* We have all the arguments, so call the primop.  First
-               find the primop. */
-            Value * primOp = &fun;
-            while (primOp->type == tPrimOpApp) primOp = primOp->primOpApp.left;
-            assert(primOp->type == tPrimOp);
-            unsigned int arity = primOp->primOp.arity;
+            /* We have all the arguments, so call the primop. */
                
            /* Put all the arguments in an array. */
            Value * vArgs[arity];
@@ -569,19 +674,16 @@ void EvalState::callFunction(Value & fun, Value & arg, Value & v)

            /* And call the primop. */
            try {
-                primOp->primOp.fun(*this, vArgs, v);
+                primOp->primOp->fun(*this, vArgs, v);
            } catch (Error & e) {
-                addErrorPrefix(e, "while evaluating the builtin function `%1%':\n", primOp->primOp.name);
+                addErrorPrefix(e, "while evaluating the builtin function `%1%':\n", primOp->primOp->name);
                throw;
            }
        } else {
-            Value * v2 = allocValues(2);
-            v2[0] = fun;
-            v2[1] = arg;
            v.type = tPrimOpApp;
-            v.primOpApp.left = &v2[0];
-            v.primOpApp.right = &v2[1];
-            v.primOpApp.argsLeft = argsLeft - 1;
+            v.primOpApp.left = allocValue();
+            *v.primOpApp.left = fun;
+            v.primOpApp.right = &arg;
        }
        return;
    }
@@ -599,13 +701,13 @@ void EvalState::callFunction(Value & fun, Value & arg, Value & v)
    unsigned int displ = 0;

    if (!fun.lambda.fun->matchAttrs)
-        env2.values[displ++] = arg;
+        env2.values[displ++] = &arg;

    else {
        forceAttrs(arg);
        
        if (!fun.lambda.fun->arg.empty())
-            env2.values[displ++] = arg;
+            env2.values[displ++] = &arg;

        /* For each formal argument, get the actual argument.  If
           there is no matching actual argument but the formal
@@ -615,11 +717,11 @@ void EvalState::callFunction(Value & fun, Value & arg, Value & v)
            Bindings::iterator j = arg.attrs->find(i->name);
            if (j == arg.attrs->end()) {
                if (!i->def) throwTypeError("function at %1% called without required argument `%2%'",
-                    fun.lambda.fun->pos, i->name);   
-                mkThunk(env2.values[displ++], env2, i->def);
+                    fun.lambda.fun->pos, i->name);
+                env2.values[displ++] = maybeThunk(env2, i->def);
            } else {
                attrsUsed++;
-                mkCopy(env2.values[displ++], j->second.value);
+                env2.values[displ++] = j->value;
            }
        }

@@ -627,7 +729,7 @@ void EvalState::callFunction(Value & fun, Value & arg, Value & v)
           argument (unless the attribute match specifies a `...').
           TODO: show the names of the expected/unexpected
           arguments. */
-        if (!fun.lambda.fun->formals->ellipsis && attrsUsed != arg.attrs->size())
+        if (!fun.lambda.fun->formals->ellipsis && attrsUsed != arg.attrs->size()) 
            throwTypeError("function at %1% called with unexpected argument", fun.lambda.fun->pos);
    }

@@ -640,7 +742,7 @@ void EvalState::callFunction(Value & fun, Value & arg, Value & v)
 }


-void EvalState::autoCallFunction(const Bindings & args, Value & fun, Value & res)
+void EvalState::autoCallFunction(Bindings & args, Value & fun, Value & res)
 {
    forceValue(fun);

@@ -650,16 +752,18 @@ void EvalState::autoCallFunction(const Bindings & args, Value & fun, Value & res
    }

    Value actualArgs;
-    mkAttrs(actualArgs);
+    mkAttrs(actualArgs, fun.lambda.fun->formals->formals.size());

    foreach (Formals::Formals_::iterator, i, fun.lambda.fun->formals->formals) {
-        Bindings::const_iterator j = args.find(i->name);
+        Bindings::iterator j = args.find(i->name);
        if (j != args.end())
-            (*actualArgs.attrs)[i->name] = j->second;
+            actualArgs.attrs->push_back(*j);
        else if (!i->def)
            throwTypeError("cannot auto-call a function that has an argument without a default value (`%1%')", i->name);
    }

+    actualArgs.attrs->sort();
+
    callFunction(fun, actualArgs, res);
 }

@@ -670,7 +774,8 @@ void ExprWith::eval(EvalState & state, Env & env, Value & v)
    env2.up = &env;
    env2.prevWith = prevWith;

-    state.evalAttrs(env, attrs, env2.values[0]);
+    env2.values[0] = state.allocValue();
+    state.evalAttrs(env, attrs, *env2.values[0]);

    state.eval(env2, body, v);
 }
@@ -732,18 +837,38 @@ void ExprOpImpl::eval(EvalState & state, Env & env, Value & v)

 void ExprOpUpdate::eval(EvalState & state, Env & env, Value & v)
 {
-    Value v2;
-    state.evalAttrs(env, e1, v2);
-        
-    state.cloneAttrs(v2, v);
-        
+    Value v1, v2;
+    state.evalAttrs(env, e1, v1);
    state.evalAttrs(env, e2, v2);
-    
-    foreach (Bindings::iterator, i, *v2.attrs) {
-        Attr & a = (*v.attrs)[i->first];
-        mkCopy(a.value, i->second.value);
-        a.pos = i->second.pos;
+
+    state.nrOpUpdates++;
+
+    if (v1.attrs->size() == 0) { v = v2; return; }
+    if (v2.attrs->size() == 0) { v = v1; return; }
+
+    state.mkAttrs(v, v1.attrs->size() + v2.attrs->size());
+
+    /* Merge the attribute sets, preferring values from the second
+       set.  Make sure to keep the resulting vector in sorted
+       order. */
+    Bindings::iterator i = v1.attrs->begin();
+    Bindings::iterator j = v2.attrs->begin();
+
+    while (i != v1.attrs->end() && j != v2.attrs->end()) {
+        if (i->name == j->name) {
+            v.attrs->push_back(*j);
+            ++i; ++j;
+        }
+        else if (i->name < j->name)
+            v.attrs->push_back(*i++);
+        else
+            v.attrs->push_back(*j++);
    }
+
+    while (i != v1.attrs->end()) v.attrs->push_back(*i++);
+    while (j != v2.attrs->end()) v.attrs->push_back(*j++);
+    
+    state.nrOpUpdateValuesCopied += v.attrs->size();
 }


@@ -806,10 +931,6 @@ void EvalState::forceValue(Value & v)
            throw;
        }
    }
-    else if (v.type == tCopy) {
-        forceValue(*v.val);
-        v = *v.val;
-    }
    else if (v.type == tApp)
        callFunction(*v.app.left, *v.app.right, v);
    else if (v.type == tBlackhole)
@@ -823,7 +944,7 @@ void EvalState::strictForceValue(Value & v)
    
    if (v.type == tAttrs) {
        foreach (Bindings::iterator, i, *v.attrs)
-            strictForceValue(i->second.value);
+            strictForceValue(*i->value);
    }
    
    else if (v.type == tList) {
@@ -884,12 +1005,18 @@ string EvalState::forceString(Value & v)
 }


-string EvalState::forceString(Value & v, PathSet & context)
+void copyContext(const Value & v, PathSet & context)
 {
-    string s = forceString(v);
    if (v.string.context)
        for (const char * * p = v.string.context; *p; ++p) 
            context.insert(*p);
+}
+
+
+string EvalState::forceString(Value & v, PathSet & context)
+{
+    string s = forceString(v);
+    copyContext(v, context);
    return s;
 }

@@ -908,7 +1035,7 @@ bool EvalState::isDerivation(Value & v)
 {
    if (v.type != tAttrs) return false;
    Bindings::iterator i = v.attrs->find(sType);
-    return i != v.attrs->end() && forceStringNoCtx(i->second.value) == "derivation";
+    return i != v.attrs->end() && forceStringNoCtx(*i->value) == "derivation";
 }


@@ -920,9 +1047,7 @@ string EvalState::coerceToString(Value & v, PathSet & context,
    string s;

    if (v.type == tString) {
-        if (v.string.context) 
-            for (const char * * p = v.string.context; *p; ++p) 
-                context.insert(*p);
+        copyContext(v, context);
        return v.string.s;
    }

@@ -954,7 +1079,7 @@ string EvalState::coerceToString(Value & v, PathSet & context,
        Bindings::iterator i = v.attrs->find(sOutPath);
        if (i == v.attrs->end())
            throwTypeError("cannot coerce an attribute set (except a derivation) to a string");
-        return coerceToString(i->second.value, context, coerceMore, copyToStore);
+        return coerceToString(*i->value, context, coerceMore, copyToStore);
    }

    if (coerceMore) {
@@ -1040,9 +1165,9 @@ bool EvalState::eqValues(Value & v1, Value & v2)

        case tAttrs: {
            if (v1.attrs->size() != v2.attrs->size()) return false;
-            Bindings::iterator i, j;
-            for (i = v1.attrs->begin(), j = v2.attrs->begin(); i != v1.attrs->end(); ++i, ++j)
-                if (i->first != j->first || !eqValues(i->second.value, j->second.value))
+            Bindings::iterator i = v1.attrs->begin(), j = v2.attrs->begin();
+            for ( ; i != v1.attrs->end(); ++i, ++j)
+                if (i->name != j->name || !eqValues(*i->value, *j->value))
                    return false;
            return true;
        }
@@ -1065,20 +1190,26 @@ void EvalState::printStats()
    bool showStats = getEnv("NIX_SHOW_STATS", "0") != "0";
    Verbosity v = showStats ? lvlInfo : lvlDebug;
    printMsg(v, "evaluation statistics:");
+    printMsg(v, format("  size of a value: %1%") % sizeof(Value));
    printMsg(v, format("  expressions evaluated: %1%") % nrEvaluated);
    printMsg(v, format("  stack space used: %1% bytes") % (&x - deepestStack));
    printMsg(v, format("  max eval() nesting depth: %1%") % maxRecursionDepth);
    printMsg(v, format("  stack space per eval() level: %1% bytes")
        % ((&x - deepestStack) / (float) maxRecursionDepth));
    printMsg(v, format("  environments allocated: %1% (%2% bytes)")
-        % nrEnvs % (nrEnvs * sizeof(Env)));
-    printMsg(v, format("  values allocated in environments: %1% (%2% bytes)")
-        % nrValuesInEnvs % (nrValuesInEnvs * sizeof(Value)));
+        % nrEnvs % (nrEnvs * sizeof(Env) + nrValuesInEnvs * sizeof(Value *)));
    printMsg(v, format("  list elements: %1% (%2% bytes)")
        % nrListElems % (nrListElems * sizeof(Value *)));
-    printMsg(v, format("  misc. values allocated: %1% (%2% bytes)")
+    printMsg(v, format("  values allocated: %1% (%2% bytes)")
        % nrValues % (nrValues * sizeof(Value)));
+    printMsg(v, format("  attribute sets allocated: %1%") % nrAttrsets);
+    printMsg(v, format("  right-biased unions: %1%") % nrOpUpdates);
+    printMsg(v, format("  values copied in right-biased unions: %1%") % nrOpUpdateValuesCopied);
    printMsg(v, format("  symbols in symbol table: %1%") % symbols.size());
+    printMsg(v, format("  number of thunks: %1%") % nrThunks);
+    printMsg(v, format("  number of thunks avoided: %1%") % nrAvoided);
+    printMsg(v, format("  number of attr lookups: %1%") % nrLookups);
+    printMsg(v, format("  attr lookup size: %1%") % nrLookupSize);
 }


--- a/src/libexpr/eval.hh
+++ b/src/libexpr/eval.hh
@@ -1,22 +1,41 @@
 #ifndef __EVAL_H
 #define __EVAL_H

-#include <map>
-
 #include "nixexpr.hh"
 #include "symbol-table.hh"
+#include "hash.hh"
+
+#include <map>
+
+#if HAVE_BOEHMGC
+#include <gc/gc_allocator.h>
+#endif


 namespace nix {


-class Hash;
 class EvalState;
 struct Env;
 struct Value;
 struct Attr;

-typedef std::map<Symbol, Attr> Bindings;
+
+/* Attribute sets are represented as a vector of attributes, sorted by
+   symbol (i.e. pointer to the attribute name in the symbol table). */
+#if HAVE_BOEHMGC
+typedef std::vector<Attr, gc_allocator<Attr> > BindingsBase;
+#else
+typedef std::vector<Attr> BindingsBase;
+#endif
+
+
+class Bindings : public BindingsBase
+{
+public:
+    iterator find(const Symbol & name);
+    void sort();
+};


 typedef enum {
@@ -30,14 +49,23 @@ typedef enum {
    tThunk,
    tApp,
    tLambda,
-    tCopy,
    tBlackhole,
    tPrimOp,
    tPrimOpApp,
 } ValueType;


-typedef void (* PrimOp) (EvalState & state, Value * * args, Value & v);
+typedef void (* PrimOpFun) (EvalState & state, Value * * args, Value & v);
+
+
+struct PrimOp
+{
+    PrimOpFun fun;
+    unsigned int arity;
+    Symbol name;
+    PrimOp(PrimOpFun fun, unsigned int arity, Symbol name)
+        : fun(fun), arity(arity), name(name) { }
+};


 struct Value
@@ -90,15 +118,9 @@ struct Value
            Env * env;
            ExprLambda * fun;
        } lambda;
-        Value * val;
-        struct {
-            PrimOp fun;
-            char * name;
-            unsigned int arity;
-        } primOp;
+        PrimOp * primOp;
        struct {
            Value * left, * right;
-            unsigned int argsLeft;
        } primOpApp;
    };
 };
@@ -108,20 +130,36 @@ struct Env
 {
    Env * up;
    unsigned int prevWith; // nr of levels up to next `with' environment
-    Value values[0];
+    Value * values[0];
 };


 struct Attr
 {
-    Value value;
+    Symbol name;
+    Value * value;
    Pos * pos;
+    Attr(Symbol name, Value * value, Pos * pos = &noPos)
+        : name(name), value(value), pos(pos) { };
    Attr() : pos(&noPos) { };
+    bool operator < (const Attr & a) const
+    {
+        return name < a.name;
+    }
 };


+/* After overwriting an app node, be sure to clear pointers in the
+   Value to ensure that the target isn't kept alive unnecessarily. */
+static inline void clearValue(Value & v)
+{
+    v.app.right = 0;
+}
+
+
 static inline void mkInt(Value & v, int n)
 {
+    clearValue(v);
    v.type = tInt;
    v.integer = n;
 }
@@ -129,26 +167,12 @@ static inline void mkInt(Value & v, int n)

 static inline void mkBool(Value & v, bool b)
 {
+    clearValue(v);
    v.type = tBool;
    v.boolean = b;
 }


-static inline void mkThunk(Value & v, Env & env, Expr * expr)
-{
-    v.type = tThunk;
-    v.thunk.env = &env;
-    v.thunk.expr = expr;
-}
-
-
-static inline void mkCopy(Value & v, Value & src)
-{
-    v.type = tCopy;
-    v.val = &src;
-}
-
-
 static inline void mkApp(Value & v, Value & left, Value & right)
 {
    v.type = tApp;
@@ -161,6 +185,8 @@ void mkString(Value & v, const char * s);
 void mkString(Value & v, const string & s, const PathSet & context = PathSet());
 void mkPath(Value & v, const char * s);

+void copyContext(const Value & v, PathSet & context);
+

 typedef std::map<Path, Hash> DrvHashes;

@@ -171,7 +197,7 @@ typedef std::map<Path, Path> SrcToStore;
 struct EvalState;


-std::ostream & operator << (std::ostream & str, Value & v);
+std::ostream & operator << (std::ostream & str, const Value & v);


 class EvalState 
@@ -181,7 +207,8 @@ public:

    SymbolTable symbols;

-    const Symbol sWith, sOutPath, sDrvPath, sType, sMeta, sName, sSystem;
+    const Symbol sWith, sOutPath, sDrvPath, sType, sMeta, sName,
+        sSystem, sOverrides;

 private:
    SrcToStore srcToStore; 
@@ -265,7 +292,7 @@ private:
    void addConstant(const string & name, Value & v);

    void addPrimOp(const string & name,
-        unsigned int arity, PrimOp primOp);
+        unsigned int arity, PrimOpFun primOp);

    Value * lookupVar(Env * env, const VarRef & var);
    
@@ -283,18 +310,20 @@ public:

    /* Automatically call a function for which each argument has a
       default value or has a binding in the `args' map. */
-    void autoCallFunction(const Bindings & args, Value & fun, Value & res);
+    void autoCallFunction(Bindings & args, Value & fun, Value & res);
    
    /* Allocation primitives. */
-    Value * allocValues(unsigned int count);
+    Value * allocValue();
    Env & allocEnv(unsigned int size);

-    void mkList(Value & v, unsigned int length);
-    void mkAttrs(Value & v);
-    void mkThunk_(Value & v, Expr * expr);
-    
-    void cloneAttrs(Value & src, Value & dst);
+    Value * allocAttr(Value & vAttrs, const Symbol & name);

+    void mkList(Value & v, unsigned int length);
+    void mkAttrs(Value & v, unsigned int expected);
+    void mkThunk_(Value & v, Expr * expr);
+
+    Value * maybeThunk(Env & env, Expr * expr);
+    
    /* Print statistics. */
    void printStats();

@@ -305,11 +334,15 @@ private:
    unsigned long nrValues;
    unsigned long nrListElems;
    unsigned long nrEvaluated;
+    unsigned long nrAttrsets;
+    unsigned long nrOpUpdates;
+    unsigned long nrOpUpdateValuesCopied;
    unsigned int recursionDepth;
    unsigned int maxRecursionDepth;
    char * deepestStack; /* for measuring stack usage */
    
    friend class RecursionCounter;
+    friend class ExprOpUpdate;
 };


--- a/src/libexpr/get-drvs.cc
+++ b/src/libexpr/get-drvs.cc
@@ -10,7 +10,7 @@ string DrvInfo::queryDrvPath(EvalState & state) const
    if (drvPath == "" && attrs) {
        Bindings::iterator i = attrs->find(state.sDrvPath);
        PathSet context;
-        (string &) drvPath = i != attrs->end() ? state.coerceToPath(i->second.value, context) : "";
+        (string &) drvPath = i != attrs->end() ? state.coerceToPath(*i->value, context) : "";
    }
    return drvPath;
 }
@@ -21,7 +21,7 @@ string DrvInfo::queryOutPath(EvalState & state) const
    if (outPath == "" && attrs) {
        Bindings::iterator i = attrs->find(state.sOutPath);
        PathSet context;
-        (string &) outPath = i != attrs->end() ? state.coerceToPath(i->second.value, context) : "";
+        (string &) outPath = i != attrs->end() ? state.coerceToPath(*i->value, context) : "";
    }
    return outPath;
 }
@@ -36,23 +36,23 @@ MetaInfo DrvInfo::queryMetaInfo(EvalState & state) const
    Bindings::iterator a = attrs->find(state.sMeta);
    if (a == attrs->end()) return meta; /* fine, empty meta information */

-    state.forceAttrs(a->second.value);
+    state.forceAttrs(*a->value);

-    foreach (Bindings::iterator, i, *a->second.value.attrs) {
+    foreach (Bindings::iterator, i, *a->value->attrs) {
        MetaValue value;
-        state.forceValue(i->second.value);
-        if (i->second.value.type == tString) {
+        state.forceValue(*i->value);
+        if (i->value->type == tString) {
            value.type = MetaValue::tpString;
-            value.stringValue = i->second.value.string.s;
-        } else if (i->second.value.type == tInt) {
+            value.stringValue = i->value->string.s;
+        } else if (i->value->type == tInt) {
            value.type = MetaValue::tpInt;
-            value.intValue = i->second.value.integer;
-        } else if (i->second.value.type == tList) {
+            value.intValue = i->value->integer;
+        } else if (i->value->type == tList) {
            value.type = MetaValue::tpStrings;
-            for (unsigned int j = 0; j < i->second.value.list.length; ++j)
-                value.stringValues.push_back(state.forceStringNoCtx(*i->second.value.list.elems[j]));
+            for (unsigned int j = 0; j < i->value->list.length; ++j)
+                value.stringValues.push_back(state.forceStringNoCtx(*i->value->list.elems[j]));
        } else continue;
-        ((MetaInfo &) meta)[i->first] = value;
+        ((MetaInfo &) meta)[i->name] = value;
    }

    return meta;
@@ -99,13 +99,13 @@ static bool getDerivation(EvalState & state, Value & v,
        Bindings::iterator i = v.attrs->find(state.sName);
        /* !!! We really would like to have a decent back trace here. */
        if (i == v.attrs->end()) throw TypeError("derivation name missing");
-        drv.name = state.forceStringNoCtx(i->second.value);
+        drv.name = state.forceStringNoCtx(*i->value);

-        i = v.attrs->find(state.sSystem);
-        if (i == v.attrs->end())
+        Bindings::iterator i2 = v.attrs->find(state.sSystem);
+        if (i2 == v.attrs->end())
            drv.system = "unknown";
        else
-            drv.system = state.forceStringNoCtx(i->second.value);
+            drv.system = state.forceStringNoCtx(*i2->value);

        drv.attrs = v.attrs;

@@ -138,7 +138,7 @@ static string addToPath(const string & s1, const string & s2)


 static void getDerivations(EvalState & state, Value & vIn,
-    const string & pathPrefix, const Bindings & autoArgs,
+    const string & pathPrefix, Bindings & autoArgs,
    DrvInfos & drvs, Done & done)
 {
    Value v;
@@ -163,12 +163,12 @@ static void getDerivations(EvalState & state, Value & vIn,
        typedef std::map<string, Symbol> SortedSymbols;
        SortedSymbols attrs;
        foreach (Bindings::iterator, i, *v.attrs)
-            attrs.insert(std::pair<string, Symbol>(i->first, i->first));
+            attrs.insert(std::pair<string, Symbol>(i->name, i->name));

        foreach (SortedSymbols::iterator, i, attrs) {
            startNest(nest, lvlDebug, format("evaluating attribute `%1%'") % i->first);
            string pathPrefix2 = addToPath(pathPrefix, i->first);
-            Value & v2((*v.attrs)[i->second].value);
+            Value & v2(*v.attrs->find(i->second)->value);
            if (combineChannels)
                getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done);
            else if (getDerivation(state, v2, pathPrefix2, drvs, done)) {
@@ -178,7 +178,7 @@ static void getDerivations(EvalState & state, Value & vIn,
                   attribute. */
                if (v2.type == tAttrs) {
                    Bindings::iterator j = v2.attrs->find(state.symbols.create("recurseForDerivations"));
-                    if (j != v2.attrs->end() && state.forceBool(j->second.value))
+                    if (j != v2.attrs->end() && state.forceBool(*j->value))
                        getDerivations(state, v2, pathPrefix2, autoArgs, drvs, done);
                }
            }
@@ -200,7 +200,7 @@ static void getDerivations(EvalState & state, Value & vIn,


 void getDerivations(EvalState & state, Value & v, const string & pathPrefix,
-    const Bindings & autoArgs, DrvInfos & drvs)
+    Bindings & autoArgs, DrvInfos & drvs)
 {
    Done done;
    getDerivations(state, v, pathPrefix, autoArgs, drvs, done);
--- a/src/libexpr/get-drvs.hh
+++ b/src/libexpr/get-drvs.hh
@@ -1,13 +1,13 @@
 #ifndef __GET_DRVS_H
 #define __GET_DRVS_H

+#include "eval.hh"
+
 #include <string>
 #include <map>

 #include <boost/shared_ptr.hpp>

-#include "eval.hh"
-

 namespace nix {

@@ -70,7 +70,7 @@ typedef list<DrvInfo> DrvInfos;
 bool getDerivation(EvalState & state, Value & v, DrvInfo & drv);

 void getDerivations(EvalState & state, Value & v, const string & pathPrefix,
-    const Bindings & autoArgs, DrvInfos & drvs);
+    Bindings & autoArgs, DrvInfos & drvs);

 
 }
--- a/src/libexpr/lexer.l
+++ b/src/libexpr/lexer.l
@@ -46,7 +46,7 @@ static void adjustLoc(YYLTYPE * loc, const char * s, size_t len)
 }


-static Expr * unescapeStr(const char * s)
+static Expr * unescapeStr(SymbolTable & symbols, const char * s)
 {
    string t;
    char c;
@@ -66,7 +66,7 @@ static Expr * unescapeStr(const char * s)
        }
        else t += c;
    }
-    return new ExprString(t);
+    return new ExprString(symbols.create(t));
 }

 
@@ -119,7 +119,7 @@ inherit     { return INHERIT; }
                 "$\"" will be consumed as part of a string, rather
                 than a "$" followed by the string terminator.
                 Disallow "$\"" for now. */
-              yylval->e = unescapeStr(yytext);
+              yylval->e = unescapeStr(data->symbols, yytext);
              return STR;
            }
 <STRING>\$\{  { BEGIN(INITIAL); return DOLLAR_CURLY; }
@@ -140,7 +140,7 @@ inherit     { return INHERIT; }
                   return IND_STR;
                 }
 <IND_STRING>\'\'\\. {
-                   yylval->e = unescapeStr(yytext + 2);
+                   yylval->e = unescapeStr(data->symbols, yytext + 2);
                   return IND_STR;
                 }
 <IND_STRING>\$\{ { BEGIN(INITIAL); return DOLLAR_CURLY; }
--- a/src/libexpr/nixexpr.cc
+++ b/src/libexpr/nixexpr.cc
@@ -55,10 +55,11 @@ void ExprAttrs::show(std::ostream & str)
 {
    if (recursive) str << "rec ";
    str << "{ ";
-    foreach (list<Inherited>::iterator, i, inherited)
-        str << "inherit " << i->first.name << "; ";
-    foreach (Attrs::iterator, i, attrs)
-        str << i->first << " = " << *i->second.first << "; ";
+    foreach (AttrDefs::iterator, i, attrs)
+        if (i->second.inherited)
+            str << "inherit " << i->first << " " << "; ";
+        else
+            str << i->first << " = " << *i->second.e << "; ";
    str << "}";
 }

@@ -91,10 +92,11 @@ void ExprLambda::show(std::ostream & str)
 void ExprLet::show(std::ostream & str)
 {
    str << "let ";
-    foreach (list<ExprAttrs::Inherited>::iterator, i, attrs->inherited)
-        str << "inherit " << i->first.name << "; ";
-    foreach (ExprAttrs::Attrs::iterator, i, attrs->attrs)
-        str << i->first << " = " << *i->second.first << "; ";
+    foreach (ExprAttrs::AttrDefs::iterator, i, attrs->attrs)
+        if (i->second.inherited)
+            str << "inherit " << i->first << "; ";
+        else
+            str << i->first << " = " << *i->second.e << "; ";
    str << "in " << *body;
 }

@@ -211,26 +213,18 @@ void ExprAttrs::bindVars(const StaticEnv & env)
        StaticEnv newEnv(false, &env);
    
        unsigned int displ = 0;
-
-        foreach (ExprAttrs::Attrs::iterator, i, attrs)
-            newEnv.vars[i->first] = displ++;
-
-        foreach (list<Inherited>::iterator, i, inherited) {
-            newEnv.vars[i->first.name] = displ++;
-            i->first.bind(env);
-        }
-
-        foreach (ExprAttrs::Attrs::iterator, i, attrs)
-            i->second.first->bindVars(newEnv);
+        foreach (AttrDefs::iterator, i, attrs)
+            newEnv.vars[i->first] = i->second.displ = displ++;
+        
+        foreach (AttrDefs::iterator, i, attrs)
+            if (i->second.inherited) i->second.var.bind(env);
+            else i->second.e->bindVars(newEnv);
    }

-    else {
-        foreach (ExprAttrs::Attrs::iterator, i, attrs)
-            i->second.first->bindVars(env);
-
-        foreach (list<Inherited>::iterator, i, inherited)
-            i->first.bind(env);
-    }
+    else
+        foreach (AttrDefs::iterator, i, attrs)
+            if (i->second.inherited) i->second.var.bind(env);
+            else i->second.e->bindVars(env);
 }

 void ExprList::bindVars(const StaticEnv & env)
@@ -263,17 +257,12 @@ void ExprLet::bindVars(const StaticEnv & env)
    StaticEnv newEnv(false, &env);
    
    unsigned int displ = 0;
-
-    foreach (ExprAttrs::Attrs::iterator, i, attrs->attrs)
-        newEnv.vars[i->first] = displ++;
-
-    foreach (list<ExprAttrs::Inherited>::iterator, i, attrs->inherited) {
-        newEnv.vars[i->first.name] = displ++;
-        i->first.bind(env);
-    }
-
-    foreach (ExprAttrs::Attrs::iterator, i, attrs->attrs)
-        i->second.first->bindVars(newEnv);
+    foreach (ExprAttrs::AttrDefs::iterator, i, attrs->attrs)
+        newEnv.vars[i->first] = i->second.displ = displ++;
+    
+    foreach (ExprAttrs::AttrDefs::iterator, i, attrs->attrs)
+        if (i->second.inherited) i->second.var.bind(env);
+        else i->second.e->bindVars(newEnv);
    
    body->bindVars(newEnv);
 }
--- a/src/libexpr/nixexpr.hh
+++ b/src/libexpr/nixexpr.hh
@@ -1,10 +1,10 @@
 #ifndef __NIXEXPR_H
 #define __NIXEXPR_H

-#include <map>
-
 #include "symbol-table.hh"

+#include <map>
+

 namespace nix {

@@ -15,6 +15,7 @@ MakeError(AssertionError, EvalError)
 MakeError(ThrownError, AssertionError)
 MakeError(Abort, EvalError)
 MakeError(TypeError, EvalError)
+MakeError(ImportError, EvalError) // error building an imported derivation


 /* Position objects. */
@@ -64,8 +65,8 @@ struct ExprInt : Expr

 struct ExprString : Expr
 {
-    string s;
-    ExprString(const string & s) : s(s) { };
+    Symbol s;
+    ExprString(const Symbol & s) : s(s) { };
    COMMON_METHODS
 };

@@ -100,6 +101,7 @@ struct VarRef
    unsigned int level;
    unsigned int displ;

+    VarRef() { };
    VarRef(const Symbol & name) : name(name) { };
    void bind(const StaticEnv & env);
 };
@@ -130,12 +132,18 @@ struct ExprOpHasAttr : Expr
 struct ExprAttrs : Expr
 {
    bool recursive;
-    typedef std::pair<Expr *, Pos> Attr;
-    typedef std::pair<VarRef, Pos> Inherited;
-    typedef std::map<Symbol, Attr> Attrs;
-    Attrs attrs;
-    list<Inherited> inherited;
-    std::map<Symbol, Pos> attrNames; // used during parsing
+    struct AttrDef {
+        bool inherited;
+        Expr * e; // if not inherited
+        VarRef var; // if inherited
+        Pos pos;
+        unsigned int displ; // displacement
+        AttrDef(Expr * e, const Pos & pos) : inherited(false), e(e), pos(pos) { };
+        AttrDef(const Symbol & name, const Pos & pos) : inherited(true), var(name), pos(pos) { };
+        AttrDef() { };
+    };
+    typedef std::map<Symbol, AttrDef> AttrDefs;
+    AttrDefs attrs;
    ExprAttrs() : recursive(false) { };
    COMMON_METHODS
 };
--- a/src/libexpr/parser.y
+++ b/src/libexpr/parser.y
@@ -7,48 +7,59 @@
 %parse-param { yyscan_t scanner }
 %parse-param { ParseData * data }
 %lex-param { yyscan_t scanner }
+%lex-param { ParseData * data }

-
-%{
-/* Newer versions of Bison copy the declarations below to
-   parser-tab.hh, which sucks bigtime since lexer.l doesn't want that
-   stuff.  So allow it to be excluded. */
-#ifndef BISON_HEADER_HACK
-#define BISON_HEADER_HACK
+%code requires {
+    
+#ifndef BISON_HEADER
+#define BISON_HEADER
    
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
 #include "util.hh"
    
 #include "nixexpr.hh"

+namespace nix {
+
+    struct ParseData 
+    {
+        SymbolTable & symbols;
+        Expr * result;
+        Path basePath;
+        Path path;
+        string error;
+        Symbol sLetBody;
+        ParseData(SymbolTable & symbols)
+            : symbols(symbols)
+            , sLetBody(symbols.create("<let-body>"))
+            { };
+    };
+    
+}
+
+#define YY_DECL int yylex \
+    (YYSTYPE * yylval_param, YYLTYPE * yylloc_param, yyscan_t yyscanner, nix::ParseData * data)
+
+#endif
+
+}
+
+%{
+
 #include "parser-tab.hh"
 #include "lexer-tab.hh"
 #define YYSTYPE YYSTYPE // workaround a bug in Bison 2.4

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+YY_DECL;

 using namespace nix;


 namespace nix {
-
    
-struct ParseData 
-{
-    SymbolTable & symbols;
-    Expr * result;
-    Path basePath;
-    Path path;
-    string error;
-    Symbol sLetBody;
-    ParseData(SymbolTable & symbols)
-        : symbols(symbols)
-        , sLetBody(symbols.create("<let-body>"))
-    { };
-};
-

 static string showAttrPath(const vector<Symbol> & attrPath)
 {
@@ -82,20 +93,20 @@ static void addAttr(ExprAttrs * attrs, const vector<Symbol> & attrPath,
    unsigned int n = 0;
    foreach (vector<Symbol>::const_iterator, i, attrPath) {
        n++;
-        ExprAttrs::Attrs::iterator j = attrs->attrs.find(*i);
+        ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(*i);
        if (j != attrs->attrs.end()) {
-            ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.first);
-            if (!attrs2 || n == attrPath.size()) dupAttr(attrPath, pos, j->second.second);
-            attrs = attrs2;
+            if (!j->second.inherited) {
+                ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
+                if (!attrs2 || n == attrPath.size()) dupAttr(attrPath, pos, j->second.pos);
+                attrs = attrs2;
+            } else
+                dupAttr(attrPath, pos, j->second.pos);
        } else {
-            if (attrs->attrNames.find(*i) != attrs->attrNames.end())
-                dupAttr(attrPath, pos, attrs->attrNames[*i]);
-            attrs->attrNames[*i] = pos;
            if (n == attrPath.size())
-                attrs->attrs[*i] = ExprAttrs::Attr(e, pos);
+                attrs->attrs[*i] = ExprAttrs::AttrDef(e, pos);
            else {
                ExprAttrs * nested = new ExprAttrs;
-                attrs->attrs[*i] = ExprAttrs::Attr(nested, pos);
+                attrs->attrs[*i] = ExprAttrs::AttrDef(nested, pos);
                attrs = nested;
            }
        }
@@ -113,9 +124,9 @@ static void addFormal(const Pos & pos, Formals * formals, const Formal & formal)
 }


-static Expr * stripIndentation(vector<Expr *> & es)
+static Expr * stripIndentation(SymbolTable & symbols, vector<Expr *> & es)
 {
-    if (es.empty()) return new ExprString("");
+    if (es.empty()) return new ExprString(symbols.create(""));
    
    /* Figure out the minimum indentation.  Note that by design
       whitespace-only final lines are not taken into account.  (So
@@ -195,7 +206,7 @@ static Expr * stripIndentation(vector<Expr *> & es)
                s2 = string(s2, 0, p + 1);
        }

-        es2->push_back(new ExprString(s2));
+        es2->push_back(new ExprString(symbols.create(s2)));
    }

    return new ExprConcatStrings(es2);
@@ -224,9 +235,6 @@ void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * err
 }


-#endif
-
-
 %}

 %union {
@@ -337,15 +345,15 @@ expr_simple
  | INT { $$ = new ExprInt($1); }
  | '"' string_parts '"' {
      /* For efficiency, and to simplify parse trees a bit. */
-      if ($2->empty()) $$ = new ExprString("");
+      if ($2->empty()) $$ = new ExprString(data->symbols.create(""));
      else if ($2->size() == 1) $$ = $2->front();
      else $$ = new ExprConcatStrings($2);
  }
  | IND_STRING_OPEN ind_string_parts IND_STRING_CLOSE {
-      $$ = stripIndentation(*$2);
+      $$ = stripIndentation(data->symbols, *$2);
  }
  | PATH { $$ = new ExprPath(absPath($1, data->basePath)); }
-  | URI { $$ = new ExprString($1); }
+  | URI { $$ = new ExprString(data->symbols.create($1)); }
  | '(' expr ')' { $$ = $2; }
  /* Let expressions `let {..., body = ...}' are just desugared
     into `(rec {..., body = ...}).body'. */
@@ -375,21 +383,19 @@ binds
  | binds INHERIT ids ';'
    { $$ = $1;
      foreach (vector<Symbol>::iterator, i, *$3) {
-          if ($$->attrNames.find(*i) != $$->attrNames.end())
-              dupAttr(*i, makeCurPos(@3, data), $$->attrNames[*i]);
+          if ($$->attrs.find(*i) != $$->attrs.end())
+              dupAttr(*i, makeCurPos(@3, data), $$->attrs[*i].pos);
          Pos pos = makeCurPos(@3, data);
-          $$->inherited.push_back(ExprAttrs::Inherited(*i, pos));
-          $$->attrNames[*i] = pos;
+          $$->attrs[*i] = ExprAttrs::AttrDef(*i, pos);
      }
    }
  | binds INHERIT '(' expr ')' ids ';'
    { $$ = $1;
      /* !!! Should ensure sharing of the expression in $4. */
      foreach (vector<Symbol>::iterator, i, *$6) {
-          if ($$->attrNames.find(*i) != $$->attrNames.end())
-              dupAttr(*i, makeCurPos(@6, data), $$->attrNames[*i]);
-          $$->attrs[*i] = ExprAttrs::Attr(new ExprSelect($4, *i), makeCurPos(@6, data));
-          $$->attrNames[*i] = makeCurPos(@6, data);
+          if ($$->attrs.find(*i) != $$->attrs.end())
+              dupAttr(*i, makeCurPos(@6, data), $$->attrs[*i].pos);
+          $$->attrs[*i] = ExprAttrs::AttrDef(new ExprSelect($4, *i), makeCurPos(@6, data));
      }}

  | { $$ = new ExprAttrs; }
@@ -480,8 +486,6 @@ Expr * parseExprFromFile(EvalState & state, Path path)
    }

    /* If `path' refers to a directory, append `/default.nix'. */
-    if (stat(path.c_str(), &st))
-        throw SysError(format("getting status of `%1%'") % path);
    if (S_ISDIR(st.st_mode))
        path = canonPath(path + "/default.nix");

--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -1,5 +1,5 @@
-#include "misc.hh"
 #include "eval.hh"
+#include "misc.hh"
 #include "globals.hh"
 #include "store-api.hh"
 #include "util.hh"
@@ -37,7 +37,11 @@ static void prim_import(EvalState & state, Value * * args, Value & v)
            throw EvalError(format("cannot import `%1%', since path `%2%' is not valid")
                % path % *i);
        if (isDerivation(*i))
-            store->buildDerivations(singleton<PathSet>(*i));
+            try {
+                store->buildDerivations(singleton<PathSet>(*i));
+            } catch (Error & e) {
+                throw ImportError(e.msg());
+            }
    }

    state.evalFile(path, v);
@@ -115,24 +119,24 @@ static void prim_genericClosure(EvalState & state, Value * * args, Value & v)
        args[0]->attrs->find(state.symbols.create("startSet"));
    if (startSet == args[0]->attrs->end())
        throw EvalError("attribute `startSet' required");
-    state.forceList(startSet->second.value);
+    state.forceList(*startSet->value);

    list<Value *> workSet;
-    for (unsigned int n = 0; n < startSet->second.value.list.length; ++n)
-        workSet.push_back(startSet->second.value.list.elems[n]);
+    for (unsigned int n = 0; n < startSet->value->list.length; ++n)
+        workSet.push_back(startSet->value->list.elems[n]);

    /* Get the operator. */
    Bindings::iterator op =
        args[0]->attrs->find(state.symbols.create("operator"));
    if (op == args[0]->attrs->end())
        throw EvalError("attribute `operator' required");
-    state.forceValue(op->second.value);
+    state.forceValue(*op->value);

    /* Construct the closure by applying the operator to element of
       `workSet', adding the result to `workSet', continuing until
       no new elements are found. */
    list<Value> res;
-    set<Value, CompareValues> doneKeys;
+    set<Value, CompareValues> doneKeys; // !!! use Value *?
    while (!workSet.empty()) {
 	Value * e = *(workSet.begin());
 	workSet.pop_front();
@@ -143,15 +147,15 @@ static void prim_genericClosure(EvalState & state, Value * * args, Value & v)
            e->attrs->find(state.symbols.create("key"));
        if (key == e->attrs->end())
            throw EvalError("attribute `key' required");
-        state.forceValue(key->second.value);
+        state.forceValue(*key->value);

-        if (doneKeys.find(key->second.value) != doneKeys.end()) continue;
-        doneKeys.insert(key->second.value);
+        if (doneKeys.find(*key->value) != doneKeys.end()) continue;
+        doneKeys.insert(*key->value);
        res.push_back(*e);
        
        /* Call the `operator' function with `e' as argument. */
        Value call;
-        mkApp(call, op->second.value, *e);
+        mkApp(call, *op->value, *e);
        state.forceList(call);

        /* Add the values returned by the operator to the work set. */
@@ -163,13 +167,9 @@ static void prim_genericClosure(EvalState & state, Value * * args, Value & v)

    /* Create the result list. */
    state.mkList(v, res.size());
-    Value * vs = state.allocValues(res.size());
-
    unsigned int n = 0;
-    foreach (list<Value>::iterator, i, res) {
-        v.list.elems[n] = &vs[n];
-        vs[n++] = *i;
-    }
+    foreach (list<Value>::iterator, i, res)
+        *(v.list.elems[n++] = state.allocValue()) = *i;
 }


@@ -206,15 +206,16 @@ static void prim_addErrorContext(EvalState & state, Value * * args, Value & v)
 * else => {success=false; value=false;} */
 static void prim_tryEval(EvalState & state, Value * * args, Value & v)
 {
-    state.mkAttrs(v);
+    state.mkAttrs(v, 2);
    try {
        state.forceValue(*args[0]);
-        (*v.attrs)[state.symbols.create("value")].value = *args[0];
-        mkBool((*v.attrs)[state.symbols.create("success")].value, true);
+        v.attrs->push_back(Attr(state.symbols.create("value"), args[0]));
+        mkBool(*state.allocAttr(v, state.symbols.create("success")), true);
    } catch (AssertionError & e) {
-        mkBool((*v.attrs)[state.symbols.create("value")].value, false);
-        mkBool((*v.attrs)[state.symbols.create("success")].value, false);
+        mkBool(*state.allocAttr(v, state.symbols.create("value")), false);
+        mkBool(*state.allocAttr(v, state.symbols.create("success")), false);
    }
+    v.attrs->sort();
 }


@@ -320,9 +321,9 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)
    if (attr == args[0]->attrs->end())
        throw EvalError("required attribute `name' missing");
    string drvName;
-    Pos & posDrvName(*attr->second.pos);
+    Pos & posDrvName(*attr->pos);
    try {        
-        drvName = state.forceStringNoCtx(attr->second.value);
+        drvName = state.forceStringNoCtx(*attr->value);
    } catch (Error & e) {
        e.addPrefix(format("while evaluating the derivation attribute `name' at %1%:\n") % posDrvName);
        throw;
@@ -337,7 +338,7 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)
    bool outputHashRecursive = false;

    foreach (Bindings::iterator, i, *args[0]->attrs) {
-        string key = i->first;
+        string key = i->name;
        startNest(nest, lvlVomit, format("processing attribute `%1%'") % key);

        try {
@@ -345,9 +346,9 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)
            /* The `args' attribute is special: it supplies the
               command-line arguments to the builder. */
            if (key == "args") {
-                state.forceList(i->second.value);
-                for (unsigned int n = 0; n < i->second.value.list.length; ++n) {
-                    string s = state.coerceToString(*i->second.value.list.elems[n], context, true);
+                state.forceList(*i->value);
+                for (unsigned int n = 0; n < i->value->list.length; ++n) {
+                    string s = state.coerceToString(*i->value->list.elems[n], context, true);
                    drv.args.push_back(s);
                }
            }
@@ -355,11 +356,11 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)
            /* All other attributes are passed to the builder through
               the environment. */
            else {
-                string s = state.coerceToString(i->second.value, context, true);
+                string s = state.coerceToString(*i->value, context, true);
                drv.env[key] = s;
                if (key == "builder") drv.builder = s;
-                else if (i->first == state.sSystem) drv.platform = s;
-                else if (i->first == state.sName) drvName = s;
+                else if (i->name == state.sSystem) drv.platform = s;
+                else if (i->name == state.sName) drvName = s;
                else if (key == "outputHash") outputHash = s;
                else if (key == "outputHashAlgo") outputHashAlgo = s;
                else if (key == "outputHashMode") {
@@ -371,7 +372,7 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)

        } catch (Error & e) {
            e.addPrefix(format("while evaluating the derivation attribute `%1%' at %2%:\n")
-                % key % *i->second.pos);
+                % key % *i->pos);
            e.addPrefix(format("while instantiating the derivation named `%1%' at %2%:\n")
                % drvName % posDrvName);
            throw;
@@ -483,9 +484,10 @@ static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)
    state.drvHashes[drvPath] = hashDerivationModulo(state, drv);

    /* !!! assumes a single output */
-    state.mkAttrs(v);
-    mkString((*v.attrs)[state.sOutPath].value, outPath, singleton<PathSet>(drvPath));
-    mkString((*v.attrs)[state.sDrvPath].value, drvPath, singleton<PathSet>("=" + drvPath));
+    state.mkAttrs(v, 2);
+    mkString(*state.allocAttr(v, state.sOutPath), outPath, singleton<PathSet>(drvPath));
+    mkString(*state.allocAttr(v, state.sDrvPath), drvPath, singleton<PathSet>("=" + drvPath));
+    v.attrs->sort();
 }


@@ -685,17 +687,14 @@ static void prim_attrNames(EvalState & state, Value * * args, Value & v)
    state.forceAttrs(*args[0]);

    state.mkList(v, args[0]->attrs->size());
-    Value * vs = state.allocValues(v.list.length);

    StringSet names;
    foreach (Bindings::iterator, i, *args[0]->attrs)
-        names.insert(i->first);
+        names.insert(i->name);

    unsigned int n = 0;
-    foreach (StringSet::iterator, i, names) {
-        v.list.elems[n] = &vs[n];
-        mkString(vs[n++], *i);
-    }
+    foreach (StringSet::iterator, i, names)
+        mkString(*(v.list.elems[n++] = state.allocValue()), *i);
 }


@@ -709,8 +708,8 @@ static void prim_getAttr(EvalState & state, Value * * args, Value & v)
    if (i == args[1]->attrs->end())
        throw EvalError(format("attribute `%1%' missing") % attr);
    // !!! add to stack trace?
-    state.forceValue(i->second.value);
-    v = i->second.value;
+    state.forceValue(*i->value);
+    v = *i->value;
 }


@@ -736,11 +735,20 @@ static void prim_removeAttrs(EvalState & state, Value * * args, Value & v)
    state.forceAttrs(*args[0]);
    state.forceList(*args[1]);

-    state.cloneAttrs(*args[0], v);
-
+    /* Get the attribute names to be removed. */
+    std::set<Symbol> names;
    for (unsigned int i = 0; i < args[1]->list.length; ++i) {
        state.forceStringNoCtx(*args[1]->list.elems[i]);
-        v.attrs->erase(state.symbols.create(args[1]->list.elems[i]->string.s));
+        names.insert(state.symbols.create(args[1]->list.elems[i]->string.s));
+    }
+
+    /* Copy all attributes not in that set.  Note that we don't need
+       to sort v.attrs because it's a subset of an already sorted
+       vector. */
+    state.mkAttrs(v, args[0]->attrs->size());
+    foreach (Bindings::iterator, i, *args[0]->attrs) {
+        if (names.find(i->name) == names.end())
+            v.attrs->push_back(*i);
    }
 }

@@ -753,7 +761,9 @@ static void prim_listToAttrs(EvalState & state, Value * * args, Value & v)
 {
    state.forceList(*args[0]);

-    state.mkAttrs(v);
+    state.mkAttrs(v, args[0]->list.length);
+
+    std::set<Symbol> seen;

    for (unsigned int i = 0; i < args[0]->list.length; ++i) {
        Value & v2(*args[0]->list.elems[i]);
@@ -762,16 +772,21 @@ static void prim_listToAttrs(EvalState & state, Value * * args, Value & v)
        Bindings::iterator j = v2.attrs->find(state.sName);
        if (j == v2.attrs->end())
            throw TypeError("`name' attribute missing in a call to `listToAttrs'");
-        string name = state.forceStringNoCtx(j->second.value);
+        string name = state.forceStringNoCtx(*j->value);
        
-        j = v2.attrs->find(state.symbols.create("value"));
-        if (j == v2.attrs->end())
+        Bindings::iterator j2 = v2.attrs->find(state.symbols.create("value"));
+        if (j2 == v2.attrs->end())
            throw TypeError("`value' attribute missing in a call to `listToAttrs'");

-        Attr & a = (*v.attrs)[state.symbols.create(name)];
-        mkCopy(a.value, j->second.value);
-        a.pos = j->second.pos;
+        Symbol sym = state.symbols.create(name);
+        if (seen.find(sym) == seen.end()) {
+            v.attrs->push_back(Attr(sym, j2->value, j2->pos));
+            seen.insert(sym);
+        }
+        /* !!! Throw an error if `name' already exists? */
    }
+
+    v.attrs->sort();
 }


@@ -783,15 +798,12 @@ static void prim_intersectAttrs(EvalState & state, Value * * args, Value & v)
    state.forceAttrs(*args[0]);
    state.forceAttrs(*args[1]);
        
-    state.mkAttrs(v);
-    
-    foreach (Bindings::iterator, i, *args[1]->attrs) {
-        Bindings::iterator j = args[0]->attrs->find(i->first);
-        if (j != args[0]->attrs->end()) {
-            Attr & a = (*v.attrs)[i->first];
-            mkCopy(a.value, i->second.value);
-            a.pos = i->second.pos;
-        }
+    state.mkAttrs(v, std::min(args[0]->attrs->size(), args[1]->attrs->size()));
+
+    foreach (Bindings::iterator, i, *args[0]->attrs) {
+        Bindings::iterator j = args[1]->attrs->find(i->name);
+        if (j != args[1]->attrs->end())
+            v.attrs->push_back(*j);
    }
 }

@@ -815,12 +827,16 @@ static void prim_functionArgs(EvalState & state, Value * * args, Value & v)
    if (args[0]->type != tLambda)
        throw TypeError("`functionArgs' requires a function");

-    state.mkAttrs(v);
-
-    if (!args[0]->lambda.fun->matchAttrs) return;
+    if (!args[0]->lambda.fun->matchAttrs) {
+        state.mkAttrs(v, 0);
+        return;
+    }

+    state.mkAttrs(v, args[0]->lambda.fun->formals->formals.size());
    foreach (Formals::Formals_::iterator, i, args[0]->lambda.fun->formals->formals)
-        mkBool((*v.attrs)[i->name].value, i->def);
+        // !!! should optimise booleans (allocate only once)
+        mkBool(*state.allocAttr(v, i->name), i->def);
+    v.attrs->sort();
 }


@@ -868,12 +884,10 @@ static void prim_map(EvalState & state, Value * * args, Value & v)
    state.forceList(*args[1]);

    state.mkList(v, args[1]->list.length);
-    Value * vs = state.allocValues(v.list.length);

-    for (unsigned int n = 0; n < v.list.length; ++n) {
-        v.list.elems[n] = &vs[n];
-        mkApp(vs[n], *args[0], *args[1]->list.elems[n]);
-    }
+    for (unsigned int n = 0; n < v.list.length; ++n)
+        mkApp(*(v.list.elems[n] = state.allocValue()), 
+            *args[0], *args[1]->list.elems[n]);
 }


@@ -1002,9 +1016,10 @@ static void prim_parseDrvName(EvalState & state, Value * * args, Value & v)
 {
    string name = state.forceStringNoCtx(*args[0]);
    DrvName parsed(name);
-    state.mkAttrs(v);
-    mkString((*v.attrs)[state.sName].value, parsed.name);
-    mkString((*v.attrs)[state.symbols.create("version")].value, parsed.version);
+    state.mkAttrs(v, 2);
+    mkString(*state.allocAttr(v, state.sName), parsed.name);
+    mkString(*state.allocAttr(v, state.symbols.create("version")), parsed.version);
+    v.attrs->sort();
 }


@@ -1029,7 +1044,7 @@ void EvalState::createBaseEnv()
    Value v;

    /* `builtins' must be first! */
-    mkAttrs(v);
+    mkAttrs(v, 128);
    addConstant("builtins", v);

    mkBool(v, true);
@@ -1068,7 +1083,7 @@ void EvalState::createBaseEnv()
    /* Add a wrapper around the derivation primop that computes the
       `drvPath' and `outPath' attributes lazily. */
    string s = "attrs: let res = derivationStrict attrs; in attrs // { drvPath = res.drvPath; outPath = res.outPath; type = \"derivation\"; }";
-    mkThunk(v, baseEnv, parseExprFromString(*this, s, "/"));
+    mkThunk_(v, parseExprFromString(*this, s, "/"));
    addConstant("derivation", v);

    // Paths
@@ -1117,7 +1132,11 @@ void EvalState::createBaseEnv()

    // Versions
    addPrimOp("__parseDrvName", 1, prim_parseDrvName);
-    addPrimOp("__compareVersions", 2, prim_compareVersions);    
+    addPrimOp("__compareVersions", 2, prim_compareVersions);
+
+    /* Now that we've added all primops, sort the `builtins' attribute
+       set, because attribute lookups expect it to be sorted. */
+    baseEnv.values[0]->attrs->sort();
 }


--- a/src/libexpr/symbol-table.hh
+++ b/src/libexpr/symbol-table.hh
@@ -1,8 +1,13 @@
 #ifndef __SYMBOL_TABLE_H
 #define __SYMBOL_TABLE_H

+#include "config.h"
+
 #include <map>
+
+#if HAVE_TR1_UNORDERED_SET
 #include <tr1/unordered_set>
+#endif

 #include "types.hh"

@@ -23,6 +28,8 @@ private:
    friend class SymbolTable;

 public:
+    Symbol() : s(0) { };
+    
    bool operator == (const Symbol & s2) const
    {
        return s == s2.s;
@@ -60,7 +67,11 @@ inline std::ostream & operator << (std::ostream & str, const Symbol & sym)
 class SymbolTable
 {
 private:
+#if HAVE_TR1_UNORDERED_SET 
    typedef std::tr1::unordered_set<string> Symbols;
+#else
+    typedef std::set<string> Symbols;
+#endif
    Symbols symbols;

 public:
--- a/src/libexpr/value-to-xml.cc
+++ b/src/libexpr/value-to-xml.cc
@@ -34,10 +34,10 @@ static void showAttrs(EvalState & state, bool strict, bool location,
    StringSet names;
    
    foreach (Bindings::iterator, i, attrs)
-        names.insert(i->first);
+        names.insert(i->name);
    
    foreach (StringSet::iterator, i, names) {
-        Attr & a(attrs[state.symbols.create(*i)]);
+        Attr & a(*attrs.find(state.symbols.create(*i)));
        
        XMLAttrs xmlAttrs;
        xmlAttrs["name"] = *i;
@@ -45,7 +45,7 @@ static void showAttrs(EvalState & state, bool strict, bool location,
        
        XMLOpenElement _(doc, "attr", xmlAttrs);
        printValueAsXML(state, strict, location,
-            a.value, doc, context, drvsSeen);
+            *a.value, doc, context, drvsSeen);
    }
 }

@@ -69,6 +69,7 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,

        case tString:
            /* !!! show the context? */
+            copyContext(v, context);
            doc.writeEmptyElement("string", singletonAttrs("value", v.string.s));
            break;

@@ -89,16 +90,16 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
                Path drvPath;
                a = v.attrs->find(state.sDrvPath);
                if (a != v.attrs->end()) {
-                    if (strict) state.forceValue(a->second.value);
-                    if (a->second.value.type == tString)
-                        xmlAttrs["drvPath"] = drvPath = a->second.value.string.s;
+                    if (strict) state.forceValue(*a->value);
+                    if (a->value->type == tString)
+                        xmlAttrs["drvPath"] = drvPath = a->value->string.s;
                }
        
                a = v.attrs->find(state.sOutPath);
                if (a != v.attrs->end()) {
-                    if (strict) state.forceValue(a->second.value);
-                    if (a->second.value.type == tString)
-                        xmlAttrs["outPath"] = a->second.value.string.s;
+                    if (strict) state.forceValue(*a->value);
+                    if (a->value->type == tString)
+                        xmlAttrs["outPath"] = a->value->string.s;
                }

                XMLOpenElement _(doc, "derivation", xmlAttrs);
--- a/src/libexpr/value-to-xml.hh
+++ b/src/libexpr/value-to-xml.hh
@@ -1,12 +1,12 @@
 #ifndef __VALUE_TO_XML_H
 #define __VALUE_TO_XML_H

-#include <string>
-#include <map>
-
 #include "nixexpr.hh"
 #include "eval.hh"

+#include <string>
+#include <map>
+
 namespace nix {

 void printValueAsXML(EvalState & state, bool strict, bool location,
--- a/src/libmain/Makefile.am
+++ b/src/libmain/Makefile.am
@@ -2,7 +2,7 @@ pkglib_LTLIBRARIES = libmain.la

 libmain_la_SOURCES = shared.cc

-libmain_la_LIBADD = ../libstore/libstore.la
+libmain_la_LIBADD = ../libstore/libstore.la @boehmgc_lib@

 pkginclude_HEADERS = shared.hh

--- a/src/libmain/shared.cc
+++ b/src/libmain/shared.cc
@@ -13,6 +13,10 @@
 #include <sys/stat.h>
 #include <unistd.h>

+#if HAVE_BOEHMGC
+#include <gc/gc.h>
+#endif
+

 namespace nix {

@@ -135,6 +139,7 @@ static void initAndRun(int argc, char * * argv)
    /* Get some settings from the configuration file. */
    thisSystem = querySetting("system", SYSTEM);
    maxBuildJobs = queryIntSetting("build-max-jobs", 1);
+    buildCores = queryIntSetting("build-cores", 1);
    maxSilentTime = queryIntSetting("build-max-silent-time", 0);

    /* Catch SIGINT. */
@@ -226,6 +231,8 @@ static void initAndRun(int argc, char * * argv)
            tryFallback = true;
        else if (arg == "--max-jobs" || arg == "-j")
            maxBuildJobs = getIntArg<unsigned int>(arg, i, args.end());
+        else if (arg == "--cores")
+            buildCores = getIntArg<unsigned int>(arg, i, args.end());
        else if (arg == "--readonly-mode")
            readOnlyMode = true;
        else if (arg == "--max-silent-time")
@@ -311,6 +318,14 @@ static void setuidInit()
 }


+/* Called when the Boehm GC runs out of memory. */
+static void * oomHandler(size_t requested)
+{
+    /* Convert this to a proper C++ exception. */
+    throw std::bad_alloc();
+}
+
+
 }


@@ -332,6 +347,26 @@ int main(int argc, char * * argv)

    std::ios::sync_with_stdio(false);

+#if HAVE_BOEHMGC
+    /* Initialise the Boehm garbage collector.  This isn't necessary
+       on most platforms, but for portability we do it anyway. */
+    GC_INIT();
+
+    GC_oom_fn = oomHandler;
+
+    /* Set the initial heap size to something fairly big (384 MiB) so
+       that in most cases we don't need to garbage collect at all.
+       (Collection has a fairly significant overhead, some.)  The heap
+       size can be overriden through libgc's GC_INITIAL_HEAP_SIZE
+       environment variable.  We should probably also provide a
+       nix.conf setting for this.  Note that GC_expand_hp() causes a
+       lot of virtual, but not physical (resident) memory to be
+       allocated.  This might be a problem on systems that don't
+       overcommit. */
+    if (!getenv("GC_INITIAL_HEAP_SIZE"))
+        GC_expand_hp(384 * 1024 * 1024);
+#endif
+
    try {
        try {
            initAndRun(argc, argv);
--- a/src/libstore/build.cc
+++ b/src/libstore/build.cc
@@ -25,6 +25,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
+#include <cstring>

 #include <pwd.h>
 #include <grp.h>
@@ -267,7 +268,7 @@ public:


 MakeError(SubstError, Error)
-MakeError(BuildError, Error) /* denoted a permanent build failure */
+MakeError(BuildError, Error) /* denotes a permanent build failure */


 //////////////////////////////////////////////////////////////////////
@@ -1411,6 +1412,9 @@ void DerivationGoal::startBuilder()
       in the store or in the build directory). */
    env["NIX_STORE"] = nixStore;

+    /* The maximum number of cores to utilize for parallel building. */
+    env["NIX_BUILD_CORES"] = (format("%d") % buildCores).str();
+
    /* Add all bindings specified in the derivation. */
    foreach (StringPairs::iterator, i, drv.env)
        env[i->first] = i->second;
@@ -2635,6 +2639,7 @@ void Worker::waitForInput()
        timeout.tv_sec = std::max((time_t) 0, lastWokenUp + wakeUpInterval - before);
    } else lastWokenUp = 0;

+    using namespace std;
    /* Use select() to wait for the input side of any logger pipe to
       become `available'.  Note that `available' (i.e., non-blocking)
       includes EOF. */
--- a/src/libstore/globals.cc
+++ b/src/libstore/globals.cc
@@ -22,6 +22,7 @@ bool keepGoing = false;
 bool tryFallback = false;
 Verbosity buildVerbosity = lvlInfo;
 unsigned int maxBuildJobs = 1;
+unsigned int buildCores = 1;
 bool readOnlyMode = false;
 string thisSystem = "unset";
 time_t maxSilentTime = 0;
--- a/src/libstore/globals.hh
+++ b/src/libstore/globals.hh
@@ -55,6 +55,11 @@ extern Verbosity buildVerbosity;
 /* Maximum number of parallel build jobs.  0 means unlimited. */
 extern unsigned int maxBuildJobs;

+/* Number of CPU cores to utilize in parallel within a build, i.e. by passing
+   this number to Make via '-j'. 0 means that the number of actual CPU cores on
+   the local host ought to be auto-detected. */
+extern unsigned int buildCores;
+
 /* Read-only mode.  Don't copy stuff to the store, don't change the
   database. */
 extern bool readOnlyMode;
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -873,6 +873,8 @@ void LocalStore::exportPath(const Path & path, bool sign,
        writeInt(1, hashAndWriteSink);
        
        Path tmpDir = createTempDir();
+        PathLocks tmpDirLock(singleton<PathSet, Path>(tmpDir));
+        tmpDirLock.setDeletion(true);
        AutoDelete delTmp(tmpDir);
        Path hashFile = tmpDir + "/hash";
        writeFile(hashFile, printHash(hash));
@@ -922,6 +924,8 @@ Path LocalStore::importPath(bool requireSignature, Source & source)
       store path follows the archive data proper), and besides, we
       don't know yet whether the signature is valid. */
    Path tmpDir = createTempDir(nixStore);
+    PathLocks tmpDirLock(singleton<PathSet, Path>(tmpDir));
+    tmpDirLock.setDeletion(true);
    AutoDelete delTmp(tmpDir); /* !!! could be GC'ed! */
    Path unpacked = tmpDir + "/unpacked";

--- a/src/libstore/optimise-store.cc
+++ b/src/libstore/optimise-store.cc
@@ -119,9 +119,23 @@ static void hashAndLink(bool dryRun, HashToPath & hashToPath,
            }

            /* Atomically replace the old file with the new hard link. */
-            if (rename(tempLink.c_str(), path.c_str()) == -1)
+            if (rename(tempLink.c_str(), path.c_str()) == -1) {
+                if (errno == EMLINK) {
+                    /* Some filesystems generate too many links on the
+                       rename, rather than on the original link.
+                       (Probably it temporarily increases the st_nlink
+                       field before decreasing it again.) */
+                    printMsg(lvlInfo, format("`%1%' has maximum number of links") % prevPath.first);
+                    hashToPath[hash] = std::pair<Path, ino_t>(path, st.st_ino);
+
+                    /* Unlink the temp link. */
+                    if (unlink(tempLink.c_str()) == -1)
+                        printMsg(lvlError, format("unable to unlink `%1%'") % tempLink);
+                    return;
+                }
                throw SysError(format("cannot rename `%1%' to `%2%'")
                    % tempLink % path);
+            }
        } else
            printMsg(lvlTalkative, format("would link `%1%' to `%2%'") % path % prevPath.first);
        
--- a/src/libstore/remote-store.cc
+++ b/src/libstore/remote-store.cc
@@ -13,6 +13,7 @@

 #include <iostream>
 #include <unistd.h>
+#include <cstring>


 namespace nix {
@@ -158,6 +159,7 @@ void RemoteStore::connectToDaemon()
    addr.sun_family = AF_UNIX;
    if (socketPathRel.size() >= sizeof(addr.sun_path))
        throw Error(format("socket path `%1%' is too long") % socketPathRel);
+    using namespace std;
    strcpy(addr.sun_path, socketPathRel.c_str());
    
    if (connect(fdSocket, (struct sockaddr *) &addr, sizeof(addr)) == -1)
@@ -196,6 +198,9 @@ void RemoteStore::setOptions()
        writeInt(logType, to);
        writeInt(printBuildTrace, to);
    }
+    if (GET_PROTOCOL_MINOR(daemonVersion) >= 6) {
+        writeInt(buildCores, to);
+    }
    processStderr();
 }

--- a/src/libstore/store-api.hh
+++ b/src/libstore/store-api.hh
@@ -1,14 +1,14 @@
 #ifndef __STOREAPI_H
 #define __STOREAPI_H

+#include "hash.hh"
+#include "serialise.hh"
+
 #include <string>
 #include <map>

 #include <boost/shared_ptr.hpp>

-#include "hash.hh"
-#include "serialise.hh"
-

 namespace nix {

@@ -16,8 +16,6 @@ namespace nix {
 typedef std::map<Path, Path> Roots;


-
-
 struct GCOptions
 {
    /* Garbage collector operation:
--- a/src/libstore/worker-protocol.hh
+++ b/src/libstore/worker-protocol.hh
@@ -8,7 +8,7 @@ namespace nix {
 #define WORKER_MAGIC_1 0x6e697863
 #define WORKER_MAGIC_2 0x6478696f

-#define PROTOCOL_VERSION 0x105
+#define PROTOCOL_VERSION 0x106
 #define GET_PROTOCOL_MAJOR(x) ((x) & 0xff00)
 #define GET_PROTOCOL_MINOR(x) ((x) & 0x00ff)

--- a/src/libutil/types.hh
+++ b/src/libutil/types.hh
@@ -1,6 +1,8 @@
 #ifndef __TYPES_H
 #define __TYPES_H

+#include "config.h"
+
 #include <string>
 #include <list>
 #include <set>
--- a/src/libutil/util.cc
+++ b/src/libutil/util.cc
@@ -12,6 +12,7 @@
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <limits.h>

 #include "util.hh"

@@ -481,7 +482,16 @@ void printMsg_(Verbosity level, const format & f)
    else if (logType == ltEscapes && level != lvlInfo)
        prefix = "\033[" + escVerbosity(level) + "s";
    string s = (format("%1%%2%\n") % prefix % f.str()).str();
-    writeToStderr((const unsigned char *) s.c_str(), s.size());
+    try {
+        writeToStderr((const unsigned char *) s.c_str(), s.size());
+    } catch (SysError & e) {
+        /* Ignore failing writes to stderr if we're in an exception
+           handler, otherwise throw an exception.  We need to ignore
+           write errors in exception handlers to ensure that cleanup
+           code runs to completion if the other side of stderr has
+           been closed unexpectedly. */
+        if (!std::uncaught_exception()) throw;
+    }
 }


--- a/src/nix-env/nix-env.cc
+++ b/src/nix-env/nix-env.cc
@@ -132,7 +132,7 @@ static void getAllExprs(EvalState & state,
            if (hasSuffix(attrName, ".nix"))
                attrName = string(attrName, 0, attrName.size() - 4);
            attrs.attrs[state.symbols.create(attrName)] =
-                ExprAttrs::Attr(parseExprFromFile(state, absPath(path2)), noPos);
+                ExprAttrs::AttrDef(parseExprFromFile(state, absPath(path2)), noPos);
        }
        else
            /* `path2' is a directory (with no default.nix in it);
@@ -154,14 +154,14 @@ static Expr * loadSourceExpr(EvalState & state, const Path & path)
       some system-wide directory). */
    ExprAttrs * attrs = new ExprAttrs;
    attrs->attrs[state.symbols.create("_combineChannels")] =
-        ExprAttrs::Attr(new ExprList(), noPos);
+        ExprAttrs::AttrDef(new ExprList(), noPos);
    getAllExprs(state, path, *attrs);
    return attrs;
 }


 static void loadDerivations(EvalState & state, Path nixExprPath,
-    string systemFilter, const Bindings & autoArgs,
+    string systemFilter, Bindings & autoArgs,
    const string & pathPrefix, DrvInfos & elems)
 {
    Value v;
@@ -247,11 +247,12 @@ static DrvInfos filterBySelector(EvalState & state, const DrvInfos & allElems,
        }

        /* If `newestOnly', if a selector matches multiple derivations
-           with the same name, pick the one with the highest priority.
-           If there are multiple derivations with the same priority,
-           pick the one with the highest version.  If there are
-           multiple derivations with the same priority and name and
-           version, then pick the first one. */
+           with the same name, pick the one matching the current
+           system.  If there are still multiple derivations, pick the
+           one with the highest priority.  If there are still multiple
+           derivations, pick the one with the highest version.
+           Finally, if there are still multiple derivations,
+           arbitrarily pick the first one. */
        if (newestOnly) {

            /* Map from package names to derivations. */
@@ -266,7 +267,11 @@ static DrvInfos filterBySelector(EvalState & state, const DrvInfos & allElems,
                Newest::iterator k = newest.find(drvName.name);
                
                if (k != newest.end()) {
-                    d = comparePriorities(state, j->first, k->second.first);
+                    d = j->first.system == k->second.first.system ? 0 :
+                        j->first.system == thisSystem ? 1 :
+                        k->second.first.system == thisSystem ? -1 : 0;
+                    if (d == 0)
+                        d = comparePriorities(state, j->first, k->second.first);
                    if (d == 0)
                        d = compareVersions(drvName.version, DrvName(k->second.first.name).version);
                }
@@ -316,7 +321,7 @@ static bool isPath(const string & s)


 static void queryInstSources(EvalState & state,
-    const InstallSourceInfo & instSource, const Strings & args,
+    InstallSourceInfo & instSource, const Strings & args,
    DrvInfos & elems, bool newestOnly)
 {
    InstallSourceType type = instSource.type;
@@ -1230,7 +1235,7 @@ void run(Strings args)
    
    globals.instSource.type = srcUnknown;
    globals.instSource.nixExprPath = getDefNixExprPath();
-    globals.instSource.systemFilter = thisSystem;
+    globals.instSource.systemFilter = "*";
    
    globals.dryRun = false;
    globals.preserveInstalled = false;
--- a/src/nix-env/user-env.cc
+++ b/src/nix-env/user-env.cc
@@ -25,7 +25,8 @@ DrvInfos queryInstalled(EvalState & state, const Path & userEnv)
    if (pathExists(manifestFile)) {
        Value v;
        state.eval(parseExprFromFile(state, manifestFile), v);
-        getDerivations(state, v, "", Bindings(), elems);
+        Bindings bindings;
+        getDerivations(state, v, "", bindings, elems);
    } else if (pathExists(oldManifestFile))
        readLegacyManifest(oldManifestFile, elems);

@@ -58,23 +59,24 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
           the meta attributes. */
        Path drvPath = keepDerivations ? i->queryDrvPath(state) : "";

-        Value & v(*state.allocValues(1));
+        Value & v(*state.allocValue());
        manifest.list.elems[n++] = &v;
-        state.mkAttrs(v);
+        state.mkAttrs(v, 8);

-        mkString((*v.attrs)[state.sType].value, "derivation");
-        mkString((*v.attrs)[state.sName].value, i->name);
-        mkString((*v.attrs)[state.sSystem].value, i->system);
-        mkString((*v.attrs)[state.sOutPath].value, i->queryOutPath(state));
+        mkString(*state.allocAttr(v, state.sType), "derivation");
+        mkString(*state.allocAttr(v, state.sName), i->name);
+        mkString(*state.allocAttr(v, state.sSystem), i->system);
+        mkString(*state.allocAttr(v, state.sOutPath), i->queryOutPath(state));
        if (drvPath != "")
-            mkString((*v.attrs)[state.sDrvPath].value, i->queryDrvPath(state));
-        
-        state.mkAttrs((*v.attrs)[state.sMeta].value);
-        
+            mkString(*state.allocAttr(v, state.sDrvPath), i->queryDrvPath(state));
+
+        Value & vMeta = *state.allocAttr(v, state.sMeta);
+        state.mkAttrs(vMeta, 16);
+
        MetaInfo meta = i->queryMetaInfo(state);

        foreach (MetaInfo::const_iterator, j, meta) {
-            Value & v2((*(*v.attrs)[state.sMeta].value.attrs)[state.symbols.create(j->first)].value);
+            Value & v2(*state.allocAttr(vMeta, state.symbols.create(j->first)));
            switch (j->second.type) {
                case MetaValue::tpInt: mkInt(v2, j->second.intValue); break;
                case MetaValue::tpString: mkString(v2, j->second.stringValue); break;
@@ -82,7 +84,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
                    state.mkList(v2, j->second.stringValues.size());
                    unsigned int m = 0;
                    foreach (Strings::const_iterator, k, j->second.stringValues) {
-                        v2.list.elems[m] = state.allocValues(1);
+                        v2.list.elems[m] = state.allocValue();
                        mkString(*v2.list.elems[m++], *k);
                    }
                    break;
@@ -91,6 +93,9 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
            }
        }
    
+        vMeta.attrs->sort();
+        v.attrs->sort();
+        
        /* This is only necessary when installing store paths, e.g.,
           `nix-env -i /nix/store/abcd...-foo'. */
        store->addTempRoot(i->queryOutPath(state));
@@ -106,8 +111,6 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
    Path manifestFile = store->addTextToStore("env-manifest.nix",
        (format("%1%") % manifest).str(), references);

-    printMsg(lvlError, manifestFile);
-
    /* Get the environment builder expression. */
    Value envBuilder;
    state.eval(parseExprFromFile(state, nixDataDir + "/nix/corepkgs/buildenv"), envBuilder);
@@ -115,11 +118,12 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
    /* Construct a Nix expression that calls the user environment
       builder with the manifest as argument. */
    Value args, topLevel;
-    state.mkAttrs(args);
-    mkString((*args.attrs)[state.sSystem].value, thisSystem);
-    mkString((*args.attrs)[state.symbols.create("manifest")].value,
+    state.mkAttrs(args, 3);
+    mkString(*state.allocAttr(args, state.sSystem), thisSystem);
+    mkString(*state.allocAttr(args, state.symbols.create("manifest")),
        manifestFile, singleton<PathSet>(manifestFile));
-    (*args.attrs)[state.symbols.create("derivations")].value = manifest;
+    args.attrs->push_back(Attr(state.symbols.create("derivations"), &manifest));
+    args.attrs->sort();
    mkApp(topLevel, envBuilder, args);
        
    /* Evaluate it. */
--- a/src/nix-hash/nix-hash.cc
+++ b/src/nix-hash/nix-hash.cc
@@ -1,9 +1,9 @@
-#include <iostream>
-
 #include "hash.hh"
 #include "shared.hh"
 #include "help.txt.hh"

+#include <iostream>
+

 using namespace nix;

--- a/src/nix-instantiate/nix-instantiate.cc
+++ b/src/nix-instantiate/nix-instantiate.cc
@@ -1,6 +1,3 @@
-#include <map>
-#include <iostream>
-
 #include "globals.hh"
 #include "shared.hh"
 #include "eval.hh"
@@ -13,6 +10,9 @@
 #include "common-opts.hh"
 #include "help.txt.hh"

+#include <map>
+#include <iostream>
+

 using namespace nix;

@@ -38,7 +38,7 @@ static bool indirectRoot = false;


 void processExpr(EvalState & state, const Strings & attrPaths,
-    bool parseOnly, bool strict, const Bindings & autoArgs,
+    bool parseOnly, bool strict, Bindings & autoArgs,
    bool evalOnly, bool xmlOutput, bool location, Expr * e)
 {
    if (parseOnly)
--- a/src/nix-store/Makefile.am
+++ b/src/nix-store/Makefile.am
@@ -1,6 +1,9 @@
 bin_PROGRAMS = nix-store

-nix_store_SOURCES = nix-store.cc dotgraph.cc dotgraph.hh help.txt
+nix_store_SOURCES =				\
+  nix-store.cc dotgraph.cc dotgraph.hh help.txt	\
+  xmlgraph.cc xmlgraph.hh
+
 nix_store_LDADD = ../libmain/libmain.la ../libstore/libstore.la ../libutil/libutil.la \
 ../boost/format/libformat.la @ADDITIONAL_NETWORK_LIBS@

--- a/src/nix-store/dotgraph.cc
+++ b/src/nix-store/dotgraph.cc
@@ -52,13 +52,13 @@ static string symbolicName(const string & path)
 }


+#if 0
 string pathLabel(const Path & nePath, const string & elemPath)
 {
    return (string) nePath + "-" + elemPath;
 }


-#if 0
 void printClosure(const Path & nePath, const StoreExpr & fs)
 {
    PathSet workList(fs.closure.roots);
--- a/src/nix-store/help.txt
+++ b/src/nix-store/help.txt
@@ -39,6 +39,7 @@ Query flags:
  --referrers-closure: print all paths (in)directly refering to the path
  --tree: print a tree showing the dependency graph of the path
  --graph: print a dot graph rooted at given path
+  --xml: emit an XML representation of the graph rooted at the given path
  --hash: print the SHA-256 hash of the contents of the path
  --roots: print the garbage collector roots that point to the path

--- a/src/nix-store/nix-store.cc
+++ b/src/nix-store/nix-store.cc
@@ -1,15 +1,16 @@
-#include <iostream>
-#include <algorithm>
-
 #include "globals.hh"
 #include "misc.hh"
 #include "archive.hh"
 #include "shared.hh"
 #include "dotgraph.hh"
+#include "xmlgraph.hh"
 #include "local-store.hh"
 #include "util.hh"
 #include "help.txt.hh"

+#include <iostream>
+#include <algorithm>
+

 using namespace nix;
 using std::cin;
@@ -226,7 +227,7 @@ static void opQuery(Strings opFlags, Strings opArgs)
 {
    enum { qOutputs, qRequisites, qReferences, qReferrers
         , qReferrersClosure, qDeriver, qBinding, qHash
-         , qTree, qGraph, qResolve, qRoots } query = qOutputs;
+         , qTree, qGraph, qXml, qResolve, qRoots } query = qOutputs;
    bool useOutput = false;
    bool includeOutputs = false;
    bool forceRealise = false;
@@ -249,6 +250,7 @@ static void opQuery(Strings opFlags, Strings opArgs)
        else if (*i == "--hash") query = qHash;
        else if (*i == "--tree") query = qTree;
        else if (*i == "--graph") query = qGraph;
+        else if (*i == "--xml") query = qXml;
        else if (*i == "--resolve") query = qResolve;
        else if (*i == "--roots") query = qRoots;
        else if (*i == "--use-output" || *i == "-u") useOutput = true;
@@ -327,7 +329,15 @@ static void opQuery(Strings opFlags, Strings opArgs)
            PathSet roots;
            foreach (Strings::iterator, i, opArgs)
                roots.insert(maybeUseOutput(followLinksToStorePath(*i), useOutput, forceRealise));
-	    printDotGraph(roots);
+            printDotGraph(roots);
+            break;
+        }
+
+        case qXml: {
+            PathSet roots;
+            foreach (Strings::iterator, i, opArgs)
+                roots.insert(maybeUseOutput(followLinksToStorePath(*i), useOutput, forceRealise));
+            printXmlGraph(roots);
            break;
        }

--- a/src/nix-store/xmlgraph.cc
+++ b/src/nix-store/xmlgraph.cc
@@ -0,0 +1,71 @@
+#include "xmlgraph.hh"
+#include "util.hh"
+#include "store-api.hh"
+
+#include <iostream>
+
+
+using std::cout;
+
+namespace nix {
+
+
+static inline const string & xmlQuote(const string & s)
+{
+    // Luckily, store paths shouldn't contain any character that needs to be
+    // quoted.
+    return s;
+}
+
+
+static string makeEdge(const string & src, const string & dst)
+{
+    format f = format("  <edge src=\"%1%\" dst=\"%2%\"/>\n")
+      % xmlQuote(src) % xmlQuote(dst);
+    return f.str();
+}
+
+
+static string makeNode(const string & id)
+{
+    format f = format("  <node name=\"%1%\"/>\n") % xmlQuote(id);
+    return f.str();
+}
+
+
+void printXmlGraph(const PathSet & roots)
+{
+    PathSet workList(roots);
+    PathSet doneSet;
+
+    cout << "<?xml version='1.0' encoding='utf-8'?>\n"
+	 << "<nix>\n";
+
+    while (!workList.empty()) {
+	Path path = *(workList.begin());
+	workList.erase(path);
+
+	if (doneSet.find(path) != doneSet.end()) continue;
+	doneSet.insert(path);
+
+	cout << makeNode(path);
+
+	PathSet references;
+	store->queryReferences(path, references);
+
+	for (PathSet::iterator i = references.begin();
+	     i != references.end(); ++i)
+	{
+	    if (*i != path) {
+		workList.insert(*i);
+		cout << makeEdge(*i, path);
+	    }
+	}
+
+    }
+
+    cout << "</nix>\n";
+}
+
+
+}
--- a/src/nix-store/xmlgraph.hh
+++ b/src/nix-store/xmlgraph.hh
@@ -0,0 +1,12 @@
+#ifndef __XMLGRAPH_H
+#define __XMLGRAPH_H
+
+#include "types.hh"
+
+namespace nix {
+
+void printXmlGraph(const PathSet & roots);
+
+}
+
+#endif /* !__XMLGRAPH_H */
--- a/src/nix-worker/nix-worker.cc
+++ b/src/nix-worker/nix-worker.cc
@@ -7,6 +7,7 @@
 #include "globals.hh"

 #include <iostream>
+#include <cstring>
 #include <unistd.h>
 #include <signal.h>
 #include <sys/types.h>
@@ -111,6 +112,7 @@ static bool isFarSideClosed(int socket)
   time and wouldn't have to worry about races. */
 static void sigPollHandler(int sigNo)
 {
+    using namespace std;
    try {
        /* Check that the far side actually closed.  We're still
           getting spurious signals every once in a while.  I.e.,
@@ -498,6 +500,9 @@ static void performOp(unsigned int clientVersion,
            logType = (LogType) readInt(from);
            printBuildTrace = readInt(from) != 0;
        }
+        if (GET_PROTOCOL_MINOR(clientVersion) >= 6) {
+            buildCores = readInt(from);
+        }
        startWork();
        stopWork();
        break;
--- a/substitute.mk
+++ b/substitute.mk
@@ -25,6 +25,6 @@
 	 -e "s^@xmlflags\@^$(xmlflags)^g" \
 	 -e "s^@xsltproc\@^$(xsltproc)^g" \
 	 -e "s^@version\@^$(VERSION)^g" \
-	 -e "s^@testPath\@^$(coreutils):$$(dirname $$(type -P expr))^g" \
+	 -e "s^@testPath\@^$(coreutils):$$(dirname $$(type -p expr))^g" \
 	 < $< > $@ || rm $@
 	if test -x $<; then chmod +x $@; fi
--- a/tests/build-hook.hook.sh
+++ b/tests/build-hook.hook.sh
@@ -6,11 +6,11 @@ drv=$4

 echo "HOOK for $drv" >&2

-outPath=$(sed 's/Derive(\[("out",\"\([^\"]*\)\".*/\1/' $drv)
+outPath=`sed 's/Derive(\[("out",\"\([^\"]*\)\".*/\1/' $drv`

 echo "output path is $outPath" >&2

-if $(echo $outPath | grep -q input-1); then
+if `echo $outPath | grep -q input-1`; then
    echo "# accept" >&2
    read x
    echo "got $x"
--- a/tests/lang/eval-okay-listtoattrs.exp
+++ b/tests/lang/eval-okay-listtoattrs.exp
@@ -1 +1 @@
-"AA"
+"AAbar"
--- a/tests/lang/eval-okay-listtoattrs.nix
+++ b/tests/lang/eval-okay-listtoattrs.nix
@@ -7,4 +7,5 @@ let
  a = builtins.listToAttrs list;
  b = builtins.listToAttrs ( list ++ list );
  r = builtins.listToAttrs [ (asi "result" [ a b ]) ( asi "throw" (throw "this should not be thrown")) ];
-in concat (map (x: x.a) r.result)
+  x = builtins.listToAttrs [ (asi "foo" "bar") (asi "foo" "bla") ];
+in concat (map (x: x.a) r.result) + x.foo
--- a/tests/lang/eval-okay-overrides.exp
+++ b/tests/lang/eval-okay-overrides.exp
@@ -0,0 +1 @@
+2
--- a/tests/lang/eval-okay-overrides.nix
+++ b/tests/lang/eval-okay-overrides.nix
@@ -0,0 +1,9 @@
+let
+
+  overrides = { a = 2; };
+
+in (rec {
+  __overrides = overrides;
+  x = a;
+  a = 1;
+}).x
--- a/tests/referrers.sh
+++ b/tests/referrers.sh
@@ -3,7 +3,7 @@ source common.sh
 # This takes way to long on Cygwin (because process creation is so slow...).
 if test "$system" = i686-cygwin; then exit 0; fi

-max=2500
+max=1000

 reference=$NIX_STORE_DIR/abcdef
 touch $reference
--- a/2
+++ b/2
@@ -1 +1 @@
-0.16
+1.0
Author	SHA1	Message	Date
Eelco Dolstra	26def5392f	* Document Boehm GC support.	2010-10-29 14:44:02 +00:00
Eelco Dolstra	3d71c8013e	* Use pkgconfig to locate the Boehm GC (as suggested by Ludo), if --enable-gc is given.	2010-10-29 14:00:47 +00:00
Eelco Dolstra	14fbf85380	* Set libgc's initial heap size to 384 MiB to prevent garbage collection in most cases (and therefore its performance overhead).	2010-10-29 13:11:50 +00:00
Eelco Dolstra	0c4828ea05	* new(UseGC) is inexplicably slower than GC_MALLOC, so prefer the latter.	2010-10-28 12:50:01 +00:00
Eelco Dolstra	e11e6fb1c6	* Handle out of memory condition.	2010-10-28 12:29:40 +00:00
Eelco Dolstra	8a788e38ac	* Install config.h.	2010-10-26 10:47:02 +00:00
Eelco Dolstra	11ccd44e95	* We need Bison 2.4 now.	2010-10-24 21:48:59 +00:00
Eelco Dolstra	43535499f3	* When allocating an attribute set, reserve enough space for all elements. This prevents the vector from having to resize itself.	2010-10-24 20:09:37 +00:00
Eelco Dolstra	e0b7fb8f27	* Keep attribute sets in sorted order to speed up attribute lookups. * Simplify the representation of attributes in the AST. * Change the behaviour of listToAttrs() in case of duplicate names.	2010-10-24 19:52:33 +00:00
Eelco Dolstra	2dc6d50941	* Don't create thunks for variable lookups (if possible). This significantly reduces the number of values allocated (e.g. from 8.7m to 4.9m for the Bittorrent test).	2010-10-24 14:20:02 +00:00
Eelco Dolstra	0b305c534f	* Store attribute sets as a vector instead of a map (i.e. a red-black tree). This saves a lot of memory. The vector should be sorted so that names can be looked up using binary search, but this is not the case yet. (Surprisingly, looking up attributes using linear search doesn't have a big impact on performance.) Memory consumption for $ nix-instantiate /etc/nixos/nixos/tests -A bittorrent.test --readonly-mode on x86_64-linux with GC enabled is now 185 MiB (compared to 946 MiB on the trunk).	2010-10-24 00:41:29 +00:00
Eelco Dolstra	a247d20604	* Fix compiling without Boehm. * Fix the stats.	2010-10-23 22:58:24 +00:00
Eelco Dolstra	02934b1200	* Regression test for listToAttr's behaviour if an attribute name occurs multiple times.	2010-10-23 22:55:30 +00:00
Eelco Dolstra	b2ba62170c	* Optimise string constants by putting them in the symbol table.	2010-10-23 21:11:59 +00:00
Eelco Dolstra	8ac06726b9	* Make Value smaller by not storing redundant PrimOp info. * Clear pointers in Values after overwriting them to make sure that no objects are kept alive unnecessarily.	2010-10-23 20:07:47 +00:00
Eelco Dolstra	3f66cfb96b	* Remove allocValues().	2010-10-23 18:18:07 +00:00
Eelco Dolstra	4dee289550	* In environments, store pointers to values rather than values. This improves GC effectiveness a bit more (because a live value doesn't keep other values in the environment plus the parent environments alive), and removes the need for copy nodes.	2010-10-22 15:51:52 +00:00
Eelco Dolstra	cf7e645a48	* Regression test for __overrides.	2010-10-22 15:15:12 +00:00
Eelco Dolstra	41c45a9b31	* Store Value nodes outside of attribute sets. I.e., Attr now stores a pointer to a Value, rather than the Value directly. This improves the effectiveness of garbage collection a lot: if the Value is stored inside the set directly, then any live pointer to the Value causes all other attributes in the set to be live as well.	2010-10-22 14:47:42 +00:00
Eelco Dolstra	64c3325b0b	* Make building against the Boehm GC a configure option.	2010-10-22 13:39:15 +00:00
Eelco Dolstra	76feaf016a	* Keep some more stats.	2010-10-20 15:48:00 +00:00
Eelco Dolstra	e879a0371b	* Use the Boehm garbage collector to reclaim unused memory in the Nix expression evaluator.	2010-10-20 11:38:30 +00:00
Eelco Dolstra	b0c11cda7e	* Evaluator garbage collection branch.	2010-10-20 09:08:39 +00:00
Rob Vermaas	8dadcede65	nix manual: fix 'install' -> 'uninstall' in garbage collection section of introduction	2010-10-06 19:04:04 +00:00
Eelco Dolstra	7119d38287	* In the referrers test, lower the nesting depth from 2500 to 1000 to prevent hitting a stack overflow bug in the garbage collector.	2010-10-04 22:26:38 +00:00
Eelco Dolstra	705868a8a9	* Make sure that config.h is included before the system headers, because it defines _FILE_OFFSET_BITS. Without this, on OpenSolaris the system headers define it to be 32, and then the 32-bit stat() ends up being called with a 64-bit "struct stat", or vice versa. This also ensures that we get 64-bit file sizes everywhere. * Remove the redundant call to stat() in parseExprFromFile(). The file cannot be a symlink because that's the exit condition of the loop before.	2010-10-04 17:55:38 +00:00
Eelco Dolstra	95f4f2cf61	* If std::tr1::unordered_set is unavailable, use std::set.	2010-10-04 16:16:19 +00:00
Eelco Dolstra	36a23e86b6	* "type -P" isn't portable.	2010-10-04 15:50:08 +00:00
Eelco Dolstra	450837bcc8	* In printMsg(), ignore failing writes to stderr if we're in an exception handler, otherwise throw an exception. We need to ignore write errors in exception handlers to ensure that cleanup code runs to completion if the other side of stderr has been closed unexpectedly.	2010-10-04 11:23:07 +00:00
Eelco Dolstra	4aa9245083	* Hack needed for GCC 4.3.2 on OpenSolaris.	2010-10-04 10:51:16 +00:00
Eelco Dolstra	923736df38	* Doh. Remove debug message.	2010-09-14 12:47:19 +00:00
Eelco Dolstra	df50916e46	* Oops - "null" was displayed as "true".	2010-08-27 12:10:56 +00:00
Eelco Dolstra	c67eccc26d	* nix-build: pass --cores.	2010-08-24 09:21:59 +00:00
Eelco Dolstra	2c8e070e5d	* Bump the version number.	2010-08-17 15:39:35 +00:00
Eelco Dolstra	ed133e6e64	* rpmBuild already includes the disk image in the output name.	2010-08-17 14:08:44 +00:00
Eelco Dolstra	2de17f4edc	* Update date.	2010-08-17 10:06:26 +00:00
Eelco Dolstra	86f65edf4e	* Document --cores in the manual.	2010-08-17 07:22:05 +00:00
Eelco Dolstra	b75e1043a3	* Typo.	2010-08-16 13:23:45 +00:00
Eelco Dolstra	8ec6594d6d	* Remove the "tarball" jobset argument.	2010-08-16 13:01:31 +00:00
Eelco Dolstra	12721a3a9a	* Nix 0.16 release notes.	2010-08-16 12:38:32 +00:00
Eelco Dolstra	5fb824e896	* Urgh, this was supposed to go in the trunk...	2010-08-12 13:36:56 +00:00
Eelco Dolstra	6846ed8b44	* Make --cores work when building through the Nix daemon.	2010-08-12 09:21:50 +00:00
Eelco Dolstra	750be19ae8	* Remove "auto" and "guess" as synonyms for 0 in the handling of build-cores and --cores. They're superfluous and just complicate the parsing.	2010-08-04 12:23:59 +00:00
Eelco Dolstra	315d8fbd75	* Set the default system filter to "*". This ensures that (for instance) "nix-env -i wine" works on x86_64-linux, even though Wine is built on i686-linux. In the event that there are multiple matching derivations, prefer those built for the current system.	2010-08-04 09:32:42 +00:00
Eelco Dolstra	6d6200f37a	* Optimisation in the // operator: if one of the sets is empty, return the other set.	2010-08-02 16:31:05 +00:00
Eelco Dolstra	7af6a2fd71	* intersectAttrs: optimise for the case where the second set is larger than the first set. (That's usually the case with callPackage.)	2010-08-02 11:54:44 +00:00
Eelco Dolstra	532d766c27	* Don't barf if the source NAR for a patch has disappeared.	2010-07-21 11:30:23 +00:00
Peter Simons	7e043d28a6	src/bsdiff-4.3/Makefile.am: include the 'compat-include' directory in distribution tarballs	2010-07-15 14:35:20 +00:00
Peter Simons	60b632b173	tests/build-hook.hook.sh: prefer more portable `...` syntax over $(...) for running sub-shells The /bin/sh interpreter on Solaris doesn't understand $(...) syntax for running sub-shells. Consequently, this test fails on Solaris. To remedy the situation, the script either needs to be run by /bin/bash -- which is non-standard --, or it needs to use the ancient but portable `...` syntax.	2010-06-25 14:05:37 +00:00
Peter Simons	a0d29040f7	Revert "configure.ac: make flex and bison required programs" This reverts commit 22405. Apparently, these programs aren't necessarily required when building from a release archive.	2010-06-24 22:22:24 +00:00
Peter Simons	af09fe12dd	Fix build of bsdiff-4.3 on machines that don't have <err.h>, such as Solaris.	2010-06-24 17:51:31 +00:00
Peter Simons	d63375d529	configure.ac: Incredibly enough, tr(1) on Solaris doesn't understand A-Z syntax for ranges.	2010-06-24 17:51:24 +00:00
Peter Simons	4c21c016c5	configure.ac: make flex and bison required programs The build fails if these tools aren't available.	2010-06-24 17:51:19 +00:00
Peter Simons	bcec46057c	src/libutil/util.cc: include <limit.h> to ensure that PATH_MAX is defined	2010-06-24 17:51:13 +00:00
Peter Simons	a17071fef1	Include <cstring> to ensure that strcpy(), strlen(), and memset() are declared. An "using namespace std" was added locally in those functions that refer to names from <cstring>. That is not pretty, but it's a very portable solution, because strcpy() and friends will be found in both the 'std' and in the global namespace.	2010-06-24 17:51:04 +00:00
Eelco Dolstra	560ab22f7d	* Ignore packages that don't have a version. * Work on a manifest instead of a channel directory.	2010-06-23 21:11:33 +00:00
Peter Simons	8b7f8b56f1	Added support for passing an (impure) NIX_BUILD_CORES variable to build expressions. This patch adds the configuration file variable "build-cores" and the command line argument "--cores". These settings specify the number of CPU cores to utilize for parallel building within a job, i.e. by passing an appropriate "-j" flag to GNU Make. The default value is 1, which means that parallel building is disabled. If the number of build cores is specified as 0 (synonymously: "guess" or "auto"), then the actual value is supposed to be auto-detected by builders at run-time, i.e by calling the nproc(1) utility from coreutils. The environment variable $NIX_BUILD_CORES is available to builders, but the contents of that variable does not influence the hash that goes into the $out store path, i.e. the number of build cores to be utilized can be changed at will without requiring any re-builds.	2010-06-23 14:34:08 +00:00
Eelco Dolstra	819548d92f	* Pass `--fallback' to the remote build to ignore failing substituters.	2010-06-22 14:41:22 +00:00
Eelco Dolstra	b57189174f	* In importPath() and exportPath(), lock the temporary directory to prevent it from being deleted by the garbage collector.	2010-06-14 08:34:48 +00:00
Eelco Dolstra	f16fe2af8d	* builtins.toXML: propagate the string context. This is a regression from the old ATerm-based evaluator.	2010-06-10 10:29:50 +00:00
Eelco Dolstra	07ca66cf24	* Applied a patch from David Brown to prevent `nix-store --optimise' from failing on rename() on BtrFS.	2010-06-04 13:56:11 +00:00
Eelco Dolstra	1ab67cf437		2010-06-02 09:43:04 +00:00
Eelco Dolstra	89865da76d	* Turn build errors during evaluation into EvalErrors.	2010-06-01 11:19:32 +00:00
Ludovic Courtès	8bcdd36f10	Add XML output to `nix-store'. * src/nix-store/Makefile.am (nix_store_SOURCES): Add `xmlgraph.cc' and `xmlgraph.hh'. * src/nix-store/help.txt (Operations): Document `--xml'. * src/nix-store/nix-store.cc (opQuery): Handle `--xml'. * src/nix-store/xmlgraph.cc, src/nix-store/xmlgraph.hh: New files.	2010-05-31 16:36:24 +00:00
Ludovic Courtès	da52f8bea0	Comment out dead code in `nix-store'. * src/nix-store/dotgraph.cc (pathLabel): Move within #if 0 section.	2010-05-31 16:36:20 +00:00
Eelco Dolstra	7343e6c8ae	* Remove an accidentally committed debug statement.	2010-05-30 20:29:56 +00:00
Eelco Dolstra	93cd5a4a13	* The << operator on values should be const.	2010-05-18 10:36:37 +00:00
Eelco Dolstra	b2235d81d1	* Restore the __overrides feature that was lost somewhere in the fast-eval branch.	2010-05-15 08:10:12 +00:00
Eelco Dolstra	8032f26ca0	* Merged the `fast-eval' branch.	2010-05-12 13:59:36 +00:00
@@ -1 +1 @@
 .16
 .0