* Mark as stable.

* Add missing file to dist.

Makefile.am

@@ -1,6 +1,6 @@
 SUBDIRS = externals src scripts corepkgs doc misc tests
 EXTRA_DIST = substitute.mk nix.spec nix.spec.in bootstrap.sh \
-  svn-revision nix.conf.example
+  svn-revision nix.conf.example NEWS
 
 include ./substitute.mk
 
@@ -45,3 +45,8 @@ endif
 
 svn-revision:
 	svnversion . > svn-revision
+
+all-local: NEWS
+
+NEWS:
+	cp doc/manual/NEWS.txt NEWS

NEWS

@@ -1,255 +0,0 @@
-Version 0.8 (April 11, 2005)
-
-NOTE: the hashing scheme in Nix 0.8 changed (as detailed below).  As a
-result, `nix-pull' manifests and channels built for Nix 0.7 and below
-will now work anymore.  However, the Nix expression language has not
-changed, so you can still build from source.  Also, existing user
-environments continue to work.  Nix 0.8 will automatically upgrade the
-database schema of previous installations when it is first run.
-
-If you get the error message
-
-  you have an old-style manifest `/nix/var/nix/manifests/[...]';
-  please delete it
-
-you should delete previously downloaded manifests:
-
-  $ rm /nix/var/nix/manifests/*
-
-If `nix-channel' gives the error message
-
-  manifest `http://catamaran.labs.cs.uu.nl/dist/nix/channels/[channel]/MANIFEST'
-  is too old (i.e., for Nix <= 0.7)
-
-then you should unsubscribe from the offending channel (`nix-channel
---remove URL'; leave out `/MANIFEST'), and subscribe to the same URL,
-with `channels' replaced by `channels-v3' (e.g.,
-http://catamaran.labs.cs.uu.nl/dist/nix/channels-v3/nixpkgs-unstable).
-
-Nix 0.8 has the following improvements:
-
-* The cryptographic hashes used in store paths are now 160 bits long,
-  but encoded in base-32 so that they are still only 32 characters
-  long (e.g., /nix/store/csw87wag8bqlqk7ipllbwypb14xainap-atk-1.9.0).
-  (This is actually a 160 bit truncation of a SHA-256 hash.)
-
-* Big cleanups and simplifications of the basic store semantics.  The
-  notion of "closure store expressions" is gone (and so is the notion
-  of "successors"); the file system references of a store path are now
-  just stored in the database.
-
-  For instance, given any store path, you can query its closure:
-
-    $ nix-store -qR $(which firefox)
-    ... lots of paths ...
-
-  Also, Nix now remembers for each store path the derivation that
-  built it (the "deriver"):
-
-    $ nix-store -qR $(which firefox)
-    /nix/store/4b0jx7vq80l9aqcnkszxhymsf1ffa5jd-firefox-1.0.1.drv
-
-  So to see the build-time dependencies, you can do
-  
-    $ nix-store -qR $(nix-store -qd $(which firefox))
-
-  or, in a nicer format:
-
-    $ nix-store -q --tree $(nix-store -qd $(which firefox))
-
-  File system references are also stored in reverse.  For instance,
-  you can query all paths that directly or indirectly use a certain
-  Glibc:
-
-    $ nix-store -q --referers-closure \
-        /nix/store/8lz9yc6zgmc0vlqmn2ipcpkjlmbi51vv-glibc-2.3.4
-
-* The concept of fixed-output derivations has been formalised.
-  Previously, functions such as `fetchurl' in Nixpkgs used a hack
-  (namely, explicitly specifying a store path hash) to prevent changes
-  to, say, the URL of the file from propagating upwards through the
-  dependency graph, causing rebuilds of everything.  This can now be
-  done cleanly by specifying the `outputHash' and `outputHashAlgo'
-  attributes.  Nix itself checks that the content of the output has
-  the specified hash.  (This is important for maintaining certain
-  invariants necessary for future work on secure shared stores.)
-
-* One-click installation :-)  It is now possible to install any
-  top-level component in Nixpkgs directly, through the web - see,
-  e.g., http://catamaran.labs.cs.uu.nl/dist/nixpkgs-0.8/.  All you
-  have to do is associate `/nix/bin/nix-install-package' with the MIME
-  type `application/nix-package' (or the extension `.nixpkg'), and
-  clicking on a package link will cause it to be installed, with all
-  appropriate dependencies.  If you just want to install some specific
-  application, this is easier than subscribing to a channel.
-
-* `nix-store -r PATHS' now builds all the derivations PATHS in
-  parallel.  Previously it did them sequentially (though exploiting
-  possible parallelism between subderivations).  This is nice for
-  build farms.
-
-* `nix-channel' has new operations `--list' and `--remove'.
-
-* New ways of installing components into user environments:
-
-  - Copy from another user environment:
-
-      $ nix-env -i --from-profile .../other-profile firefox
-
-  - Install a store derivation directly (bypassing the Nix expression
-    language entirely):
-
-      $ nix-env -i /nix/store/z58v41v21xd3...-aterm-2.3.1.drv
-
-    (This is used to implement `nix-install-package', which is
-    therefore immune to evolution in the Nix expression language.)
-
-  - Install an already built store path directly:
-
-      $ nix-env -i /nix/store/hsyj5pbn0d9i...-aterm-2.3.1
-
-  - Install the result of a Nix expression specified as a command-line
-    argument:
-
-      $ nix-env -f .../i686-linux.nix -i -E 'x: x.firefoxWrapper'
-
-    The difference with the normal installation mode is that `-E' does
-    not use the `name' attributes of derivations.  Therefore, this can
-    be used to disambiguate multiple derivations with the same name.
-
-* A hash of the contents of a store path is now stored in the database
-  after a succesful build.  This allows you to check whether store
-  paths have been tampered with: `nix-store --verify --check-contents'.
-    
-* Implemented a concurrent garbage collector.  It is now always safe
-  to run the garbage collector, even if other Nix operations are
-  happening simultaneously.
-
-  However, there can still be GC races if you use `nix-instantiate'
-  and `nix-store -r' directly to build things.  To prevent races, use
-  the `--add-root' flag of those commands.
-
-* The garbage collector now finally deletes paths in the right order
-  (i.e., topologically sorted under the `references' relation), thus
-  making it safe to interrupt the collector without risking a store
-  that violates the closure invariant.
-
-* Likewise, the substitute mechanism now downloads files in the right
-  order, thus preserving the closure invariant at all times.
-
-* The result of `nix-build' is now registered as a root of the garbage
-  collector.  If the `./result' link is deleted, the GC root
-  disappears automatically.
-
-* The behaviour of the garbage collector can be changed globally by
-  setting options in `/nix/etc/nix/nix.conf'.
-
-  - `gc-keep-derivations' specifies whether deriver links should be
-    followed when searching for live paths.
-
-  - `gc-keep-outputs' specifies whether outputs of derivations should
-    be followed when searching for live paths.
-  
-  - `env-keep-derivations' specifies whether user environments should
-    store the paths of derivations when they are added (thus keeping
-    the derivations alive).
-
-* New `nix-env' query flags `--drv-path' and `--out-path'.
-
-* `fetchurl' allows SHA-1 and SHA-256 in addition to MD5.  Just
-  specify the attribute `sha1' or `sha256' instead of `md5'.
-
-* Manual updates.
-
-  
-Version 0.7 (January 12, 2005)
-
-* Binary patching.  When upgrading components using pre-built binaries
-  (through nix-pull / nix-channel), Nix can automatically download and
-  apply binary patches to already installed components instead of full
-  downloads.  Patching is "smart": if there is a *sequence* of patches
-  to an installed component, Nix will use it.  Patches are currently
-  generated automatically between Nixpkgs (pre-)releases.
-
-* Simplifications to the substitute mechanism.
-
-* Nix-pull now stores downloaded manifests in /nix/var/nix/manifests.
-
-* Metadata on files in the Nix store is canonicalised after builds:
-  the last-modified timestamp is set to 0 (00:00:00 1/1/1970), the
-  mode is set to 0444 or 0555 (readable and possibly executable by
-  all; setuid/setgid bits are dropped), and the group is set to the
-  default.  This ensures that the result of a build and an
-  installation through a substitute is the same; and that timestamp
-  dependencies are revealed.
-
-
-Version 0.6 (November 14, 2004)
-
-Major changes include the following:
-
-* Rewrite of the normalisation engine.
-
-  * Multiple builds can now be performed in parallel (option `-j').
-
-  * Distributed builds.  Nix can now call a shell script to forward
-    builds to Nix installations on remote machines, which may or may
-    not be of the same platform type.
-
-  * Option `--fallback' allows recovery from broken substitutes.
-
-  * Option `--keep-going' causes building of other (unaffected)
-    derivations to continue if one failed.
-    
-* Improvements to the garbage collector (i.e., it should actually work
-  now).
-
-* Setuid Nix installations allow a Nix store to be shared among
-  multiple users.
-
-* Substitute registration is much faster now.
-
-* A utility `nix-build' to build a Nix expression and create a symlink
-  to the result int the current directory; useful for testing Nix
-  derivations.
-
-* Manual updates.
-
-* `nix-env' changes:
-
-  * Derivations for other platforms are filtered out (which can be
-    overriden using `--system-filter').
-
-  * `--install' by default now uninstall previous derivations with the
-    same name.
-
-  * `--upgrade' allows upgrading to a specific version.
-
-  * New operation `--delete-generations' to remove profile
-    generations (necessary for effective garbage collection).
-
-  * Nicer output (sorted, columnised).
-
-* More sensible verbosity levels all around (builder output is now
-  shown always, unless `-Q' is given).
-
-* Nix expression language changes:
-
-  * New language construct: `with E1; E2' brings all attributes
-    defined in the attribute set E1 in scope in E2.
-
-  * Added a `map' function.
-
-  * Various new operators (e.g., string concatenation).
-
-* Expression evaluation is much faster.
-
-* An Emacs mode for editing Nix expressions (with syntax highlighting
-  and indentation) has been added.
-
-* Many bug fixes.
-
-
-Version 0.5 and earlier
-
-Please refer to the Subversion commit log messages.

bootstrap.sh

@@ -1,4 +1,6 @@
 #! /bin/sh -e
+mkdir -p config
+libtoolize --copy
 aclocal
 autoheader
 automake --add-missing --copy

configure.ac

@@ -1,8 +1,8 @@
-AC_INIT(nix, "0.8")
+AC_INIT(nix, "0.9.1")
 AC_CONFIG_SRCDIR(README)
 AC_CONFIG_AUX_DIR(config)
-AM_INIT_AUTOMAKE
-
+AM_INIT_AUTOMAKE([dist-bzip2 foreign])
+        
 # Change to `1' to produce a `stable' release (i.e., the `preREVISION'
 # suffix is not added).
 STABLE=1
@@ -48,6 +48,10 @@ AC_PROG_CC
 AC_PROG_CXX
 AC_PROG_RANLIB
 
+# We are going to use libtool.
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+
 # Check for pubsetbuf.
 AC_MSG_CHECKING([for pubsetbuf])
 AC_LANG_PUSH(C++)
@@ -78,6 +82,7 @@ NEED_PROG(bunzip2, bunzip2)
 NEED_PROG(shell, sh)
 AC_PATH_PROG(xmllint, xmllint, false)
 AC_PATH_PROG(xsltproc, xsltproc, false)
+AC_PATH_PROG(w3m, w3m, false)
 AC_PATH_PROG(flex, flex, false)
 AC_PATH_PROG(bison, bison, false)
 NEED_PROG(perl, perl)

corepkgs/buildenv/builder.pl.in

@@ -26,6 +26,7 @@ sub createLinks {
 	if ($srcFile =~ /\/propagated-build-inputs$/ ||
             $srcFile =~ /\/nix-support$/ ||
             $srcFile =~ /\/perllocal.pod$/ ||
+            $srcFile =~ /\/info\/dir$/ ||
             $srcFile =~ /\/log$/)
         {
             # Do nothing.

corepkgs/channels/unpack.sh.in

@@ -10,7 +10,7 @@ echo '[' > $expr
 nr=0
 for i in $inputs; do
     echo "unpacking $i"
-    @bunzip2@ < $i | @tar@ xvf -
+    @bunzip2@ < $i | @tar@ xf -
     @coreutils@/mv * ../$nr # !!! hacky
     echo "(import ./$nr)" >> $expr
     nr=$(($nr + 1))

doc/manual/Makefile.am

@@ -20,7 +20,7 @@ MANUAL_SRCS = manual.xml introduction.xml installation.xml \
  $(man1_MANS:.1=.xml) \
  troubleshooting.xml bugs.xml opt-common.xml opt-common-syn.xml \
  env-common.xml quick-start.xml nix-lang-ref.xml glossary.xml \
- conf-file.xml \
+ conf-file.xml release-notes.xml \
  style.css images
 
 manual.is-valid: $(MANUAL_SRCS) version.txt
@@ -37,7 +37,25 @@ manual.html: $(MANUAL_SRCS) manual.is-valid images
 	$(XSLTPROC) --nonet --xinclude --output manual.html \
 	  $(docbookxsl)/html/docbook.xsl manual.xml
 
-all-local: manual.html
+
+NEWS_OPTS = \
+ --stringparam generate.toc "article nop" \
+ --stringparam section.autolabel.max.depth 0 \
+ --stringparam header.rule 0
+
+NEWS.html: release-notes.xml
+	$(XSLTPROC) --nonet --xinclude --output $@ $(NEWS_OPTS) \
+	  $(docbookxsl)/html/docbook.xsl release-notes.xml
+
+NEWS.txt: release-notes.xml
+	$(XSLTPROC) --nonet --xinclude quote-literals.xsl release-notes.xml | \
+	  $(XSLTPROC) --nonet --output $@.tmp.html $(NEWS_OPTS) \
+	  $(docbookxsl)/html/docbook.xsl -
+	LANG=en_US $(w3m) -dump $@.tmp.html > $@
+	rm $@.tmp.html
+
+
+all-local: manual.html NEWS.html NEWS.txt
 
 install-data-local: manual.html
 	$(INSTALL) -d $(DESTDIR)$(datadir)/nix/manual
@@ -54,7 +72,7 @@ images:
 	cp $(docbookxsl)/images/callouts/*.png images/callouts
 	chmod +w -R images
 
-KEEP = manual.html manual.is-valid version.txt $(MANS)
+KEEP = manual.html manual.is-valid version.txt $(MANS) NEWS.html NEWS.txt
 
 EXTRA_DIST = $(MANUAL_SRCS) $(FIGURES) $(KEEP)
 

doc/manual/introduction.xml

@@ -130,8 +130,8 @@ collection.  It also discusses some advanced topics, such as setting
 up a Nix-based build farm, and doing service deployment using
 Nix.</para>
 
-<note><para>Some background information on Nix can be found in three
-papers.  The ICSE 2004 paper <ulink
+<note><para>Some background information on Nix can be found in a
+number of papers.  The ICSE 2004 paper <ulink
 url='http://www.cs.uu.nl/~eelco/pubs/immdsd-icse2004-final.pdf'><citetitle>Imposing
 a Memory Management Discipline on Software
 Deployment</citetitle></ulink> discusses the hashing mechanism used to
@@ -144,7 +144,10 @@ Deployment</citetitle></ulink> gives a more general discussion of Nix
 from a system-administration perspective.  The CBSE 2005 paper <ulink
 url='http://www.cs.uu.nl/~eelco/pubs/eupfcdm-cbse2005-final.pdf'><citetitle>Efficient
 Upgrading in a Purely Functional Component Deployment Model
-</citetitle></ulink> is about transparent patch deployment in
-Nix.</para></note>
+</citetitle></ulink> is about transparent patch deployment in Nix.
+Finally, the SCM-12 paper <ulink
+url='http://www.cs.uu.nl/~eelco/pubs/servicecm-scm12-final.pdf'>
+Service Configuration Management</ulink> shows how services (e.g., web
+servers) can be deployed and managed through Nix.</para></note>
 
 </chapter>

doc/manual/manual.xml

@@ -80,4 +80,9 @@
   <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="bugs.xml" />
   <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="glossary.xml" />
 
+  <appendix>
+    <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="release-notes.xml"
+                xpointer="xpointer(article/*)" />
+  </appendix>
+    
 </book>

doc/manual/nix-build.xml

@@ -25,6 +25,10 @@ to multiple derivations, multiple sequentially numbered symlinks are
 created (<filename>result</filename>, <filename>result-2</filename>,
 and so on).</para>
 
+<para>If no <replaceable>paths</replaceable> are specified, then
+<command>nix-build</command> will use <filename>default.nix</filename>
+in the current directory, if it exists.</para>
+
 <note><para><command>nix-build</command> is essentially a wrapper
 around <link
 linkend="sec-nix-instantiate"><command>nix-instantiate</command></link>

doc/manual/nix-env.xml

@@ -311,7 +311,7 @@ $ nix-env -i /nix/store/fibjb1bfbpm5mrsxc4mh2d8n37sxh91i-gcc-3.4.3.drv</screen>
 <para>To install a specific output path:
 
 <screen>
-$ nix-env -i /nix/store/x3cgx0xj1p4iv9x0pnnmdhr8iyg741vk-gcc-3.4.3</screen>
+$ nix-env -i /nix/store/y3cgx0xj1p4iv9x0pnnmdhr8iyg741vk-gcc-3.4.3</screen>
 
 </para>
 

doc/manual/nix-pull.xml

@@ -36,7 +36,7 @@
     <title>Examples</title>
 
     <screen>
-$ nix-pull http://catamaran.labs.cs.uu.nl/dist/nix/nixpkgs-0.5pre753/MANIFEST</screen>
+$ nix-pull http://nix.cs.uu.nl/dist/nix/nixpkgs-0.5pre753/MANIFEST</screen>
 
   </refsection>
     

doc/manual/nix-store.xml

@@ -500,8 +500,8 @@ query is applied to the target of the symlink.</para>
     
 <screen>
 $ nix-store -qR $(which svn)
-/nix/store/4mbglq5ldqld8sj57273aljwkfvj22mc-subversion-1.1.4
-/nix/store/8lz9yc6zgmc0vlqmn2ipcpkjlmbi51vv-glibc-2.3.4
+/nix/store/5mbglq5ldqld8sj57273aljwkfvj22mc-subversion-1.1.4
+/nix/store/9lz9yc6zgmc0vlqmn2ipcpkjlmbi51vv-glibc-2.3.4
 <replaceable>...</replaceable></screen>
 
 </para>
@@ -538,7 +538,7 @@ $ nix-store -q --tree $(nix-store -qd $(which svn))
 <screen>
 $ nix-store -q --referers $(nix-store -q --binding openssl $(nix-store -qd $(which svn)))
 /nix/store/23ny9l9wixx21632y2wi4p585qhva1q8-sylpheed-1.0.0
-/nix/store/4mbglq5ldqld8sj57273aljwkfvj22mc-subversion-1.1.4
+/nix/store/5mbglq5ldqld8sj57273aljwkfvj22mc-subversion-1.1.4
 /nix/store/dpmvp969yhdqs7lm2r1a3gng7pyq6vy4-subversion-1.1.3
 /nix/store/l51240xqsgg8a7yrbqdx1rfzyv6l26fx-lynx-2.8.5</screen>
 
@@ -550,7 +550,7 @@ $ nix-store -q --referers $(nix-store -q --binding openssl $(nix-store -qd $(whi
 <screen>
 $ nix-store -q --referers-closure $(ldd $(which svn) | grep /libc.so | awk '{print $3}')
 /nix/store/034a6h4vpz9kds5r6kzb9lhh81mscw43-libgnomeprintui-2.8.2
-/nix/store/05l3yi0d45prm7a82pcrknxdh6nzmxza-gawk-3.1.4
+/nix/store/15l3yi0d45prm7a82pcrknxdh6nzmxza-gawk-3.1.4
 <replaceable>...</replaceable></screen>
 
 Note that <command>ldd</command> is a command that prints out the

doc/manual/package-management.xml

@@ -32,8 +32,8 @@ components ranging from basic development stuff such as GCC and Glibc,
 to end-user applications like Mozilla Firefox.  (Nix is however not
 tied to the Nix Package collection; you could write your own Nix
 expressions based on it, or completely new ones.)  You can download
-the latest version from <ulink
-url='http://catamaran.labs.cs.uu.nl/dist/nix' />.</para>
+the latest version from <ulink url='http://nix.cs.uu.nl/dist/nix'
+/>.</para>
 
 <para>Assuming that you have downloaded and unpacked a release of Nix
 Packages, you can view the set of available components in the release:
@@ -97,16 +97,15 @@ available somewhere.  This is done using the
 containing a <emphasis>manifest</emphasis> describing what binaries
 are available.  This URL should correspond to the Nix Packages release
 that you’re using.  For instance, if you obtained a release from
-<ulink
-url='http://catamaran.labs.cs.uu.nl/dist/nix/nixpkgs-0.6pre1554/' />,
-then you should do:
+<ulink url='http://nix.cs.uu.nl/dist/nix/nixpkgs-0.6pre1554/' />, then
+you should do:
 
 <screen>
-$ nix-pull http://catamaran.labs.cs.uu.nl/dist/nix/nixpkgs-0.6pre1554/MANIFEST</screen>
+$ nix-pull http://nix.cs.uu.nl/dist/nix/nixpkgs-0.6pre1554/MANIFEST</screen>
 
 If you then issue the installation command, it should start
 downloading binaries from <systemitem
-class='fqdomainname'>catamaran.labs.cs.uu.nl</systemitem>, instead of
+class='fqdomainname'>nix.cs.uu.nl</systemitem>, instead of
 building them from source.  This might still take a while since all
 dependencies must be downloaded, but on a reasonably fast connection
 such as an DSL line it’s on the order of a few minutes.</para>
@@ -176,7 +175,7 @@ set.</para></footnote></para>
 <sect1 id="sec-profiles"><title>Profiles</title>
 
 <para>Profiles and user environments are Nix’s mechanism for
-implementing the ability to allow differens users to have different
+implementing the ability to allow different users to have different
 configurations, and to do atomic upgrades and rollbacks.  To
 understand how they work, it’s useful to know a bit about how Nix
 works.  In Nix, components are stored in unique locations in the
@@ -425,7 +424,7 @@ URL.</para>
 <command>nix-channel --add</command>, e.g.,
 
 <screen>
-$ nix-channel --add http://catamaran.labs.cs.uu.nl/dist/nix/channels/nixpkgs-unstable</screen>
+$ nix-channel --add http://nix.cs.uu.nl/dist/nix/channels-v3/nixpkgs-unstable</screen>
 
 subscribes you to a channel that always contains that latest version
 of the Nix Packages collection.  (Instead of

doc/manual/quick-start.xml

@@ -27,7 +27,7 @@ file).</para></listitem>
 <listitem><para>Subscribe to the Nix Packages channel.
 
 <screen>
-$ nix-channel --add http://catamaran.labs.cs.uu.nl/dist/nix/channels/nixpkgs-unstable</screen>
+$ nix-channel --add http://nix.cs.uu.nl/dist/nix/channels-v3/nixpkgs-unstable</screen>
 
 </para></listitem>
 

doc/manual/quote-literals.xsl

@@ -0,0 +1,40 @@
+<?xml version="1.0"?>
+
+<xsl:stylesheet
+  version="1.0"
+  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+  xmlns:str="http://exslt.org/strings"
+  extension-element-prefixes="str">
+
+  <xsl:output method="xml"/>
+  
+  <xsl:template match="function|command|literal|varname|filename|option|quote">`<xsl:apply-templates/>'</xsl:template>
+  
+  <xsl:template match="token"><xsl:text>    </xsl:text><xsl:apply-templates /><xsl:text>
+</xsl:text></xsl:template>
+
+  <xsl:template match="screen|programlisting">
+    <screen><xsl:apply-templates select="str:split(., '&#xA;')" /></screen>
+  </xsl:template>
+
+  <xsl:template match="section[following::section]">
+    <section>
+      <xsl:apply-templates />
+      <screen><xsl:text>
+      </xsl:text></screen>        
+    </section>
+  </xsl:template>
+
+  <xsl:template match="*">
+    <xsl:element name="{name(.)}" namespace="{namespace-uri(.)}">
+      <xsl:copy-of select="namespace::*" />
+      <xsl:for-each select="@*">
+	<xsl:attribute name="{name(.)}" namespace="{namespace-uri(.)}">
+	  <xsl:value-of select="."/>
+	</xsl:attribute>
+      </xsl:for-each>
+      <xsl:apply-templates/>
+    </xsl:element>
+  </xsl:template>
+
+</xsl:stylesheet>

doc/manual/release-notes.xml

@@ -0,0 +1,533 @@
+<?xml version="1.0"?>
+<!DOCTYPE book
+    PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
+    "http://www.docbook.org/xml/4.3/docbook-xml-4.3.zip"
+[
+]>
+
+<article><title>Nix Release Notes</title>
+
+
+<section><title>Release 0.9.1 (September 20, 2005)</title>
+
+<para>This bug fix release addresses a problem with the ATerm library
+when the <option>--with-aterm</option> flag in
+<command>configure</command> was <emphasis>not</emphasis> used.</para>
+
+</section>
+
+
+
+<section><title>Release 0.9 (September 16, 2005)</title>
+
+<para>NOTE: this version of Nix uses Berkeley DB 4.3 instead of 4.2.
+The database is upgraded automatically, but you should be careful not
+to use old versions of Nix that still use Berkeley DB 4.2.  In
+particular, if you use a Nix installed through Nix, you should run
+
+<screen>
+$ nix-store --clear-substitutes</screen>
+
+first.</para>
+
+
+<itemizedlist>
+
+  <listitem><para>Unpacking of patch sequences is much faster now
+  since we no longer do redundant unpacking and repacking of
+  intermediate paths.</para></listitem>
+
+  <listitem><para>Nix now uses Berkeley DB 4.3.</para></listitem>
+
+  <listitem><para>The <function>derivation</function> primitive is
+  lazier.  Attributes of dependent derivations can mutually refer to
+  each other (as long as there are no data dependencies on the
+  <varname>outPath</varname> and <varname>drvPath</varname> attributes
+  computed by <function>derivation</function>).</para>
+
+  <para>For example, the expression <literal>derivation
+  attrs</literal> now evaluates to (essentially)
+
+  <programlisting>
+attrs // {
+  type = "derivation";
+  outPath = derivation! attrs;
+  drvPath = derivation! attrs;
+}</programlisting>
+
+  where <function>derivation!</function> is a primop that does the
+  actual derivation instantiation (i.e., it does what
+  <function>derivation</function> used to do).  The advantage is that
+  it allows commands such as <command>nix-env -qa</command> and
+  <command>nix-env -i</command> to be much faster since they no longer
+  need to instantiate all derivations, just the
+  <varname>name</varname> attribute.</para>
+
+  <para>Also, it allows derivations to cyclically reference each
+  other, for example,
+
+  <programlisting>
+webServer = derivation {
+  ...
+  hostName = "svn.cs.uu.nl";
+  services = [svnService];
+};
+&#x20;
+svnService = derivation {
+  ...
+  hostName = webServer.hostName;
+};</programlisting>
+
+  Previously, this would yield a black hole (infinite recursion).</para>
+  
+  </listitem>
+
+  <listitem><para><command>nix-build</command> now defaults to using
+  <filename>./default.nix</filename> if no Nix expression is
+  specified.</para></listitem>
+
+  <listitem><para><command>nix-instantiate</command>, when applied to
+  a Nix expression that evaluates to a function, will call the
+  function automatically if all its arguments have
+  defaults.</para></listitem>
+
+  <listitem><para>Nix now uses libtool to build dynamic libraries.
+  This reduces the size of executables.</para></listitem>
+
+  <listitem><para>A new list concatenation operator
+  <literal>++</literal>.  For example, <literal>[1 2 3] ++ [4 5
+  6]</literal> evaluates to <literal>[1 2 3 4 5
+  6]</literal>.</para></listitem>
+
+  <listitem><para>Some currently undocumented primops to support
+  low-level build management using Nix (i.e., using Nix as a Make
+  replacement).  See the commit messages for <literal>r3578</literal>
+  and <literal>r3580</literal>.</para></listitem>
+
+  <listitem><para>Various bug fixes and performance
+  improvements.</para></listitem>
+
+</itemizedlist>
+
+</section>
+
+
+
+<section><title>Release 0.8.1 (April 13, 2005)</title>
+
+<para>This is a bug fix release.</para>
+
+<itemizedlist>
+
+  <listitem><para>Patch downloading was broken.</para></listitem>
+
+  <listitem><para>The garbage collector would not delete paths that
+  had references from invalid (but substitutable)
+  paths.</para></listitem>
+
+</itemizedlist>
+
+</section>
+
+
+
+<section><title>Release 0.8 (April 11, 2005)</title>
+
+<para>NOTE: the hashing scheme in Nix 0.8 changed (as detailed below).
+As a result, <command>nix-pull</command> manifests and channels built
+for Nix 0.7 and below will now work anymore.  However, the Nix
+expression language has not changed, so you can still build from
+source.  Also, existing user environments continue to work.  Nix 0.8
+will automatically upgrade the database schema of previous
+installations when it is first run.</para>
+
+<para>If you get the error message
+
+<screen>
+you have an old-style manifest `/nix/var/nix/manifests/[...]'; please
+delete it</screen>
+
+you should delete previously downloaded manifests:
+
+<screen>
+$ rm /nix/var/nix/manifests/*</screen>
+
+If <command>nix-channel</command> gives the error message
+
+<screen>
+manifest `http://catamaran.labs.cs.uu.nl/dist/nix/channels/[channel]/MANIFEST'
+is too old (i.e., for Nix &lt;= 0.7)</screen>
+
+then you should unsubscribe from the offending channel
+(<command>nix-channel --remove
+<replaceable>URL</replaceable></command>; leave out
+<literal>/MANIFEST</literal>), and subscribe to the same URL, with
+<literal>channels</literal> replaced by <literal>channels-v3</literal>
+(e.g.,
+http://catamaran.labs.cs.uu.nl/dist/nix/channels-v3/nixpkgs-unstable).</para>
+
+<para>Nix 0.8 has the following improvements:
+
+<itemizedlist>
+
+  <listitem><para>The cryptographic hashes used in store paths are now
+  160 bits long, but encoded in base-32 so that they are still only 32
+  characters long (e.g.,
+  /nix/store/csw87wag8bqlqk7ipllbwypb14xainap-atk-1.9.0).  (This is
+  actually a 160 bit truncation of a SHA-256 hash.)</para></listitem>
+
+  <listitem><para>Big cleanups and simplifications of the basic store
+  semantics.  The notion of "closure store expressions" is gone (and
+  so is the notion of "successors"); the file system references of a
+  store path are now just stored in the database.</para>
+
+  <para>For instance, given any store path, you can query its closure:
+
+  <screen>
+$ nix-store -qR $(which firefox)
+... lots of paths ...</screen>
+
+  Also, Nix now remembers for each store path the derivation that
+  built it (the "deriver"):
+
+  <screen>
+$ nix-store -qR $(which firefox)
+/nix/store/4b0jx7vq80l9aqcnkszxhymsf1ffa5jd-firefox-1.0.1.drv</screen>
+
+  So to see the build-time dependencies, you can do
+
+  <screen>
+$ nix-store -qR $(nix-store -qd $(which firefox))</screen>
+
+  or, in a nicer format:
+
+  <screen>
+$ nix-store -q --tree $(nix-store -qd $(which firefox))</screen>
+
+  </para>
+
+  <para>File system references are also stored in reverse.  For
+  instance, you can query all paths that directly or indirectly use a
+  certain Glibc:
+
+  <screen>
+$ nix-store -q --referers-closure \
+    /nix/store/8lz9yc6zgmc0vlqmn2ipcpkjlmbi51vv-glibc-2.3.4</screen>
+
+  </para>
+  
+  </listitem>
+
+  <listitem><para>The concept of fixed-output derivations has been
+  formalised.  Previously, functions such as
+  <function>fetchurl</function> in Nixpkgs used a hack (namely,
+  explicitly specifying a store path hash) to prevent changes to, say,
+  the URL of the file from propagating upwards through the dependency
+  graph, causing rebuilds of everything.  This can now be done cleanly
+  by specifying the <varname>outputHash</varname> and
+  <varname>outputHashAlgo</varname> attributes.  Nix itself checks
+  that the content of the output has the specified hash.  (This is
+  important for maintaining certain invariants necessary for future
+  work on secure shared stores.)</para></listitem>
+
+  <listitem><para>One-click installation :-) It is now possible to
+  install any top-level component in Nixpkgs directly, through the web
+  - see, e.g., http://catamaran.labs.cs.uu.nl/dist/nixpkgs-0.8/.  All
+  you have to do is associate
+  <filename>/nix/bin/nix-install-package</filename> with the MIME type
+  <literal>application/nix-package</literal> (or the extension
+  <filename>.nixpkg</filename>), and clicking on a package link will
+  cause it to be installed, with all appropriate dependencies.  If you
+  just want to install some specific application, this is easier than
+  subscribing to a channel.</para></listitem>
+
+  <listitem><para><command>nix-store -r
+  <replaceable>PATHS</replaceable></command> now builds all the
+  derivations PATHS in parallel.  Previously it did them sequentially
+  (though exploiting possible parallelism between subderivations).
+  This is nice for build farms.</para></listitem>
+
+  <listitem><para><command>nix-channel</command> has new operations
+  <option>--list</option> and
+  <option>--remove</option>.</para></listitem>
+
+  <listitem><para>New ways of installing components into user
+  environments:
+
+  <itemizedlist>
+
+    <listitem><para>Copy from another user environment:
+
+    <screen>
+$ nix-env -i --from-profile .../other-profile firefox</screen>
+
+    </para></listitem>
+
+    <listitem><para>Install a store derivation directly (bypassing the
+    Nix expression language entirely):
+
+    <screen>
+$ nix-env -i /nix/store/z58v41v21xd3...-aterm-2.3.1.drv</screen>
+
+    (This is used to implement <command>nix-install-package</command>,
+    which is therefore immune to evolution in the Nix expression
+    language.)</para></listitem>
+
+    <listitem><para>Install an already built store path directly:
+
+    <screen>
+$ nix-env -i /nix/store/hsyj5pbn0d9i...-aterm-2.3.1</screen>
+
+    </para></listitem>
+
+    <listitem><para>Install the result of a Nix expression specified
+    as a command-line argument:
+
+    <screen>
+$ nix-env -f .../i686-linux.nix -i -E 'x: x.firefoxWrapper'</screen>
+
+    The difference with the normal installation mode is that
+    <option>-E</option> does not use the <varname>name</varname>
+    attributes of derivations.  Therefore, this can be used to
+    disambiguate multiple derivations with the same
+    name.</para></listitem>
+
+  </itemizedlist></para></listitem>
+
+  <listitem><para>A hash of the contents of a store path is now stored
+  in the database after a succesful build.  This allows you to check
+  whether store paths have been tampered with: <command>nix-store
+  --verify --check-contents</command>.</para></listitem>
+
+  <listitem>
+
+    <para>Implemented a concurrent garbage collector.  It is now
+    always safe to run the garbage collector, even if other Nix
+    operations are happening simultaneously.</para>
+
+    <para>However, there can still be GC races if you use
+    <command>nix-instantiate</command> and <command>nix-store
+    --realise</command> directly to build things.  To prevent races,
+    use the <option>--add-root</option> flag of those commands.</para>
+
+  </listitem>
+
+  <listitem><para>The garbage collector now finally deletes paths in
+  the right order (i.e., topologically sorted under the
+  <quote>references</quote> relation), thus making it safe to
+  interrupt the collector without risking a store that violates the
+  closure invariant.</para></listitem>
+
+  <listitem><para>Likewise, the substitute mechanism now downloads
+  files in the right order, thus preserving the closure invariant at
+  all times.</para></listitem>
+
+  <listitem><para>The result of <command>nix-build</command> is now
+  registered as a root of the garbage collector.  If the
+  <filename>./result</filename> link is deleted, the GC root
+  disappears automatically.</para></listitem>
+
+  <listitem>
+
+    <para>The behaviour of the garbage collector can be changed
+    globally by setting options in
+    <filename>/nix/etc/nix/nix.conf</filename>.
+
+    <itemizedlist>
+
+      <listitem><para><literal>gc-keep-derivations</literal> specifies
+      whether deriver links should be followed when searching for live
+      paths.</para></listitem>
+
+      <listitem><para><literal>gc-keep-outputs</literal> specifies
+      whether outputs of derivations should be followed when searching
+      for live paths.</para></listitem>
+
+      <listitem><para><literal>env-keep-derivations</literal>
+      specifies whether user environments should store the paths of
+      derivations when they are added (thus keeping the derivations
+      alive).</para></listitem>
+
+    </itemizedlist>
+
+  </para></listitem>
+
+  <listitem><para>New <command>nix-env</command> query flags
+  <option>--drv-path</option> and
+  <option>--out-path</option>.</para></listitem>
+
+  <listitem><para><command>fetchurl</command> allows SHA-1 and SHA-256
+  in addition to MD5.  Just specify the attribute
+  <varname>sha1</varname> or <varname>sha256</varname> instead of
+  <varname>md5</varname>.</para></listitem>
+
+  <listitem><para>Manual updates.</para></listitem>
+
+</itemizedlist>
+
+</para>
+
+</section>
+
+
+
+<section><title>Release 0.7 (January 12, 2005)</title>
+
+<itemizedlist>
+
+  <listitem><para>Binary patching.  When upgrading components using
+  pre-built binaries (through nix-pull / nix-channel), Nix can
+  automatically download and apply binary patches to already installed
+  components instead of full downloads.  Patching is "smart": if there
+  is a *sequence* of patches to an installed component, Nix will use
+  it.  Patches are currently generated automatically between Nixpkgs
+  (pre-)releases.</para></listitem>
+
+  <listitem><para>Simplifications to the substitute
+  mechanism.</para></listitem>
+
+  <listitem><para>Nix-pull now stores downloaded manifests in
+  /nix/var/nix/manifests.</para></listitem>
+
+  <listitem><para>Metadata on files in the Nix store is canonicalised
+  after builds: the last-modified timestamp is set to 0 (00:00:00
+  1/1/1970), the mode is set to 0444 or 0555 (readable and possibly
+  executable by all; setuid/setgid bits are dropped), and the group is
+  set to the default.  This ensures that the result of a build and an
+  installation through a substitute is the same; and that timestamp
+  dependencies are revealed.</para></listitem>
+
+</itemizedlist>
+
+</section>
+
+
+
+<section><title>Release 0.6 (November 14, 2004)</title>
+
+<itemizedlist>
+
+  <listitem>
+    <para>Rewrite of the normalisation engine.
+
+    <itemizedlist>
+
+      <listitem><para>Multiple builds can now be performed in parallel
+      (option <option>-j</option>).</para></listitem>
+
+      <listitem><para>Distributed builds.  Nix can now call a shell
+      script to forward builds to Nix installations on remote
+      machines, which may or may not be of the same platform
+      type.</para></listitem>
+
+      <listitem><para>Option <option>--fallback</option> allows
+      recovery from broken substitutes.</para></listitem>
+
+      <listitem><para>Option <option>--keep-going</option> causes
+      building of other (unaffected) derivations to continue if one
+      failed.</para></listitem>
+
+    </itemizedlist>
+
+    </para>
+
+  </listitem>
+
+  <listitem><para>Improvements to the garbage collector (i.e., it
+  should actually work now).</para></listitem>
+
+  <listitem><para>Setuid Nix installations allow a Nix store to be
+  shared among multiple users.</para></listitem>
+
+  <listitem><para>Substitute registration is much faster
+  now.</para></listitem>
+
+  <listitem><para>A utility <command>nix-build</command> to build a
+  Nix expression and create a symlink to the result int the current
+  directory; useful for testing Nix derivations.</para></listitem>
+
+  <listitem><para>Manual updates.</para></listitem>
+
+  <listitem>
+
+    <para><command>nix-env</command> changes:
+
+    <itemizedlist>
+
+      <listitem><para>Derivations for other platforms are filtered out
+      (which can be overriden using
+      <option>--system-filter</option>).</para></listitem>
+
+      <listitem><para><option>--install</option> by default now
+      uninstall previous derivations with the same
+      name.</para></listitem>
+
+      <listitem><para><option>--upgrade</option> allows upgrading to a
+      specific version.</para></listitem>
+
+      <listitem><para>New operation
+      <option>--delete-generations</option> to remove profile
+      generations (necessary for effective garbage
+      collection).</para></listitem>
+
+      <listitem><para>Nicer output (sorted,
+      columnised).</para></listitem>
+
+    </itemizedlist>
+    
+    </para>
+
+  </listitem>
+
+  <listitem><para>More sensible verbosity levels all around (builder
+  output is now shown always, unless <option>-Q</option> is
+  given).</para></listitem>
+
+  <listitem>
+
+    <para>Nix expression language changes:
+
+    <itemizedlist>
+      
+      <listitem><para>New language construct: <literal>with
+      <replaceable>E1</replaceable>;
+      <replaceable>E2</replaceable></literal> brings all attributes
+      defined in the attribute set <replaceable>E1</replaceable> in
+      scope in <replaceable>E2</replaceable>.</para></listitem>
+
+      <listitem><para>Added a <function>map</function>
+      function.</para></listitem>
+
+      <listitem><para>Various new operators (e.g., string
+      concatenation).</para></listitem>
+
+    </itemizedlist>
+
+    </para>
+
+  </listitem>
+
+  <listitem><para>Expression evaluation is much
+  faster.</para></listitem>
+
+  <listitem><para>An Emacs mode for editing Nix expressions (with
+  syntax highlighting and indentation) has been
+  added.</para></listitem>
+
+  <listitem><para>Many bug fixes.</para></listitem>
+
+</itemizedlist>
+
+</section>
+
+
+
+<section><title>Release 0.5 and earlier</title>
+
+<para>Please refer to the Subversion commit log messages.</para>
+
+</section>
+
+
+
+</article>

doc/manual/writing-nix-expressions.xml

@@ -1046,6 +1046,11 @@ weakest binding).</para>
         contains an attribute named
         <replaceable>id</replaceable>.</entry>
       </row>
+      <row>
+        <entry><replaceable>e1</replaceable> ++ <replaceable>e2</replaceable></entry>
+        <entry>right</entry>
+        <entry>List concatenation.</entry>
+      </row>
       <row>
         <entry><replaceable>e1</replaceable> + <replaceable>e2</replaceable></entry>
         <entry>left</entry>

externals/Makefile.am

@@ -1,11 +1,11 @@
 # Berkeley DB
 
-DB = db-4.2.52
+DB = db-4.3.28.NC
 
 $(DB).tar.gz:
 	@echo "Nix requires Berkeley DB to build."
-	@echo "Please download version 4.2.52 from"
-	@echo "  http://www.sleepycat.com/update/snapshot/db-4.2.52.tar.gz"
+	@echo "Please download version 4.3.28 from"
+	@echo "  http://downloads.sleepycat.com/db-4.3.28.NC.tar.gz"
 	@echo "and place it in the externals/ directory."
 	false
 
@@ -26,20 +26,20 @@ build-db: have-db
 	 ../dist/configure --prefix=$$pfx/inst-bdb \
 	 --enable-cxx --disable-shared --disable-cryptography \
          --disable-replication --disable-verify && \
-	make && \
-	make install)
+	$(MAKE) && \
+	$(MAKE) install)
 	touch build-db
 endif
 
 
 # CWI ATerm
 
-ATERM = aterm-2.3.1
+ATERM = aterm-2.4
 
 $(ATERM).tar.gz:
 	@echo "Nix requires the CWI ATerm library to build."
-	@echo "Please download version 2.3.1 from"
-	@echo "  http://www.cwi.nl/projects/MetaEnv/aterm/aterm-2.3.1.tar.gz"
+	@echo "Please download version 2.4 from"
+	@echo "  http://www.cwi.nl/projects/MetaEnv/aterm/aterm-2.4.tar.gz"
 	@echo "and place it in the externals/ directory."
 	false
 
@@ -56,9 +56,10 @@ else
 build-aterm: have-aterm
 	(pfx=`pwd` && \
 	cd $(ATERM) && \
-	CC="$(CC)" ./configure --prefix=$$pfx/inst-aterm && \
-	make && \
-	make install)
+	CC="$(CC)" ./configure --prefix=$$pfx/inst-aterm \
+	  --disable-shared --enable-static CFLAGS=-O1 && \
+	$(MAKE) && \
+	$(MAKE) install)
 	touch build-aterm
 endif
 

make/examples/aterm/aterm/default.nix

@@ -0,0 +1,30 @@
+{sharedLib ? true}:
+
+rec {
+
+  inherit (import ../../../lib) compileC makeLibrary;
+
+  sources = [
+    ./afun.c
+    ./aterm.c
+    ./bafio.c
+    ./byteio.c
+    ./gc.c
+    ./hash.c
+    ./list.c
+    ./make.c
+    ./md5c.c
+    ./memory.c
+    ./tafio.c
+    ./version.c
+  ];
+
+  compile = main: compileC {inherit main sharedLib;};
+
+  libATerm = makeLibrary {
+    libraryName = "ATerm";
+    objects = map compile sources;
+    inherit sharedLib;
+  };
+
+}

make/examples/aterm/default.nix

@@ -0,0 +1 @@
+import test/default.nix

make/examples/aterm/test/default.nix

@@ -0,0 +1,15 @@
+with (import ../../../lib);
+
+let {
+  inherit (import ../aterm {}) libATerm;
+
+  compileTest = main: link {
+    objects = [(compileC {inherit main; localIncludePath = [ ../aterm ];})];
+    libraries = libATerm;
+  };
+
+  body = [
+    (compileTest ./fib.c)
+    (compileTest ./primes.c)
+  ];
+}

make/examples/default.nix

@@ -0,0 +1,6 @@
+[ (import ./trivial)
+  (import ./simple-header)
+  (import ./not-so-simple-header)
+  (import ./not-so-simple-header-auto)
+  (import ./aterm)
+]

make/examples/not-so-simple-header-auto/bar/hello.h

@@ -0,0 +1 @@
+#define WHAT "World"

make/examples/not-so-simple-header-auto/default.nix

@@ -0,0 +1,13 @@
+with import ../../lib;
+
+let {
+
+  hello = link {programName = "hello"; objects = compileC {
+    main = ./foo/hello.c;
+    localIncludes = "auto";
+  };};
+
+#  body = findIncludes {main = ./foo/hello.c;};
+
+  body = [hello];
+}

make/examples/not-so-simple-header-auto/foo/fnord/indirect.h

@@ -0,0 +1,3 @@
+#define HELLO "Hello"
+
+#include "../../bar/hello.h"

make/examples/not-so-simple-header-auto/foo/hello.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+#include "fnord/indirect.h"
+
+int main(int argc, char * * argv)
+{
+    printf(HELLO " " WHAT "\n");
+    return 0;
+}

make/examples/not-so-simple-header/bar/hello.h

@@ -0,0 +1 @@
+#define WHAT "World"

make/examples/not-so-simple-header/default.nix

@@ -0,0 +1,14 @@
+let {
+
+  inherit (import ../../lib) compileC link;
+
+  hello = link {programName = "hello"; objects = compileC {
+    main = ./foo/hello.c;
+    localIncludes = [
+      [./foo/fnord/indirect.h "fnord/indirect.h"]
+      [./bar/hello.h "fnord/../../bar/hello.h"]
+    ];
+  };};
+
+  body = [hello];
+}

make/examples/not-so-simple-header/foo/fnord/indirect.h

@@ -0,0 +1,3 @@
+#define HELLO "Hello"
+
+#include "../../bar/hello.h"

make/examples/not-so-simple-header/foo/hello.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+#include "fnord/indirect.h"
+
+int main(int argc, char * * argv)
+{
+    printf(HELLO " " WHAT "\n");
+    return 0;
+}

make/examples/simple-header/default.nix

@@ -0,0 +1,11 @@
+let {
+
+  inherit (import ../../lib) compileC link;
+
+  hello = link {objects = compileC {
+    main = ./hello.c;
+    localIncludes = [ [./hello.h "hello.h"] ];
+  };};
+
+  body = [hello];
+}

make/examples/simple-header/hello.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+#include "hello.h"
+
+int main(int argc, char * * argv)
+{
+    printf("Hello " WHAT "\n");
+    return 0;
+}

make/examples/simple-header/hello.h

@@ -0,0 +1 @@
+#define WHAT "World"

make/examples/trivial/default.nix

@@ -0,0 +1,8 @@
+let {
+
+  inherit (import ../../lib) compileC link;
+
+  hello = link {objects = compileC {main = ./hello.c;};};
+
+  body = [hello];
+}

make/examples/trivial/hello.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main(int argc, char * * argv)
+{
+    printf("Hello World\n");
+    return 0;
+}

make/lib/compile-c.sh

@@ -0,0 +1,73 @@
+. $stdenv/setup
+
+mainName=$(basename $main | cut -c34-)
+
+echo "compiling \`$mainName'..."
+
+# Turn $localIncludes into an array.
+localIncludes=($localIncludes)
+
+# Determine how many `..' levels appear in the header file references.
+# E.g., if there is some reference `../../foo.h', then we have to
+# insert two extra levels in the directory structure, so that `a.c' is
+# stored at `dotdot/dotdot/a.c', and a reference from it to
+# `../../foo.h' resolves to `dotdot/dotdot/../../foo.h' == `foo.h'.
+n=0
+maxDepth=0
+for ((n = 0; n < ${#localIncludes[*]}; n += 2)); do
+    target=${localIncludes[$((n + 1))]}
+
+    # Split the target name into path components using some IFS magic.
+    savedIFS="$IFS"
+    IFS=/
+    components=($target)
+    depth=0
+    for ((m = 0; m < ${#components[*]}; m++)); do
+        c=${components[m]}
+        if test "$c" = ".."; then
+            depth=$((depth + 1))
+        fi
+    done
+    IFS="$savedIFS"
+
+    if test $depth -gt $maxDepth; then
+        maxDepth=$depth;
+    fi
+done
+
+# Create the extra levels in the directory hierarchy.
+prefix=
+for ((n = 0; n < maxDepth; n++)); do
+    prefix="dotdot/$prefix"
+done
+
+# Create symlinks to the header files.
+for ((n = 0; n < ${#localIncludes[*]}; n += 2)); do
+    source=${localIncludes[n]}
+    target=${localIncludes[$((n + 1))]}
+
+    # Create missing directories.  We use IFS magic to split the path
+    # into path components.
+    savedIFS="$IFS"
+    IFS=/
+    components=($prefix$target)
+    fullPath=(.)
+    for ((m = 0; m < ${#components[*]} - 1; m++)); do
+        fullPath=("${fullPath[@]}" ${components[m]})
+        if ! test -d "${fullPath[*]}"; then
+            mkdir "${fullPath[*]}"
+        fi
+    done
+    IFS="$savedIFS"
+    
+    ln -sf $source $prefix$target
+done
+
+# Create a symlink to the main file.
+if ! test "$(readlink $prefix$mainName)" = $main; then
+    ln -s $main $prefix$mainName
+fi
+
+mkdir $out
+test "$prefix" && cd $prefix
+gcc -Wall $cFlags -c $mainName -o $out/$mainName.o

make/lib/default.nix

@@ -0,0 +1,69 @@
+rec {
+
+  # Should point at your Nixpkgs installation.
+  pkgPath = ./pkgs;
+
+  pkgs = import (pkgPath + /system/all-packages.nix) {};
+
+  stdenv = pkgs.stdenv;
+  
+
+  compileC =
+  { main
+  , localIncludes ? "auto"
+  , localIncludePath ? []
+  , cFlags ? ""
+  , sharedLib ? false
+  }:
+  stdenv.mkDerivation {
+    name = "compile-c";
+    builder = ./compile-c.sh;
+    
+    localIncludes =
+      if localIncludes == "auto" then
+        dependencyClosure {
+          scanner = main:
+            import (findIncludes {
+              inherit main;
+            });
+          searchPath = localIncludePath;
+          startSet = [main];
+        }
+      else
+        localIncludes;
+        
+    inherit main;
+    
+    cFlags = [
+      cFlags
+      (if sharedLib then ["-fpic"] else [])
+      (map (p: "-I" + (relativise (dirOf main) p)) localIncludePath)
+    ];
+  };
+
+  
+  findIncludes = {main}: stdenv.mkDerivation {
+    name = "find-includes";
+    realBuilder = pkgs.perl ~ "bin/perl";
+    args = [ ./find-includes.pl ];
+    inherit main;
+  };
+
+    
+  link = {objects, programName ? "program", libraries ? []}: stdenv.mkDerivation {
+    name = "link";
+    builder = ./link.sh;
+    inherit objects programName libraries;
+  };
+
+  
+  makeLibrary = {objects, libraryName ? [], sharedLib ? false}:
+  # assert sharedLib -> fold (obj: x: assert obj.sharedLib && x) false objects
+  stdenv.mkDerivation {
+    name = "library";
+    builder = ./make-library.sh;
+    inherit objects libraryName sharedLib;
+  };
+
+  
+}

make/lib/find-includes.pl

@@ -0,0 +1,21 @@
+use strict;
+
+my $root = $ENV{"main"};
+my $out = $ENV{"out"};
+
+open OUT, ">$out" or die "$!";
+print OUT "[\n";
+
+open IN, "<$root" or die "$!";
+while (<IN>) {
+    if (/^\#include\s+\"(.*)\"/) {
+        print OUT "\"$1\"\n";
+    }
+    if (/^\#include\s+\<(.*)\>/) {
+        print OUT "\"$1\"\n";
+    }
+}
+close IN;
+
+print OUT "]\n";
+close OUT;

make/lib/link.sh

@@ -0,0 +1,21 @@
+. $stdenv/setup
+
+shopt -s nullglob
+
+objs=
+for i in $objects; do
+    obj=$(echo $i/*.o)
+    objs="$objs $obj"
+done
+
+libs=
+for i in $libraries; do
+    lib=$(echo $i/*.a; echo $i/*.so)
+    name=$(echo $(basename $lib) | sed -e 's/^lib//' -e 's/.a$//' -e 's/.so$//')
+    libs="$libs -L$(dirname $lib) -l$name" 
+done
+
+echo "linking object files into \`$programName'..."
+
+mkdir $out
+gcc -o $out/$programName $objs $libs

make/lib/make-library.sh

@@ -0,0 +1,28 @@
+. $stdenv/setup
+
+objs=
+for i in $objects; do
+    obj=$(echo $i/*.o)
+    objs="$objs $obj"
+done
+
+echo "archiving object files into library \`$libraryName'..."
+
+ensureDir $out
+
+if test -z "$sharedLib"; then
+
+    outPath=$out/lib${libraryName}.a
+
+    ar crs $outPath $objs
+    ranlib $outPath
+
+else
+
+    outPath=$out/lib${libraryName}.so
+
+    gcc -shared -o $outPath $objs
+
+fi    
+
+    

nix.spec.in

@@ -14,11 +14,12 @@ Release: 1
 License: GPL
 Group: Software Deployment
 URL: http://www.cs.uu.nl/groups/ST/Trace/Nix
-Source0: %{name}-@version@.tar.gz
+Source0: %{name}-@version@.tar.bz2
 BuildRoot: %{_tmppath}/%{name}-%{version}-buildroot
 %define _prefix /nix
 Prefix: %{_prefix}
 Requires: /usr/bin/perl
+Requires: curl
 
 # Hack to make that shitty RPM scanning hack shut up.
 Provides: perl(readmanifest)
@@ -66,6 +67,7 @@ fi
 %files
 #%defattr(-,root,root)
 %{_prefix}/bin
+%{_prefix}/lib
 %{_prefix}/libexec
 %{_prefix}/var
 %{_prefix}/share

scripts/download-using-manifests.pl.in

@@ -2,6 +2,7 @@
 
 use strict;
 use readmanifest;
+use POSIX qw(tmpnam);
 
 my $manifestDir = "@localstatedir@/nix/manifests";
 my $logFile = "@localstatedir@/log/nix/downloads";
@@ -9,6 +10,19 @@ my $logFile = "@localstatedir@/log/nix/downloads";
 open LOGFILE, ">>$logFile" or die "cannot open log file $logFile";
 
 
+# Create a temporary directory.
+my $tmpDir;
+do { $tmpDir = tmpnam(); }
+until mkdir $tmpDir, 0700;
+
+chdir $tmpDir or die "cannot change to `$tmpDir': $!";
+
+my $tmpNar = "$tmpDir/nar";
+my $tmpNar2 = "$tmpDir/nar2";
+
+END { unlink $tmpNar; unlink $tmpNar2; rmdir $tmpDir; }
+
+
 # Check the arguments.
 die unless scalar @ARGV == 1;
 my $targetPath = $ARGV[0];
@@ -76,7 +90,7 @@ addToQueue $targetPath;
 
 sub isValidPath {
     my $p = shift;
-    system "@bindir@/nix-store --isvalid '$p' 2> /dev/null";
+    system "@bindir@/nix-store --check-validity '$p' 2> /dev/null";
     return $? == 0;
 }
 
@@ -207,11 +221,19 @@ while (scalar @path > 0) {
     my $v = $edge->{end};
 
     print "\n*** Step $curStep/$maxStep: ";
-    $curStep++;
 
     if ($edge->{type} eq "present") {
         print "using already present path `$v'\n";
         print LOGFILE "$$ present $v\n";
+
+        if ($curStep < $maxStep) {
+            # Since this is not the last step, the path will be used
+            # as a base to one or more patches.  So turn the base path
+            # into a NAR archive, to which we can apply the patch.
+            print "  packing base path...\n";
+            system "@bindir@/nix-store --dump $v > $tmpNar";
+            die "cannot dump `$v'" if ($? != 0);
+        }
     }
 
     elsif ($edge->{type} eq "patch") {
@@ -224,21 +246,22 @@ while (scalar @path > 0) {
         print "  downloading patch...\n";
         my $patchPath = downloadFile "$patch->{url}", "$patch->{hash}";
 
-        # Turn the base path into a NAR archive, to which we can
-        # actually apply the patch.
-        print "  packing base path...\n";
-        system "@bindir@/nix-store --dump $patch->{basePath} > /tmp/nar";
-        die "cannot dump `$patch->{basePath}'" if ($? != 0);
-
-        # Apply the patch.
+        # Apply the patch to the NAR archive produced in step 1 (for
+        # the already present path) or a later step (for patch sequences).
         print "  applying patch...\n";
-        system "@libexecdir@/bspatch /tmp/nar /tmp/nar2 $patchPath";
-        die "cannot apply patch `$patchPath' to /tmp/nar" if ($? != 0);
+        system "@libexecdir@/bspatch $tmpNar $tmpNar2 $patchPath";
+        die "cannot apply patch `$patchPath' to $tmpNar" if ($? != 0);
 
-        # Unpack the resulting NAR archive into the target path.
-        print "  unpacking patched archive...\n";
-        system "@bindir@/nix-store --restore $v < /tmp/nar2";
-        die "cannot unpack /tmp/nar2 into `$v'" if ($? != 0);
+        if ($curStep < $maxStep) {
+            # The archive will be used as the base of the next patch.
+            rename "$tmpNar2", "$tmpNar" or die "cannot rename NAR archive: $!";
+        } else {
+            # This was the last patch.  Unpack the final NAR archive
+            # into the target path.
+            print "  unpacking patched archive...\n";
+            system "@bindir@/nix-store --restore $v < $tmpNar2";
+            die "cannot unpack $tmpNar2 into `$v'" if ($? != 0);
+        }
     }
 
     elsif ($edge->{type} eq "narfile") {
@@ -251,11 +274,18 @@ while (scalar @path > 0) {
         print "  downloading archive...\n";
         my $narFilePath = downloadFile "$narFile->{url}", "$narFile->{hash}";
 
-        # Unpack the archive into the target path.
-        print "  unpacking archive...\n";
-        system "@bunzip2@ < '$narFilePath' | @bindir@/nix-store --restore '$v'";
-        die "cannot unpack `$narFilePath' into `$v'" if ($? != 0);
+        if ($curStep < $maxStep) {
+            # The archive will be used a base to a patch.
+            system "@bunzip2@ < '$narFilePath' > $tmpNar";
+        } else {
+            # Unpack the archive into the target path.
+            print "  unpacking archive...\n";
+            system "@bunzip2@ < '$narFilePath' | @bindir@/nix-store --restore '$v'";
+            die "cannot unpack `$narFilePath' into `$v'" if ($? != 0);
+        }
     }
+
+    $curStep++;
 }
 
 

scripts/generate-patches.pl.in

@@ -237,10 +237,10 @@ foreach my $p (keys %dstOutPaths) {
             $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";
-                next;
-            }
+#            if ($ratio >= 2) {
+#                print "  SKIPPING $q due to use ratio $ratio ($srcUses $dstUses)\n";
+#                next;
+#            }
 
             # If there are multiple matching names, include the ones
             # with the closest version numbers.
@@ -277,13 +277,25 @@ foreach my $p (keys %dstOutPaths) {
         
         my $srcNarBz2 = getNarBz2 \%srcNarFiles, $closest;
         my $dstNarBz2 = getNarBz2 \%dstNarFiles, $p;
-        
+
+        my $maxNarSize = 150 * 1024 * 1024;
+
         system("@bunzip2@ < $srcNarBz2 > $tmpdir/A") == 0
             or die "cannot unpack $srcNarBz2";
 
+        if ((stat "$tmpdir/A")[7] >= $maxNarSize) {
+            print "    skipping, source is too large\n";
+            next;
+        }
+        
         system("@bunzip2@ < $dstNarBz2 > $tmpdir/B") == 0
             or die "cannot unpack $dstNarBz2";
 
+        if ((stat "$tmpdir/B")[7] >= $maxNarSize) {
+            print "    skipping, destination is too large\n";
+            next;
+        }
+        
         system("@libexecdir@/bsdiff $tmpdir/A $tmpdir/B $tmpdir/DIFF") == 0
             or die "cannot compute binary diff";
 

scripts/nix-build.in

@@ -2,11 +2,6 @@
 
 nixExpr=$1
 
-if test -z "$nixExpr"; then
-    echo "syntax: $0 NIX-EXPR..." >&2
-    exit 1
-fi
-
 extraArgs=
 addDrvLink=0
 addOutLink=1
@@ -16,9 +11,15 @@ trap 'rm -f ./.nix-build-tmp-*' EXIT
 
 
 # Process the arguments.
+exprs=
 for i in "$@"; do
     case "$i" in
-    
+
+        --help)
+            echo "syntax: $0 [NIX-EXPR...]" >&2
+            exit 0
+            ;;
+
         --add-drv-link)
             addDrvLink=1
             ;;
@@ -32,28 +33,37 @@ for i in "$@"; do
             ;;
             
         *)
-            # Instantiate the Nix expression.
-            prefix=
-            if test "$addDrvLink" = 0; then prefix=.nix-build-tmp-; fi
-            storeExprs=$(@bindir@/nix-instantiate \
-                --add-root ./${prefix}derivation --indirect \
-                "$i")
-                
-            for j in $storeExprs; do
-                echo "store expression is $(readlink "$j")" >&2
-            done
-
-            # Build the resulting store derivation.
-            prefix=
-            if test "$addOutLink" = 0; then prefix=.nix-build-tmp-; fi
-            outPaths=$(@bindir@/nix-store \
-                --add-root ./${prefix}result --indirect \
-                -rv $extraArgs $storeExprs)
-                
-            for j in $outPaths; do
-                echo "$(readlink "$j")"
-            done
-            
+            exprs="$exprs $i"
             ;;
     esac
 done
+
+if test -z "$exprs"; then
+    exprs="./default.nix"
+fi
+
+# Process the specified Nix expressions.
+for i in $exprs; do
+
+    # Instantiate the Nix expression.
+    prefix=
+    if test "$addDrvLink" = 0; then prefix=.nix-build-tmp-; fi
+    storeExprs=$(@bindir@/nix-instantiate \
+        --add-root ./${prefix}derivation --indirect \
+        "$i")
+                
+    for j in $storeExprs; do
+        echo "store expression is $(readlink "$j")" >&2
+    done
+
+    # Build the resulting store derivation.
+    prefix=
+    if test "$addOutLink" = 0; then prefix=.nix-build-tmp-; fi
+    outPaths=$(@bindir@/nix-store \
+        --add-root ./${prefix}result --indirect \
+        -rv $extraArgs $storeExprs)
+                
+    for j in $outPaths; do
+        echo "$(readlink "$j")"
+    done
+done            

scripts/prebuilts.conf

@@ -1,2 +0,0 @@
-# A list of URLs from where `nix-pull' obtain Nix archives if
-# no URL is specified on the command line.

src/boost/format/Makefile.am

@@ -1,6 +1,6 @@
-noinst_LIBRARIES = libformat.a
+lib_LTLIBRARIES = libformat.la
 
-libformat_a_SOURCES = format_implementation.cc free_funcs.cc \
+libformat_la_SOURCES = format_implementation.cc free_funcs.cc \
  parsing.cc exceptions.hpp feed_args.hpp format_class.hpp \
  format_fwd.hpp group.hpp internals.hpp internals_fwd.hpp \
  macros_default.hpp

src/boost/shared_ptr.hpp

@@ -324,7 +324,7 @@ public:
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#if 0
 
 private:
 

src/boost/weak_ptr.hpp

@@ -154,7 +154,7 @@ public:
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 
-#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+#if 0
 
 private:
 

src/libexpr/Makefile.am

@@ -1,6 +1,6 @@
-noinst_LIBRARIES = libexpr.a
+lib_LTLIBRARIES = libexpr.la
 
-libexpr_a_SOURCES = nixexpr.cc nixexpr.hh parser.cc parser.hh \
+libexpr_la_SOURCES = nixexpr.cc nixexpr.hh parser.cc parser.hh \
  eval.cc eval.hh primops.cc \
  lexer-tab.c lexer-tab.h parser-tab.c parser-tab.h \
  nixexpr-ast.hh
@@ -33,3 +33,11 @@ nixexpr.cc nixexpr.hh: nixexpr-ast.hh
 
 
 CLEANFILES =
+
+
+# SDF stuff (not built by default).
+nix.tbl: nix.sdf
+	sdf2table -m Nix -s -i nix.sdf -o nix.tbl
+
+test.ast: test.nix nix.tbl
+	sglri -p nix.tbl -i test.nix -o test.ast

src/libexpr/eval.cc

@@ -140,6 +140,15 @@ bool evalBool(EvalState & state, Expr e)
 }
 
 
+ATermList evalList(EvalState & state, Expr e)
+{
+    e = evalExpr(state, e);
+    ATermList list;
+    if (!matchList(e, list)) throw Error("list expected");
+    return list;
+}
+
+
 Expr evalExpr2(EvalState & state, Expr e)
 {
     Expr e1, e2, e3, e4;
@@ -336,6 +345,13 @@ Expr evalExpr2(EvalState & state, Expr e)
         else throw Error("wrong argument types in `+' operator");
     }
 
+    /* List concatenation. */
+    if (matchOpConcat(e, e1, e2)) {
+        ATermList l1 = evalList(state, e1);
+        ATermList l2 = evalList(state, e2);
+        return makeList(ATconcat(l1, l2));
+    }
+
     /* Barf. */
     throw badTerm("invalid expression", e);
 }

