Merge from trunk

svn path=/nixpkgs/branches/darwin-updates/; revision=28944

VERSION

@@ -1 +1 @@
-0.13
+0.14

doc/package-notes.xml

@@ -11,7 +11,7 @@ Linux kernel or X.org.</para>
 
 <!--============================================================-->
 
-<section>
+<section xml:id="sec-linux-kernel">
 
 <title>Linux kernel</title>
 
@@ -181,7 +181,7 @@ generator.</para>
 
 <screen>
 $ cd pkgs/servers/x11/xorg
-$ cat tarballs-7.4.list extra.list old.list \
+$ cat tarballs-7.5.list extra.list old.list \
   | perl ./generate-expr-from-tarballs.pl
 </screen>
 
@@ -195,7 +195,7 @@ tarballs between runs.  Pay close attention to the <literal>NOT FOUND:
 run, since they may indicate missing dependencies.  (Some might be
 optional dependencies, however.)</para>
 
-<para>A file like <filename>tarballs-7.4.list</filename> contains all
+<para>A file like <filename>tarballs-7.5.list</filename> contains all
 tarballs in a X.org release.  It can be generated like this:
 
 <screen>

doc/quick-start.xml

@@ -105,7 +105,7 @@ $ svn add pkgs/development/libraries/libfoo/default.nix</screen>
 
         <listitem>
           <para>Thunderbird: <link
-          xlink:href="https://svn.nixos.org/repos/nix/nixpkgs/trunk/pkgs/applications/networking/mailreaders/thunderbird-2.x/default.nix"><filename>pkgs/applications/networking/mailreaders/thunderbird-2.x/default.nix</filename></link>.
+          xlink:href="https://svn.nixos.org/repos/nix/nixpkgs/trunk/pkgs/applications/networking/mailreaders/thunderbird/3.x.nix"><filename>pkgs/applications/networking/mailreaders/thunderbird/3.x.nix</filename></link>.
           Lots of dependencies.</para>
         </listitem>
 

doc/release-notes.xml

@@ -5,6 +5,31 @@
 <title>Nixpkgs Release Notes</title>
 
 
+<section><title>Release 0.13 (February 5, 2010)</title>
+
+<para>As always, there are many changes.  Some of the most important
+updates are:
+
+<itemizedlist>
+
+  <listitem><para>Glibc 2.9.</para></listitem>
+
+  <listitem><para>GCC 4.3.3.</para></listitem>
+
+  <listitem><para>Linux 2.6.32.</para></listitem>
+
+  <listitem><para>X.org 7.5.</para></listitem>
+
+  <listitem><para>KDE 4.3.4.</para></listitem>
+
+</itemizedlist>
+
+</para>
+
+
+</section>
+
+
 <section><title>Release 0.12 (April 24, 2009)</title>
 
 <para>There are way too many additions to Nixpkgs since the last

doc/stdenv.xml

@@ -470,7 +470,7 @@ Additional file types can be supported by setting the
 <section><title>The configure phase</title>
 
 <para>The configure phase prepares the source tree for building.  The
-default <function>unpackPhase</function> runs
+default <function>configurePhase</function> runs
 <filename>./configure</filename> (typically an Autoconf-generated
 script) if it exists.</para>
 
@@ -879,7 +879,7 @@ distribution of the package.  The default
 <function>distPhase</function> first calls <command>make
 dist</command>, then it copies the resulting source tarballs to
 <filename>$out/tarballs/</filename>.  This phase is only executed if
-the attribute <varname>doDist</varname> is not set.</para>
+the attribute <varname>doDist</varname> is set.</para>
 
 <variablelist>
   <title>Variables controlling the distribution phase</title>

maintainers/docs/update-upstream-data.txt

@@ -0,0 +1,14 @@
+Semi-automatic source information updating using "update-upstream-data.sh" script and "src-{,info-}for-*.nix"
+
+1. Recognizing when a pre-existing package uses this mechanism.
+
+Packages using this automatical update mechanism have src-info-for-default.nix and src-for-default.nix next to default.nix. src-info-for-default.nix describes getting the freshest source from upstream web site; src-for-default.nix is a generated file with the current data about used source. Both files define a simple attrSet. 
+
+src-info-for-default.nix (for a file grabbed via http) contains at least downloadPage attribute - it is the page we need to look at to find out the latest version. It also contains baseName that is used for automatical generation of package name containing version. It can contain extra data for trickier cases.
+
+src-for-default.nix will contain advertisedUrl (raw URL chosen on the site; its change prompts regeneration of source data), url for fetchurl, hash, version retrieved from the download URL and suggested package name.
+
+2. Updating a package
+
+nixpkgs/pkgs/build-support/upstream-updater directory contains some scripts. The worker script is called update-upstream-data.sh. This script requires main expression name (e.g. default.nix). It can optionally accpet a second parameter, URL which will be used instead of getting one by parsing the downloadPage (version extraction, mirror URL creation etc. will still be run). After running the script, check src-for-default.nix (or replace default.nix with expression name, if there are seceral expressions in the directory) for new version information.
+

maintainers/scripts/copy-tarballs.sh

@@ -2,7 +2,7 @@
 
 distDir=/data/webserver/tarballs
 