src/libexpr/eval.hh

@@ -46,6 +46,7 @@ Expr evalFile(EvalState & state, const Path & path);
 /* Specific results. */
 string evalString(EvalState & state, Expr e);
 Path evalPath(EvalState & state, Expr e);
+ATermList evalList(EvalState & state, Expr e);
 
 /* Print statistics. */
 void printEvalStats(EvalState & state);

src/libexpr/lexer.l

@@ -59,6 +59,7 @@ inherit     { return INHERIT; }
 \|\|        { return OR; }
 \-\>        { return IMPL; }
 \/\/        { return UPDATE; }
+\+\+        { return CONCAT; }
 
 {ID}        { yylval->t = ATmake("<str>", yytext); return ID; /* !!! alloc */ }
 {INT}       { int n = atoi(yytext); /* !!! overflow */

src/libexpr/nix.sdf

@@ -0,0 +1,129 @@
+definition
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Top level syntax.
+
+module Nix
+imports Nix-Exprs Nix-Layout
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Expressions.
+
+module Nix-Exprs
+imports Nix-Lexicals
+exports
+  sorts Expr Formal Bind ExprList
+  context-free start-symbols Expr
+  context-free syntax
+
+    Id | Int | Str | Uri | Path -> Expr {cons("Var")}
+
+    "(" Expr ")" -> Expr {bracket}
+
+    Expr Expr -> Expr {cons("Call"), left}
+
+    Id ":" Expr -> Expr {cons("Function1")}
+    "{" {Formal ","}* "}" ":" Expr -> Expr {cons("Function")}
+    Id -> Formal {cons("NoDefFormal")}
+    Id "?" Expr -> Formal {cons("DefFormal")}
+
+    "assert" Expr ";" Expr -> Expr {cons("Assert")}
+
+    "with" Expr ";" Expr -> Expr {cons("With")}
+
+    "rec" "{" Bind* "}" -> Expr {cons("Rec")}
+    "let" "{" Bind* "}" -> Expr {cons("LetRec")}
+    "{" Bind* "}" -> Expr {cons("Attrs")}
+
+    Id "=" Expr ";" -> Bind {cons("Bind")}
+    "inherit" ("(" Expr ")")? Id* ";" -> Bind {cons("Inherit")}
+
+    "[" ExprList "]" -> Expr {cons("List")}
+    "" -> ExprList {cons("ExprNil")}
+    Expr ExprList -> ExprList {cons("ExprCons")}
+
+    Expr "." Id -> Expr {cons("Select")}
+
+    "if" Expr "then" Expr "else" Expr -> Expr {cons("If")}
+
+    Expr "==" Expr -> Expr {cons("OpEq"), non-assoc}
+    Expr "!=" Expr -> Expr {cons("OpNEq"), non-assoc}
+
+    "!" Expr -> Expr {cons("OpNot")}
+    Expr "&&" Expr -> Expr {cons("OpAnd"), right}
+    Expr "||" Expr -> Expr {cons("OpOr"), right}
+    Expr "->" Expr -> Expr {cons("OpImpl"), right}
+
+    Expr "//" Expr -> Expr {cons("OpUpdate"), right}
+    Expr "~" Expr -> Expr {cons("SubPath"), non-assoc}
+    Expr "?" Id -> Expr {cons("OpHasAttr")}
+    Expr "+" Expr -> Expr {cons("OpPlus"), left}
+
+  context-free priorities
+
+    Expr "." Id -> Expr
+  > Expr ExprList -> ExprList
+  > Expr Expr -> Expr
+  > Expr "~" Expr -> Expr
+  > Expr "?" Id -> Expr
+  > Expr "+" Expr -> Expr
+  > "!" Expr -> Expr
+  > Expr "//" Expr -> Expr
+  > Expr "==" Expr -> Expr
+  > Expr "!=" Expr -> Expr
+  > Expr "&&" Expr -> Expr
+  > Expr "||" Expr -> Expr
+  > Expr "->" Expr -> Expr
+  > "if" Expr "then" Expr "else" Expr -> Expr
+  > "assert" Expr ";" Expr -> Expr
+  > "with" Expr ";" Expr -> Expr
+  > Id ":" Expr -> Expr
+  > "{" {Formal ","}* "}" ":" Expr -> Expr
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Lexical syntax.
+
+module Nix-Lexicals
+exports
+  sorts Id Int Str Path Uri
+  lexical syntax
+    [a-zA-Z\_][a-zA-Z0-9\_\']* -> Id
+    "rec" | "let" | "if" | "then" | "else" | "assert" | "with" | "inherit" -> Id {reject}
+
+    [0-9]+ -> Int
+
+    "\"" ~[\n\"]* "\"" -> Str
+
+    [a-zA-Z0-9\.\_\-\+]* ("/"[a-zA-Z0-9\.\_\-\+]+)+ -> Path
+
+    [a-zA-Z] [a-zA-Z0-9\+\-\.]* ":" [a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']* -> Uri
+
+  lexical restrictions
+    Id -/- [a-zA-Z0-9\_\']
+    Int -/- [0-9]
+    Path -/- [a-zA-Z0-9\.\_\-\+\/]
+    Uri -/- [a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']
+    "rec" "let" "if" "then" "else" "assert" "with" "inherit" -/- [A-Za-z0-9\_\']
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% Layout.
+
+module Nix-Layout
+exports
+  sorts HashComment Asterisk Comment
+  lexical syntax
+    [\ \t\n] -> LAYOUT
+    HashComment -> LAYOUT
+    Comment -> LAYOUT
+    "#" ~[\n]* -> HashComment
+    "/*" ( ~[\*] | Asterisk )* "*/" -> Comment
+    [\*] -> Asterisk
+  lexical restrictions
+    Asterisk -/- [\/]
+    HashComment -/- ~[\n]
+  context-free restrictions
+    LAYOUT? -/- [\ \t\n]

src/libexpr/nixexpr-ast.def

@@ -18,6 +18,7 @@ OpUpdate | Expr Expr | Expr |
 SubPath | Expr Expr | Expr |
 OpHasAttr | Expr string | Expr |
 OpPlus | Expr Expr | Expr |
+OpConcat | Expr Expr | Expr |
 Call | Expr Expr | Expr |
 Select | Expr string | Expr |
 Var | string | Expr |

src/libexpr/nixexpr.cc

@@ -7,6 +7,7 @@
 
 
 ATermMap::ATermMap(unsigned int initialSize, unsigned int maxLoadPct)
+    : table(0)
 {
     this->maxLoadPct = maxLoadPct;
     table = ATtableCreate(initialSize, maxLoadPct);
@@ -16,6 +17,36 @@ ATermMap::ATermMap(unsigned int initialSize, unsigned int maxLoadPct)
 
 ATermMap::ATermMap(const ATermMap & map)
     : table(0)
+{
+    copy(map);
+}
+
+
+ATermMap::~ATermMap()
+{
+    free();
+}
+
+
+ATermMap & ATermMap::operator = (const ATermMap & map)
+{
+    if (this == &map) return *this;
+    free();
+    copy(map);
+    return *this;
+}
+
+
+void ATermMap::free()
+{
+    if (table) {
+        ATtableDestroy(table);
+        table = 0;
+    }
+}
+
+
+void ATermMap::copy(const ATermMap & map)
 {
     ATermList keys = map.keys();
 
@@ -28,12 +59,6 @@ ATermMap::ATermMap(const ATermMap & map)
 }
 
 
-ATermMap::~ATermMap()
-{
-    if (table) ATtableDestroy(table);
-}
-
-
 void ATermMap::set(ATerm key, ATerm value)
 {
     return ATtablePut(table, key, value);
@@ -208,7 +233,12 @@ Expr substitute(const ATermMap & subs, Expr e)
 
     if (matchVar(e, name)) {
         Expr sub = subs.get(name);
-        return sub ? makeClosed(sub) : e;
+        Expr wrapped;
+        /* Add a "closed" wrapper around terms that aren't already
+           closed.  The check is necessary to prevent repeated
+           wrapping, e.g., closed(closed(closed(...))), which kills
+           caching. */
+        return sub ? (matchClosed(sub, wrapped) ? sub : makeClosed(sub)) : e;
     }
 
     /* In case of a function, filter out all variables bound by this

src/libexpr/nixexpr.hh

@@ -29,6 +29,8 @@ public:
     ATermMap(const ATermMap & map);
     ~ATermMap();
 
+    ATermMap & ATermMap::operator = (const ATermMap & map);
+        
     void set(ATerm key, ATerm value);
     void set(const string & key, ATerm value);
 
@@ -46,6 +48,9 @@ public:
 
 private:
     void add(const ATermMap & map, ATermList & keys);
+
+    void free();
+    void copy(const ATermMap & map);
 };
 
 

src/libexpr/parser.y

@@ -64,6 +64,7 @@ static Pos makeCurPos(YYLTYPE * loc, void * data)
 %right UPDATE
 %left NEG
 %left '+'
+%right CONCAT
 %nonassoc '?'
 %nonassoc '~'
 
@@ -102,6 +103,7 @@ expr_op
   | expr_op '~' expr_op { $$ = makeSubPath($1, $3); }
   | expr_op '?' ID { $$ = makeOpHasAttr($1, $3); }
   | expr_op '+' expr_op { $$ = makeOpPlus($1, $3); }
+  | expr_op CONCAT expr_op { $$ = makeOpConcat($1, $3); }
   | expr_app
   ;
 

src/libexpr/primops.cc

@@ -1,3 +1,5 @@
+#include <algorithm>
+
 #include "build.hh"
 #include "eval.hh"
 #include "globals.hh"
@@ -8,11 +10,36 @@
    argument. */ 
 static Expr primImport(EvalState & state, const ATermVector & args)
 {
-    ATerm path;
-    Expr fn = evalExpr(state, args[0]);
-    if (!matchPath(fn, path))
-        throw Error("path expected");
-    return evalFile(state, aterm2String(path));
+    ATermList es;
+    Path path;
+
+    Expr arg = evalExpr(state, args[0]), arg2;
+    
+    if (matchPath(arg, arg2))
+        path = aterm2String(arg2);
+
+    else if (matchAttrs(arg, es)) {
+        Expr a = queryAttr(arg, "type");
+
+        /* If it is a derivation, we have to realise it and load the
+           Nix expression created at the derivation's output path. */
+        if (a && evalString(state, a) == "derivation") {
+            a = queryAttr(arg, "drvPath");
+            if (!a) throw Error("bad derivation in import");
+            Path drvPath = evalPath(state, a);
+
+            buildDerivations(singleton<PathSet>(drvPath));
+ 
+            a = queryAttr(arg, "outPath");
+            if (!a) throw Error("bad derivation in import");
+            path = evalPath(state, a);
+        }
+    }
+
+    if (path == "")
+        throw Error("path or derivation expected in import");
+    
+    return evalFile(state, path);
 }
 
 
@@ -188,14 +215,12 @@ static string concatStrings(const Strings & ss)
    derivation; `drvPath' containing the path of the Nix expression;
    and `type' set to `derivation' to indicate that this is a
    derivation. */
-static Expr primDerivation(EvalState & state, const ATermVector & _args)
+static Expr primDerivationStrict(EvalState & state, const ATermVector & args)
 {
     startNest(nest, lvlVomit, "evaluating derivation");
 
     ATermMap attrs;
-    Expr args = _args[0];
-    args = evalExpr(state, args);
-    queryAllAttrs(args, attrs, true);
+    queryAllAttrs(evalExpr(state, args[0]), attrs, true);
 
     /* Build the derivation expression by processing the attributes. */
     Derivation drv;
@@ -316,10 +341,27 @@ static Expr primDerivation(EvalState & state, const ATermVector & _args)
     state.drvHashes[drvPath] = hashDerivationModulo(state, drv);
 
     /* !!! assumes a single output */
-    attrs.set("outPath", makeAttrRHS(makePath(toATerm(outPath)), makeNoPos()));
-    attrs.set("drvPath", makeAttrRHS(makePath(toATerm(drvPath)), makeNoPos()));
+    ATermMap outAttrs;
+    outAttrs.set("outPath", makeAttrRHS(makePath(toATerm(outPath)), makeNoPos()));
+    outAttrs.set("drvPath", makeAttrRHS(makePath(toATerm(drvPath)), makeNoPos()));
+
+    return makeAttrs(outAttrs);
+}
+
+
+static Expr primDerivationLazy(EvalState & state, const ATermVector & args)
+{
+    Expr eAttrs = evalExpr(state, args[0]);
+    ATermMap attrs;
+    queryAllAttrs(eAttrs, attrs, true);
+
     attrs.set("type", makeAttrRHS(makeStr(toATerm("derivation")), makeNoPos()));
 
+    Expr drvStrict = makeCall(makeVar(toATerm("derivation!")), eAttrs);
+
+    attrs.set("outPath", makeAttrRHS(makeSelect(drvStrict, toATerm("outPath")), makeNoPos()));
+    attrs.set("drvPath", makeAttrRHS(makeSelect(drvStrict, toATerm("drvPath")), makeNoPos()));
+    
     return makeAttrs(attrs);
 }
 
@@ -332,6 +374,14 @@ static Expr primBaseNameOf(EvalState & state, const ATermVector & args)
 }
 
 
+/* Return the directory of the given path, i.e., everything before the
+   last slash. */
+static Expr primDirOf(EvalState & state, const ATermVector & args)
+{
+    return makePath(toATerm(dirOf(evalPath(state, args[0]))));
+}
+
+
 /* Convert the argument (which can be a path or a uri) to a string. */
 static Expr primToString(EvalState & state, const ATermVector & args)
 {
@@ -339,7 +389,7 @@ static Expr primToString(EvalState & state, const ATermVector & args)
     ATerm s;
     if (matchStr(arg, s) || matchPath(arg, s) || matchUri(arg, s))
         return makeStr(s);
-    else throw Error("cannot coerce value to string");
+    throw Error("cannot coerce value to string");
 }
 
 
@@ -370,21 +420,161 @@ static Expr primIsNull(EvalState & state, const ATermVector & args)
 }
 
 
+static Path findDependency(Path dir, string dep)
+{
+    if (dep[0] == '/') throw Error(
+        format("illegal absolute dependency `%1%'") % dep);
+
+    Path p = canonPath(dir + "/" + dep);
+
+    if (pathExists(p))
+        return p;
+    else
+        return "";
+}
+
+
+/* Make path `p' relative to directory `pivot'.  E.g.,
+   relativise("/a/b/c", "a/b/x/y") => "../x/y".  Both input paths
+   should be in absolute canonical form. */
+static string relativise(Path pivot, Path p)
+{
+    assert(pivot.size() > 0 && pivot[0] == '/');
+    assert(p.size() > 0 && p[0] == '/');
+        
+    if (pivot == p) return ".";
+
+    /* `p' is in `pivot'? */
+    Path pivot2 = pivot + "/";
+    if (p.substr(0, pivot2.size()) == pivot2) {
+        return p.substr(pivot2.size());
+    }
+
+    /* Otherwise, `p' is in a parent of `pivot'.  Find up till which
+       path component `p' and `pivot' match, and add an appropriate
+       number of `..' components. */
+    unsigned int i = 1;
+    while (1) {
+        unsigned int j = pivot.find('/', i);
+        if (j == string::npos) break;
+        j++;
+        if (pivot.substr(0, j) != p.substr(0, j)) break;
+        i = j;
+    }
+
+    string prefix;
+    unsigned int slashes = count(pivot.begin() + i, pivot.end(), '/') + 1;
+    while (slashes--) {
+        prefix += "../";
+    }
+
+    return prefix + p.substr(i);
+}
+
+
+static Expr primDependencyClosure(EvalState & state, const ATermVector & args)
+{
+    startNest(nest, lvlDebug, "finding dependencies");
+
+    Expr attrs = evalExpr(state, args[0]);
+
+    /* Get the start set. */
+    Expr startSet = queryAttr(attrs, "startSet");
+    if (!startSet) throw Error("attribute `startSet' required");
+    ATermList startSet2 = evalList(state, startSet);
+
+    Path pivot;
+    PathSet workSet;
+    for (ATermIterator i(startSet2); i; ++i) {
+        Path p = evalPath(state, *i);
+        workSet.insert(p);
+        pivot = dirOf(p);
+    }
+
+    /* Get the search path. */
+    PathSet searchPath;
+    Expr e = queryAttr(attrs, "searchPath");
+    if (e) {
+        ATermList list = evalList(state, e);
+        for (ATermIterator i(list); i; ++i) {
+            Path p = evalPath(state, *i);
+            searchPath.insert(p);
+        }
+    }
+
+    Expr scanner = queryAttr(attrs, "scanner");
+    if (!scanner) throw Error("attribute `scanner' required");
+    
+    /* Construct the dependency closure by querying the dependency of
+       each path in `workSet', adding the dependencies to
+       `workSet'. */
+    PathSet doneSet;
+    while (!workSet.empty()) {
+	Path path = *(workSet.begin());
+	workSet.erase(path);
+
+	if (doneSet.find(path) != doneSet.end()) continue;
+        doneSet.insert(path);
+
+        try {
+            
+            /* Call the `scanner' function with `path' as argument. */
+            debug(format("finding dependencies in `%1%'") % path);
+            ATermList deps = evalList(state, makeCall(scanner, makePath(toATerm(path))));
+
+            /* Try to find the dependencies relative to the `path'. */
+            for (ATermIterator i(deps); i; ++i) {
+                string s = evalString(state, *i);
+                
+                Path dep = findDependency(dirOf(path), s);
+
+                if (dep == "") {
+                    for (PathSet::iterator j = searchPath.begin();
+                         j != searchPath.end(); ++j)
+                    {
+                        dep = findDependency(*j, s);
+                        if (dep != "") break;
+                    }
+                }
+                
+                if (dep == "")
+                    debug(format("did NOT find dependency `%1%'") % s);
+                else {
+                    debug(format("found dependency `%1%'") % dep);
+                    workSet.insert(dep);
+                }
+            }
+
+        } catch (Error & e) {
+            throw Error(format("while finding dependencies in `%1%':\n%2%")
+                % path % e.msg());
+        }
+    }
+
+    /* Return a list of the dependencies we've just found. */
+    ATermList deps = ATempty;
+    for (PathSet::iterator i = doneSet.begin(); i != doneSet.end(); ++i) {
+        deps = ATinsert(deps, makeStr(toATerm(relativise(pivot, *i))));
+        deps = ATinsert(deps, makePath(toATerm(*i)));
+    }
+
+    debug(format("dependency list is `%1%'") % makeList(deps));
+    
+    return makeList(deps);
+}
+
+
 /* Apply a function to every element of a list. */
 static Expr primMap(EvalState & state, const ATermVector & args)
 {
     Expr fun = evalExpr(state, args[0]);
-    Expr list = evalExpr(state, args[1]);
+    ATermList list = evalList(state, args[1]);
 
-    ATermList list2;
-    if (!matchList(list, list2))
-        throw Error("`map' expects a list as its second argument");
+    ATermList res = ATempty;
+    for (ATermIterator i(list); i; ++i)
+        res = ATinsert(res, makeCall(fun, *i));
 
-    ATermList list3 = ATempty;
-    for (ATermIterator i(list2); i; ++i)
-        list3 = ATinsert(list3, makeCall(fun, *i));
-
-    return makeList(ATreverse(list3));
+    return makeList(ATreverse(res));
 }
 
 
@@ -398,18 +588,53 @@ static Expr primCurrentSystem(EvalState & state, const ATermVector & args)
 }
 
 
+static Expr primCurrentTime(EvalState & state, const ATermVector & args)
+{
+    return ATmake("Int(<int>)", time(0));
+}
+
+
+static Expr primRemoveAttrs(EvalState & state, const ATermVector & args)
+{
+    ATermMap attrs;
+    queryAllAttrs(evalExpr(state, args[0]), attrs, true);
+    
+    ATermList list = evalList(state, args[1]);
+
+    for (ATermIterator i(list); i; ++i)
+        /* It's not an error for *i not to exist. */
+        attrs.remove(evalString(state, *i));
+
+    return makeAttrs(attrs);
+}
+
+
+static Expr primRelativise(EvalState & state, const ATermVector & args) 
+{
+    Path pivot = evalPath(state, args[0]);
+    Path path = evalPath(state, args[1]);
+    return makeStr(toATerm(relativise(pivot, path)));
+}
+
+
 void EvalState::addPrimOps()
 {
     addPrimOp("true", 0, primTrue);
     addPrimOp("false", 0, primFalse);
     addPrimOp("null", 0, primNull);
     addPrimOp("__currentSystem", 0, primCurrentSystem);
+    addPrimOp("__currentTime", 0, primCurrentTime);
 
     addPrimOp("import", 1, primImport);
-    addPrimOp("derivation", 1, primDerivation);
+    addPrimOp("derivation!", 1, primDerivationStrict);
+    addPrimOp("derivation", 1, primDerivationLazy);
     addPrimOp("baseNameOf", 1, primBaseNameOf);
+    addPrimOp("dirOf", 1, primDirOf);
     addPrimOp("toString", 1, primToString);
     addPrimOp("isNull", 1, primIsNull);
+    addPrimOp("dependencyClosure", 1, primDependencyClosure);
 
     addPrimOp("map", 2, primMap);
+    addPrimOp("removeAttrs", 2, primRemoveAttrs);
+    addPrimOp("relativise", 2, primRelativise);
 }

src/libmain/Makefile.am

@@ -1,6 +1,6 @@
-noinst_LIBRARIES = libmain.a
+lib_LTLIBRARIES = libmain.la
 
-libmain_a_SOURCES = shared.cc shared.hh
+libmain_la_SOURCES = shared.cc shared.hh
 
 AM_CXXFLAGS = \
  -DNIX_STORE_DIR=\"$(storedir)\" \

src/libstore/Makefile.am

@@ -1,6 +1,6 @@
-noinst_LIBRARIES = libstore.a
+lib_LTLIBRARIES = libstore.la
 
-libstore_a_SOURCES = \
+libstore_la_SOURCES = \
  store.cc store.hh derivations.cc derivations.hh \
  build.cc misc.cc build.hh \
  globals.cc globals.hh db.cc db.hh \

src/libstore/build.cc

@@ -1139,7 +1139,7 @@ void DerivationGoal::computeClosure()
             Hash h2 = recursive ? hashPath(ht, path) : hashFile(ht, path);
             if (h != h2)
                 throw Error(
-                    format("output path `%1% should have %2% hash `%3%', instead has `%4%'")
+                    format("output path `%1%' should have %2% hash `%3%', instead has `%4%'")
                     % path % algo % printHash(h) % printHash(h2));
         }
 
@@ -1149,8 +1149,6 @@ void DerivationGoal::computeClosure()
 	   in it. */
         PathSet references;
         if (!pathExists(path + "/nix-support/no-scan")) {
-            startNest(nest2, lvlChatty,
-                format("scanning for store references in `%1%'") % path);
             Paths references2;
             references2 = filterReferences(path, 
                 Paths(allPaths.begin(), allPaths.end()));
@@ -1167,8 +1165,6 @@ void DerivationGoal::computeClosure()
                 else
                     debug(format("referenced input: `%1%'") % *i);
             }
-            
-            nest2.close();
         }
 
         allReferences[path] = references;

src/libstore/db.cc

@@ -165,127 +165,152 @@ static int my_fsync(int fd)
 }
 
 
-void Database::open(const string & path)
+void Database::open2(const string & path, bool removeOldEnv)
 {
     if (env) throw Error(format("environment already open"));
 
-    try {
-
-        debug(format("opening database environment"));
+    debug(format("opening database environment"));
 
 
-        /* Create the database environment object. */
-        DbEnv * env = 0; /* !!! close on error */
-        env = new DbEnv(0);
-
-        /* Smaller log files. */
-        env->set_lg_bsize(32 * 1024); /* default */
-        env->set_lg_max(256 * 1024); /* must be > 4 * lg_bsize */
-
-        /* Write the log, but don't sync.  This protects transactions
-           against application crashes, but if the system crashes,
-           some transactions may be undone.  An acceptable risk, I
-           think. */
-        env->set_flags(DB_TXN_WRITE_NOSYNC | DB_LOG_AUTOREMOVE, 1);
-
-        /* Increase the locking limits.  If you ever get `Dbc::get:
-           Cannot allocate memory' or similar, especially while
-           running `nix-store --verify', just increase the following
-           number, then run db_recover on the database to remove the
-           existing DB environment (since changes only take effect on
-           new environments). */
-        env->set_lk_max_locks(10000);
-        env->set_lk_max_lockers(10000);
-        env->set_lk_max_objects(10000);
-        env->set_lk_detect(DB_LOCK_DEFAULT);
-
-        /* Dangerous, probably, but from the docs it *seems* that BDB
-           shouldn't sync when DB_TXN_WRITE_NOSYNC is used, but it
-           still fsync()s sometimes. */
-        db_env_set_func_fsync(my_fsync);
+    /* Create the database environment object. */
+    DbEnv * env = 0; /* !!! close on error */
+    env = new DbEnv(0);
+    
+    /* Smaller log files. */
+    env->set_lg_bsize(32 * 1024); /* default */
+    env->set_lg_max(256 * 1024); /* must be > 4 * lg_bsize */
+    
+    /* Write the log, but don't sync.  This protects transactions
+       against application crashes, but if the system crashes, some
+       transactions may be undone.  An acceptable risk, I think. */
+    env->set_flags(DB_TXN_WRITE_NOSYNC | DB_LOG_AUTOREMOVE, 1);
+    
+    /* Increase the locking limits.  If you ever get `Dbc::get: Cannot
+       allocate memory' or similar, especially while running
+       `nix-store --verify', just increase the following number, then
+       run db_recover on the database to remove the existing DB
+       environment (since changes only take effect on new
+       environments). */
+    env->set_lk_max_locks(10000);
+    env->set_lk_max_lockers(10000);
+    env->set_lk_max_objects(10000);
+    env->set_lk_detect(DB_LOCK_DEFAULT);
+    
+    /* Dangerous, probably, but from the docs it *seems* that BDB
+       shouldn't sync when DB_TXN_WRITE_NOSYNC is used, but it still
+       fsync()s sometimes. */
+    db_env_set_func_fsync(my_fsync);
         
 
-        /* The following code provides automatic recovery of the
-           database environment.  Recovery is necessary when a process
-           dies while it has the database open.  To detect this,
-           processes atomically increment a counter when they open the
-           database, and decrement it when they close it.  If we see
-           that counter is > 0 but no processes are accessing the
-           database---determined by attempting to obtain a write lock
-           on a lock file on which all accessors have a read lock---we
-           must run recovery.  Note that this also ensures that we
-           only run recovery when there are no other accessors (which
-           could cause database corruption). */
+    /* The following code provides automatic recovery of the database
+       environment.  Recovery is necessary when a process dies while
+       it has the database open.  To detect this, processes atomically
+       increment a counter when they open the database, and decrement
+       it when they close it.  If we see that counter is > 0 but no
+       processes are accessing the database---determined by attempting
+       to obtain a write lock on a lock file on which all accessors
+       have a read lock---we must run recovery.  Note that this also
+       ensures that we only run recovery when there are no other
+       accessors (which could cause database corruption). */
 
-        /* !!! close fdAccessors / fdLock on exception */
+    /* !!! close fdAccessors / fdLock on exception */
 
-        /* Open the accessor count file. */
-        string accessorsPath = path + "/accessor_count";
-        fdAccessors = ::open(accessorsPath.c_str(), O_RDWR | O_CREAT, 0666);
-        if (fdAccessors == -1)
-            if (errno == EACCES)
-                throw DbNoPermission(
-                    format("permission denied to database in `%1%'") % accessorsPath);
-            else
-                throw SysError(format("opening file `%1%'") % accessorsPath);
-
-        /* Open the lock file. */
-        string lockPath = path + "/access_lock";
-        fdLock = ::open(lockPath.c_str(), O_RDWR | O_CREAT, 0666);
-        if (fdLock == -1)
-            throw SysError(format("opening lock file `%1%'") % lockPath);
-
-        /* Try to acquire a write lock. */
-        debug(format("attempting write lock on `%1%'") % lockPath);
-        if (lockFile(fdLock, ltWrite, false)) { /* don't wait */
-
-            debug(format("write lock granted"));
-
-            /* We have a write lock, which means that there are no
-               other readers or writers. */
-
-            int n = getAccessorCount(fdAccessors);
-
-            if (n != 0) {
-                printMsg(lvlTalkative,
-                    format("accessor count is %1%, running recovery") % n);
-
-                /* Open the environment after running recovery. */
-                openEnv(env, path, DB_RECOVER);
-            }
+    /* Open the accessor count file. */
+    string accessorsPath = path + "/accessor_count";
+    fdAccessors = ::open(accessorsPath.c_str(), O_RDWR | O_CREAT, 0666);
+    if (fdAccessors == -1)
+        if (errno == EACCES)
+            throw DbNoPermission(
+                format("permission denied to database in `%1%'") % accessorsPath);
+        else    
+            throw SysError(format("opening file `%1%'") % accessorsPath);
+    
+    /* Open the lock file. */
+    string lockPath = path + "/access_lock";
+    fdLock = ::open(lockPath.c_str(), O_RDWR | O_CREAT, 0666);
+    if (fdLock == -1)
+        throw SysError(format("opening lock file `%1%'") % lockPath);
+    
+    /* Try to acquire a write lock. */
+    debug(format("attempting write lock on `%1%'") % lockPath);
+    if (lockFile(fdLock, ltWrite, false)) { /* don't wait */
+        
+        debug(format("write lock granted"));
+        
+        /* We have a write lock, which means that there are no other
+           readers or writers. */
+        
+        if (removeOldEnv) {
+            printMsg(lvlError, "removing old Berkeley DB database environment...");
+            env->remove(path.c_str(), DB_FORCE);
+            return;
+        }
+        
+        int n = getAccessorCount(fdAccessors);
+        
+        if (n != 0) {
+            printMsg(lvlTalkative,
+                format("accessor count is %1%, running recovery") % n);
             
-            else 
-                /* Open the environment normally. */
-                openEnv(env, path, 0);
-
-            setAccessorCount(fdAccessors, 1);
-
-            /* Downgrade to a read lock. */
-            debug(format("downgrading to read lock on `%1%'") % lockPath);
-            lockFile(fdLock, ltRead, true);
-
-        } else {
-            /* There are other accessors. */ 
-            debug(format("write lock refused"));
-
-            /* Acquire a read lock. */
-            debug(format("acquiring read lock on `%1%'") % lockPath);
-            lockFile(fdLock, ltRead, true); /* wait indefinitely */
-
-            /* Increment the accessor count. */
-            lockFile(fdAccessors, ltWrite, true);
-            int n = getAccessorCount(fdAccessors) + 1;
-            setAccessorCount(fdAccessors, n);
-            debug(format("incremented accessor count to %1%") % n);
-            lockFile(fdAccessors, ltNone, true);
-
+            /* Open the environment after running recovery. */
+            openEnv(env, path, DB_RECOVER);
+        }
+            
+        else 
             /* Open the environment normally. */
             openEnv(env, path, 0);
-        }
 
-        this->env = env;
+        setAccessorCount(fdAccessors, 1);
+
+        /* Downgrade to a read lock. */
+        debug(format("downgrading to read lock on `%1%'") % lockPath);
+        lockFile(fdLock, ltRead, true);
+
+    } else {
+        /* There are other accessors. */ 
+        debug(format("write lock refused"));
+
+        /* Acquire a read lock. */
+        debug(format("acquiring read lock on `%1%'") % lockPath);
+        lockFile(fdLock, ltRead, true); /* wait indefinitely */
         
-    } catch (DbException e) { rethrow(e); }
+        /* Increment the accessor count. */
+        lockFile(fdAccessors, ltWrite, true);
+        int n = getAccessorCount(fdAccessors) + 1;
+        setAccessorCount(fdAccessors, n);
+        debug(format("incremented accessor count to %1%") % n);
+        lockFile(fdAccessors, ltNone, true);
+        
+        /* Open the environment normally. */
+        openEnv(env, path, 0);
+    }
+    
+    this->env = env;
+}       
+
+
+void Database::open(const string & path)
+{
+    try {
+
+        open2(path, false);
+        
+    } catch (DbException e) {
+        
+        if (e.get_errno() == DB_VERSION_MISMATCH) {
+            /* Remove the environment while we are holding the global
+               lock.  If things go wrong there, we bail out.  !!!
+               there is some leakage here op DbEnv and lock
+               handles. */
+            open2(path, true);
+
+            /* Try again. */
+            open2(path, false);
+        }
+        else
+            rethrow(e);
+    }
+    
 }
 
 

src/libstore/db.hh

@@ -58,6 +58,8 @@ private:
 
     Db * getDb(TableId table);
 
+    void open2(const string & path, bool removeOldEnv);
+    
 public:
     Database();
     ~Database();

src/libstore/gc.cc

@@ -249,7 +249,12 @@ static void findRoots(const Path & path, bool recurseSymlinks,
         if (isInStore(target2)) {
             debug(format("found root `%1%' in `%2%'")
                 % target2 % path);
-            roots.insert(toStorePath(target2));
+            Path target3 = toStorePath(target2);
+            if (isValidPath(target3)) 
+                roots.insert(target3);
+            else
+                printMsg(lvlInfo, format("skipping invalid root from `%1%' to `%2%'")
+                    % path % target3);
         }
 
         else if (recurseSymlinks) {

src/libstore/store.cc

@@ -63,7 +63,7 @@ static TableId dbSubstitutes = 0;
 static TableId dbDerivers = 0;
 
 
-bool Substitute::operator == (const Substitute & sub)
+bool Substitute::operator == (const Substitute & sub) const
 {
     return program == sub.program
         && args == sub.args;
@@ -170,7 +170,7 @@ void copyPath(const Path & src, const Path & dst)
 bool isInStore(const Path & path)
 {
     return path[0] == '/'
-        && path.compare(0, nixStore.size(), nixStore) == 0
+        && string(path, 0, nixStore.size()) == nixStore
         && path.size() >= nixStore.size() + 2
         && path[nixStore.size()] == '/';
 }
@@ -644,7 +644,7 @@ static Path _addToStore(bool fixed, bool recursive,
         
     else dstPath = makeStorePath("source", h, baseName);
 
-    addTempRoot(dstPath);
+    if (!readOnlyMode) addTempRoot(dstPath);
 
     if (!readOnlyMode && !isValidPath(dstPath)) { 
 
@@ -699,7 +699,7 @@ Path addTextToStore(const string & suffix, const string & s,
 
     Path dstPath = makeStorePath("text", hash, suffix);
     
-    addTempRoot(dstPath);
+    if (!readOnlyMode) addTempRoot(dstPath);
 
     if (!readOnlyMode && !isValidPath(dstPath)) {
 
@@ -737,10 +737,10 @@ void deleteFromStore(const Path & _path)
     Transaction txn(nixDB);
     if (isValidPathTxn(txn, path)) {
         PathSet referers = getReferers(txn, path);
-        if (referers.size() > 1 ||
-            (referers.size() == 1 &&
-                *referers.begin() != path))
-            throw Error(format("cannot delete path `%1%' because it is in use") % path);
+        for (PathSet::iterator i = referers.begin();
+             i != referers.end(); ++i)
+            if (*i != path && isValidPathTxn(txn, *i))
+                throw Error(format("cannot delete path `%1%' because it is in use by path `%2%'") % path % *i);
         invalidatePath(txn, path);
     }
     txn.commit();

src/libstore/store.hh

@@ -28,7 +28,7 @@ struct Substitute
        is the store path to be substituted). */
     Strings args;
 
-    bool operator == (const Substitute & sub);
+    bool operator == (const Substitute & sub) const;
 };
 
 typedef list<Substitute> Substitutes;

src/libutil/Makefile.am

@@ -1,6 +1,6 @@
-noinst_LIBRARIES = libutil.a
+lib_LTLIBRARIES = libutil.la
 
-libutil_a_SOURCES = util.cc util.hh hash.cc hash.hh \
+libutil_la_SOURCES = util.cc util.hh hash.cc hash.hh \
  archive.cc archive.hh aterm.cc aterm.hh \
  md5.c md5.h sha1.c sha1.h sha256.c sha256.h md32_common.h
 

src/libutil/md5.h

@@ -21,7 +21,7 @@
 #ifndef _MD5_H
 #define _MD5_H 1
 
-#include <stdint.h>
+#include <inttypes.h>
 typedef uint32_t md5_uint32;
 typedef uintptr_t md5_uintptr;
 

src/libutil/sha1.h

@@ -1,7 +1,7 @@
 #ifndef _SHA_H
 #define _SHA_H
 
-#include <stdint.h>
+#include <inttypes.h>
 
 /* The SHA block size and message digest sizes, in bytes */
 

src/libutil/sha256.h

@@ -1,7 +1,7 @@
 #ifndef _SHA256_H
 #define _SHA256_H 1
 
-#include <stdint.h>
+#include <inttypes.h>
 
 #define SHA_LBLOCK	16
 #define SHA_CBLOCK	(SHA_LBLOCK*4)	/* SHA treats input data as a

src/libutil/util.cc

@@ -688,5 +688,5 @@ bool string2Int(const string & s, int & n)
 {
     istringstream str(s);
     str >> n;
-    return str && str.eof();
+    return str && str.get() == EOF;
 }

src/log2xml/log2html.xsl

@@ -23,12 +23,14 @@
     </html>
   </xsl:template>
 
+  
   <xsl:template match="nest">
 
     <!-- The tree should be collapsed by default if all children are
          unimportant or if the header is unimportant. -->
-    <xsl:variable name="collapsed"
-                  select="count(.//line[not(@priority = 3)]) = 0 or ./head[@priority = 3]" />
+<!--    <xsl:variable name="collapsed"
+                  select="count(.//line[not(@priority = 3)]) = 0 or ./head[@priority = 3]" /> -->
+    <xsl:variable name="collapsed" select="count(.//*[@error]) = 0"/>
                   
     <xsl:variable name="style"><xsl:if test="$collapsed">display: none;</xsl:if></xsl:variable>
     <xsl:variable name="arg"><xsl:choose><xsl:when test="$collapsed">true</xsl:when><xsl:otherwise>false</xsl:otherwise></xsl:choose></xsl:variable>
@@ -52,13 +54,18 @@
       </xsl:for-each>
     </ul>
   </xsl:template>
+
   
   <xsl:template match="head|line">
     <code>
+      <xsl:if test="@error">
+        <xsl:attribute name="class">error</xsl:attribute>
+      </xsl:if>
       <xsl:apply-templates/>
     </code>
   </xsl:template>
 
+  
   <xsl:template match="storeref">
     <em class='storeref'>
       <span class='popup'><xsl:apply-templates/></span>

src/log2xml/log2xml.cc

@@ -117,10 +117,11 @@ void Decoder::finishLine()
     if (priority != 1) cout << " priority='" << priority << "'";
     cout << ">";
 
-    for (int i = 0; i < line.size(); i++) {
+    for (unsigned int i = 0; i < line.size(); i++) {
 
         if (line[i] == '<') cout << "&lt;";
         else if (line[i] == '&') cout << "&amp;";
+        else if (line[i] < 32 && line[i] != 9) cout << "&#xfffd;";
         else if (i + sz + 33 < line.size() &&
             string(line, i, sz) == storeDir &&
             line[i + sz + 32] == '-')

src/log2xml/logfile.css

@@ -78,4 +78,9 @@ em.storeref:hover span.popup {
 .showTree, .hideTree {
     font-family: monospace;
     font-size: larger;
+}
+
+.error {
+    color: #ff0000;
+    font-weight: bold;
 }

src/log2xml/mark-errors.xsl

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+  <xsl:template match="@*|node()">
+    <xsl:copy>
+      <xsl:apply-templates select="@*|node()"/>
+    </xsl:copy>
+  </xsl:template>
+
+  <xsl:template match="line">
+    <line>
+      <xsl:if test="contains(text(), ' *** ') or
+                    contains(text(), 'LaTeX Error') or
+                    contains(text(), 'FAIL:') or
+                    contains(text(), ' error: ') or
+                    true">
+         <xsl:attribute name="error"></xsl:attribute>
+      </xsl:if>
+      <xsl:apply-templates select="@*|node()"/>
+    </line>
+  </xsl:template>
+  
+</xsl:stylesheet>

src/nix-env/Makefile.am

@@ -2,9 +2,9 @@ bin_PROGRAMS = nix-env
 
 nix_env_SOURCES = main.cc names.cc names.hh \
  profiles.cc profiles.hh help.txt
-nix_env_LDADD = ../libmain/libmain.a ../libexpr/libexpr.a \
- ../libstore/libstore.a ../libutil/libutil.a \
- ../boost/format/libformat.a ${bdb_lib} ${aterm_lib}
+nix_env_LDADD = ../libmain/libmain.la ../libexpr/libexpr.la \
+ ../libstore/libstore.la ../libutil/libutil.la \
+ ../boost/format/libformat.la ${bdb_lib} ${aterm_lib}
 
 main.o: help.txt.hh
 

src/nix-env/main.cc

@@ -11,6 +11,7 @@
 
 #include <cerrno>
 #include <ctime>
+#include <algorithm>
 
 
 typedef enum {
@@ -48,13 +49,47 @@ typedef void (* Operation) (Globals & globals,
 
 struct UserEnvElem
 {
+private:
+    string drvPath;
+    string outPath;
+    
+public:
     string name;
     string system;
-    Path drvPath;
-    Path outPath;
+
+    ATermMap attrs;
+
+    string queryDrvPath(EvalState & state) const
+    {
+        if (drvPath == "") {
+            Expr a = attrs.get("drvPath");
+            (string &) drvPath = a ? evalPath(state, a) : "";
+        }
+        return drvPath;
+    }
+    
+    string queryOutPath(EvalState & state) const
+    {
+        if (outPath == "") {
+            Expr a = attrs.get("outPath");
+            if (!a) throw Error("output path missing");
+            (string &) outPath = evalPath(state, a);
+        }
+        return outPath;
+    }
+
+    void setDrvPath(const string & s)
+    {
+        drvPath = s;
+    }
+    
+    void setOutPath(const string & s)
+    {
+        outPath = s;
+    }
 };
 
-typedef map<Path, UserEnvElem> UserEnvElems;
+typedef map<unsigned int, UserEnvElem> UserEnvElems;
 
 
 void printHelp()
@@ -68,30 +103,32 @@ static bool parseDerivation(EvalState & state, Expr e, UserEnvElem & elem)
     ATermList es;
     e = evalExpr(state, e);
     if (!matchAttrs(e, es)) return false;
-    Expr a = queryAttr(e, "type");
+
+    ATermMap attrs;
+    queryAllAttrs(e, attrs, false);
+    
+    Expr a = attrs.get("type");
     if (!a || evalString(state, a) != "derivation") return false;
 
-    a = queryAttr(e, "name");
+    a = attrs.get("name");
     if (!a) throw badTerm("derivation name missing", e);
     elem.name = evalString(state, a);
 
-    a = queryAttr(e, "system");
+    a = attrs.get("system");
     if (!a)
         elem.system = "unknown";
     else
         elem.system = evalString(state, a);
 
-    a = queryAttr(e, "drvPath");
-    if (a) elem.drvPath = evalPath(state, a);
-
-    a = queryAttr(e, "outPath");
-    if (!a) throw badTerm("output path missing", e);
-    elem.outPath = evalPath(state, a);
+    elem.attrs = attrs;
 
     return true;
 }
 
 
+static unsigned int elemCounter = 0;
+
+
 static void parseDerivations(EvalState & state, Expr e, UserEnvElems & elems)
 {
     ATermList es;
@@ -100,15 +137,15 @@ static void parseDerivations(EvalState & state, Expr e, UserEnvElems & elems)
     e = evalExpr(state, e);
 
     if (parseDerivation(state, e, elem)) 
-        elems[elem.outPath] = elem;
+        elems[elemCounter++] = elem;
 
     else if (matchAttrs(e, es)) {
         ATermMap drvMap;
         queryAllAttrs(e, drvMap);
         for (ATermIterator i(drvMap.keys()); i; ++i) {
-            debug(format("evaluating attribute `%1%'") % *i);
+            debug(format("evaluating attribute `%1%'") % aterm2String(*i));
             if (parseDerivation(state, drvMap.get(*i), elem))
-                elems[elem.outPath] = elem;
+                elems[elemCounter++] = elem;
             else
                 parseDerivations(state, drvMap.get(*i), elems);
         }
@@ -118,7 +155,7 @@ static void parseDerivations(EvalState & state, Expr e, UserEnvElems & elems)
         for (ATermIterator i(es); i; ++i) {
             debug(format("evaluating list element"));
             if (parseDerivation(state, *i, elem))
-                elems[elem.outPath] = elem;
+                elems[elemCounter++] = elem;
             else
                 parseDerivations(state, *i, elems);
         }
@@ -199,8 +236,9 @@ static void createUserEnv(EvalState & state, const UserEnvElems & elems,
          i != elems.end(); ++i)
         /* Call to `isDerivation' is for compatibility with Nix <= 0.7
            user environments. */
-        if (i->second.drvPath != "" && isDerivation(i->second.drvPath))
-            drvsToBuild.insert(i->second.drvPath);
+        if (i->second.queryDrvPath(state) != "" &&
+            isDerivation(i->second.queryDrvPath(state)))
+            drvsToBuild.insert(i->second.queryDrvPath(state));
 
     debug(format("building user environment dependencies"));
     buildDerivations(drvsToBuild);
@@ -216,7 +254,7 @@ static void createUserEnv(EvalState & state, const UserEnvElems & elems,
     for (UserEnvElems::const_iterator i = elems.begin(); 
          i != elems.end(); ++i)
     {
-        Path drvPath = keepDerivations ? i->second.drvPath : "";
+        Path drvPath = keepDerivations ? i->second.queryDrvPath(state) : "";
         ATerm t = makeAttrs(ATmakeList5(
             makeBind(toATerm("type"),
                 makeStr(toATerm("derivation")), makeNoPos()),
@@ -227,17 +265,17 @@ static void createUserEnv(EvalState & state, const UserEnvElems & elems,
             makeBind(toATerm("drvPath"),
                 makePath(toATerm(drvPath)), makeNoPos()),
             makeBind(toATerm("outPath"),
-                makePath(toATerm(i->second.outPath)), makeNoPos())
+                makePath(toATerm(i->second.queryOutPath(state))), makeNoPos())
             ));
         manifest = ATinsert(manifest, t);
-        inputs = ATinsert(inputs, makeStr(toATerm(i->second.outPath)));
+        inputs = ATinsert(inputs, makeStr(toATerm(i->second.queryOutPath(state))));
 
         /* This is only necessary when installing store paths, e.g.,
            `nix-env -i /nix/store/abcd...-foo'. */
-        addTempRoot(i->second.outPath);
-        ensurePath(i->second.outPath);
+        addTempRoot(i->second.queryOutPath(state));
+        ensurePath(i->second.queryOutPath(state));
         
-        references.insert(i->second.outPath);
+        references.insert(i->second.queryOutPath(state));
         if (drvPath != "") references.insert(drvPath);
     }
 
@@ -268,11 +306,11 @@ static void createUserEnv(EvalState & state, const UserEnvElems & elems,
     
     /* Realise the resulting store expression. */
     debug(format("building user environment"));
-    buildDerivations(singleton<PathSet>(topLevelDrv.drvPath));
+    buildDerivations(singleton<PathSet>(topLevelDrv.queryDrvPath(state)));
 
     /* Switch the current user environment to the output path. */
     debug(format("switching to new user environment"));
-    Path generation = createGeneration(profile, topLevelDrv.outPath);
+    Path generation = createGeneration(profile, topLevelDrv.queryOutPath(state));
     switchLink(profile, generation);
 }
 
@@ -377,17 +415,17 @@ static void queryInstSources(EvalState & state,
                     name = string(name, dash + 1);
 
                 if (isDerivation(*i)) {
-                    elem.drvPath = *i;
-                    elem.outPath = findOutput(derivationFromPath(*i), "out");
+                    elem.setDrvPath(*i);
+                    elem.setOutPath(findOutput(derivationFromPath(*i), "out"));
                     if (name.size() >= drvExtension.size() &&
                         string(name, name.size() - drvExtension.size()) == drvExtension)
                         name = string(name, 0, name.size() - drvExtension.size());
                 }
-                else elem.outPath = *i;
+                else elem.setOutPath(*i);
 
                 elem.name = name;
 
-                elems[elem.outPath] = elem;
+                elems[elemCounter++] = elem;
             }
             
             break;
@@ -510,7 +548,8 @@ static void upgradeDerivations(Globals & globals,
         }
 
         if (bestElem != availElems.end() &&
-            i->second.outPath != bestElem->second.outPath)
+            i->second.queryOutPath(globals.state) !=
+                bestElem->second.queryOutPath(globals.state))
         {
             printMsg(lvlInfo,
                 format("upgrading `%1%' to `%2%'")
@@ -545,23 +584,27 @@ static void uninstallDerivations(Globals & globals, DrvNames & selectors,
     Path & profile)
 {
     UserEnvElems installedElems = queryInstalled(globals.state, profile);
+    UserEnvElems newElems;
 
     for (UserEnvElems::iterator i = installedElems.begin();
          i != installedElems.end(); ++i)
     {
         DrvName drvName(i->second.name);
+        bool found = false;
         for (DrvNames::iterator j = selectors.begin();
              j != selectors.end(); ++j)
             if (j->matches(drvName)) {
                 printMsg(lvlInfo,
                     format("uninstalling `%1%'") % i->second.name);
-                installedElems.erase(i);
+                found = true;
+                break;
             }
+        if (!found) newElems.insert(*i);
     }
 
     if (globals.dryRun) return;
 
-    createUserEnv(globals.state, installedElems,
+    createUserEnv(globals.state, newElems,
         profile, globals.keepDerivations);
 }
 
@@ -677,10 +720,15 @@ static void opQuery(Globals & globals,
 
     /* We only need to know the installed paths when we are querying
        the status of the derivation. */
-    UserEnvElems installed; /* installed paths */
+    PathSet installed; /* installed paths */
     
-    if (printStatus)
-        installed = queryInstalled(globals.state, globals.profile);
+    if (printStatus) {
+        UserEnvElems installedElems; 
+        installedElems = queryInstalled(globals.state, globals.profile);
+        for (UserEnvElems::iterator i = installedElems.begin();
+             i != installedElems.end(); ++i)
+            installed.insert(i->second.queryOutPath(globals.state));
+    }
             
     /* Print the desired columns. */
     Table table;
@@ -691,11 +739,11 @@ static void opQuery(Globals & globals,
         Strings columns;
         
         if (printStatus) {
-            Substitutes subs = querySubstitutes(noTxn, i->drvPath);
+            Substitutes subs = querySubstitutes(noTxn, i->queryDrvPath(globals.state));
             columns.push_back(
-                (string) (installed.find(i->outPath)
+                (string) (installed.find(i->queryOutPath(globals.state))
                     != installed.end() ? "I" : "-")
-                + (isValidPath(i->outPath) ? "P" : "-")
+                + (isValidPath(i->queryOutPath(globals.state)) ? "P" : "-")
                 + (subs.size() > 0 ? "S" : "-"));
         }
 
@@ -703,10 +751,11 @@ static void opQuery(Globals & globals,
 
         if (printSystem) columns.push_back(i->system);
 
-        if (printDrvPath) columns.push_back(i->drvPath == "" ? "-" : i->drvPath);
+        if (printDrvPath) columns.push_back(
+            i->queryDrvPath(globals.state) == ""
+            ? "-" : i->queryDrvPath(globals.state));
         
-        if (printOutPath) columns.push_back(i->outPath);
-
+        if (printOutPath) columns.push_back(i->queryOutPath(globals.state));
         table.push_back(columns);
     }
 
@@ -871,7 +920,7 @@ static void opDefaultExpr(Globals & globals,
 
 
 static string needArg(Strings::iterator & i,
-    const Strings & args, const string & arg)
+    Strings & args, const string & arg)
 {
     ++i;
     if (i == args.end()) throw UsageError(

src/nix-env/profiles.cc

@@ -4,6 +4,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <errno.h>
+#include <stdio.h>
 
 
 static bool cmpGensByNumber(const Generation & a, const Generation & b)

src/nix-hash/Makefile.am

@@ -1,8 +1,8 @@
 bin_PROGRAMS = nix-hash
 
 nix_hash_SOURCES = nix-hash.cc help.txt
-nix_hash_LDADD = ../libmain/libmain.a ../libstore/libstore.a ../libutil/libutil.a \
- ../boost/format/libformat.a ${bdb_lib} ${aterm_lib}
+nix_hash_LDADD = ../libmain/libmain.la ../libstore/libstore.la ../libutil/libutil.la \
+ ../boost/format/libformat.la ${bdb_lib} ${aterm_lib}
 
 nix-hash.o: help.txt.hh
 

src/nix-hash/help.txt

@@ -6,3 +6,4 @@ files.
   --flat: compute hash of regular file contents, not metadata
   --base32: print hash in base-32 instead of hexadecimal
   --type HASH: use hash algorithm HASH ("md5" (default), "sha1", "sha256")
+  --truncate: truncate the hash to 160 bits

src/nix-hash/nix-hash.cc

@@ -16,12 +16,14 @@ void run(Strings args)
     HashType ht = htMD5;
     bool flat = false;
     bool base32 = false;
+    bool truncate = false;
     
     for (Strings::iterator i = args.begin();
          i != args.end(); i++)
     {
         if (*i == "--flat") flat = true;
         else if (*i == "--base32") base32 = true;
+        else if (*i == "--truncate") truncate = true;
         else if (*i == "--type") {
             ++i;
             if (i == args.end()) throw UsageError("`--type' requires an argument");
@@ -31,6 +33,7 @@ void run(Strings args)
         }
         else {
             Hash h = flat ? hashFile(ht, *i) : hashPath(ht, *i);
+            if (truncate && h.hashSize > 20) h = compressHash(h, 20);
             cout << format("%1%\n") %
                 (base32 ? printHash32(h) : printHash(h));
         }

src/nix-instantiate/Makefile.am

@@ -1,9 +1,9 @@
 bin_PROGRAMS = nix-instantiate
 
 nix_instantiate_SOURCES = main.cc help.txt
-nix_instantiate_LDADD = ../libmain/libmain.a ../libexpr/libexpr.a \
- ../libstore/libstore.a ../libutil/libutil.a \
- ../boost/format/libformat.a ${bdb_lib} ${aterm_lib}
+nix_instantiate_LDADD = ../libmain/libmain.la ../libexpr/libexpr.la \
+ ../libstore/libstore.la ../libutil/libutil.la \
+ ../boost/format/libformat.la ${bdb_lib} ${aterm_lib}
 
 main.o: help.txt.hh
 

src/nix-instantiate/main.cc

@@ -73,6 +73,23 @@ static void printDrvPaths(EvalState & state, Expr e)
         return;
     }
 
+    ATermList formals;
+    ATerm body, pos;
+    if (matchFunction(e, formals, body, pos)) {
+        for (ATermIterator i(formals); i; ++i) {
+            Expr name, def;
+            if (matchNoDefFormal(*i, name))
+                throw Error(format("expression evaluates to a function with no-default arguments (`%1%')")
+                    % aterm2String(name));
+            else if (!matchDefFormal(*i, name, def))
+                abort(); /* can't happen */
+        }
+
+        printDrvPaths(state, evalExpr(state,
+            makeCall(e, makeAttrs(ATermMap()))));
+        return;
+    }
+
     throw Error("expression does not evaluate to one or more derivations");
 }
 

src/nix-store/Makefile.am

@@ -1,8 +1,8 @@
 bin_PROGRAMS = nix-store
 
 nix_store_SOURCES = main.cc dotgraph.cc dotgraph.hh help.txt
-nix_store_LDADD = ../libmain/libmain.a ../libstore/libstore.a ../libutil/libutil.a \
- ../boost/format/libformat.a ${bdb_lib} ${aterm_lib}
+nix_store_LDADD = ../libmain/libmain.la ../libstore/libstore.la ../libutil/libutil.la \
+ ../boost/format/libformat.la ${bdb_lib} ${aterm_lib}
 
 main.o: help.txt.hh
 

src/nix-store/main.cc

@@ -1,4 +1,5 @@
 #include <iostream>
+#include <algorithm>
 
 #include "globals.hh"
 #include "build.hh"

tests/Makefile.am

@@ -40,7 +40,6 @@ gc-concurrent.sh: gc-concurrent.nix gc-concurrent2.nix
 TESTS = init.sh hash.sh lang.sh simple.sh dependencies.sh locking.sh parallel.sh \
   build-hook.sh substitutes.sh substitutes2.sh fallback.sh nix-push.sh gc.sh \
   gc-concurrent.sh verify.sh nix-pull.sh
-#TESTS = init.sh gc.sh
 
 XFAIL_TESTS =
 

tests/init.sh

@@ -56,6 +56,11 @@ for i in \
     chmod +x $i
 done
 
+# Another ugly hack.
+sed "s|^$|PATH=$PATH|" < $NIX_DATA_DIR/nix/corepkgs/nar/nar.sh > tmp
+chmod +x tmp
+mv tmp $NIX_DATA_DIR/nix/corepkgs/nar/nar.sh
+
 # Initialise the database.
 $TOP/src/nix-store/nix-store --init
 

tests/lang/eval-fail-remove.nix

@@ -0,0 +1,5 @@
+let {
+  attrs = {x = 123; y = 456;};
+
+  body = (removeAttrs attrs ["x"]).x;
+}

tests/lang/eval-okay-concat.exp

@@ -0,0 +1 @@
+List([Int(1),Int(2),Int(3),Int(4),Int(5),Int(6),Int(7),Int(8),Int(9)])

tests/lang/eval-okay-concat.nix

@@ -0,0 +1 @@
+[1 2 3] ++ [4 5 6] ++ [7 8 9]

tests/lang/eval-okay-remove.exp

@@ -0,0 +1 @@
+Int(456)

tests/lang/eval-okay-remove.nix

@@ -0,0 +1,5 @@
+let {
+  attrs = {x = 123; y = 456;};
+
+  body = (removeAttrs attrs ["x"]).y;
+}

tests/nix-pull.sh

@@ -34,4 +34,4 @@ cat $outPath/input-2/bar
 
 # Check that the derivers are set properly.
 test $($TOP/src/nix-store/nix-store -q --deriver "$outPath") = "$drvPath"
-$TOP/src/nix-store/nix-store -q --deriver $(readlink $outPath/input-2) | grep -q -- "-input-2.drv" 
+$TOP/src/nix-store/nix-store -q --deriver $(/bin/ls -l $outPath/input-2 | sed 's/.*->\ //') | grep -q -- "-input-2.drv"