-urls=$(nix-instantiate --eval-only --xml --strict pkgs/top-level/build-for-release.nix \
+urls=$(nix-instantiate --eval-only --xml --strict ./eval-release.nix \
     | grep -A2 'name="urls"' \
     | grep '<string value=' \
     | sed 's/.*"\(.*\)".*/\1/' \

maintainers/scripts/eval-release.nix

@@ -0,0 +1,24 @@
+# Evaluate `release.nix' like Hydra would (i.e. call each job
+# attribute with the expected `system' argument).  Too bad
+# nix-instantiate can't to do this.
+
+let
+
+  lib = (import ../.. {}).lib;
+
+  rel = removeAttrs (import ../../pkgs/top-level/release.nix) [ "tarball" "xbursttools" ];
+
+  seqList = xs: res: lib.fold (x: xs: lib.seq x xs) res xs;
+  
+  strictAttrs = as: seqList (lib.attrValues as) as;
+
+  maybe = as: let y = builtins.tryEval (strictAttrs as); in if y.success then y.value else builtins.trace "FAIL" null;
+
+  call = attrs: lib.flip lib.mapAttrs attrs
+    (n: v: builtins.trace n (
+      if builtins.isFunction v then maybe (v { system = "i686-linux"; })
+      else if builtins.isAttrs v then call v
+      else null
+    ));
+
+in call rel

maintainers/scripts/gnu/gnupdate

@@ -0,0 +1,949 @@
+#!/bin/sh
+# This is actually -*- mode: scheme; coding: utf-8; -*- text.
+main='(module-ref (resolve-module '\''(gnupdate)) '\'gnupdate')'
+exec ${GUILE-guile} -L "$PWD" -l "$0"    \
+         -c "(apply $main (command-line))" "$@"
+!#
+;;; GNUpdate -- Update GNU packages in Nixpkgs.
+;;; Copyright (C) 2010, 2011  Ludovic Courtès <ludo@gnu.org>
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation, either version 3 of the License, or
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+(cond-expand (guile-2 #t)
+             (else (error "GNU Guile 2.0 is required")))
+
+(define-module (gnupdate)
+  #:use-module (sxml ssax)
+  #:use-module (ice-9 popen)
+  #:use-module (ice-9 match)
+  #:use-module (ice-9 rdelim)
+  #:use-module (ice-9 format)
+  #:use-module (ice-9 regex)
+  #:use-module (ice-9 vlist)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-9)
+  #:use-module (srfi srfi-11)
+  #:use-module (srfi srfi-26)
+  #:use-module (srfi srfi-37)
+  #:use-module (system foreign)
+  #:use-module (rnrs bytevectors)
+  #:export (gnupdate))
+
+
+;;;
+;;; SNix.
+;;;
+
+(define-record-type <location>
+  (make-location file line column)
+  location?
+  (file          location-file)
+  (line          location-line)
+  (column        location-column))
+
+(define (->loc line column path)
+  (and line column path
+       (make-location path (string->number line) (string->number column))))
+
+;; Nix object types visible in the XML output of `nix-instantiate' and
+;; mapping to S-expressions (we map to sexps, not records, so that we
+;; can do pattern matching):
+;;
+;;   at               (at varpat attrspat)
+;;   attr             (attribute loc name value)
+;;   attrs            (attribute-set attributes)
+;;   attrspat         (attribute-set-pattern patterns)
+;;   bool             #f|#t
+;;   derivation       (derivation drv-path out-path attributes)
+;;   ellipsis         '...
+;;   expr             (snix loc body ...)
+;;   function         (function loc at|attrspat|varpat)
+;;   int              int
+;;   list             list
+;;   null             'null
+;;   path             string
+;;   string           string
+;;   unevaluated      'unevaluated
+;;   varpat           (varpat name)
+;;
+;; Initially ATTRIBUTES in `derivation' and `attribute-set' was a promise;
+;; however, handling `repeated' nodes makes it impossible to do anything
+;; lazily because the whole SXML tree has to be traversed to maintain the
+;; list of known derivations.
+
+(define (xml-element->snix elem attributes body derivations)
+  ;; Return an SNix element corresponding to XML element ELEM.
+
+  (define (loc)
+    (->loc (assq-ref attributes 'line)
+           (assq-ref attributes 'column)
+           (assq-ref attributes 'path)))
+
+  (case elem
+    ((at)
+     (values `(at ,(car body) ,(cadr body)) derivations))
+    ((attr)
+     (let ((name (assq-ref attributes 'name)))
+       (cond ((null? body)
+              (values `(attribute-pattern ,name) derivations))
+             ((and (pair? body) (null? (cdr body)))
+              (values `(attribute ,(loc) ,name ,(car body))
+                      derivations))
+             (else
+              (error "invalid attribute body" name (loc) body)))))
+    ((attrs)
+     (values `(attribute-set ,(reverse body)) derivations))
+    ((attrspat)
+     (values `(attribute-set-pattern ,body) derivations))
+    ((bool)
+     (values (string-ci=? "true" (assq-ref attributes 'value))
+             derivations))
+    ((derivation)
+     (let ((drv-path (assq-ref attributes 'drvPath))
+           (out-path (assq-ref attributes 'outPath)))
+       (if (equal? body '(repeated))
+           (let ((body (vhash-assoc drv-path derivations)))
+             (if (pair? body)
+                 (values `(derivation ,drv-path ,out-path ,(cdr body))
+                         derivations)
+
+                 ;; DRV-PATH hasn't been encountered yet but may be later
+                 ;; (see <http://article.gmane.org/gmane.linux.distributions.nixos/5946>.)
+                 ;; Return an `unresolved' node.
+                 (values `(unresolved
+                           ,(lambda (derivations)
+                              (let ((body (vhash-assoc drv-path derivations)))
+                                (if (pair? body)
+                                    `(derivation ,drv-path ,out-path
+                                                 ,(cdr body))
+                                    (error "no previous occurrence of derivation"
+                                           drv-path)))))
+                         derivations)))
+           (values `(derivation ,drv-path ,out-path ,body)
+                   (vhash-cons drv-path body derivations)))))
+    ((ellipsis)
+     (values '... derivations))
+    ((expr)
+     (values `(snix ,(loc) ,@body) derivations))
+    ((function)
+     (values `(function ,(loc) ,body) derivations))
+    ((int)
+     (values (string->number (assq-ref attributes 'value))
+             derivations))
+    ((list)
+     (values body derivations))
+    ((null)
+     (values 'null derivations))
+    ((path)
+     (values (assq-ref attributes 'value) derivations))
+    ((repeated)
+     (values 'repeated derivations))
+    ((string)
+     (values (assq-ref attributes 'value) derivations))
+    ((unevaluated)
+     (values 'unevaluated derivations))
+    ((varpat)
+     (values `(varpat ,(assq-ref attributes 'name)) derivations))
+    (else (error "unhandled Nix XML element" elem))))
+
+(define (resolve snix derivations)
+  "Return a new SNix tree where `unresolved' nodes from SNIX have been
+replaced by the result of their application to DERIVATIONS, a vhash."
+  (let loop ((node snix)
+             (seen vlist-null))
+    (if (vhash-assq node seen)
+        (values node seen)
+        (match node
+          (('unresolved proc)
+           (let ((n (proc derivations)))
+             (values n seen)))
+          ((tag body ...)
+           (let ((body+seen (fold (lambda (n body+seen)
+                                    (call-with-values
+                                        (lambda ()
+                                          (loop n (cdr body+seen)))
+                                      (lambda (n* seen)
+                                        (cons (cons n* (car body+seen))
+                                              (vhash-consq n #t seen)))))
+                                  (cons '() (vhash-consq node #t seen))
+                                  body)))
+             (values (cons tag (reverse (car body+seen)))
+                     (vhash-consq node #t (cdr body+seen)))))
+          (anything
+           (values anything seen))))))
+
+(define xml->snix
+  ;; Return the SNix represention of TREE, an SXML tree as returned by
+  ;; parsing the XML output of `nix-instantiate' on Nixpkgs.
+  (let ((parse
+         (ssax:make-parser NEW-LEVEL-SEED
+                           (lambda (elem-gi attributes namespaces expected-content
+                                    seed)
+                             (cons '() (cdr seed)))
+
+                           FINISH-ELEMENT
+                           (lambda (elem-gi attributes namespaces parent-seed
+                                            seed)
+                             (let ((snix        (car seed))
+                                   (derivations (cdr seed)))
+                               (let-values (((snix derivations)
+                                             (xml-element->snix elem-gi
+                                                                attributes
+                                                                snix
+                                                                derivations)))
+                                 (cons (cons snix (car parent-seed))
+                                       derivations))))
+
+                           CHAR-DATA-HANDLER
+                           (lambda (string1 string2 seed)
+                             ;; Discard inter-node strings, which are blanks.
+                             seed))))
+    (lambda (port)
+      (match (parse port (cons '() vlist-null))
+        (((snix) . derivations)
+         (resolve snix derivations))))))
+
+(define (call-with-package snix proc)
+  (match snix
+    (('attribute _ (and attribute-name (? string?))
+                 ('derivation _ _ body))
+     ;; Ugly pattern matching.
+     (let ((meta
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "meta" ('attribute-set metas)) metas)
+                     (_ #f)))
+                 body))
+           (package-name
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "name" (and name (? string?)))
+                      name)
+                     (_ #f)))
+                 body))
+           (location
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute loc "name" (? string?))
+                      loc)
+                     (_ #f)))
+                 body))
+           (src
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "src" src)
+                      src)
+                     (_ #f)))
+                 body)))
+       (proc attribute-name package-name location meta src)))))
+
+(define (call-with-src snix proc)
+  ;; Assume SNIX contains the SNix expression for the value of an `src'
+  ;; attribute, as returned by `call-with-package', and call PROC with the
+  ;; relevant SRC information, or #f if SNIX doesn't match.
+  (match snix
+    (('derivation _ _ body)
+     (let ((name
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "name" (and name (? string?)))
+                      name)
+                     (_ #f)))
+                 body))
+           (output-hash
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "outputHash" (and hash (? string?)))
+                      hash)
+                     (_ #f)))
+                 body))
+           (urls
+            (any (lambda (attr)
+                   (match attr
+                     (('attribute _ "urls" (and urls (? pair?)))
+                      urls)
+                     (_ #f)))
+                 body)))
+       (proc name output-hash urls)))
+    (_ (proc #f #f #f))))
+
+(define (src->values snix)
+  (call-with-src snix values))
+
+(define (attribute-value attribute)
+  ;; Return the value of ATTRIBUTE.
+  (match attribute
+    (('attribute _ _ value) value)))
+
+(define (derivation-source derivation)
+  ;; Return the "src" attribute of DERIVATION or #f if not found.
+  (match derivation
+    (('derivation _ _ (attributes ...))
+     (find-attribute-by-name "src" attributes))))
+
+(define (derivation-output-path derivation)
+  ;; Return the output path of DERIVATION.
+  (match derivation
+    (('derivation _ out-path _)
+     out-path)
+    (_ #f)))
+
+(define (source-output-path src)
+  ;; Return the output path of SRC, the "src" attribute of a derivation.
+  (derivation-output-path (attribute-value src)))
+
+(define (derivation-source-output-path derivation)
+  ;; Return the output path of the "src" attribute of DERIVATION or #f if
+  ;; DERIVATION lacks an "src" attribute.
+  (and=> (derivation-source derivation) source-output-path))
+
+(define (open-nixpkgs nixpkgs)
+  (let ((script  (string-append nixpkgs
+                                "/maintainers/scripts/eval-release.nix")))
+    (open-pipe* OPEN_READ "nix-instantiate"
+                "--strict" "--eval-only" "--xml"
+                script)))
+
+(define (pipe-failed? pipe)
+  "Close pipe and return its status if it failed."
+  (let ((status (close-pipe pipe)))
+    (if (or (status:term-sig status)
+            (not (= (status:exit-val status) 0)))
+        status
+        #f)))
+
+(define (nix-prefetch-url url)
+  ;; Download URL in the Nix store and return the base32-encoded SHA256 hash
+  ;; of the file at URL
+  (let* ((pipe (open-pipe* OPEN_READ "nix-prefetch-url" url))
+         (hash (read-line pipe)))
+    (if (or (pipe-failed? pipe)
+            (eof-object? hash))
+        (values #f #f)
+        (let* ((pipe (open-pipe* OPEN_READ "nix-store" "--print-fixed-path"
+                                   "sha256" hash (basename url)))
+               (path (read-line pipe)))
+          (if (or (pipe-failed? pipe)
+                  (eof-object? path))
+              (values #f #f)
+              (values (string-trim-both hash) (string-trim-both path)))))))
+
+(define (update-nix-expression file
+                               old-version old-hash
+                               new-version new-hash)
+  ;; Modify FILE in-place.  Ugly: we call out to sed(1).
+  (let ((cmd (format #f "sed -i \"~a\" -e 's/~A/~a/g ; s/~A/~A/g'"
+                     file
+                     (regexp-quote old-version) new-version
+                     old-hash
+                     (or new-hash "new hash not available, check the log"))))
+    (format #t "running `~A'...~%" cmd)
+    (system cmd)))
+
+(define (find-attribute-by-name name attributes)
+  ;; Return attribute NAME in ATTRIBUTES, a list of SNix attributes, or #f if
+  ;; NAME cannot be found.
+  (find (lambda (a)
+          (match a
+            (('attribute _ (? (cut string=? <> name)) _)
+             a)
+            (_ #f)))
+        attributes))
+
+(define (find-package-by-attribute-name name packages)
+  ;; Return the package bound to attribute NAME in PACKAGES, a list of
+  ;; packages (SNix attributes), or #f if NAME cannot be found.
+  (find (lambda (package)
+          (match package
+            (('attribute _ (? (cut string=? <> name))
+                         ('derivation _ _ _))
+             package)
+            (_ #f)))
+        packages))
+
+(define (stdenv-package packages)
+  ;; Return the `stdenv' package from PACKAGES, a list of SNix attributes.
+  (find-package-by-attribute-name "stdenv" packages))
+
+(define (package-requisites package)
+  ;; Return the list of derivations required to build PACKAGE (including that
+  ;; of PACKAGE) by recurring into its derivation attributes.
+  (let loop ((snix   package)
+             (result '()))
+    (match snix
+      (('attribute _ _ body)
+       (loop body result))
+      (('derivation _ out-path body)
+       (if (any (lambda (d)
+                  (match d
+                    (('derivation _ (? (cut string=? out-path <>)) _) #t)
+                    (_ #f)))
+                result)
+           result
+           (loop body (cons snix result))))
+      ((things ...)
+       (fold loop result things))
+      (_ result))))
+
+(define (package-source-output-path package)
+  ;; Return the output path of the "src" derivation of PACKAGE.
+  (derivation-source-output-path (attribute-value package)))
+
+
+;;;
+;;; FTP client.
+;;;
+
+(define-record-type <ftp-connection>
+  (%make-ftp-connection socket addrinfo)
+  ftp-connection?
+  (socket    ftp-connection-socket)
+  (addrinfo  ftp-connection-addrinfo))
+
+(define %ftp-ready-rx
+  (make-regexp "^([0-9]{3}) (.+)$"))
+
+(define (%ftp-listen port)
+  (let loop ((line (read-line port)))
+    (cond ((eof-object? line) (values line #f))
+          ((regexp-exec %ftp-ready-rx line)
+           =>
+           (lambda (match)
+             (values (string->number (match:substring match 1))
+                     (match:substring match 2))))
+          (else
+           (loop (read-line port))))))
+
+(define (%ftp-command command expected-code port)
+  (format port "~A~A~A" command (string #\return) (string #\newline))
+  (let-values (((code message) (%ftp-listen port)))
+    (if (eqv? code expected-code)
+        message
+        (throw 'ftp-error port command code message))))
+
+(define (%ftp-login user pass port)
+  (let ((command (string-append "USER " user (string #\newline))))
+    (display command port)
+    (let-values (((code message) (%ftp-listen port)))
+      (case code
+        ((230)  #t)
+        ((331) (%ftp-command (string-append "PASS " pass) 230 port))
+        (else  (throw 'ftp-error port command code message))))))
+
+(define (ftp-open host)
+  (catch 'getaddrinfo-error
+    (lambda ()
+      (let* ((ai (car (getaddrinfo host "ftp")))
+             (s  (socket (addrinfo:fam ai) (addrinfo:socktype ai)
+                         (addrinfo:protocol ai))))
+        (connect s (addrinfo:addr ai))
+        (setvbuf s _IOLBF)
+        (let-values (((code message) (%ftp-listen s)))
+          (if (eqv? code 220)
+              (begin
+                ;(%ftp-command "OPTS UTF8 ON" 200 s)
+                (%ftp-login "anonymous" "ludo@example.com" s)
+                (%make-ftp-connection s ai))
+              (begin
+                (format (current-error-port) "FTP to `~a' failed: ~A: ~A~%"
+                        host code message)
+                (close s)
+                #f)))))
+    (lambda (key errcode)
+      (format (current-error-port) "failed to resolve `~a': ~a~%"
+              host (gai-strerror errcode))
+      #f)))
+
+(define (ftp-close conn)
+  (close (ftp-connection-socket conn)))
+
+(define (ftp-chdir conn dir)
+  (%ftp-command (string-append "CWD " dir) 250
+                (ftp-connection-socket conn)))
+
+(define (ftp-pasv conn)
+  (define %pasv-rx
+    (make-regexp "([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+)"))
+
+  (let ((message (%ftp-command "PASV" 227 (ftp-connection-socket conn))))
+    (cond ((regexp-exec %pasv-rx message)
+           =>
+           (lambda (match)
+             (+ (* (string->number (match:substring match 5)) 256)
+                (string->number (match:substring match 6)))))
+          (else
+           (throw 'ftp-error conn "PASV" 227 message)))))
+
+
+(define* (ftp-list conn #:optional directory)
+  (define (address-with-port sa port)
+    (let ((fam  (sockaddr:fam sa))
+          (addr (sockaddr:addr sa)))
+      (cond ((= fam AF_INET)
+             (make-socket-address fam addr port))
+            ((= fam AF_INET6)
+             (make-socket-address fam addr port
+                                  (sockaddr:flowinfo sa)
+                                  (sockaddr:scopeid sa)))
+            (else #f))))
+
+  (if directory
+      (ftp-chdir conn directory))
+
+  (let* ((port (ftp-pasv conn))
+         (ai   (ftp-connection-addrinfo conn))
+         (s    (socket (addrinfo:fam ai) (addrinfo:socktype ai)
+                       (addrinfo:protocol ai))))
+    (connect s (address-with-port (addrinfo:addr ai) port))
+    (setvbuf s _IOLBF)
+
+    (dynamic-wind
+      (lambda () #t)
+      (lambda ()
+        (%ftp-command "LIST" 150 (ftp-connection-socket conn))
+
+        (let loop ((line   (read-line s))
+                   (result '()))
+          (cond ((eof-object? line) (reverse result))
+                ((regexp-exec %ftp-ready-rx line)
+                 =>
+                 (lambda (match)
+                   (let ((code (string->number (match:substring match 1))))
+                     (if (= 126 code)
+                         (reverse result)
+                         (throw 'ftp-error conn "LIST" code)))))
+                (else
+                 (loop (read-line s)
+                       (match (reverse (string-tokenize line))
+                         ((file _ ... permissions)
+                          (let ((type (case (string-ref permissions 0)
+                                        ((#\d) 'directory)
+                                        (else 'file))))
+                            (cons (list file type) result)))
+                         ((file _ ...)
+                          (cons (cons file 'file) result))))))))
+      (lambda ()
+        (close s)
+        (let-values (((code message) (%ftp-listen (ftp-connection-socket conn))))
+          (or (eqv? code 226)
+              (throw 'ftp-error conn "LIST" code message)))))))
+
+
+;;;
+;;; GNU.
+;;;
+
+(define %ignored-package-attributes
+  ;; Attribute name of packages to be ignored.
+  '("bash" "bashReal" "bashInteractive" ;; the full versioned name is incorrect
+    "autoconf213"
+    "automake17x"
+    "automake19x"
+    "automake110x"
+    "bison1875"
+    "bison23"
+    "bison24"
+    "bison" ;; = 2.4
+    "ccrtp_1_8"
+    "emacs22"
+    "emacsSnapshot"
+    "gcc295"
+    "gcc33"
+    "gcc34"
+    "gcc40"
+    "gcc41"
+    "gcc42"
+    "gcc43"
+    "gcc44"
+    "gcc45"
+    "gcc45_real"
+    "gcc45_realCross"
+    "gfortran45"
+    "gcj45"
+    "gcc46"
+    "gcc46_real"
+    "gcc46_realCross"
+    "gfortran46"
+    "gcj46"
+    "glibc25"
+    "glibc27"
+    "glibc29"
+    "guile_1_8"
+    "icecat3Xul" ;; redundant with `icecat'
+    "icecatWrapper"
+    "icecatXulrunner3"
+    "libzrtpcpp_1_6"
+    "parted_2_3"
+    ))
+
+(define (gnu? package)
+  ;; Return true if PACKAGE (a snix expression) is a GNU package (according
+  ;; to a simple heuristic.)  Otherwise return #f.
+  (match package
+    (('attribute _ _ ('derivation _ _ body))
+     (any (lambda (attr)
+            (match attr
+              (('attribute _ "meta" ('attribute-set metas))
+               (any (lambda (attr)
+                      (match attr
+                        (('attribute _ "description" value)
+                         (string-prefix? "GNU" value))
+                        (('attribute _ "homepage" value)
+                         (string-contains value "www.gnu.org"))
+                        (_ #f)))
+                    metas))
+              (_ #f)))
+          body))
+    (_ #f)))
+
+(define (gnu-packages packages)
+  (fold (lambda (package gnu)
+          (match package
+            (('attribute _ "emacs23Packages" emacs-packages)
+             ;; XXX: Should prepend `emacs23Packages.' to attribute names.
+             (append (gnu-packages emacs-packages) gnu))
+            (('attribute _ attribute-name ('derivation _ _ body))
+             (if (member attribute-name %ignored-package-attributes)
+                 gnu
+                 (if (gnu? package)
+                     (cons package gnu)
+                     gnu)))
+            (_ gnu)))
+        '()
+        packages))
+
+(define (ftp-server/directory project)
+  (define quirks
+    '(("commoncpp2"   "ftp.gnu.org"   "/gnu/commoncpp" #f)
+      ("ucommon"      "ftp.gnu.org"   "/gnu/commoncpp" #f)
+      ("libzrtpcpp"   "ftp.gnu.org"   "/gnu/ccrtp" #f)
+      ("libosip2"     "ftp.gnu.org"   "/gnu/osip" #f)
+      ("libgcrypt"    "ftp.gnupg.org" "/gcrypt" #t)
+      ("libgpg-error" "ftp.gnupg.org" "/gcrypt" #t)
+      ("freefont-ttf" "ftp.gnu.org"   "/gnu/freefont" #f)
+      ("gnupg"        "ftp.gnupg.org" "/gcrypt" #t)
+      ("gnu-ghostscript" "ftp.gnu.org"  "/gnu/ghostscript" #f)
+      ("GNUnet"       "ftp.gnu.org" "/gnu/gnunet" #f)
+      ("mit-scheme"   "ftp.gnu.org" "/gnu/mit-scheme/stable.pkg" #f)
+      ("icecat"       "ftp.gnu.org" "/gnu/gnuzilla" #f)
+      ("source-highlight" "ftp.gnu.org" "/gnu/src-highlite" #f)
+      ("TeXmacs"      "ftp.texmacs.org" "/TeXmacs/targz" #f)))
+
+  (let ((quirk (assoc project quirks)))
+    (match quirk
+      ((_ server directory subdir?)
+       (values server (if (not subdir?)
+                          directory
+                          (string-append directory "/" project))))
+      (_
+       (values "ftp.gnu.org" (string-append "/gnu/" project))))))
+
+(define (nixpkgs->gnu-name project)
+  (define quirks
+    '(("gcc-wrapper" . "gcc")
+      ("ghostscript" . "gnu-ghostscript") ;; ../ghostscript/gnu-ghoscript-X.Y.tar.gz
+      ("gnum4"       . "m4")
+      ("gnugrep"     . "grep")
+      ("gnumake"     . "make")
+      ("gnused"      . "sed")
+      ("gnutar"      . "tar")
+      ("gnunet"      . "GNUnet") ;; ftp.gnu.org/gnu/gnunet/GNUnet-x.y.tar.gz
+      ("mitscheme"   . "mit-scheme")
+      ("texmacs"     . "TeXmacs")))
+
+  (or (assoc-ref quirks project) project))
+
+(define (releases project)
+  "Return the list of releases of PROJECT as a list of release name/directory
+pairs.  Example: (\"mit-scheme-9.0.1\" . \"/gnu/mit-scheme/stable.pkg/9.0.1\"). "
+  ;; TODO: Parse something like fencepost.gnu.org:/gd/gnuorg/packages-ftp.
+  (define release-rx
+    (make-regexp (string-append "^" project
+                                "-([0-9]|[^-])*(-src)?\\.tar\\.")))
+
+  (define alpha-rx
+    (make-regexp "^.*-.*[0-9](-|~)?(alpha|beta|rc|cvs|svn|git)-?[0-9\\.]*\\.tar\\."))
+
+  (define (sans-extension tarball)
+    (let ((end (string-contains tarball ".tar")))
+      (substring tarball 0 end)))
+
+  (catch 'ftp-error
+    (lambda ()
+      (let-values (((server directory) (ftp-server/directory project)))
+        (define conn (ftp-open server))
+
+        (let loop ((directories (list directory))
+                   (result      '()))
+          (if (null? directories)
+              (begin
+                (ftp-close conn)
+                result)
+              (let* ((directory (car directories))
+                     (files     (ftp-list conn directory))
+                     (subdirs   (filter-map (lambda (file)
+                                              (match file
+                                                ((name 'directory . _) name)
+                                                (_ #f)))
+                                            files)))
+                (loop (append (map (cut string-append directory "/" <>)
+                                   subdirs)
+                              (cdr directories))
+                      (append
+                       ;; Filter out signatures, deltas, and files which are potentially
+                       ;; not releases of PROJECT (e.g., in /gnu/guile, filter out
+                       ;; guile-oops and guile-www; in mit-scheme, filter out
+                       ;; binaries).
+                       (filter-map (lambda (file)
+                                     (match file
+                                       ((file 'file . _)
+                                        (and (not (string-suffix? ".sig" file))
+                                             (regexp-exec release-rx file)
+                                             (not (regexp-exec alpha-rx file))
+                                             (let ((s (sans-extension file)))
+                                               (and (regexp-exec
+                                                     %package-name-rx s)
+                                                    (cons s directory)))))
+                                       (_ #f)))
+                                   files)
+                       result)))))))
+    (lambda (key subr message . args)
+      (format (current-error-port)
+              "failed to get release list for `~A': ~S ~S~%"
+              project message args)
+      '())))
+
+(define version-string>?
+  (let ((strverscmp
+         (let ((sym (or (dynamic-func "strverscmp" (dynamic-link))
+                        (error "could not find `strverscmp' (from GNU libc)"))))
+           (pointer->procedure int sym (list '* '*)))))
+    (lambda (a b)
+      (> (strverscmp (string->pointer a) (string->pointer b)) 0))))
+
+(define (latest-release project)
+  "Return (\"FOO-X.Y\" . \"/bar/foo\") or #f."
+  (let ((releases (releases project)))
+    (and (not (null? releases))
+         (fold (lambda (release latest)
+                 (if (version-string>? (car release) (car latest))
+                     release
+                     latest))
+               '("" . "")
+               releases))))
+
+(define %package-name-rx
+  ;; Regexp for a package name, e.g., "foo-X.Y".  Since TeXmacs uses
+  ;; "TeXmacs-X.Y-src", the `-src' suffix is allowed.
+  (make-regexp "^(.*)-(([0-9]|\\.)+)(-src)?"))
+
+(define (package/version name+version)
+  "Return the package name and version number extracted from NAME+VERSION."
+  (let ((match (regexp-exec %package-name-rx name+version)))
+    (if (not match)
+        (values name+version #f)
+        (values (match:substring match 1) (match:substring match 2)))))
+
+(define (file-extension file)
+  (let ((dot (string-rindex file #\.)))
+    (and dot (substring file (+ 1 dot) (string-length file)))))
+
+(define (packages-to-update gnu-packages)
+  (define (unpack latest)
+    (call-with-values (lambda ()
+                        (package/version (car latest)))
+      (lambda (name version)
+        (list name version (cdr latest)))))
+
+  (fold (lambda (pkg result)
+          (call-with-package pkg
+            (lambda (attribute name+version location meta src)
+              (let-values (((name old-version)
+                            (package/version name+version)))
+                (let ((latest (latest-release (nixpkgs->gnu-name name))))
+                  (if (not latest)
+                      (begin
+                        (format #t "~A [unknown latest version]~%"
+                                name+version)
+                        result)
+                      (match (unpack latest)
+                        ((_ (? (cut string=? old-version <>)) _)
+                         (format #t "~A [up to date]~%" name+version)
+                         result)
+                        ((project new-version directory)
+                         (let-values (((old-name old-hash old-urls)
+                                       (src->values src)))
+                           (format #t "~A -> ~A [~A]~%"
+                                   name+version (car latest)
+                                   (and (pair? old-urls) (car old-urls)))
+                           (let* ((url      (and (pair? old-urls)
+                                                 (car old-urls)))
+                                  (new-hash (fetch-gnu project directory
+                                                       new-version
+                                                       (if url
+                                                           (file-extension url)
+                                                           "gz"))))
+                             (cons (list name attribute
+                                         old-version old-hash
+                                         new-version new-hash
+                                         location)
+                                   result)))))))))))
+        '()
+        gnu-packages))
+
+(define (fetch-gnu project directory version archive-type)
+  (let* ((server  (ftp-server/directory project))
+         (base    (string-append project "-" version ".tar." archive-type))
+         (url     (string-append "ftp://" server "/" directory "/" base))
+         (sig     (string-append base ".sig"))
+         (sig-url (string-append url ".sig")))
+    (let-values (((hash path) (nix-prefetch-url url)))
+      (pk 'prefetch-url url hash path)
+      (and hash path
+           (begin
+             (false-if-exception (delete-file sig))
+             (system* "wget" sig-url)
+             (if (file-exists? sig)
+                 (let ((ret (system* "gpg" "--verify" sig path)))
+                   (false-if-exception (delete-file sig))
+                   (if (and ret (= 0 (status:exit-val ret)))
+                       hash
+                       (begin
+                         (format (current-error-port)
+                                 "signature verification failed for `~a'~%"
+                                 base)
+                         (format (current-error-port)
+                                 "(could be because the public key is not in your keyring)~%")
+                         #f)))
+                 (begin
+                   (format (current-error-port)
+                           "no signature for `~a'~%" base)
+                   hash)))))))
+
+
+;;;
+;;; Main program.
+;;;
+
+(define %options
+  ;; Specifications of the command-line options.
+  (list (option '(#\h "help") #f #f
+                (lambda (opt name arg result)
+                  (format #t "Usage: gnupdate [OPTIONS...]~%")
+                  (format #t "GNUpdate -- update Nix expressions of GNU packages in Nixpkgs~%")
+                  (format #t "~%")
+                  (format #t "  -x, --xml=FILE      Read XML output of `nix-instantiate'~%")
+                  (format #t "                      from FILE.~%")
+                  (format #t "  -s, --select=SET    Update only packages from SET, which may~%")
+                  (format #t "                      be either `all', `stdenv', or `non-stdenv'.~%")
+                  (format #t "  -d, --dry-run       Don't actually update Nix expressions~%")
+                  (format #t "  -h, --help          Give this help list.~%~%")
+                  (format #t "Report bugs to <ludo@gnu.org>~%")
+                  (exit 0)))
+        (option '(#\s "select") #t #f
+                (lambda (opt name arg result)
+                  (cond ((string-ci=? arg "stdenv")
+                         (alist-cons 'filter 'stdenv result))
+                        ((string-ci=? arg "non-stdenv")
+                         (alist-cons 'filter 'non-stdenv result))
+                        ((string-ci=? arg "all")
+                         (alist-cons 'filter #f result))
+                        (else
+                         (format (current-error-port)
+                                 "~A: unrecognized selection type~%"
+                                 arg)
+                         (exit 1)))))
+
+        (option '(#\d "dry-run") #f #f
+                (lambda (opt name arg result)
+                  (alist-cons 'dry-run #t result)))
+
+        (option '(#\x "xml") #t #f
+                (lambda (opt name arg result)
+                  (alist-cons 'xml-file arg result)))))
+
+(define (gnupdate . args)
+  ;; Assume Nixpkgs is under $NIXPKGS or ~/src/nixpkgs.
+
+  (define (nixpkgs->snix xml-file)
+    (format (current-error-port) "evaluating Nixpkgs...~%")
+    (let* ((home (getenv "HOME"))
+           (xml  (if xml-file
+                     (open-input-file xml-file)
+                     (open-nixpkgs (or (getenv "NIXPKGS")
+                                       (string-append home "/src/nixpkgs")))))
+           (snix (xml->snix xml)))
+      (if (not xml-file)
+          (let ((status (pipe-failed? xml)))
+            (if status
+                (begin
+                  (format (current-error-port) "`nix-instantiate' failed: ~A~%"
+                          status)
+                  (exit 1)))))
+      snix))
+
+  (let* ((opts      (args-fold (cdr args) %options
+                               (lambda (opt name arg result)
+                                 (error "unrecognized option `~A'" name))
+                               (lambda (operand result)
+                                 (error "extraneous argument `~A'" operand))
+                               '()))
+         (snix      (nixpkgs->snix (assoc-ref opts 'xml-file)))
+         (packages  (match snix
+                      (('snix _ ('attribute-set attributes))
+                       attributes)
+                      (_ #f)))
+         (stdenv    (delay
+                      ;; The source tarballs that make up stdenv.
+                      (filter-map derivation-source-output-path
+                                  (package-requisites (stdenv-package packages)))))
+         (gnu       (gnu-packages packages))
+         (gnu*      (case (assoc-ref opts 'filter)
+                      ;; Filter out packages that are/aren't in `stdenv'.  To
+                      ;; do that reliably, we check whether their "src"
+                      ;; derivation is a requisite of stdenv.
+                      ((stdenv)
+                       (filter (lambda (p)
+                                 (member (package-source-output-path p)
+                                         (force stdenv)))
+                               gnu))
+                      ((non-stdenv)
+                       (filter (lambda (p)
+                                 (not (member (package-source-output-path p)
+                                              (force stdenv))))
+                               gnu))
+                      (else gnu)))
+         (updates   (packages-to-update gnu*)))
+
+    (format #t "~%~A packages to update...~%" (length updates))
+    (for-each (lambda (update)
+                (match update
+                  ((name attribute
+                    old-version old-hash
+                    new-version new-hash
+                    location)
+                   (if (assoc-ref opts 'dry-run)
+                       (format #t "`~a' would be updated from ~a to ~a (~a -> ~a)~%"
+                               name old-version new-version
+                               old-hash new-hash)
+                       (update-nix-expression (location-file location)
+                                              old-version old-hash
+                                              new-version new-hash)))
+                  (_ #f)))
+              updates)
+    #t))
+
+;;; Local Variables:
+;;; eval: (put 'call-with-package 'scheme-indent-function 1)
+;;; End:

maintainers/scripts/hydra_eval_check

@@ -0,0 +1,13 @@
+#! /bin/sh
+
+# give absolute path of release.nix as argument
+hydra_eval_jobs \
+  --argstr system x86_64-linux \
+  --argstr system i686-linux \
+  --argstr system x86_64-darwin \
+  --argstr system i686-darwin \
+  --argstr system i686-cygwin \
+  --argstr system i686-freebsd \
+  --arg officialRelease false \
+  --arg nixpkgs "{ outPath = builtins.storePath ./. ; rev = 1234; }" \
+  $@

maintainers/scripts/nix-call-package

@@ -0,0 +1,5 @@
+#! /bin/sh
+
+echo "let pkgs = import /etc/nixos/nixpkgs$2 {}; x = pkgs.callPackage $1 { $3 }; in ${4:-x}" |
+nix-instantiate --show-trace - |
+xargs nix-store -r -K

maintainers/scripts/test-eval-release.sh

@@ -0,0 +1,3 @@
+#! /bin/sh
+
+nix-instantiate --strict --eval-only --xml --show-trace "$(dirname "$0")"/eval-release.nix 2>&1 > /dev/null

pkgs/applications/audio/abcde/default.nix

@@ -1,4 +1,4 @@
-{ stdenv, fetchurl, libcdio, cddiscid, wget, bash, vorbisTools
+{ stdenv, fetchurl, libcdio, cddiscid, wget, bash, vorbisTools, id3v2, lame
 , makeWrapper }:
 
 let version = "2.3.99.6";
@@ -40,7 +40,7 @@ in
          --replace '#!/bin/bash' '#!${bash}/bin/bash'
 
       wrapProgram "$out/bin/abcde" --prefix PATH ":" \
-        "$out/bin:${libcdio}/bin:${cddiscid}/bin:${wget}/bin:${vorbisTools}/bin"
+        "$out/bin:${libcdio}/bin:${cddiscid}/bin:${wget}/bin:${vorbisTools}/bin:${id3v2}/bin:${lame}/bin"
 
       wrapProgram "$out/bin/cddb-tool" --prefix PATH ":" \
         "${wget}/bin"
@@ -58,4 +58,4 @@ in
         format, and tags them, all in one go.
       '';
     };
-  }
+  }

pkgs/applications/audio/amarok/default.nix

@@ -0,0 +1,31 @@
+{ stdenv, fetchurl, lib, cmake, qt4, qtscriptgenerator, perl, gettext, curl
+, libxml2, mysql, taglib, taglib_extras, loudmouth , kdelibs, automoc4, phonon
+, strigi, soprano, qca2, libmtp, liblastfm, libgpod, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+
+  pname = "amarok";
+  version = "2.4.3";
+
+  src = fetchurl {
+    url = "mirror://kde/stable/${pname}/${version}/src/${name}.tar.bz2";
+    sha256 = "0242psqci1b6wfhrrds14h4c4qin9s83cxk1259d9hqcsgn4ir3c";
+  };
+
+  QT_PLUGIN_PATH="${qtscriptgenerator}/lib/qt4/plugins";
+  buildInputs = [ cmake qt4 qtscriptgenerator perl stdenv.gcc.libc gettext curl
+    libxml2 mysql taglib taglib_extras loudmouth kdelibs automoc4 phonon strigi
+    soprano qca2 libmtp liblastfm libgpod pkgconfig ];
+
+  postInstall = ''
+    mkdir -p $out/nix-support
+    echo ${qtscriptgenerator} > $out/nix-support/propagated-user-env-packages
+  '';
+  meta = {
+    description = "Popular music player for KDE";
+    license = "GPL";
+    homepage = http://amarok.kde.org;
+    inherit (kdelibs.meta) platforms maintainers;
+  };
+}

pkgs/applications/audio/amarok/live.nix

@@ -0,0 +1,37 @@
+{ stdenv, fetchgit, fetchgitrevision
+, lib, cmake, qt4, qtscriptgenerator, perl, gettext, curl
+, libxml2, mysql, taglib, taglib_extras, loudmouth , kdelibs, automoc4, phonon
+, strigi, soprano, qca2, libmtp, liblastfm, libgpod, pkgconfig
+, repository ? "git://git.kde.org/amarok"
+, branch ? "heads/master"
+, rev ? fetchgitrevision repository branch
+, src ? fetchgit {
+    url = repository;
+    rev = rev;
+  }
+}:
+
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+
+  pname = "amarok";
+  version = "live";
+
+  inherit src;
+
+  QT_PLUGIN_PATH="${qtscriptgenerator}/lib/qt4/plugins";
+  buildInputs = [ cmake qt4 qtscriptgenerator perl stdenv.gcc.libc gettext curl
+    libxml2 mysql taglib taglib_extras loudmouth kdelibs automoc4 phonon strigi
+    soprano qca2 libmtp liblastfm libgpod pkgconfig ];
+
+  postInstall = ''
+    mkdir -p $out/nix-support
+    echo ${qtscriptgenerator} > $out/nix-support/propagated-user-env-packages
+  '';
+  meta = {
+    description = "Popular music player for KDE";
+    license = "GPL";
+    homepage = http://amarok.kde.org;
+    inherit (kdelibs.meta) maintainers;
+  };
+}

pkgs/applications/audio/ardour/ardour3.nix

@@ -0,0 +1,48 @@
+{ stdenv, fetchsvn, alsaLib, aubio, boost, cairomm, curl, fftw,
+fftwSinglePrec, flac, glib, glibmm, gtk, gtkmm, jackaudio,
+libgnomecanvas, libgnomecanvasmm, liblo, libmad, libogg, librdf,
+librdf_raptor, librdf_rasqal, libsamplerate, libsigcxx, libsndfile,
+libusb, libuuid, libxml2, libxslt, pango, perl, pkgconfig, python }:
+
+let
+  rev = "9942";
+in
+
+stdenv.mkDerivation {
+  name = "ardour3-svn-${rev}";
+
+  src = fetchsvn {
+    url = http://subversion.ardour.org/svn/ardour2/branches/3.0;
+    inherit rev;
+    sha256 = "5f463e5a67bcb1ee6b4d24c25307419ea14ce52130819054b775e377c31a0664";
+  };
+
+  buildInputs = [ alsaLib aubio boost cairomm curl fftw fftwSinglePrec
+    flac glib glibmm gtk gtkmm jackaudio libgnomecanvas
+    libgnomecanvasmm liblo libmad libogg librdf librdf_raptor
+    librdf_rasqal libsamplerate libsigcxx libsndfile libusb libuuid
+    libxml2 libxslt pango perl pkgconfig python ];
+
+  patchPhase = ''
+    printf '#include "ardour/svn_revision.h"\nnamespace ARDOUR { const char* svn_revision = \"${rev}\"; }\n' > libs/ardour/svn_revision.cc
+    sed -e 's|^#!/usr/bin/perl.*$|#!${perl}/bin/perl|g' -i tools/fmt-bindings
+    sed -e 's|^#!/usr/bin/env.*$|#!${perl}/bin/perl|g' -i tools/*.pl
+  '';
+
+  configurePhase = "python waf configure --prefix=$out";
+
+  buildPhase = "python waf";
+
+  installPhase = "python waf install";
+
+  meta = with stdenv.lib; {
+    description = "Multi-track hard disk recording software";
+    longDescription = ''
+      Also read "The importance of Paying Something" on their homepage, please!
+    '';
+    homepage = http://ardour.org/;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/ardour/default.nix

@@ -1,7 +1,10 @@
-args: with args;
+{ stdenv, fetchurl, scons, boost, pkgconfig, fftw, librdf_raptor
+, librdf_rasqal, jackaudio, flac, libsamplerate, alsaLib, libxml2
+, libxslt, libsndfile, libsigcxx, libusb, cairomm, glib, pango
+, gtk, glibmm, gtkmm, libgnomecanvas, librdf, liblo, aubio
+, fftwSinglePrec, libmad }:
 
 stdenv.mkDerivation {
-
   name = "ardour-2.8.2";
 
   # svn is the source to get official releases from their site?
@@ -13,11 +16,10 @@ stdenv.mkDerivation {
   };
 
   buildInputs = [
-    scons boost
-    pkgconfig fftw redland librdf_raptor librdf_rasqal jackaudio flac
-    libsamplerate alsaLib libxml2 libxslt libsndfile libsigcxx libusb cairomm
-    glib pango gtk glibmm gtkmm libgnomecanvas fftw librdf liblo aubio
-    fftw fftwSinglePrec libmad
+    scons boost pkgconfig fftw librdf_raptor librdf_rasqal jackaudio
+    flac libsamplerate alsaLib libxml2 libxslt libsndfile libsigcxx
+    libusb cairomm glib pango gtk glibmm gtkmm libgnomecanvas librdf
+    liblo aubio fftwSinglePrec libmad
   ];
 
   buildPhase = ''
@@ -25,16 +27,17 @@ stdenv.mkDerivation {
     export CXX=g++
     scons PREFIX=$out install
   '';
+  
   installPhase = ":";
 
   meta = { 
-    description = "multi-track hard disk recording software";
+    description = "Multi-track hard disk recording software";
     longDescription = ''
-      Also read "the importance of Paying Something on their homepage, pelase!"
+      Also read "The importance of Paying Something" on their homepage, please!
     '';
     homepage = http://ardour.org/;
     license = "GPLv2";
-    maintainers = [args.lib.maintainers.marcweber];
-    platforms = args.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.marcweber ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/audacious/default.nix

@@ -0,0 +1,56 @@
+{ stdenv, fetchurl, pkgconfig, glib, gtk, libmowgli, libmcs
+, gettext, dbus_glib, libxml2, libmad, xlibs, alsaLib, libogg
+, libvorbis, libcdio, libcddb, flac, ffmpeg
+}:
+
+stdenv.mkDerivation rec {
+  name = "audacious-3.0";
+  
+  src = fetchurl {
+    url = "http://distfiles.atheme.org/${name}.tar.gz";
+    sha256 = "0kj78hgf73fmbm6y3idir2kavbnnlv0jb9ka0pcsb12sxb994s68";
+  };
+
+  pluginsSrc = fetchurl {
+    url = "http://distfiles.atheme.org/audacious-plugins-3.0.tar.gz";
+    sha256 = "0hhxk1mxnnrb1shshpf1nf8mqpc9q1qpsljwn4jzylcnwy6pq4rw";
+  };
+  
+  # `--enable-amidiplug' is to prevent configure from looking in /proc/asound.
+  configureFlags = "--enable-amidiplug --disable-oss";
+  
+  buildInputs =
+    [ gettext pkgconfig glib gtk libmowgli libmcs libxml2 dbus_glib
+      libmad xlibs.libXcomposite libogg libvorbis flac alsaLib libcdio
+      libcddb ffmpeg
+    ];
+
+  # Here we build bouth audacious and audacious-plugins in one
+  # derivations, since they really expect to be in the same prefix.
+  # This is slighly tricky.
+  builder = builtins.toFile "builder.sh"
+    ''
+      # First build audacious.
+      (
+        source $stdenv/setup
+        genericBuild
+      )
+
+      # Then build the plugins.
+      (
+        buildNativeInputs="$out $buildNativeInputs" # to find audacious
+        source $stdenv/setup
+        rm -rfv audacious-*
+        src=$pluginsSrc
+        genericBuild
+      )
+    '';
+
+  enableParallelBuilding = true;
+
+  meta = {
+    description = "Audacious, a media player forked from the Beep Media Player, which was itself an XMMS fork";
+    homepage = http://audacious-media-player.org/;
+    maintainers = [ stdenv.lib.maintainers.eelco ];
+  };
+}

pkgs/applications/audio/audacious/player.nix

@@ -1,32 +0,0 @@
-{ stdenv, fetchurl, pkgconfig, glib, gtk, libmowgli
-, libglade, libmcs, gettext, xlibs, dbus_glib
-}:
-
-stdenv.mkDerivation {
-  name = "audacious-1.5.1";
-  
-  src = fetchurl {
-    url = http://distfiles.atheme.org/audacious-1.5.1.tbz2;
-    sha256 = "1s32pdgx85qkrq15wwmvdw7wbcbxcf3nrhqxi6y72aijqm6fjwnz";
-  };
-
-  buildInputs = [pkgconfig libglade libmcs gettext dbus_glib];
-
-  propagatedBuildInputs = [glib gtk libmowgli libmcs];
-
-  NIX_LDFLAGS = "-rpath ${xlibs.libX11}/lib";
-
-  # Otherwise we barf with "libgcc_s.so.1 must be installed for
-  # pthread_cancel to work" on exit, as it tries to find libgcc_s
-  # dynamically.
-  dontPatchELF = true;
-
-  preBuild = ''
-    ensureDir $out/lib
-  '';
-
-  meta = {
-    description = "Audacious, a media player forked from the Beep Media Player, which was itself an XMMS fork";
-    homepage = http://audacious-media-player.org/;
-  };
-}

pkgs/applications/audio/audacious/plugins.nix

@@ -1,33 +0,0 @@
-{ stdenv, fetchurl, pkgconfig, audacious, dbus_glib, gettext
-, libmad, xlibs, alsaLib, taglib, libmpcdec, libogg, libvorbis
-, libcdio, libcddb, libxml2
-}:
-
-stdenv.mkDerivation {
-  name = "audacious-plugins-1.5.1";
-  
-  src = fetchurl {
-    url = http://distfiles.atheme.org/audacious-plugins-1.5.1.tbz2;
-    sha256 = "1ki5bd50g4vi4d0qzxynyrgaq2n4cwhbsxln9rwk8ppphvk9pawc";
-  };
-
-  buildInputs = [
-    pkgconfig audacious dbus_glib gettext libmad
-    xlibs.libXcomposite alsaLib taglib libmpcdec
-    libogg libvorbis libcdio libcddb libxml2
-  ];
-
-  preBuild = ''
-    makeFlagsArray=(pluginlibdir=$out/lib/audacious)
-  '';
-
-  NIX_LDFLAGS = "-L${audacious}/lib/audacious"; # needed because we override pluginlibdir
-
-  # `--enable-amidiplug' is to prevent configure from looking in /proc/asound.
-  configureFlags = "--enable-amidiplug";
-  
-  meta = {
-    description = "Plugins for the Audacious media player";
-    homepage = http://audacious-media-player.org/;
-  };
-}

pkgs/applications/audio/audacity/default.nix

@@ -1,22 +1,31 @@
 { stdenv, fetchurl, wxGTK, pkgconfig, gettext, gtk, glib, zlib, perl, intltool,
-  libogg, libvorbis, libmad
+  libogg, libvorbis, libmad, alsaLib, libsndfile, libsamplerate, flac, lame,
+  expat, id3lib, ffmpeg, portaudio
   }:
 
-stdenv.mkDerivation {
-  name = "audacity-1.3.7";
+stdenv.mkDerivation rec {
+  version = "1.3.13";
+  name = "audacity-${version}";
 
   NIX_CFLAGS_COMPILE = "-fPIC -lgtk-x11-2.0 -lglib-2.0 -lgobject-2.0 -lz";
 
   src = fetchurl {
-    url = mirror://sourceforge/audacity/audacity-fullsrc-1.3.7.tar.bz2;
-    sha256 = "0b4arafpdyjjk52l6n7aw518hzm65iv9w5g39jqr2bmvn6a9qivi";
+    url = "mirror://sourceforge/audacity/audacity-minsrc-${version}-beta.tar.bz2";
+    sha256 = "4c2eda638e16e16dfddd202e86ccbe1d170b04c26cfb2c12ffcba0b79e7e1e83";
   };
   buildInputs = [ wxGTK pkgconfig gettext gtk glib zlib intltool perl 
-    libogg libvorbis libmad];
+    libogg libvorbis libmad alsaLib libsndfile libsamplerate flac lame
+    expat id3lib ffmpeg portaudio];
+
+  configureFlags = [
+  ];
+
+  dontDisableStatic = true;
 
   meta = {
     description = "Sound editor with graphical UI";
     homepage = http://audacity.sourceforge.net;
     license = "GPLv2+";
+    platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/audio/aumix/default.nix

@@ -5,22 +5,26 @@
 
 assert gtkGUI -> pkgconfig != null && gtk != null;
 
-stdenv.mkDerivation {
-  name = "aumix-2.8";
+stdenv.mkDerivation rec {
+  name = "aumix-2.9.1";
   src = fetchurl {
-    url = http://www.jpj.net/~trevor/aumix/aumix-2.8.tar.bz2;
-    sha256 = "636eef7f400c2f3df489c0d2fa21507e88692113561e75a40a26c52bc422d7fc";
+    url = "http://www.jpj.net/~trevor/aumix/releases/${name}.tar.bz2";
+    sha256 = "0a8fwyxnc5qdxff8sl2sfsbnvgh6pkij4yafiln0fxgg6bal7knj";
   };
 
   buildInputs = [ gettext ncurses ]
     ++ (if gtkGUI then [pkgconfig gtk] else []);
 
   meta = {
+    description = "Aumix, an audio mixer for X and the console";
     longDescription = ''
       Aumix adjusts an audio mixer from X, the console, a terminal,
       the command line or a script.
     '';
     homepage = http://www.jpj.net/~trevor/aumix.html;
-    license = "GPL";
+    license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/beast/default.nix

@@ -1,36 +1,37 @@
-args: with args;
-args.stdenv.mkDerivation {
+{ stdenv, fetchurl, zlib, guile, libart_lgpl, pkgconfig, intltool
+, gtk, glib, libogg, libvorbis, libgnomecanvas, gettext, perl }:
+
+stdenv.mkDerivation {
   name = "beast-0.7.1";
 
-  src = args.fetchurl {
+  src = fetchurl {
     url = ftp://beast.gtk.org/pub/beast/v0.7/beast-0.7.1.tar.bz2;
     sha256 = "0jyl1i1918rsn4296w07fsf6wx3clvad522m3bzgf8ms7gxivg5l";
   };
 
-  buildInputs =[zlib guile libart_lgpl pkgconfig intltool gtk glib
+  buildInputs =
+    [ zlib guile libart_lgpl pkgconfig intltool gtk glib
       libogg libvorbis libgnomecanvas gettext
-      ];
-
-  inherit bash perl;
+    ];
 
   patchPhase = ''
     unset patchPhase; patchPhase
     sed 's=-DG_DISABLE_DEPRECATED==g' -i `find -type f` # the patches didn't remove all occurences
-    sed 's=/bin/bash=/$bash/bin/bash=g' -i `find -type f`
-    sed 's=/usr/bin/perl=/$perl/bin/bash=g' -i `find -type f`
+    sed 's=/bin/bash=/${stdenv.shell}=g' -i `find -type f`
+    sed 's=/usr/bin/perl=/${perl}/bin/perl=g' -i `find -type f`
   '';
 
-  patches = [
-        (fetchurl {
-          url = mirror://gentoo/distfiles/beast-0.7.1-guile-1.8.diff.bz2;
-          sha256 = "dc5194deff4b0a0eec368a69090db682d0c3113044ce2c2ed017ddfec9d3814e";
-        })
-        ./patch.patch # patches taken from gentoo
-  ];
+  patches =
+    [ (fetchurl {
+        url = mirror://gentoo/distfiles/beast-0.7.1-guile-1.8.diff.bz2;
+        sha256 = "dc5194deff4b0a0eec368a69090db682d0c3113044ce2c2ed017ddfec9d3814e";
+      })
+      ./patch.patch # patches taken from gentoo
+    ];
 
   meta = { 
-      description = "BEAST - the Bedevilled Sound Engine";
-      homepage = http://beast.gtk.org;
-      license = ["GPL-2" "LGPL-2.1"];
+    description = "BEAST - the Bedevilled Sound Engine";
+    homepage = http://beast.gtk.org;
+    license = ["GPL-2" "LGPL-2.1"];
   };
 }

pkgs/applications/audio/bmp-plugins/musepack/builder.sh

@@ -1,6 +0,0 @@
-source $stdenv/setup
-
-ensureDir "$out/lib/bmp/Input"
-installFlags="install libdir=$out/lib/bmp/Input"
-
-genericBuild

pkgs/applications/audio/bmp-plugins/musepack/default.nix

@@ -1,11 +0,0 @@
-{stdenv, fetchurl, pkgconfig, bmp, libmpcdec, taglib}:
-
-stdenv.mkDerivation {
-  name = "bmp-plugin-musepack-1.2";
-  builder = ./builder.sh;
-  src = fetchurl {
-    url = http://files2.musepack.net/linux/plugins/bmp-musepack-1.2.tar.bz2;
-    md5 = "5fe0c9d341ca37d05c780a478f829a5f";
-  };
-  buildInputs = [pkgconfig bmp libmpcdec taglib];
-}

pkgs/applications/audio/bmp-plugins/wma/default.nix

@@ -1,19 +0,0 @@
-{stdenv, fetchurl, pkgconfig, bmp}:
-
-stdenv.mkDerivation {
-  name = "bmp-plugin-wma-1.0.5";
-  
-  src = fetchurl {
-    url = http://mcmcc.bat.ru/xmms-wma/xmms-wma-1.0.5.tar.bz2;
-    md5 = "5d62a0f969617aeb40096362c7a8a506";
-  };
-  
-  buildInputs = [pkgconfig bmp];
-
-  buildFlags = "-f Makefile.bmp";
-  
-  installPhase = ''
-    ensureDir "$out/lib/bmp/Input"
-    cp libwma.so "$out/lib/bmp/Input"
-  '';
-}

pkgs/applications/audio/bmp/default.nix

@@ -1,21 +0,0 @@
-{ stdenv, fetchurl, pkgconfig, alsaLib, esound, libogg, libvorbis, id3lib
-, glib, gtk, libglade
-}:
-
-stdenv.mkDerivation {
-  name = "bmp-0.9.7.1";
-  src = fetchurl {
-    url = mirror://sourceforge/beepmp/bmp-0.9.7.1.tar.gz;
-    md5 = "c25d5a8d49cc5851d13d525a20023c4c";
-  };
-
-  buildInputs = [
-    pkgconfig alsaLib esound libogg libvorbis id3lib libglade
-  ];
-
-  meta = {
-    description = "Beep Media Player, an XMMS fork";
-  };
-
-  propagatedBuildInputs = [glib gtk];
-}

pkgs/applications/audio/cdparanoia/default.nix

@@ -1,15 +1,15 @@
-{stdenv, fetchurl}:
+{ stdenv, fetchurl }:
 
-stdenv.mkDerivation {
-  name = "cdparanoia-III-alpha9.8";
+stdenv.mkDerivation rec {
+  name = "cdparanoia-III-10.2";
+  
   src = fetchurl {
-    url = http://downloads.xiph.org/releases/cdparanoia/cdparanoia-III-alpha9.8.src.tgz;
-    md5 = "7218e778b5970a86c958e597f952f193";
+    url = "http://downloads.xiph.org/releases/cdparanoia/${name}.src.tgz";
+    sha256 = "1pv4zrajm46za0f6lv162iqffih57a8ly4pc69f7y0gfyigb8p80";
   };
   
-  patches = [./fix.patch];
-
   meta = {
     homepage = http://xiph.org/paranoia;
+    description = "A tool and library for reading digital audio from CDs";
   };
 }

pkgs/applications/audio/cdparanoia/fix.patch

@@ -1,46 +0,0 @@
-*** cdparanoia-III-alpha9.8/interface/utils.h	Thu Apr 20 00:41:04 2000
---- cdparanoia-III-alpha9.8-old/interface/utils.h	Wed Jan 19 21:44:08 2005
-***************
-*** 110,117 ****
-      case CDDA_MESSAGE_LOGIT:
-        d->errorbuf=catstring(d->errorbuf,s);
-        break;
--     case CDDA_MESSAGE_FORGETIT:
--     default:
-      }
-    }
-  }
---- 110,115 ----
-***************
-*** 125,132 ****
-      case CDDA_MESSAGE_LOGIT:
-        d->messagebuf=catstring(d->messagebuf,s);
-        break;
--     case CDDA_MESSAGE_FORGETIT:
--     default:
-      }
-    }
-  }
---- 123,128 ----
-***************
-*** 167,174 ****
-  	}
-        }
-        break;
--     case CDDA_MESSAGE_FORGETIT:
--     default:
-      }
-    }
-    if(malloced)free(buffer);
---- 163,168 ----
-***************
-*** 203,210 ****
-  	if(!malloced)*messages=catstring(*messages,"\n");
-  	}
-        break;
--     case CDDA_MESSAGE_FORGETIT:
--     default:
-      }
-    }
-    if(malloced)free(buffer);
---- 197,202 ----

pkgs/applications/audio/cmus/default.nix

@@ -0,0 +1,21 @@
+{ stdenv, fetchurl, ncurses, pkgconfig, alsaLib, flac, libmad, ffmpeg, libvorbis, mpc, mp4v2 }:
+
+stdenv.mkDerivation rec {
+  name = "cmus-${version}";
+  version = "2.3.3";
+
+  configurePhase = "./configure prefix=$out";
+
+  buildInputs = [ ncurses pkgconfig alsaLib flac libmad ffmpeg libvorbis mpc mp4v2 ];
+
+  src = fetchurl {
+    url = "mirror://sourceforge/cmus/cmus-v${version}.tar.bz2";
+    sha256 = "13hc5d7h2ayjwnip345hc59rpjj9fgrp1i5spjw3s14prdqr733v";
+  };
+
+  meta = {
+    description = "cmus is a small, fast and powerful console music player for Linux and *BSD";
+    homepage = http://cmus.sourceforge.net;
+    license = stdenv.lib.licenses.gpl2;
+  };
+}

pkgs/applications/audio/espeak/default.nix

@@ -0,0 +1,29 @@
+{stdenv, fetchurl, unzip, portaudio }:
+
+stdenv.mkDerivation {
+  name = "espeak-1.44.03";
+  src = fetchurl {
+    url = mirror://sourceforge/espeak/espeak-1.44.03-source.zip;
+    sha256 = "0lnv89xmsq3bax0qpabd0z2adaag7mdl973bkw3gdszidafmfyx4";
+  };
+
+  buildInputs = [ unzip portaudio ];
+
+  patchPhase = ''
+    sed -e s,/bin/ln,ln,g -i src/Makefile
+    sed -e 's,^CXXFLAGS=-O2,CXXFLAGS=-O2 -D PATH_ESPEAK_DATA=\\\"$(DATADIR)\\\",' -i src/Makefile
+  '' + (if portaudio.api_version == 19 then ''
+    cp src/portaudio19.h src/portaudio.h
+  '' else "");
+
+  configurePhase = ''
+    cd src
+    makeFlags="PREFIX=$out"
+  '';
+
+  meta = {
+    description = "Compact open source software speech synthesizer";
+    homepage = http://espeak.sourceforge.net/;
+    license = "GPLv3+";
+  };
+}

pkgs/applications/audio/gmu/default.nix

@@ -0,0 +1,35 @@
+{stdenv, fetchurl, SDL, SDL_gfx, SDL_image, tremor, flac, mpg123, libmikmod
+, speex
+, keymap ? "newdefault"
+, conf ? "unknown"
+}:
+
+stdenv.mkDerivation rec {
+  name = "gmu-0.7.2";
+  
+  src = fetchurl {
+    url = http://wejp.k.vu/files/gmu-0.7.2.tar.gz;
+    sha256 = "0gvhwhhlj64lc425wqch4g6v59ldd5i3rxll3zdcrdgk2vkh8nys";
+  };
+
+  buildInputs = [ SDL SDL_gfx SDL_image tremor flac mpg123 libmikmod speex ];
+
+  NIX_LDFLAGS = "-lgcc_s";
+
+  preBuild = ''
+    makeFlags="$makeFlags PREFIX=$out"
+  '';
+
+  postInstall = ''
+    cp ${keymap}.keymap $out/share/gmu/default.keymap
+    cp gmuinput.${conf}.conf $out/share/gmu/gmuinput.conf
+    ensureDir $out/etc/gmu
+    cp gmu.${conf}.conf $out/etc/gmu/gmu.conf
+  '';
+
+  meta = {
+    homepage = http://wejp.k.vu/projects/gmu;
+    description = "Open source music player for portable gaming consoles and handhelds";
+    license = "GPLv2";
+  };
+}

pkgs/applications/audio/gtkpod/default.nix

@@ -1,14 +1,16 @@
-{ stdenv, fetchurl, pkgconfig, libgpod, gtk, glib, gettext, perl, perlXMLParser, libglade, flex, libid3tag, libvorbis }:
+{ stdenv, fetchurl, pkgconfig, libgpod, gtk, glib, gettext, perl, perlXMLParser
+, libglade, flex, libid3tag, libvorbis, intltool }:
 
 stdenv.mkDerivation {
-  name = "gtkpod-0.99.14";
+  name = "gtkpod-1.0.0";
 
   src = fetchurl {
-    url = mirror://sourceforge/gtkpod/gtkpod-0.99.14.tar.gz;
-    sha256 = "0ggcfyhcdlf3br88csdki215k4clxixa192afz6f16k7h8s2iqbk";
+    url = mirror://sourceforge/gtkpod/gtkpod-1.0.0.tar.gz;
+    sha256 = "04jzybs55c27kyp7r9c58prcq0q4ssvj5iggva857f49s1ar826q";
   };
 
-  buildInputs = [ pkgconfig libgpod gettext perl perlXMLParser gtk libglade flex libid3tag libvorbis ];
+  buildInputs = [ pkgconfig libgpod gettext perl perlXMLParser gtk libglade flex
+    libid3tag libvorbis intltool ];
 
   patchPhase = ''
     sed -i 's/which/type -P/' scripts/*.sh
@@ -18,5 +20,6 @@ stdenv.mkDerivation {
     description = "GTK Manager for an Apple ipod";
     homepage = http://gtkpod.sourceforge.net;
     license = "GPLv2+";
+    platforms = with stdenv.lib.platforms; linux;
   };
 }

pkgs/applications/audio/hydrogen/default.nix

@@ -0,0 +1,35 @@
+{ stdenv, fetchurl, 
+  alsaLib, boost, glib, jackaudio, libarchive, liblrdf, libsndfile,
+  pkgconfig, qt4, scons, subversion }:
+
+stdenv.mkDerivation rec {
+  version = "0.9.5";
+  name = "hydrogen-${version}";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/hydrogen/hydrogen-${version}.tar.gz";
+    sha256 = "1hyri49va2ss26skd6p9swkx0kbr7ggifbahkrcfgj8yj7pp6g4n";
+  };
+
+  buildInputs = [ 
+    alsaLib boost glib jackaudio libarchive liblrdf libsndfile
+    pkgconfig qt4 scons subversion 
+  ];
+
+  patches = [ ./scons-env.patch ];
+
+  # why doesn't scons find librdf?
+  buildPhase = ''
+    scons prefix=$out libarchive=1 lrdf=0 install
+  '';
+
+  installPhase = ":";
+
+  meta = with stdenv.lib; {
+    description = "Advanced drum machine";
+    homepage = http://www.hydrogen-music.org;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/hydrogen/scons-env.patch

@@ -0,0 +1,20 @@
+--- hydrogen-0.9.5/Sconstruct	2011-03-15 13:22:35.000000000 +0100
++++ hydrogen-0.9.5/Sconstruct	2011-04-17 16:06:54.000000000 +0200
+@@ -178,7 +178,7 @@
+ 
+ 	includes.append( "libs/hydrogen/include" )
+ 	
+-	env = Environment( options = opts ) 
++	env = Environment( options = opts, ENV = os.environ ) 
+ 
+ 
+ 	#location of qt4.py
+@@ -379,7 +379,7 @@
+ 
+ includes, a , b = get_platform_flags( opts )
+ 
+-env = Environment(options = opts, CPPPATH = includes)
++env = Environment(options = opts, ENV = os.environ)
+ 
+ 
+ Help(opts.GenerateHelpText(env))

pkgs/applications/audio/id3v2/default.nix

@@ -0,0 +1,28 @@
+{stdenv, fetchurl, id3lib, groff}:
+
+stdenv.mkDerivation rec {
+  name = "id3v2-0.1.11";
+  src = fetchurl {
+    url = "mirror://sourceforge/id3v2/${name}.tar.gz";
+    sha256 = "00r6f9yzmkrqa62dnkm8njg5cjzhmy0l17nj1ba15nrrm0mnand4";
+  };
+
+  patches = [ ./id3v2-0.1.11-track-bad-free.patch ];
+
+  buildNativeInputs = [ groff ];
+  buildInputs = [ id3lib ];
+
+  configurePhase = ''
+    export makeFlags=PREFIX=$out
+  '';
+
+  preInstall = ''
+    ensureDir $out/bin $out/man/man1
+  '';
+
+  meta = {
+    description = "A command line editor for id3v2 tags";
+    homepage = http://id3v2.sourceforge.net/;
+    license = "GPLv2+";
+  };
+}

pkgs/applications/audio/id3v2/id3v2-0.1.11-track-bad-free.patch

@@ -0,0 +1,14 @@
+http://sourceforge.net/tracker/index.php?func=detail&aid=1252035&group_id=4193&atid=304193
+
+diff -up id3v2-0.1.11/id3v2.cpp~ id3v2-0.1.11/id3v2.cpp
+--- id3v2-0.1.11/id3v2.cpp~	2004-05-04 21:30:15.000000000 +0300
++++ id3v2-0.1.11/id3v2.cpp	2008-01-03 21:22:02.000000000 +0200
+@@ -423,7 +423,7 @@ int main( int argc, char *argv[])
+         {
+           // check if there is a total track number and if we only have 
+           // the track number for this file.  In this case combine them.
+-          char *currentTrackNum, *newTrackNum;
++          char *currentTrackNum, *newTrackNum = NULL;
+ 
+           if (pFrame != NULL) 
+           {

pkgs/applications/audio/jackmeter/default.nix

@@ -1,23 +1,20 @@
-args: with args;
+{ stdenv, fetchurl, jackaudio, pkgconfig }:
 
-let name = "jackmeter-0.3";
-in
-stdenv.mkDerivation {
-
-  inherit name;
+stdenv.mkDerivation rec {
+  name = "jackmeter-0.3";
 
   src = fetchurl {
     url = "http://www.aelius.com/njh/jackmeter/${name}.tar.gz";
     sha256 = "03siznnq3f0nnqyighgw9qdq1y4bfrrxs0mk6394pza3sz4b6sgp";
   };
 
-  buildInputs = [jackaudio pkgconfig];
+  buildInputs = [ jackaudio pkgconfig ];
 
   meta = { 
-    description = "console jack loudness meter";
+    description = "Console jack loudness meter";
     homepage = http://www.aelius.com/njh/jackmeter/;
     license = "GPLv2";
-    maintainers = [args.lib.maintainers.marcweber];
-    platforms = args.lib.platforms.linux;
+    maintainers = [ stdenv.lib.maintainers.marcweber ];
+    platforms = stdenv.lib.platforms.linux;
   };
 }

pkgs/applications/audio/ladspa-plugins/default.nix

@@ -1,27 +1,22 @@
-args: with args;
-	let localDefs = builderDefs.passthru.function {
-		src = 
-		fetchurl {
-			url = http://plugin.org.uk/releases/0.4.15/swh-plugins-0.4.15.tar.gz;
-			sha256 = "0h462s4mmqg4iw7zdsihnrmz2vjg0fd49qxw2a284bnryjjfhpnh";
-		};
-		buildInputs = [fftw ladspaH pkgconfig];
-		configureFlags = [];
-	};
-	in with localDefs;
-let
-	postInstall = fullDepEntry ("
-		ensureDir \$out/share/ladspa/
-		ln -s \$out/lib/ladspa \$out/share/ladspa/lib
-	") [minInit defEnsureDir];
-in
+{ stdenv, fetchurl, fftw, ladspaH, pkgconfig }:
+
 stdenv.mkDerivation {
-	name = "swh-plugins-0.4.15";
-	builder = writeScript "swh-plugins-0.4.15-builder"
-		(textClosure localDefs [doConfigure doMakeInstall 
-			postInstall doForceShare]);
-	meta = {
-		description = "LADSPA format audio plugins";
-		inherit src;
-	};
+  name = "swh-plugins-0.4.15";
+
+  src = fetchurl {
+    url = http://plugin.org.uk/releases/0.4.15/swh-plugins-0.4.15.tar.gz;
+    sha256 = "0h462s4mmqg4iw7zdsihnrmz2vjg0fd49qxw2a284bnryjjfhpnh";
+  };
+  
+  buildInputs = [fftw ladspaH pkgconfig];
+
+  postInstall =
+    ''
+      ensureDir $out/share/ladspa/
+      ln -sv $out/lib/ladspa $out/share/ladspa/lib
+    '';
+
+  meta = {
+    description = "LADSPA format audio plugins";
+  };
 }

pkgs/applications/audio/ladspa-plugins/ladspah.nix

@@ -1,28 +1,28 @@
-args: with args;
+{ stdenv, fetchurl, builderDefs }:
+
 let 
-	src = 
-	fetchurl {
-		url = http://www.ladspa.org/ladspa_sdk/ladspa.h.txt;
-		sha256 = "1b908csn85ng9sz5s5d1mqk711cmawain2z8px2ajngihdrynb67";
-	};
+  src = fetchurl {
+    url = http://www.ladspa.org/ladspa_sdk/ladspa.h.txt;
+    sha256 = "1b908csn85ng9sz5s5d1mqk711cmawain2z8px2ajngihdrynb67";
+  };
 in
-	let localDefs = builderDefs.passthru.function {
-		buildInputs = [];
-		inherit src;
-	};
-	in with localDefs;
+  let localDefs = builderDefs.passthru.function {
+    buildInputs = [];
+    inherit src;
+  };
+  in with localDefs;
 let
-	copyFile = fullDepEntry ("
-		ensureDir \$out/include
-		cp ${src} \$out/include/ladspa.h
-	") [minInit defEnsureDir];
+  copyFile = fullDepEntry ("
+    ensureDir \$out/include
+    cp ${src} \$out/include/ladspa.h
+  ") [minInit defEnsureDir];
 in
 stdenv.mkDerivation {
-	name = "ladspa.h";
-	builder = writeScript "ladspa.h-builder"
-		(textClosure localDefs [copyFile]);
-	meta = {
-		description = "LADSPA format audio plugins";
-		inherit src;
-	};
+  name = "ladspa.h";
+  builder = writeScript "ladspa.h-builder"
+    (textClosure localDefs [copyFile]);
+  meta = {
+    description = "LADSPA format audio plugins";
+    inherit src;
+  };
 }

pkgs/applications/audio/lame/default.nix

@@ -1,12 +1,16 @@
-{stdenv, fetchurl}:
+{stdenv, fetchurl, nasm}:
 
-stdenv.mkDerivation {
-  name = "lame-3.98.2";
+stdenv.mkDerivation rec {
+  name = "lame-3.98.4";
   src = fetchurl {
-    url = mirror://sourceforge/lame/lame-398-2.tar.gz;
-    sha256 = "0cmgr515szd9kd19mpzvwl3cbnpfyjyi47swj4afblcfkmb2hym1";
+    url = "mirror://sourceforge/lame/${name}.tar.gz";
+    sha256 = "1j3jywv6ic2cy0x0q1a1h6rcl6xmcs5f58xawjdkl8hpcv3l8cdc";
   };
 
+  buildInputs = [ nasm ];
+
+  configureFlags = [ "--enable-nasm" ];
+
   # Either disable static, or fix the rpath of 'lame' for it to point
   # properly to the libmp3lame shared object.
   dontDisableStatic = true;

pkgs/applications/audio/lash/default.nix

@@ -0,0 +1,36 @@
+{ stdenv, fetchurl, alsaLib, gtk, jackaudio, libuuid, libxml2
+, makeWrapper, pkgconfig, readline }:
+
+assert libuuid != null;
+
+stdenv.mkDerivation  rec {
+  name = "lash-${version}";
+  version = "0.5.4";
+
+  src = fetchurl {
+    url = "mirror://savannah/lash/${name}.tar.gz";
+    sha256 = "05kc4brcx8mncai0rj2gz4s4bsrsy9q8xlnaddf75i0m8jl7snhh";
+  };
+
+  patches = [ ./socket.patch ];
+
+  buildInputs = [ alsaLib gtk jackaudio libuuid libxml2 makeWrapper
+    pkgconfig readline ];
+
+  postInstall = ''
+    for i in lash_control lash_panel
+      do wrapProgram "$out/bin/$i" --prefix LD_LIBRARY_PATH ":" "${libuuid}/lib"
+    done
+  '';
+
+  meta = with stdenv.lib; {
+    description = "LASH Audio Session Handler";
+    longDescription = ''
+      Session management system for GNU/Linux audio applications.
+    '';
+    homepage = http://www.nongnu.org/lash;
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/lash/socket.patch

@@ -0,0 +1,16 @@
+Via http://bugs.gentoo.org/show_bug.cgi?id=229603
+
+--- lash-0.5.4/liblash/socket.c	2008-06-26 15:20:44.227064193 +0200
++++ lash-0.5.4/liblash/socket.c	2008-06-26 15:21:18.245063129 +0200
+@@ -20,6 +20,11 @@ 
+ 
+ #define _POSIX_SOURCE /* addrinfo */
+ 
++#ifdef LASH_BUILD
++#define _GNU_SOURCE
++#include "config.h"
++#endif /* LASH_BUILD */
++
+ #include <stdint.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>

pkgs/applications/audio/lingot/default.nix

@@ -0,0 +1,22 @@
+{ stdenv, fetchurl, pkgconfig, intltool, gtk, alsaLib, libglade }:
+
+stdenv.mkDerivation {
+  name = "lingot-0.9.0";
+
+  src = fetchurl {
+    url = http://download.savannah.gnu.org/releases/lingot/lingot-0.9.0.tar.gz;
+    sha256 = "07z129lp8m4sz608q409wb11c639w7cbn497r7bscgg08p6c07xb";
+  };
+
+  buildInputs = [ pkgconfig intltool gtk alsaLib libglade ];
+
+  configureFlags = "--disable-jack";
+
+  meta = {
+    description = "Not a Guitar-Only tuner";
+    homepage = http://www.nongnu.org/lingot/;
+    license = "GPLv2+";
+    platforms = with stdenv.lib.platforms; linux;
+    maintainers = with stdenv.lib.maintainers; [viric];
+  };
+}

pkgs/applications/audio/lmms/default.nix

@@ -0,0 +1,23 @@
+{ stdenv, fetchurl, SDL, alsaLib, cmake, fftw, jackaudio, libogg,
+libsamplerate, libsndfile, pkgconfig, pulseaudio, qt4 }:
+
+stdenv.mkDerivation  rec {
+  name = "lmms-${version}";
+  version = "0.4.10";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/lmms/${name}.tar.bz2";
+    sha256 = "035cqmxcbr9ipnicdv5l7h05q2hqbavxkbaxyq06ppnv2y7fxwrb";
+  };
+
+  buildInputs = [ SDL alsaLib cmake fftw jackaudio libogg
+    libsamplerate libsndfile pkgconfig pulseaudio qt4 ];
+
+  meta = with stdenv.lib; {
+    description = "Linux MultiMedia Studio";
+    homepage = "http://lmms.sourceforge.net";
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/mp3info/default.nix

@@ -0,0 +1,42 @@
+{ fetchurl, stdenv, ncurses, pkgconfig, gtk }:
+
+stdenv.mkDerivation rec {
+  name = "mp3info-0.8.5a";
+
+  src = fetchurl {
+    url = "ftp://ftp.ibiblio.org/pub/linux/apps/sound/mp3-utils/mp3info/${name}.tgz";
+    sha256 = "042f1czcs9n2sbqvg4rsvfwlqib2gk976mfa2kxlfjghx5laqf04";
+  };
+
+  buildInputs = [ ncurses pkgconfig gtk ];
+
+  configurePhase =
+    '' sed -i Makefile \
+           -e "s|^prefix=.*$|prefix=$out|g ;
+               s|/bin/rm|rm|g ;
+               s|/usr/bin/install|install|g"
+    '';
+
+  preInstall =
+    '' ensureDir "$out/bin"
+       ensureDir "$out/man/man1"
+    '';
+
+  meta = {
+    description = "MP3Info, an MP3 technical info viewer and ID3 1.x tag editor";
+
+    longDescription =
+      '' MP3Info is a little utility used to read and modify the ID3 tags of
+         MP3 files.  MP3Info can also display various techincal aspects of an
+         MP3 file including playing time, bit-rate, sampling frequency and
+         other attributes in a pre-defined or user-specifiable output format.
+      '';
+
+    homepage = http://www.ibiblio.org/mp3info/;
+
+    license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.unix;
+  };
+}

pkgs/applications/audio/mpc123/default.nix

@@ -0,0 +1,32 @@
+{ fetchurl, stdenv, gettext, libmpcdec, libao }:
+
+let version = "0.2.4"; in
+stdenv.mkDerivation rec {
+  name = "mpc123-${version}";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/mpc123/version%20${version}/${name}.tar.gz";
+    sha256 = "0sf4pns0245009z6mbxpx7kqy4kwl69bc95wz9v23wgappsvxgy1";
+  };
+
+  patches = [ ./use-gcc.patch ];
+
+  buildInputs = [ gettext libmpcdec libao ];
+
+  installPhase =
+    # XXX: Should install locales too (though there's only 1 available).
+    '' ensureDir "$out/bin"
+       cp -v mpc123 "$out/bin"
+    '';
+
+  meta = {
+    homepage = http://mpc123.sourceforge.net/;
+
+    description = "mpc123, a Musepack (.mpc) audio player";
+
+    license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu; # arbitrary choice
+  };
+}

pkgs/applications/audio/mpc123/use-gcc.patch

@@ -0,0 +1,13 @@
+Don't worry, just use GCC and everything's gonna be alright.
+
+--- mpc123-0.2.4/Makefile	2008-03-21 22:14:38.000000000 +0100
++++ mpc123-0.2.4/Makefile	2010-01-28 23:26:49.000000000 +0100
+@@ -17,7 +17,7 @@
+ # along with this program; if not, write to the Free Software Foundation,
+ # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ 
+-CC := $(shell which colorgcc || which cc)
++CC := gcc
+ 
+ TAGSPRG := ctags
+ 

pkgs/applications/audio/mpg123/default.nix

@@ -0,0 +1,23 @@
+{stdenv, fetchurl, alsaLib }:
+
+stdenv.mkDerivation {
+  name = "mpg123-1.12.3";
+
+  src = fetchurl {
+    url = mirror://sourceforge/mpg123/mpg123-1.12.3.tar.bz2;
+    sha256 = "1ij689s7jch3d4g0ja3jylaphallc8vgrsrm9b12254phnyy23xf";
+  };
+
+  buildInputs = [ alsaLib ];
+
+  crossAttrs = {
+    configureFlags = if stdenv.cross ? mpg123 then
+      "--with-cpu=${stdenv.cross.mpg123.cpu}" else "";
+  };
+
+  meta = {
+    description = "Command-line MP3 player";
+    homepage = http://mpg123.sourceforge.net/;
+    license = "LGPL";
+  };
+}

pkgs/applications/audio/mpg321/default.nix

@@ -1,17 +1,20 @@
 {stdenv, fetchurl, libao, libmad, libid3tag, zlib}:
 
-stdenv.mkDerivation {
-  name = "mpg321-0.2.10";
+stdenv.mkDerivation rec {
+  name = "mpg321-0.2.13-2";
+
   src = fetchurl {
-    url = mirror://sourceforge/mpg321/mpg321-0.2.10.tar.gz;
-    sha256 = "db0c299592b8f1f704f41bd3fc3a2bf138658108588d51af61638c551af1b0d4";
+    url = "mirror://sourceforge/mpg321/0.2.13/${name}.tar.gz";
+    sha256 = "0zx9xyr97frlyrwyk2msm9h1sn2b84vqaxcy5drbzcd2n585lwlx";
   };
 
   buildInputs = [libao libid3tag libmad zlib];
 
   meta = {
-    description = "Command-line MP3 player.";
+    description = "mpg321, a command-line MP3 player";
     homepage = http://mpg321.sourceforge.net/;
     license = "GPLv2";
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;
   };
 }

pkgs/applications/audio/pavucontrol/default.nix

@@ -2,11 +2,11 @@
 , libglademm, libcanberra, intltool, gettext }:
 
 stdenv.mkDerivation rec {
-  name = "pavucontrol-0.9.7";
+  name = "pavucontrol-0.9.10";
 
   src = fetchurl {
     url = "http://0pointer.de/lennart/projects/pavucontrol/${name}.tar.gz";
-    sha256 = "1a1v06hbl1j78ryqy5aiccg6w5hf1yzday2b9h31kx7vr42ir1w0";
+    sha256 = "0g2sd9smwwpnyq8yc65dl9z0iafj2rrimi8v58wkxx98vhnnvsby";
   };
 
   buildInputs = [ pkgconfig pulseaudio gtkmm libsigcxx libglademm libcanberra
@@ -26,5 +26,8 @@ stdenv.mkDerivation rec {
     homepage = http://0pointer.de/lennart/projects/pavucontrol/;
 
     license = "GPLv2+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
   };
 }

pkgs/applications/audio/puredata/default.nix

@@ -0,0 +1,28 @@
+{ stdenv, fetchurl, alsaLib, autoconf, automake, fftw, gettext, glib,
+libX11, libtool, tcl, tk }:
+
+stdenv.mkDerivation  rec {
+  name = "puredata-${version}";
+  version = "0.43-0";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/pure-data/pd-${version}.src.tar.gz";
+    sha256 = "1qfq7x8vj12kr0cdrnbvmxfhc03flicc6vcc8bz6hwrrakwciyz2";
+  };
+
+  buildInputs = [ alsaLib autoconf automake fftw gettext glib libX11
+    libtool tcl tk ];
+
+  preConfigure = ''
+    ./autogen.sh
+  '';
+
+  meta = with stdenv.lib; {
+    description = ''Real-time graphical programming environment for
+                    audio, video, and graphical processing'';
+    homepage = http://puredata.info;
+    license = licenses.bsd3;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/qjackctl/default.nix

@@ -1,20 +1,21 @@
-args:
-args.stdenv.mkDerivation {
+{ stdenv, fetchurl, qt4, alsaLib, jackaudio, dbus }:
+
+stdenv.mkDerivation rec {
+  version = "0.3.7";
+  name = "qjackctl-${version}";
 
   # some dependencies such as killall have to be installed additionally
 
-  name = "qjackctl-0.3.3";
-
-  src = args.fetchurl {
-    url = http://downloads.sourceforge.net/qjackctl/qjackctl-0.3.3.tar.gz;
-    sha256 = "1z9v208fs79ka6ni3p5v5xb0k5y1wqqm2a9cf903387b9p3fhpxj";
+  src = fetchurl {
+    url = "mirror://sourceforge/qjackctl/${name}.tar.gz";
+    sha256 = "1gynym21d8d4d38qyl817qg0v8360brcpga4wcdapccbgpaz3c28";
   };
 
-  buildInputs =(with args; [qt4 alsaLib jackaudio]);
+  buildInputs = [ qt4 alsaLib jackaudio dbus ];
 
-  meta = { 
-      description = "qt jackd control gui tool";
-      homepage = http://qjackctl.sourceforge.net/;
-      license = "GPL";
+  meta = {
+    description = "qt jackd control gui tool";
+    homepage = http://qjackctl.sourceforge.net/;
+    license = "GPL";
   };
 }

pkgs/applications/audio/qtractor/default.nix

@@ -0,0 +1,25 @@
+{ alsaLib, autoconf, automake, dssi, fetchurl, gtk, jackaudio,
+ladspaH, ladspaPlugins, liblo, libmad, libsamplerate, libsndfile,
+libtool, libvorbis, pkgconfig, qt4, rubberband, stdenv }:
+
+stdenv.mkDerivation rec {
+  version = "0.5.0";
+  name = "qtractor-${version}";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/qtractor/${name}.tar.gz";
+    sha256 = "de5991d2d29b2713d73a90ab29efc24db0be68d8e9ca328062d53d229e902e89";
+  };
+
+  buildInputs = [ alsaLib autoconf automake dssi gtk jackaudio ladspaH
+    ladspaPlugins liblo libmad libsamplerate libsndfile libtool
+    libvorbis pkgconfig qt4 rubberband ];
+
+  meta = with stdenv.lib; {
+    description = "Audio/MIDI multi-track sequencer";
+    homepage = http://qtractor.sourceforge.net;
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/rakarrack/default.nix

@@ -0,0 +1,23 @@
+{ stdenv, fetchurl, alsaLib, alsaUtils, fltk, jackaudio, libXft,
+libXpm, libjpeg, libpng, libsamplerate, libsndfile, zlib }:
+
+stdenv.mkDerivation  rec {
+  name = "rakarrack-${version}";
+  version = "0.6.1";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/rakarrack/${name}.tar.bz2";
+    sha256 = "1rpf63pdn54c4yg13k7cb1w1c7zsvl97c4qxcpz41c8l91xd55kn";
+  };
+
+  buildInputs = [ alsaLib alsaUtils fltk jackaudio libXft libXpm libjpeg
+    libpng libsamplerate libsndfile zlib ];
+
+  meta = with stdenv.lib; {
+    description = "multi-effects processor emulating a guitar effects pedalboard";
+    homepage = http://rakarrack.sourceforge.net;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/seq24/default.nix

@@ -0,0 +1,21 @@
+{ stdenv, fetchurl, alsaLib, gtkmm, jackaudio, pkgconfig }:
+
+stdenv.mkDerivation  rec {
+  name = "seq24-${version}";
+  version = "0.9.2";
+
+  src = fetchurl {
+    url = "http://launchpad.net/seq24/trunk/${version}/+download/${name}.tar.gz";
+    sha256 = "07n80zj95i80vjmsflnlbqx5vv90qmp5f6a0zap8d30849l4y258";
+  };
+
+  buildInputs = [ alsaLib gtkmm jackaudio pkgconfig ];
+
+  meta = with stdenv.lib; {
+    description = "minimal loop based midi sequencer";
+    homepage = "http://www.filter24.org/seq24";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/sonic-visualiser/default.nix

@@ -0,0 +1,53 @@
+# TODO add plugins having various licenses, see http://www.vamp-plugins.org/download.html
+
+{ stdenv, fetchurl, alsaLib, bzip2, fftw, jackaudio, libX11, liblo,
+libmad, libogg, librdf, librdf_raptor, librdf_rasqal, libsamplerate,
+libsndfile, makeWrapper, pulseaudio, qt4, redland, rubberband, vampSDK
+}:
+
+stdenv.mkDerivation {
+  name = "sonic-visualiser-1.8";
+
+  src = fetchurl {
+    url = http://downloads.sourceforge.net/sv1/sonic-visualiser-1.8.tar.gz;
+    sha256 = "16ik6q9n92wljvnqcv7hyzb9v3yp3ixxp6df9kasf53fii973dh7";
+  };
+
+  buildInputs =
+    [ libsndfile qt4 fftw /* should be fftw3f ??*/ bzip2 librdf rubberband
+      libsamplerate vampSDK alsaLib librdf_raptor librdf_rasqal redland
+      # optional
+      jackaudio
+      # portaudio
+      pulseaudio
+      libmad
+      libogg # ?
+      # fishsound
+      liblo
+      libX11
+      makeWrapper
+    ];
+
+  buildPhase = ''
+    for i in sonic-visualiser svapp svcore svgui; 
+      do cd $i && qmake -makefile PREFIX=$out && cd ..;
+    done
+    make
+  '';
+
+  installPhase = ''
+    ensureDir $out/{bin,share/sonic-visualiser}
+    cp sonic-visualiser/sonic-visualiser $out/bin
+    cp -r sonic-visualiser/samples $out/share/sonic-visualiser/samples
+    wrapProgram $out/bin/sonic-visualiser --prefix LD_LIBRARY_PATH : ${libX11}/lib
+  '';
+
+  meta = { 
+    description = "View and analyse contents of music audio files";
+    homepage = http://www.sonicvisualiser.org/;
+    license = "GPLv2";
+    maintainers = [ stdenv.lib.maintainers.marcweber 
+      stdenv.lib.maintainers.goibhniu ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}

pkgs/applications/audio/sonic-visualizer/default.nix

@@ -1,45 +0,0 @@
-# TODO add plugins having various licenses, see http://www.vamp-plugins.org/download.html
-
-args: with args;
-
-stdenv.mkDerivation {
-
-#TODO add plugins!
-
-  name = "sonic-visualizer-1.6";
-
-  src = fetchurl {
-    url = http://downloads.sourceforge.net/sv1/sonic-visualiser-1.6.tar.bz2;
-    sha256 = "1dbqqa7anii2jnjpfwm4sr83nn4bwmz68xw4n6clycsz5iqk52f5";
-  };
-
-  buildInputs = [libsndfile qt fftw /* should be fftw3f ??*/ bzip2 librdf rubberband
-    libsamplerate vampSDK alsaLib librdf_raptor librdf_rasqal redland
-    # optional
-    jackaudio
-    # portaudio
-    pulseaudio
-    libmad
-    libogg # ?
-    # fishsound
-    liblo
-    ];
-
-  buildPhase = ''
-    qmake -makefile PREFIX=$out && make
-  '';
-
-  installPhase = ''
-    ensureDir $out/{bin,share/sv}
-    cp sv/sonic-visualiser $out/bin
-    cp -r sv/samples $out/share/sv/samples
-  '';
-
-  meta = { 
-    description = "View and analyse contents of music audio files";
-    homepage = http://www.sonicvisualiser.org/;
-    license = "GPLv2";
-    maintainers = [args.lib.maintainers.marcweber];
-    platforms = args.lib.platforms.linux;
-  };
-}

pkgs/applications/audio/specimen/default.nix

@@ -0,0 +1,28 @@
+{ stdenv, fetchsvn, alsaLib, autoconf, automake, gtk, jackaudio,
+libgnomecanvas, libsamplerate, libsndfile, libtool, libxml2, phat,
+pkgconfig }:
+
+stdenv.mkDerivation  rec {
+  name = "specimen-svn-89";
+
+  # The released version won't compile with newer versions of jack
+  src = fetchsvn {
+    url = http://zhevny.com/svn/specimen/trunk;
+    rev = 89;
+    sha256 = "1i24nchw14cbjv7kmzs7cvmis2xv4r7bxghi8d6gq5lprwk8xydf";
+  };
+
+  preConfigure = "sh autogen.sh";
+
+  buildInputs = [ alsaLib autoconf automake gtk jackaudio
+    libgnomecanvas libsamplerate libsndfile libtool libxml2 phat
+    pkgconfig ];
+
+  meta = with stdenv.lib; {
+    description = "MIDI controllable audio sampler";
+    homepage = http://zhevny.com/specimen/;
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/spotify/default.nix

@@ -0,0 +1,63 @@
+{ fetchurl, stdenv, dpkg, xlibs, qt4, alsaLib, makeWrapper }:
+
+assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";
+
+let version = "0.5.2.84"; in
+
+stdenv.mkDerivation {
+  name = "spotify-${version}";
+
+  src =
+    if stdenv.system == "i686-linux" then 
+      fetchurl {
+        url = "http://repository.spotify.com/pool/non-free/s/spotify/spotify-client-qt_${version}.g6d797eb-1_i386.deb";
+        sha256 = "0l1pvvkkssng0yc7zlgxr39jx3cs6i71sspmm4xb84y1bl045pas";
+      }
+    else if stdenv.system == "x86_64-linux" then 
+      fetchurl {
+        url = "http://repository.spotify.com/pool/non-free/s/spotify/spotify-client-qt_${version}.g6d797eb-1_amd64.deb";
+        sha256 = "1wi1z3dyzjz13mkb0r2ilm914p8sg06923sv872nclrl102qbbni";
+      }
+    else throw "Spotify not supported on this platform.";
+
+  buildInputs = [ dpkg makeWrapper ];
+
+  unpackPhase = "true";
+  
+  installPhase =
+    ''
+      mkdir -p $out
+      dpkg-deb -x $src $out
+      mv $out/usr/* $out/
+      rmdir $out/usr
+
+      patchelf \
+        --interpreter "$(cat $NIX_GCC/nix-support/dynamic-linker)" \
+        --set-rpath ${stdenv.lib.makeLibraryPath [ xlibs.libXScrnSaver xlibs.libX11 qt4 alsaLib stdenv.gcc.gcc ]}:${stdenv.gcc.gcc}/lib64 \
+        $out/bin/spotify
+
+      preload=$out/libexec/spotify/libpreload.so
+      mkdir -p $out/libexec/spotify
+      gcc -shared ${./preload.c} -o $preload -ldl -DOUT=\"$out\" -fPIC
+
+      wrapProgram $out/bin/spotify --set LD_PRELOAD $preload
+    ''; # */
+
+  dontStrip = true;
+  dontPatchELF = true;
+
+  meta = {
+    homepage = https://www.spotify.com/download/previews/;
+    description = "Spotify for Linux allows you to play music from the Spotify music service";
+    license = "unfree";
+    maintainers = [ stdenv.lib.maintainers.eelco ];
+
+    longDescription =
+      ''
+        Spotify is a digital music streaming service.  This package
+        provides the Spotify client for Linux.  At present, it does not
+        work with free Spotify accounts; it requires a Premium or
+        Unlimited account.
+      '';
+  };
+}

pkgs/applications/audio/spotify/preload.c

@@ -0,0 +1,66 @@
+/* Spotify looks for its theme data in /usr/share/spotify/theme.  This
+   LD_PRELOAD library intercepts open() and stat() calls to redirect
+   them to the corresponding location in $out. */
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <limits.h>
+
+char themeDir [] = "/usr/share/spotify/theme";
+char realThemeDir [] = OUT "/share/spotify/theme";
+
+const char * rewrite(const char * path, char * buf)
+{
+    if (strncmp(path, themeDir, sizeof(themeDir) - 1) != 0) return path;
+    if (snprintf(buf, PATH_MAX, "%s%s", realThemeDir, path + sizeof(themeDir) - 1) >= PATH_MAX)
+        abort();
+    return buf;
+}
+
+int open(const char *path, int flags, ...)
+{
+    char buf[PATH_MAX];
+    int (*_open) (const char *, int, mode_t) = dlsym(RTLD_NEXT, "open");
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = va_arg(ap, mode_t);
+        va_end(ap);
+    }
+    return _open(rewrite(path, buf), flags, mode);
+}
+
+int open64(const char *path, int flags, ...)
+{
+    char buf[PATH_MAX];
+    int (*_open64) (const char *, int, mode_t) = dlsym(RTLD_NEXT, "open64");
+    mode_t mode = 0;
+    if (flags & O_CREAT) {
+        va_list ap;
+        va_start(ap, flags);
+        mode = va_arg(ap, mode_t);
+        va_end(ap);
+    }
+    return _open64(rewrite(path, buf), flags, mode);
+}
+
+int __xstat64(int ver, const char *path, struct stat64 *st)
+{
+    char buf[PATH_MAX];
+    int (*___xstat64) (int ver, const char *, struct stat64 *) = dlsym(RTLD_NEXT, "__xstat64");
+    return ___xstat64(ver, rewrite(path, buf), st);
+}
+
+int access(const char *path, int mode)
+{
+    char buf[PATH_MAX];
+    int (*_access) (const char *path, int mode) = dlsym(RTLD_NEXT, "access");
+    return _access(rewrite(path, buf), mode);
+}

pkgs/applications/audio/vkeybd/default.nix

@@ -0,0 +1,32 @@
+{ stdenv, fetchurl, alsaLib, libX11, makeWrapper, tcl, tk }:
+
+stdenv.mkDerivation  rec {
+  name = "vkeybd-${version}";
+  version = "0.1.18d";
+
+  src = fetchurl {
+    url = "ftp://ftp.suse.com/pub/people/tiwai/vkeybd/${name}.tar.bz2";
+    sha256 = "0107b5j1gf7dwp7qb4w2snj4bqiyps53d66qzl2rwj4jfpakws5a";
+  };
+
+  buildInputs = [ alsaLib libX11 makeWrapper tcl tk ];
+
+  configurePhase = ''
+    ensureDir $out/bin
+    sed -e "s@/usr/local@$out@" -i Makefile
+  '';
+
+  makeFlags = [ "TKLIB=-ltk8.5" "TCLLIB=-ltcl8.5" ];
+
+  postInstall = ''
+    wrapProgram $out/bin/vkeybd --set TK_LIBRARY "${tk}/lib/${tk.libPrefix}"
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Virtual MIDI keyboard";
+    homepage = http://www.alsa-project.org/~tiwai/alsa.html;
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/vorbis-tools/default.nix

@@ -2,18 +2,14 @@
 , speex, flac}:
 
 stdenv.mkDerivation {
-  name = "vorbis-tools-1.1.1";
+  name = "vorbis-tools-1.4.0";
   src = fetchurl {
-    url = http://downloads.xiph.org/releases/vorbis/vorbis-tools-1.1.1.tar.gz;
-    sha256 = "617b4aa69e600c215b34fa3fd5764bc1d9d205d9d7d9fe7812bde7ec956fcaad";
+    url = http://downloads.xiph.org/releases/vorbis/vorbis-tools-1.4.0.tar.gz;
+    sha256 = "1g12bnh5ah08v529y72kfdz5lhvy75iaz7f9jskyby23m9dkk2d3";
   };
 
-  # FIXME: Vorbis-tools expects `libOggFLAC', but this library was
-  # merged with `libFLAC' as of FLAC 1.1.3.
   buildInputs = [ libogg libvorbis libao pkgconfig curl speex glibc flac ];
 
-  patches = [ ./ogg123-curlopt-mute.patch ];
-
   meta = {
     longDescription = ''
       A set of command-line tools to manipulate Ogg Vorbis audio

pkgs/applications/audio/vorbis-tools/ogg123-curlopt-mute.patch

@@ -1,13 +0,0 @@
---- vorbis-tools-1.1.1/ogg123/http_transport.c	2005-06-13 15:11:44.000000000 +0200
-+++ vorbis-tools-1.1.1/ogg123/http_transport.c	2008-02-12 18:38:41.000000000 +0100
-@@ -116,7 +116,9 @@ void set_curl_opts (http_private_t *priv
-   if (inputOpts.ProxyTunnel)
-     curl_easy_setopt (handle, CURLOPT_HTTPPROXYTUNNEL, inputOpts.ProxyTunnel);
-   */
-+#ifdef CURLOPT_MUTE
-   curl_easy_setopt(handle, CURLOPT_MUTE, 1);
-+#endif
-   curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, private->error);
-   curl_easy_setopt(handle, CURLOPT_PROGRESSFUNCTION, progress_callback);
-   curl_easy_setopt(handle, CURLOPT_PROGRESSDATA, private);
-

pkgs/applications/audio/xsynth-dssi/default.nix

@@ -0,0 +1,37 @@
+{ stdenv, fetchurl, alsaLib, autoconf, automake, dssi, gtk, jackaudio,
+ladspaH, ladspaPlugins, liblo, pkgconfig }:
+
+stdenv.mkDerivation  rec {
+  name = "xsynth-dssi-${version}";
+  version = "0.9.4";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/dssi/${name}.tar.gz";
+    sha256 = "00nwv2pqjbmxqdc6xdm0cljq6z05lv4y6bibmhz1kih9lm0lklnk";
+  };
+
+  buildInputs = [ alsaLib autoconf automake dssi gtk jackaudio ladspaH
+    ladspaPlugins liblo pkgconfig ];
+
+  installPhase = ''
+    ensureDir $out/bin
+    ensureDir $out/lib
+    cp src/Xsynth_gtk $out/bin
+    cp src/.libs/* $out/lib
+  '';
+
+  meta = with stdenv.lib; {
+    description = "classic-analog (VCOs-VCF-VCA) style software synthesizer";
+    longDescription = ''
+      Xsynth-DSSI is a classic-analog (VCOs-VCF-VCA) style software
+      synthesizer which operates as a plugin for the DSSI Soft Synth
+      Interface.  DSSI is a plugin API for software instruments (soft
+      synths) with user interfaces, permitting them to be hosted
+      in-process by audio applications.
+    '';
+    homepage = "http://dssi.sourceforge.net/download.html#Xsynth-DSSI";
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/yoshimi/default.nix

@@ -0,0 +1,36 @@
+{ stdenv, fetchurl, alsaLib, boost, cmakeCurses, fftwSinglePrec, fltk
+, jackaudio, libsndfile, mesa, minixml, pkgconfig, zlib }:
+
+assert stdenv ? glibc;
+
+stdenv.mkDerivation  rec {
+  name = "yoshimi-${version}";
+  version = "0.060.10";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/yoshimi/${name}.tar.bz2";
+    sha256 = "0y67w7y515hx2bi5gfjgsw1hdah1bdrrvcfmqyjsvn7jbd0q47v1";
+  };
+
+  buildInputs = [ alsaLib boost cmakeCurses fftwSinglePrec fltk
+    jackaudio libsndfile mesa minixml pkgconfig zlib ];
+
+  preConfigure = ''
+    cd src
+  '';
+
+  cmakeFlags = [ "-DFLTK_MATH_LIBRARY=${stdenv.glibc}/lib/libm.so" ];
+
+  meta = with stdenv.lib; {
+    description = "high quality software synthesizer based on ZynAddSubFX";
+    longDescription = ''
+      Yoshimi delivers the same synthesizer capabilities as
+      ZynAddSubFX along with very good Jack and Alsa midi/audio
+      functionality on Linux
+    '';
+    homepage = http://yoshimi.sourceforge.net;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/audio/zynaddsubfx/default.nix

@@ -0,0 +1,25 @@
+{ stdenv, fetchurl, alsaLib, fftw, fltk, minixml, zlib }:
+
+stdenv.mkDerivation  rec {
+  name = "zynaddsubfx-${version}";
+  version = "2.4.1";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/zynaddsubfx/ZynAddSubFX-${version}.tar.bz2";
+    sha256 = "1zn5lgh76rrbfj8d4jys2gc1j2pqrbdd18ywfdrk0s7jq4inwyfg";
+  };
+
+  buildInputs = [ alsaLib fftw fltk minixml zlib ];
+
+  preConfigure = "cd src";
+
+  installPhase = "mkdir -p $out/bin; cp zynaddsubfx $out/bin";
+
+  meta = with stdenv.lib; {
+    description = "high quality software synthesizer";
+    homepage = http://zynaddsubfx.sourceforge.net;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.goibhniu ];
+  };
+}

pkgs/applications/display-managers/slim/default.nix

@@ -1,11 +1,11 @@
 {stdenv, fetchurl, x11, libjpeg, libpng, libXmu, freetype, pam}:
 
 stdenv.mkDerivation rec {
-  name = "slim-1.3.1";
+  name = "slim-1.3.2";
 
   src = fetchurl {
     url = "http://download.berlios.de/slim/${name}.tar.gz";
-    sha256 = "0xqgzvg6h1bd29140mcgg9r16vcmskz7zmym7i7jlz7x9c1a9mxc";
+    sha256 = "1f42skdp5k1zrb364s3i0ps5wmx9szz9h192i2dkn9az00jh2mpi";
   };
 
   patches = [

pkgs/applications/editors/bvi/default.nix

@@ -1,4 +1,5 @@
-args : with args;
+{ stdenv, fetchurl, ncurses }:
+
 stdenv.mkDerivation {
   name = "bvi-1.3.2";
 
@@ -7,11 +8,11 @@ stdenv.mkDerivation {
     sha256 = "110wxqnyianqamxq4y53drqqxb9vp4k2fcvic45qggvlqkqhlfgz";
   };
 
-  buildInputs = [ncurses];
+  buildInputs = [ ncurses ];
 
   meta = { 
-      description = "hex editor with vim style keybindings";
-      homepage = http://bvi.sourceforge.net/download.html;
-      license = "GPL2";
+    description = "Hex editor with vim style keybindings";
+    homepage = http://bvi.sourceforge.net/download.html;
+    license = "GPL2";
   };
 }

pkgs/applications/editors/eclipse/default.nix

@@ -5,55 +5,159 @@
 
 assert stdenv ? glibc;
 
-stdenv.mkDerivation rec {
-  name = "eclipse-3.5.1";
-  
-  src =
-    if stdenv.system == "x86_64-linux" then
-      fetchurl {
-        url = http://ftp.ing.umu.se/mirror/eclipse/eclipse/downloads/drops/R-3.5.1-200909170800/eclipse-SDK-3.5.1-linux-gtk-x86_64.tar.gz;
-        sha256 = "132zd7q9q29h978wnlsfbrlszc85r1wj30yqs2aqbv3l5xgny1kk";
-      }
-    else
-      fetchurl {
-        url = http://mirrors.linux-bg.org/eclipse/eclipse/downloads/drops/R-3.5.1-200909170800/eclipse-SDK-3.5.1-linux-gtk.tar.gz;
-        sha256 = "0a0lpa7gxg91zswpahi6fvg3csl4csvlym4z2ad5cc1d4yvicp56";
+let
+
+  buildEclipse =
+    { name, src, description }:
+
+    stdenv.mkDerivation rec {
+      inherit name src;
+
+      desktopItem = makeDesktopItem {
+        name = "Eclipse";
+        exec = "eclipse";
+        icon = "eclipse";
+        comment = "Integrated Development Environment";
+        desktopName = "Eclipse IDE";
+        genericName = "Integrated Development Environment";
+        categories = "Application;Development;";
       };
 
-  desktopItem = makeDesktopItem {
-    name = "Eclipse";
-    exec = "eclipse";
-    icon = "eclipse";
-    comment = "Integrated Development Environment";
-    desktopName = "Eclipse IDE";
-    genericName = "Integrated Development Environment";
-    categories = "Application;Development;";
+      buildInputs = [ makeWrapper patchelf ];
+
+      buildCommand = ''
+        # Unpack tarball.
+        ensureDir $out
+        tar xfvz $src -C $out
+
+        # Patch binaries.
+        interpreter=$(echo ${stdenv.glibc}/lib/ld-linux*.so.2)
+        patchelf --set-interpreter $interpreter $out/eclipse/eclipse
+        patchelf --set-rpath ${freetype}/lib:${fontconfig}/lib:${libX11}/lib:${libXrender}/lib:${zlib}/lib $out/eclipse/libcairo-swt.so
+
+        # Create wrapper script.  Pass -configuration to store
+        # settings in ~/.eclipse/org.eclipse.platform_<version> rather
+        # than ~/.eclipse/org.eclipse.platform_<version>_<number>.
+        productId=$(sed 's/id=//; t; d' $out/eclipse/.eclipseproduct)
+        productVersion=$(sed 's/version=//; t; d' $out/eclipse/.eclipseproduct)
+        
+        makeWrapper $out/eclipse/eclipse $out/bin/eclipse \
+          --prefix PATH : ${jre}/bin \
+          --prefix LD_LIBRARY_PATH : ${glib}/lib:${gtk}/lib:${libXtst}/lib \
+          --add-flags "-configuration \$HOME/.eclipse/''${productId}_$productVersion/configuration"
+
+        # Create desktop item.
+        ensureDir $out/share/applications
+        cp ${desktopItem}/share/applications/* $out/share/applications
+      ''; # */
+
+      meta = {
+        homepage = http://www.eclipse.org/;
+        inherit description;
+      };
+
+    };
+    
+in {
+
+  eclipse_sdk_35 = buildEclipse {
+    name = "eclipse-sdk-3.5.2";
+    description = "Eclipse Classic";
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://archive.eclipse.org/eclipse/downloads/drops/R-3.5.2-201002111343/eclipse-SDK-3.5.2-linux-gtk-x86_64.tar.gz;
+          md5 = "54e2ce0660b2b1b0eb4267acf70ea66d";
+        }
+      else
+        fetchurl {
+          url = http://archive.eclipse.org/eclipse/downloads/drops/R-3.5.2-201002111343/eclipse-SDK-3.5.2-linux-gtk.tar.gz;
+          md5 = "bde55a2354dc224cf5f26e5320e72dac";
+        };
   };
 
-  buildInputs = [ makeWrapper patchelf ];
-  
-  buildCommand = ''
-    # Unpack tarball
-    ensureDir $out
-    tar xfvz $src -C $out
-    
-    # Patch binaries
-    interpreter=$(echo ${stdenv.glibc}/lib/ld-linux*.so.2)
-    patchelf --set-interpreter $interpreter $out/eclipse/eclipse
-    patchelf --set-rpath ${freetype}/lib:${fontconfig}/lib:${libX11}/lib:${libXrender}/lib:${zlib}/lib $out/eclipse/libcairo-swt.so
+  # !!! Use mirror://eclipse/.
 
-    # Create wrapper script
-    makeWrapper $out/eclipse/eclipse $out/bin/eclipse \
-      --prefix PATH : ${jre}/bin \
-      --prefix LD_LIBRARY_PATH : ${glib}/lib:${gtk}/lib:${libXtst}/lib
-    
-    # Create desktop item
-    ensureDir $out/share/applications
-    cp ${desktopItem}/share/applications/* $out/share/applications
-  '';
-
-  meta = {
-    homepage = http://www.eclipse.org/;
-    description = "A extensible multi-language software development environment";
+  eclipse_sdk_36 = buildEclipse {
+    name = "eclipse-sdk-3.6.2";
+    description = "Eclipse Classic";
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://ftp.ing.umu.se/mirror/eclipse/eclipse/downloads/drops/R-3.6.2-201102101200/eclipse-SDK-3.6.2-linux-gtk-x86_64.tar.gz;
+          sha256 = "0dfcfadcd6337c897fbfd5b292de481931dfce12d43289ecb93691fd27dd47f4";
+        }
+      else
+        fetchurl {
+          url = http://ftp.ing.umu.se/mirror/eclipse/eclipse/downloads/drops/R-3.6.2-201102101200/eclipse-SDK-3.6.2-linux-gtk.tar.gz;
+          sha256 = "1bh8ykliqr8wbciv13vpiy50rvm7yszk7y8dslr796dbwhi5b1cj";
+        };
   };
+
+  eclipse_cpp_36 = buildEclipse {
+    name = "eclipse-cpp-3.6.2";
+    description = "Eclipse IDE for C/C++ Developers";
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://ftp-stud.fht-esslingen.de/pub/Mirrors/eclipse/technology/epp/downloads/release/helios/SR2/eclipse-cpp-helios-SR2-linux-gtk-x86_64.tar.gz;
+          sha1 = "6f914e11fa15a900c46825e4aa8299afd76e7e65";
+        }
+      else
+        fetchurl {
+          url = http://ftp-stud.fht-esslingen.de/pub/Mirrors/eclipse/technology/epp/downloads/release/helios/SR2/eclipse-cpp-helios-SR2-linux-gtk.tar.gz;
+          sha1 = "1156e4bc0253ae3a3a4e54839e4944dc64d3108f";
+        };
+  };
+
+  eclipse_modeling_36 = buildEclipse {
+    name = "eclipse-modeling-3.6.2";
+    description = "Eclipse Modeling Tools (includes Incubating components)";
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://ftp-stud.fht-esslingen.de/pub/Mirrors/eclipse/technology/epp/downloads/release/helios/SR2/eclipse-modeling-helios-SR2-incubation-linux-gtk-x86_64.tar.gz;
+          sha1 = "e96f5f006298f68476f4a15a2be8589158d5cc61";
+        }
+      else
+        fetchurl {
+          url = http://ftp-stud.fht-esslingen.de/pub/Mirrors/eclipse/technology/epp/downloads/release/helios/SR2/eclipse-modeling-helios-SR2-incubation-linux-gtk.tar.gz;
+          sha1 = "696377895bb26445de39d82a916b7e69edb1d939";
+        };
+  };
+
+  eclipse_sdk_37 = buildEclipse {
+    name = "eclipse-sdk-3.7";
+    description = "Eclipse Classic";
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://eclipse.ialto.com/eclipse/downloads/drops/R-3.7-201106131736/eclipse-SDK-3.7-linux-gtk-x86_64.tar.gz;
+          sha256 = "00ig3ww98r8imf32sx5npm6csn5nx288gvdk6w653nijni0di16j";
+        }
+      else
+        fetchurl {
+          url = http://eclipse.ialto.com/eclipse/downloads/drops/R-3.7-201106131736/eclipse-SDK-3.7-linux-gtk.tar.gz;
+          sha256 = "08rgw85cam51l98mzb39fdc3ykb369v8pap93qhknbs6a3f5dnff";
+        };
+  };
+
+  eclipse_cpp_37 = buildEclipse {
+    name = "eclipse-cpp-3.7";
+    description = "Eclipse IDE for C/C++ Developers";
+    src =
+      if stdenv.system == "x86_64-linux" then
+        fetchurl {
+          url = http://eclipse.ialto.com/technology/epp/downloads/release/indigo/R/eclipse-cpp-indigo-incubation-linux-gtk-x86_64.tar.gz;
+          sha256 = "14ppc9g9igzvj1pq7jl01vwhzb66nmzbl9wsdl1sf3xnwa9wnqk3";
+        }
+      else
+        fetchurl {
+          url = http://eclipse.ialto.com/technology/epp/downloads/release/indigo/R/eclipse-cpp-indigo-incubation-linux-gtk.tar.gz;
+          sha256 = "1cvg1vgyazrkinwzlvlf0dpl197p4784752srqybqylyj5psdi3b";
+        };
+  };
+
+
 }
+

pkgs/applications/editors/ed/default.nix

@@ -10,6 +10,10 @@ stdenv.mkDerivation rec {
 
   doCheck = true;
 
+  crossAttrs = {
+    compileFlags = [ "CC=${stdenv.cross.config}-gcc" ];
+  };
+
   meta = {
     description = "GNU ed, an implementation of the standard Unix editor";
 

pkgs/applications/editors/emacs-22/default.nix

@@ -16,17 +16,17 @@ stdenv.mkDerivation rec {
   name = "emacs-22.3";
 
   builder = ./builder.sh;
-  
+
   src = fetchurl {
     url = "mirror://gnu/emacs/${name}.tar.gz";
     sha256 = "05hd89bchcpwzcx5la0alcp0wb7xywvnf98dxrshrqlfvccvgnbv";
   };
-  
+
   buildInputs = [ncurses x11]
     ++ stdenv.lib.optional xawSupport (if xaw3dSupport then Xaw3d else libXaw)
     ++ stdenv.lib.optional xpmSupport libXpm
     ++ stdenv.lib.optionals gtkGUI [pkgconfig gtk];
-  
+
   configureFlags =
     stdenv.lib.optional gtkGUI "--with-x-toolkit=gtk";
 
@@ -43,6 +43,6 @@ stdenv.mkDerivation rec {
     homepage = http://www.gnu.org/software/emacs/;
     license = "GPLv3+";
 
-    platforms = stdenv.lib.platforms.linux;  # GTK & co. are needed.
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/applications/editors/emacs-23/default.nix

@@ -1,46 +1,35 @@
-{ xawSupport ? true
-, xpmSupport ? true
-, dbusSupport ? true
-, xaw3dSupport ? false
-, gtkGUI ? false
-, xftSupport ? false
-, stdenv, fetchurl, ncurses, x11, libXaw ? null, libXpm ? null, Xaw3d ? null
-, pkgconfig ? null, gtk ? null, libXft ? null, dbus ? null
-, libpng, libjpeg, libungif, libtiff, texinfo
+{ stdenv, fetchurl, ncurses, x11, libXaw, libXpm, Xaw3d
+, pkgconfig, gtk, libXft, dbus, libpng, libjpeg, libungif
+, libtiff, librsvg, texinfo, gconf
 }:
 
-assert xawSupport -> libXaw != null;
-assert xpmSupport -> libXpm != null;
-assert dbusSupport -> dbus != null;
-assert xaw3dSupport -> Xaw3d != null;
-assert gtkGUI -> pkgconfig != null && gtk != null;
-assert xftSupport -> libXft != null && libpng != null; # libpng = probably a bug
-assert stdenv.system == "i686-darwin" -> xawSupport; # fails to link otherwise
+assert (gtk != null) -> (pkgconfig != null);
+assert (libXft != null) -> libpng != null;	# probably a bug
+assert stdenv.isDarwin -> libXaw != null;	# fails to link otherwise
 
 stdenv.mkDerivation rec {
-  name = "emacs-23.1";
+  name = "emacs-23.3";
 
   builder = ./builder.sh;
 
   src = fetchurl {
     url = "mirror://gnu/emacs/${name}.tar.bz2";
-    sha256 = "076b4ixdp29l4c02bwic26d14gxlj0lcqyam33wyj3ksgi2z8d9b";
+    sha256 = "0kfa546qi0idkwk29gclgi13qd8q54pcqgy9qwjknlclszprdp3a";
   };
 
-  buildInputs = [
-    ncurses x11 texinfo
-    (if xawSupport then libXaw else null)
-    (if xpmSupport then libXpm else null)
-    (if dbusSupport then dbus else null)
-    (if xaw3dSupport then Xaw3d else null)
-    libpng libjpeg libungif libtiff # maybe not strictly required?
-  ]
-  ++ (if gtkGUI then [pkgconfig gtk] else [])
-  ++ (if xftSupport then [libXft] else []);
+  buildInputs = 
+    [ ncurses x11 texinfo libXaw Xaw3d libXpm libpng libjpeg libungif
+      libtiff librsvg libXft gconf
+    ] 
+    ++ stdenv.lib.optionals (gtk != null) [ gtk pkgconfig ]
+    ++ stdenv.lib.optional stdenv.isLinux dbus;
 
-  configureFlags = "
-    ${if gtkGUI then "--with-x-toolkit=gtk --enable-font-backend --with-xft" else ""}
-  ";
+  configureFlags =
+    stdenv.lib.optionals (gtk != null) [ "--with-x-toolkit=gtk" "--with-xft"]
+
+    # On NixOS, help Emacs find `crt*.o'.
+    ++ stdenv.lib.optional (stdenv ? glibc)
+         [ "--with-crt-dir=${stdenv.glibc}/lib" ];
 
   doCheck = true;
 
@@ -67,7 +56,7 @@ stdenv.mkDerivation rec {
     homepage = http://www.gnu.org/software/emacs/;
     license = "GPLv3+";
 
-    maintainers = [ stdenv.lib.maintainers.ludo ];
-    platforms = stdenv.lib.platforms.linux;  # GTK & co. are needed.
+    maintainers = [ stdenv.lib.maintainers.ludo stdenv.lib.maintainers.simons ];
+    platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/applications/editors/emacs-modes/bbdb/builder.sh

@@ -1,12 +0,0 @@
-source "$stdenv/setup" || exit 1
-
-unpackPhase &&							\
-cd bbdb-*.* && patchPhase &&					\
-./configure --prefix="$out"					\
-            --with-package-dir="$out/share/emacs/site-lisp" &&	\
-make && make install-pkg &&					\
-mkdir -p "$out/info" &&						\
-make -C texinfo install-pkg &&					\
-mv "$out/share/emacs/site-lisp/lisp/bbdb/"*			\
-   "$out/share/emacs/site-lisp" &&				\
-rm -rf "$out/share/emacs/site-lisp/lisp"

pkgs/applications/editors/emacs-modes/bbdb/default.nix

@@ -11,7 +11,20 @@ stdenv.mkDerivation {
   patches = [ ./install-infodir.patch ];
 
   buildInputs = [emacs texinfo ctags];
-  builder = ./builder.sh;
+  configureFlags = "--with-package-dir=$$out/share/emacs/site-lisp";
+  preInstall = "ensureDir $out/info";
+  installTargets = "install-pkg texinfo";
+  postInstall = ''
+    mv  $out/info $out/share/
+    mv "$out/share/emacs/site-lisp/lisp/bbdb/"* $out/share/emacs/site-lisp/
+    mv $out/share/emacs/site-lisp/etc/bbdb $out/share/
+    rm -rf $out/share/emacs/site-lisp/{lisp,etc}
+    mv bits $out/share/bbdb/
+    # Make optional modules from bbdb available for import, but symlink
+    # them into the site-lisp directory to make it obvious that they are
+    # not a genuine part of the distribution.
+    ln -s "$out/share/bbdb/bits/"*.el $out/share/emacs/site-lisp/
+  '';
 
   meta = {
     description = "The Insidious Big Brother Database (BBDB), a contact management utility for Emacs";

pkgs/applications/editors/emacs-modes/emms/default.nix

@@ -1,5 +1,5 @@
 { stdenv, fetchurl, emacs, texinfo
-, mpg321, vorbisTools, taglib, alsaUtils }:
+, mpg321, vorbisTools, taglib, mp3info, alsaUtils }:
 
 # XXX: EMMS also supports Xine, MPlayer, Jack, etc.
 
@@ -36,12 +36,18 @@ stdenv.mkDerivation rec {
     # Use the libtag info back-end for MP3s since we're building it.
     sed -i "emms-setup.el" \
         -e 's|emms-info-mp3info|emms-info-libtag|g'
+
+    # But use mp3info for the tag editor.
+    sed -i "emms-info-mp3info.el" \
+        -e 's|emms-info-mp3info-program-name[[:blank:]]\+"mp3info"|emms-info-mp3info-program-name "${mp3info}/bin/mp3info"|g'
+    sed -i "emms-tag-editor.el" \
+        -e 's|"mp3info"|"${mp3info}/bin/mp3info"|g'
   '';
 
   postInstall = ''
     ensureDir "$out/bin" && cp emms-print-metadata "$out/bin"
   '';
-  
+
   meta = {
     description = "GNU EMMS, The Emacs Multimedia System";
 
@@ -57,6 +63,10 @@ stdenv.mkDerivation rec {
     '';
 
     homepage = http://www.gnu.org/software/emms/;
+
     license = "GPLv3+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo ];
+    platforms = stdenv.lib.platforms.gnu;
   };
 }

pkgs/applications/editors/emacs-modes/haskell/default.nix

@@ -1,11 +1,11 @@
 {stdenv, fetchurl, emacs}:
 
 stdenv.mkDerivation rec {
-  name = "haskell-mode-2.6.1";
+  name = "haskell-mode-2.8.0";
 
   src = fetchurl {
     url = "http://projects.haskell.org/haskellmode-emacs/${name}.tar.gz";
-    sha256 = "cc33fd0d4692667a6eb56fea3dc549de3897d8dbb7b71818489760f45d564a76";
+    sha256 = "1065g4xy3ca72xhqh6hfxs5j3mls82bli8w5rhz1npzyfwlwhkb1";
   };
 
   buildInputs = [emacs];
@@ -14,4 +14,12 @@ stdenv.mkDerivation rec {
     ensureDir "$out/share/emacs/site-lisp"
     cp *.el *.elc *.hs "$out/share/emacs/site-lisp/"
   '';
+
+  meta = {
+    homepage = "http://projects.haskell.org/haskellmode-emacs/";
+    description = "Haskell mode package for Emacs";
+
+    platforms = stdenv.lib.platforms.unix;
+    maintainers = [ stdenv.lib.maintainers.simons ];
+  };
 }

pkgs/applications/editors/emacs-modes/hol_light/default.nix

@@ -0,0 +1,25 @@
+{stdenv, fetchsvn}:
+
+let
+  revision = "73";
+in
+
+stdenv.mkDerivation {
+  name = "hol_light_mode-${revision}";
+
+  src = fetchsvn {
+    url = http://seanmcl-ocaml-lib.googlecode.com/svn/trunk/workshop/software/emacs;
+    rev = revision;
+    sha256 = "3ca83098960439da149a47e1caff32536601559a77f04822be742a390c67feb7";
+  };
+
+  installPhase = ''
+    DEST=$out/share/emacs/site-lisp
+    ensureDir $DEST
+    cp -a * $DEST
+  '';
+
+  meta = {
+    description = "A HOL Light mode for emacs";
+  };
+}

pkgs/applications/editors/emacs-modes/htmlize/builder.sh

@@ -0,0 +1,4 @@
+source $stdenv/setup
+
+mkdir -p $out/share/emacs/site-lisp
+cp $src $out/share/emacs/site-lisp/htmlize.el

pkgs/applications/editors/emacs-modes/htmlize/default.nix

@@ -0,0 +1,16 @@
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation {
+  name = "htmlize-1.37";
+
+  builder = ./builder.sh;
+
+  src = fetchurl {
+    url = http://fly.srk.fer.hr/~hniksic/emacs/htmlize.el;
+    sha256 = "17sbhf4r6jh4610x8qb2y0y3hww7w33vfsjqg4vrz99pr29xffry";
+  };
+
+  meta = {
+    description = "Convert buffer text and decorations to HTML.";
+  };
+}

pkgs/applications/editors/emacs-modes/jabber/default.nix

@@ -0,0 +1,23 @@
+{ stdenv, fetchurl, emacs }:
+stdenv.mkDerivation rec {
+  pname  = "emacs-jabber";
+  version = "0.8.0";
+  name = "${pname}-${version}";
+  src = fetchurl {
+    url = "mirror://sourceforge/${pname}/${name}.tar.bz2";
+    sha256 = "75e3b7853de4783b8ab8270dcbe6a1e4f576224f77f7463116532e11c6498c26";
+  };
+  buildInputs = [ emacs ];
+  meta = {
+    description = "A Jabber client for Emacs";
+    longDescription = ''
+      jabber.el is a Jabber client for Emacs. It may seem strange to have a
+      chat client in an editor, but consider that chatting is, after all, just
+      a special case of text editing.
+    '';
+    homepage = http://emacs-jabber.sourceforge.net/;
+    license = [ "GPLv2+" ];
+    maintainers = with stdenv.lib.maintainers; [ astsmtl ];
+    platforms = with stdenv.lib.platforms; linux;
+  };
+}

pkgs/applications/editors/emacs-modes/jdee/default.nix

@@ -9,12 +9,13 @@ in
     # Last release is too old, so use SVN.
     # See http://www.emacswiki.org/emacs/JavaDevelopmentEnvironment .
     src = fetchsvn {
-      # Looks like they're not sure whether to put one or two `e'...
-      url = "https://jdee.svn.sourceforge.net/svnroot/jdee/trunk/jde";
+      url = "https://jdee.svn.sourceforge.net/svnroot/jdee/trunk/jdee";
       rev = revision;
-      sha256 = "0pjkbr1srx2m428xkky1csf97fr5219prs4dif7njlydyrwp0gnn";
+      sha256 = "1qj5cv74dp6nf6060jyvnlcbmc4sz8a09806gwa1zfiwz6mm9zrs";
     };
 
+    patchFlags = "-p1 --ignore-whitespace";
+
     patches = [
       ./build-properties.patch
       ./cedet-paths.patch ./elib-avltree.patch
@@ -91,5 +92,6 @@ in
       license = "GPLv2+";
 
       maintainers = [ stdenv.lib.maintainers.ludo ];
+      platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
     };
   }

pkgs/applications/editors/emacs-modes/magit/default.nix

@@ -1,17 +1,25 @@
-{stdenv, fetchurl, emacs, texinfo}:
+{ stdenv, fetchurl, emacs, texinfo }:
 
+let
+  version = "1.0.0";
+in
 stdenv.mkDerivation {
-  name = "magit-0.7";
+  name = "magit-${version}";
 
   src = fetchurl {
-    url = "http://zagadka.vm.bytemark.co.uk/magit/magit-0.7.tar.gz";
-    sha256 = "0qry1vj41pycwkf71sqrz3zgzh85zdg5acq26asscq4s7jksrjiz";
+    url = "http://github.com/downloads/magit/magit/magit-${version}.tar.gz";
+    sha256 = "1hfdl90d96zin31v8x4p8zx5f0x0i5i9hccysx6q3prdgw9r6wzq";
   };
 
   buildInputs = [emacs texinfo];
 
+  configurePhase =
+    '' sed -i Makefile \
+           -e "s|^PREFIX=.*$|PREFIX=$out|g ; s|/etc/emacs/|$out/etc/emacs/|"
+    '';
+
   meta = {
-    description = "An an interface to Git, implemented as an extension to Emacs.";
+    description = "Magit, an Emacs interface to Git";
 
     longDescription = ''
       With Magit, you can inspect and modify your Git repositories with
@@ -26,6 +34,8 @@ stdenv.mkDerivation {
     '';
 
     license = "GPLv3+";
-    homepage = "http://zagadka.vm.bytemark.co.uk/magit/";
+    homepage = "http://github.com/philjackson/magit";
+    platforms = stdenv.lib.platforms.all;
+    maintainers = with stdenv.lib.maintainers; [ simons ludo ];
   };
 }

pkgs/applications/editors/emacs-modes/maude/default.nix

@@ -1,13 +1,20 @@
 {stdenv, fetchurl, emacs}:
 
-stdenv.mkDerivation
-{
-  name = "maude-mode-0.1";
-  src = fetchurl
-  {
-    url = "mirror://sourceforge/maude-mode/maude-mode.tar.gz";
-    sha256 = "12555j01mar48da2jy3ay93xfn7ybl23bpvhp0srzg8858gisx5g";
+stdenv.mkDerivation {
+  name = "maude-mode-0.2";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/maude-mode/maude-mode-0.2.tar.gz";
+    sha256 = "19jdd7la0bxxxnnq4ryckf63jykg0r3v92z126x6djaigi3xn1yx";
   };
+
   buildInputs = [emacs];
   configureFlags = "--with-lispdir=$$out/share/emacs/site-lisp";
+
+  meta = {
+    description = "Emacs mode for the programming language Maude";
+    license = "GPLv2";
+    platforms = stdenv.lib.platforms.all;
+    maintainers = [ stdenv.lib.maintainers.simons ];
+  };
 }

pkgs/applications/editors/emacs-modes/org/default.nix

@@ -0,0 +1,55 @@
+{ fetchurl, stdenv, emacs, texinfo, which }:
+
+stdenv.mkDerivation rec {
+  name = "org-7.5";
+
+  src = fetchurl {
+    url = "http://orgmode.org/${name}.tar.gz";
+    sha256 = "978822bc4c5f9f67450fbaa8572f1d4217406b7e28551278c9f23f7e9515cd4b";
+  };
+
+  buildInputs = [ emacs texinfo ];
+
+  patchPhase =
+    '' sed -i "lisp/org-clock.el" -e's|"which"|"${which}/bin/which"|g'
+    '';
+
+  configurePhase =
+    '' sed -i Makefile \
+           -e "s|^prefix=.*$|prefix=$out|g"
+    '';
+
+  #XXX: fails because of missing UTILITIES/manfull.pl, currently not
+  # included in the release tarball, but git.
+
+  #postBuild =
+  #  '' make doc
+  #  '';
+
+  installPhase =
+    '' make install install-info
+
+       ensureDir "$out/share/doc/${name}"
+       cp -v doc/org*.{html,pdf,txt} "$out/share/doc/${name}"
+
+       ensureDir "$out/share/org"
+       cp -R contrib "$out/share/org/contrib"
+    '';
+
+  meta = {
+    description = "Org-Mode, an Emacs mode for notes, project planning, and authoring";
+
+    longDescription =
+      '' Org-mode is for keeping notes, maintaining ToDo lists, doing project
+         planning, and authoring with a fast and effective plain-text system.
+
+         This package contains a version of Org-mode typically more recent
+         than that found in GNU Emacs.
+      '';
+
+    license = "GPLv3+";
+
+    maintainers = [ stdenv.lib.maintainers.ludo stdenv.lib.maintainers.chaoflow ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
+  };
+}

pkgs/applications/editors/emacs-modes/php/builder.sh

@@ -0,0 +1,7 @@
+source $stdenv/setup
+
+mkdir -p $out/share/emacs/site-lisp
+cd $out/share/emacs/site-lisp
+tar xvfz $src
+mv php-mode-*/* .
+rmdir php-mode-*

pkgs/applications/editors/emacs-modes/php/default.nix

@@ -0,0 +1,12 @@
+{stdenv, fetchurl}:
+
+stdenv.mkDerivation rec {
+  name = "php-mode-1.5.0";
+
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/php-mode/${name}.tar.gz";
+    sha256 = "1bffgg4rpiggxqc1hvjcby24sfyzj5728zg7r6f4v6a126a7kcfq";
+  };
+
+  builder = ./builder.sh;
+}

pkgs/applications/editors/emacs-modes/proofgeneral/default.nix

@@ -0,0 +1,43 @@
+{ stdenv, fetchurl, emacs, texinfo, texLive, perl, which, automake }:
+
+stdenv.mkDerivation (rec {
+  name = "ProofGeneral-4.0";
+
+  src = fetchurl {
+    url = http://proofgeneral.inf.ed.ac.uk/releases/ProofGeneral-4.0.tgz;
+    sha256 = "1ang2lsc97vl70fkgypfsr1ivdzsdliq3bkvympj30wnc7ayzbmq";
+  };
+
+  sourceRoot = name;
+
+  buildInputs = [ emacs texinfo texLive perl which ];
+
+  patches = [ ./emacs-23.3.patch ];
+
+  postPatch =
+    '' sed -i "Makefile" \
+           -e "s|^\(\(DEST_\)\?PREFIX\)=.*$|\1=$out|g ; \
+               s|/sbin/install-info|install-info|g"
+
+       sed -i "bin/proofgeneral" -e's/which/type -p/g'
+    '';
+
+  preBuild = "make clean";
+
+  installPhase =
+    # Copy `texinfo.tex' in the right place so that `texi2pdf' works.
+    '' cp -v "${automake}/share/"automake-*/texinfo.tex doc
+       make install install-doc
+    '';
+
+  meta = {
+    description = "Proof General, an Emacs front-end for proof assistants";
+    longDescription = ''
+      Proof General is a generic front-end for proof assistants (also known as
+      interactive theorem provers), based on the customizable text editor Emacs.
+    '';
+    homepage = http://proofgeneral.inf.ed.ac.uk;
+    license = "GPLv2+";
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
+  };
+})

pkgs/applications/editors/emacs-modes/proofgeneral/emacs-23.3.patch

@@ -0,0 +1,45 @@
+diff -Nuar ProofGeneral-4.0/contrib/mmm/mmm-mode.el ProofGeneral-4.0-nix/contrib/mmm/mmm-mode.el
+--- ProofGeneral-4.0/contrib/mmm/mmm-mode.el	2010-10-11 00:56:57.000000000 +0200
++++ ProofGeneral-4.0-nix/contrib/mmm/mmm-mode.el	2011-05-14 21:55:12.000000000 +0200
+@@ -160,9 +160,9 @@
+      (mmm-add-hooks)
+      (mmm-fixup-skeleton)
+      (make-local-variable 'font-lock-fontify-region-function)
+-     (make-local-variable 'font-lock-beginning-of-syntax-function)
++     (make-local-variable 'syntax-begin-function)
+      (setq font-lock-fontify-region-function 'mmm-fontify-region
+-	   font-lock-beginning-of-syntax-function 'mmm-beginning-of-syntax)
++	   syntax-begin-function 'mmm-beginning-of-syntax)
+      (setq mmm-mode t)
+      (condition-case err
+ 	 (mmm-apply-all)
+@@ -190,7 +190,7 @@
+     (mmm-update-submode-region)
+     (setq font-lock-fontify-region-function
+ 	  (get mmm-primary-mode 'mmm-fontify-region-function)
+-	  font-lock-beginning-of-syntax-function
++	  syntax-begin-function
+ 	  (get mmm-primary-mode 'mmm-beginning-of-syntax-function))
+     (mmm-update-font-lock-buffer)
+     (mmm-refontify-maybe)
+diff -Nuar ProofGeneral-4.0/contrib/mmm/mmm-region.el ProofGeneral-4.0-nix/contrib/mmm/mmm-region.el
+--- ProofGeneral-4.0/contrib/mmm/mmm-region.el	2010-10-11 00:56:57.000000000 +0200
++++ ProofGeneral-4.0-nix/contrib/mmm/mmm-region.el	2011-05-14 21:58:01.000000000 +0200
+@@ -548,7 +548,7 @@
+ 	    (put mode 'mmm-fontify-region-function
+ 		 font-lock-fontify-region-function))
+ 	  (put mode 'mmm-beginning-of-syntax-function
+-	       font-lock-beginning-of-syntax-function))
++	       syntax-begin-function))
+ 	;; Get variables
+ 	(setq global-vars (mmm-get-locals 'global)
+ 	      buffer-vars (mmm-get-locals 'buffer)
+@@ -768,7 +768,7 @@
+   ;; For some reason `font-lock-fontify-block' binds this to nil, thus
+   ;; preventing `mmm-beginning-of-syntax' from doing The Right Thing.
+   ;; I don't know why it does this, but let's undo it here.
+-  (let ((font-lock-beginning-of-syntax-function 'mmm-beginning-of-syntax))
++  (let ((syntax-begin-function 'mmm-beginning-of-syntax))
+     (mapc #'(lambda (elt)
+ 		(when (get (car elt) 'mmm-font-lock-mode)
+ 		  (mmm-fontify-region-list (car elt) (cdr elt))))

pkgs/applications/editors/emacs-modes/quack/default.nix

@@ -1,12 +1,12 @@
 { fetchurl, stdenv, emacs }:
 
 stdenv.mkDerivation {
-  name = "quack-0.37";
+  name = "quack-0.39";
 
   src = fetchurl {
     # XXX: Upstream URL is not versioned, which might eventually break this.
     url = "http://www.neilvandyke.org/quack/quack.el";
-    sha256 = "1q5442cpvw2i0qhmhn7mh45jnmzg0cmd01k5zp4gvg1526c0hbcc";
+    sha256 = "1w3p03f1f3l2nldxc7dig1kkgbbvy5j7zid0cfmkcrpp1qrcsqic";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/editors/emacs-modes/rudel/default.nix

@@ -0,0 +1,28 @@
+{stdenv, fetchurl}:
+
+let
+    version = "0.2-4";
+in
+stdenv.mkDerivation
+{
+  name = "rudel-${version}";
+  src = fetchurl
+  {
+    url = "mirror://sourceforge/rudel/rudel-${version}.tar.gz";
+    sha256 = "68247bfb702d929877f6d098932e8b0ca45c573a3510187e1ccc43e5ea194f25";
+  };
+
+  installPhase = ''
+    for n in . obby zeroconf jupiter; do
+      ensureDir "$out/share/emacs/site-lisp/$n";
+      cp $n/*.el "$out/share/emacs/site-lisp/$n/";
+    done
+    install -D -m444 doc/card.pdf "$out/share/doc/rudel/card.pdf"
+  '';
+
+  meta = {
+    homepage = "http://rudel.sourceforge.net/";
+    description = "Rudel is a collaborative editing environment for GNU Emacs";
+    license = "GPL";
+  };
+}

pkgs/applications/editors/gobby/default.nix

@@ -0,0 +1,31 @@
+{ avahiSupport ? false # build support for Avahi in libinfinity
+, gnomeSupport ? false # build support for Gnome(gnome-vfs)
+, stdenv, fetchurl, pkgconfig
+, gtkmm, gsasl, gtksourceview, libxmlxx, libinfinity, intltool
+, gnomevfs ? null}:
+
+let
+  libinf = libinfinity.override { gtkWidgets = true; inherit avahiSupport; };
+  
+in stdenv.mkDerivation rec {
+
+  name = "gobby-0.4.93";
+  src = fetchurl {
+    url = "http://releases.0x539.de/gobby/${name}.tar.gz";
+    sha256 = "1zk6p0kdp9vcvrr3kx0kw106ln309hd7bbsq8li1g0pcnkgrf4q4";
+  };
+
+  buildInputs = [ pkgconfig gtkmm gsasl gtksourceview libxmlxx libinf intltool ]
+    ++ stdenv.lib.optional gnomeSupport gnomevfs;
+  
+  configureFlags = ''
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = http://gobby.0x539.de/;
+    description = "A GTK-based collaborative editor supporting multiple documents in one session and a multi-user chat";
+    license = "GPLv2+";
+    maintainers = [ maintainers.phreedom ];
+    platforms = platforms.all;
+  };
+}

pkgs/applications/editors/jedit/default.nix

@@ -1,4 +1,5 @@
-args: with args;
+{ stdenv, fetchurl, ant }:
+
 stdenv.mkDerivation {
   name = "jedit-4.2";
 
@@ -18,11 +19,11 @@ stdenv.mkDerivation {
     cp modes/catalog \$out/lib/modes
   ";
 
-  buildInputs = [ant];
+  buildInputs = [ ant ];
 
   meta = { 
-      description = "really nice programmers editor written in Java. Give it a try";
-      homepage = http://www.jedit.org;
-      license = "GPL";
+    description = "really nice programmers editor written in Java. Give it a try";
+    homepage = http://www.jedit.org;
+    license = "GPL";
   };
 }

pkgs/applications/editors/kdevelop/default.nix

@@ -0,0 +1,36 @@
+{ stdenv, fetchurl, kdevplatform, cmake, pkgconfig, automoc4, shared_mime_info,
+  kdebase_workspace, gettext, perl, kdeutils, kdesdk }:
+
+let
+  okteta = if kdeutils ? okteta then kdeutils.okteta else kdesdk.okteta;
+in
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+  version = "4.2.3";
+  pname = "kdevelop";
+
+  src = fetchurl {
+    url = "mirror://kde/stable/${pname}/${version}/src/${name}.tar.bz2";
+    sha256 = "0ay3d2s5442pvdsx9lyfzb986kh6848qhbls9ff982f0glzqdcya";
+  };
+
+  buildInputs = [ kdevplatform cmake pkgconfig automoc4 shared_mime_info
+    kdebase_workspace gettext stdenv.gcc.libc perl okteta ];
+
+  NIX_CFLAGS_COMPILE = "-I${okteta}/include/KDE";
+
+  meta = with stdenv.lib; {
+    maintainers = [ maintainers.urkud ];
+    platforms = platforms.linux;
+    description = "KDE official IDE";
+    longDescription =
+      ''
+        A free, opensource IDE (Integrated Development Environment)
+        for MS Windows, Mac OsX, Linux, Solaris and FreeBSD. It is a
+        feature-full, plugin extendable IDE for C/C++ and other
+        programing languages. It is based on KDevPlatform, KDE and Qt
+        libraries and is under development since 1998.
+      '';
+    homepage = http://www.kdevelop.org;
+  };
+}

pkgs/applications/editors/leksah/default.nix

@@ -1,26 +1,28 @@
-{cabal, gtk2hs, binary, parsec, regexPosix, regexCompat, utf8String, libedit, makeWrapper}:
+{ cabal, binary, binaryShared, deepseq, glib, gtk, gtksourceview2
+, hslogger, leksahServer, ltk, mtl, network, parsec, processLeksah
+, regexBase, regexTdfa, strict, time, utf8String
+}:
 
-cabal.mkDerivation (self : {
+cabal.mkDerivation (self: {
   pname = "leksah";
-  version = "0.6.1";
-  sha256 = "de4e0974be3df0e58fd26bfbb76594d81514f1e1d898b9f47881b42084bacf35";
-
-  # !!! The explicit libedit dependency shouldn't be necessary.
-  extraBuildInputs = [gtk2hs binary parsec regexPosix regexCompat utf8String libedit makeWrapper];
-
-  preConfigure =
-    ''
-      substituteInPlace leksah.cabal --replace 'Cabal ==1.6.0.1' 'Cabal >=1.6.0.1' 
-    '';
-
-  postInstall =
-    ''
-      wrapProgram $out/bin/leksah --prefix XDG_DATA_DIRS : ${gtk2hs.gtksourceview}/share
-    '';
-  
+  version = "0.10.0.4";
+  sha256 = "1g12w1kl63fxzz1c2x237yrqkaja9awiqyyipkdms5iql0ini7bw";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    binary binaryShared deepseq glib gtk gtksourceview2 hslogger
+    leksahServer ltk mtl network parsec processLeksah regexBase
+    regexTdfa strict time utf8String
+  ];
+  noHaddock = true;
   meta = {
-    homepage = http://leksah.org/;
-    description = "An Integrated Development Environment for Haskell written in Haskell";
+    homepage = "http://www.leksah.org";
+    description = "Haskell IDE written in Haskell";
+    license = "GPL";
+    platforms = self.stdenv.lib.platforms.linux;
+    maintainers = [
+      self.stdenv.lib.maintainers.andres
+      self.stdenv.lib.maintainers.simons
+    ];
   };
-})  
-
+})

pkgs/applications/editors/nano/default.nix

@@ -1,17 +1,19 @@
-args: with args;
+{ stdenv, fetchurl, ncurses, gettext }:
+
 stdenv.mkDerivation (rec {
   pname = "nano";
-  version = "2.0.7";
+  version = "2.2.3";
 
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "mirror://gnu/nano/${name}.tar.gz";
-    sha256 = "5dc783c412c4d1ff463c450d2a2f9e1ea53a43d9ba1dda92bbf5182f60db532f";
+    sha256 = "1vpl993xrpj8bqi1ayga8fc0j2jag90xp6rqakzwm3bxw71hmwi2";
   };
-  buildInputs = [ncurses gettext];
-#  configureFlags = "--enable-tiny";
-  configureFlags = "
+  
+  buildInputs = [ ncurses gettext ];
+  
+  configureFlags = ''
     --disable-browser 
     --disable-help 
     --disable-justify 
@@ -20,7 +22,7 @@ stdenv.mkDerivation (rec {
     --disable-speller
     --disable-tabcomp
     --disable-wrapping
-  ";
+  '';
 
   meta = {
     homepage = http://www.nano-editor.org/;

pkgs/applications/editors/nvi/default.nix

@@ -4,7 +4,11 @@ stdenv.mkDerivation rec {
   name = "nvi-1.79";
 
   src = fetchurl {
-    url = ftp://ftp.bostic.com/pub/nvi-1.79.tar.gz;
+    urls =
+      [ "ftp://ftp.eenet.ee/pub/cpan/src/misc/nvi-1.79.tar.gz"
+        "ftp://ftp.saintjoe.edu/pub/CPAN/src/misc/nvi-1.79.tar.gz"
+        "ftp://ftp.free.fr/.mirrors1/ftp.netbsd.org/packages/distfiles/nvi-1.79.tar.gz"
+      ];
     sha256 = "0cvf56rbylz7ksny6g2256sjg8yrsxrmbpk82r64rhi53sm8fnvm";
   };
 

pkgs/applications/editors/texmacs/default.nix

@@ -0,0 +1,95 @@
+{stdenv, fetchurl, guile, libX11, libXext, xmodmap, which, makeWrapper, freetype,
+ tex ? null,
+ aspell ? null,
+ ghostscriptX ? null,
+ extraFonts ? false,
+ chineseFonts ? false,
+ japaneseFonts ? false,
+ koreanFonts ? false }:
+
+let 
+  pname = "TeXmacs";
+  version = "1.0.7.10";
+  extraFontsSrc = fetchurl {
+    url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-extra-fonts-1.0-noarch.tar.gz";
+    sha256 = "0hylgjmd95y9yahbblmawkkw0i71vb145xxv2xqrmff81301n6k7";
+  };
+
+  fullFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-windows-fonts-1.0-noarch.tar.gz";
+   sha256 = "1yxzjpqpm7kvx0ly5jmfpzlfhsh41b0ibn1v84qv6xy73r2vis2f";
+  };
+
+  chineseFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-chinese-fonts.tar.gz";
+   sha256 = "0yprqjsx5mfsaxr525mcm3xqwcadzxp14njm38ir1325baada2fp";
+  };
+
+  japaneseFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-japanese-fonts.tar.gz";
+   sha256 = "1dn6zvsa7gk59d61xicwpbapab3rm6kz48rp5w1bhmihxixw21jn";
+  };
+
+  koreanFontsSrc = fetchurl {
+   url = "ftp://ftp.texmacs.org/pub/TeXmacs/fonts/TeXmacs-korean-fonts.tar.gz";
+   sha256 = "07axg57mqm3jbnm4lawx0h3r2h56xv9acwzjppryfklw4c27f5hh";
+  };
+in
+stdenv.mkDerivation rec {
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "ftp://ftp.texmacs.org/pub/${pname}/targz/${name}-src.tar.gz";
+    sha256 = "02gqalr775r4xyfy4bq3qq1h3pkarsxjb6ami7lgxfgmyg6ca5kn";
+  };
+
+  buildInputs = [ guile libX11 libXext makeWrapper ghostscriptX freetype ];
+
+  patchPhase = (if tex == null then ''
+    gunzip < ${fullFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else if extraFonts then ''
+    gunzip < ${extraFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "") +
+   (if chineseFonts then ''
+    gunzip < ${chineseFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "") +
+   (if japaneseFonts then ''
+    gunzip < ${japaneseFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "") +
+   (if koreanFonts then ''
+    gunzip < ${koreanFontsSrc} | (cd TeXmacs && tar xvf -)
+   '' else "");
+
+  postInstall = "wrapProgram $out/bin/texmacs --suffix PATH : " +
+        (if ghostscriptX == null then "" else "${ghostscriptX}/bin:") +
+        (if aspell == null then "" else "${aspell}/bin:") +
+        (if tex == null then "" else "${tex}/bin:") +
+        "${xmodmap}/bin:${which}/bin";
+
+  meta = {
+    description = "GNU TeXmacs, a free WYSIWYW editing platform with special features for scientists";
+    longDescription =
+      '' GNU TeXmacs is a free wysiwyw (what you see is what you want)
+         editing platform with special features for scientists.  The software
+         aims to provide a unified and user friendly framework for editing
+         structured documents with different types of content (text,
+         graphics, mathematics, interactive content, etc.).  The rendering
+         engine uses high-quality typesetting algorithms so as to produce
+         professionally looking documents, which can either be printed out or
+         presented from a laptop.
+
+         The software includes a text editor with support for mathematical
+         formulas, a small technical picture editor and a tool for making
+         presentations from a laptop.  Moreover, TeXmacs can be used as an
+         interface for many external systems for computer algebra, numerical
+         analysis, statistics, etc.  New presentation styles can be written
+         by the user and new features can be added to the editor using the
+         Scheme extension language.  A native spreadsheet and tools for
+         collaborative authoring are planned for later.
+      '';
+    homepage = http://texmacs.org/;
+    license = "GPLv2+";
+    maintainers = [ stdenv.lib.maintainers.ludo stdenv.lib.maintainers.roconnor ];
+    platforms = stdenv.lib.platforms.gnu;  # arbitrary choice
+  };
+}

pkgs/applications/editors/vim/configurable.nix

@@ -4,17 +4,18 @@ args: with args;
 let inherit (args.composableDerivation) composableDerivation edf; in
 composableDerivation {} {
 
-    name = "vim_configurable-7.2";
+    name = "vim_configurable-7.3";
 
     src = args.fetchurl {
-      url = ftp://ftp.vim.org/pub/vim/unix/vim-7.2.tar.bz2;
-      sha256 = "11hxkb6r2550c4n13nwr0d8afvh30qjyr5c2hw16zgay43rb0kci";
+      url = ftp://ftp.vim.org/pub/vim/unix/vim-7.3.tar.bz2;
+      sha256 = "079201qk8g9yisrrb0dn52ch96z3lzw6z473dydw9fzi0xp5spaw";
     };
 
     configureFlags = ["--enable-gui=auto" "--with-features=${args.features}"];
 
-    buildInputs = [ncurses pkgconfig]
-      ++ [ gtk libX11 libXext libSM libXpm libXt libXaw libXau libXmu ];
+    buildNativeInputs = [ncurses pkgconfig]
+      ++ [ gtk libX11 libXext libSM libXpm libXt libXaw libXau libXmu glib 
+           libICE ];
 
     # most interpreters aren't tested yet.. (see python for example how to do it)
     flags = {
@@ -26,26 +27,33 @@ composableDerivation {} {
       // edf { name = "xsmp"; } #Disable XSMP session management
       // edf { name = "xsmp_interact"; } #Disable XSMP interaction
       // edf { name = "mzscheme"; } #Include MzScheme interpreter.
-      // edf { name = "perl"; feat = "perlinterp"; enable = { buildInputs = [perl]; };} #Include Perl interpreter.
-      // edf { name = "python"; feat = "pythoninterp"; enable = { buildInputs = [python]; }; } #Include Python interpreter.
-      // edf { name = "tcl"; enable = { buildInputs = [tcl]; }; } #Include Tcl interpreter.
-      // edf { name = "ruby"; feat = "rubyinterp"; enable = { buildInputs = [ruby]; };} #Include Ruby interpreter.
+      // edf { name = "perl"; feat = "perlinterp"; enable = { buildNativeInputs = [perl]; };} #Include Perl interpreter.
+      // edf { name = "python"; feat = "pythoninterp"; enable = { buildNativeInputs = [python]; }; } #Include Python interpreter.
+      // edf { name = "tcl"; enable = { buildNativeInputs = [tcl]; }; } #Include Tcl interpreter.
+      // edf { name = "ruby"; feat = "rubyinterp"; enable = { buildNativeInputs = [ruby]; };} #Include Ruby interpreter.
+      // edf { name = "lua" ; feat = "luainterp"; enable = { buildNativeInputs = [lua]; configureFlags = ["--with-lua-prefix=${args.lua}"];};}
       // edf { name = "cscope"; } #Include cscope interface.
       // edf { name = "workshop"; } #Include Sun Visual Workshop support.
       // edf { name = "netbeans"; } #Disable NetBeans integration support.
-      // edf { name = "sniff"; } #Include Sniff interface.
+      // edf { name = "sniff"; feat = "sniff" ; } #Include Sniff interface.
       // edf { name = "multibyte"; } #Include multibyte editing support.
-      // edf { name = "hangulinput"; } #Include Hangul input support.
-      # // edf { name = "xim"; enable = { buildInputs = [xim]; }; } #Include XIM input support.
+      // edf { name = "hangulinput"; feat = "hangulinput" ;} #Include Hangul input support.
+      // edf { name = "xim"; } #Include XIM input support.
       // edf { name = "fontset"; } #Include X fontset output support.
       // edf { name = "acl"; } #Don't check for ACL support.
       // edf { name = "gpm"; } #Don't use gpm (Linux mouse daemon).
-      // edf { name = "nls"; } #Don't support NLS (gettext()).
+      // edf { name = "nls"; enable = {buildNativeInputs = [gettext];}; } #Don't support NLS (gettext()).
       ;
 
   cfg = {
-    pythonSupport = true;
-    ftNixSupport = true; # add .nix filetype detection and minimal syntax highlighting support
+    pythonSupport    = getConfig [ "vim" "python" ] true;
+    darwinSupport    = getConfig [ "vim" "darwin" ] false;
+    nlsSupport       = getConfig [ "vim" "nls" ] false;
+    tclSupport       = getConfig [ "vim" "tcl" ] false;
+    multibyteSupport = getConfig [ "vim" "multibyte" ] false;
+    cscopeSupport    = getConfig [ "vim" "cscope" ] false;
+    # add .nix filetype detection and minimal syntax highlighting support
+    ftNixSupport     = getConfig [ "vim" "ftNix" ] true;
   };
 
   #--enable-gui=OPTS     X11 GUI default=auto OPTS=auto/no/gtk/gtk2/gnome/gnome2/motif/athena/neXtaw/photon/carbon
@@ -62,11 +70,11 @@ composableDerivation {} {
 
   postInstall = "
     rpath=`patchelf --print-rpath \$out/bin/vim`;
-    for i in $\buildInputs; do
+    for i in $\buildNativeInputs; do
       echo adding \$i/lib
       rpath=\$rpath:\$i/lib
     done
-    echo \$buildInputs
+    echo \$buildNativeInputs
     echo \$rpath
     patchelf --set-rpath \$rpath \$out/bin/{vim,gvim}
   ";

pkgs/applications/editors/vim/default.nix

@@ -1,62 +1,46 @@
-args:
-let 
-	defList = [];
-	#stdenv and fetchurl are added automatically
-	getVal = (args.lib.getValue args defList);
-	check = args.lib.checkFlag args;
-	reqsList = [
-	["gtkGUI" "glib" "gtk" "pkgconfig" "libXpm" "libXext" "x11Support"]
-	["athenaGUI" "libXau" "libXt" "libXaw" "libXpm" "libXext" "x11Support"]
-	["x11Support" "libX11"]
-	["hugeFeatures"]
-	["pythonSupport" "python"]
-	["perlSupport" "perl"]
-	["tclSupport" "tcl"]
-	["true" "ncurses"]
-	["false" "libSM"]
-	];
-	nameSuffixes = [
-	"hugeFeatures" "-huge"
-	"x11Support" "-X11"
-	"pythonSupport" "-python"
-	"perlSupport" "-perl"
-	"tclSupport" "-tcl"
-	"ximSupport" "-xim"
-	];
-	configFlags = [
-	"true" " --enable-multibyte "
-	"x11Support" " --enable-gui=auto "
-	"hugeFeatures" "--with-features=huge --enable-cscope --enable-xsmp "
-	"pythonSupport" " --enable-pythoninterp "
-	"perlSupport" " --enable-perlinterp "
-	"tclSupport" " --enable-tclinterp "
-	"ximSupport" " --enable-xim "
-	];
-	buildInputsNames = args.lib.filter (x: (null!=getVal x)) 
-		(args.lib.uniqList {inputList = 
-		(args.lib.concatLists (map 
-		(x:(if (x==[]) then [] else builtins.tail x)) 
-		reqsList));});
-in
-	assert args.lib.checkReqs args defList reqsList;
-args.stdenv.mkDerivation {
-  name = args.lib.condConcat "vim-7.2" nameSuffixes check;
+{ stdenv, fetchurl, ncurses, gettext, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "vim-7.3";
  
-  src = args.fetchurl {
-    url = ftp://ftp.vim.org/pub/vim/unix/vim-7.2.tar.bz2;
-    sha256 = "11hxkb6r2550c4n13nwr0d8afvh30qjyr5c2hw16zgay43rb0kci";
+  src = fetchurl {
+    url = "ftp://ftp.vim.org/pub/vim/unix/${name}.tar.bz2";
+    sha256 = "079201qk8g9yisrrb0dn52ch96z3lzw6z473dydw9fzi0xp5spaw";
   };
  
-  inherit (args) ncurses;
+  buildInputs = [ ncurses pkgconfig ];
+  buildNativeInputs = [ gettext ];
 
-  buildInputs = args.lib.filter (x: (x!=null)) (map getVal buildInputsNames);
+  configureFlags = [
+    "--enable-multibyte"
+    "--enable-nls"
+  ];
 
   postInstall = "ln -s $out/bin/vim $out/bin/vi";
-  preBuild="touch src/auto/link.sed";
-  configureFlags = args.lib.condConcat "" configFlags check;
 
-  NIX_LDFLAGS = "-lpthread -lutil";
+  crossAttrs = {
+    configureFlags = [
+      "vim_cv_toupper_broken=no"
+      "--with-tlib=ncurses"
+      "vim_cv_terminfo=yes"
+      "vim_cv_tty_group=tty"
+      "vim_cv_tty_mode=0660"
+      "vim_cv_getcwd_broken=no"
+      "vim_cv_stat_ignores_slash=yes"
+      "ac_cv_sizeof_int=4"
+      "vim_cv_memmove_handles_overlap=yes"
+      "vim_cv_memmove_handles_overlap=yes"
+      "STRIP=${stdenv.cross.config}-strip"
+    ];
+  };
 
+  # To fix the trouble in vim73, that it cannot cross-build with this patch
+  # to bypass a configure script check that cannot be done cross-building.
+  # http://groups.google.com/group/vim_dev/browse_thread/thread/66c02efd1523554b?pli=1
+  patchPhase = ''
+    sed -i -e 's/as_fn_error.*int32.*/:/' src/auto/configure
+  '';
+  
   meta = {
     description = "The most popular clone of the VI editor";
     homepage = http://www.vim.org;