Import latest revision from CVS at luaforge.netv1.0v0.5.2v0.5.1v0.5v0.4.3v0.4.2v0.4.1v0.4v0.3.2v0.3.1v0.3v0.2v0.1

git-svn-id: http://luarocks.org/svn/luarocks/trunk@1 9ca3f7c1-7366-0410-b1a3-b5c78f85698c

41 files changed, 6781 insertions, 0 deletions

diff --git a/COPYING b/COPYING
new file mode 100644
index 00000000..adec4655
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,32 @@
+LuaRocks is free software: it can be used for both academic and commercial
+purposes at absolutely no cost. There are no royalties or GNU-like "copyleft"
+restrictions. LuaRocks qualifies as Open Source software. Its licenses are
+compatible with the GPL. LuaRocks is not in the public domain and the Kepler
+Project keeps its copyright. The legal details are below.
+
+The spirit of the license is that you are free to use LuaRocks for any purpose
+at no cost without having to ask us. The only requirement is that if you do
+use LuaRocks, then you should give us credit by including the appropriate
+copyright notice somewhere in your product or its documentation.
+
+------------------------------------------------------------------------------
+
+Copyright © 2007 Kepler Project.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..5241eb7a
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,123 @@
+# $Id: Makefile,v 1.30 2008/08/18 14:07:35 hisham Exp $
+
+include config.unix
+
+DESTDIR =
+PREFIX ?= /usr/local
+BINDIR ?= $(PREFIX)/bin
+LUADIR ?= $(PREFIX)/share/lua/5.1/
+LUA_DIR ?= /usr/local
+LUA_BINDIR ?= $(LUA_DIR)/bin
+
+BIN_FILES = luarocks luarocks-admin
+LUAROCKS_FILES = build/cmake.lua build/command.lua build.lua build/make.lua \
+command_line.lua cfg.lua deps.lua fetch.lua fs.lua fs/unix.lua \
+fs/win32.lua help.lua install.lua list.lua persist.lua \
+make_manifest.lua pack.lua path.lua rep.lua require.lua search.lua \
+type_check.lua util.lua remove.lua build/builtin.lua make.lua manif.lua unpack.lua \
+fetch/cvs.lua fetch/sscm.lua fetch/git.lua
+
+CONFIG_FILE = $(SYSCONFDIR)/config.lua
+
+all:
+        for f in $(BIN_FILES) ;\
+        do \
+           sed "1d" src/bin/$$f >> src/bin/$$f.bak ;\
+           echo "#!$(LUA_BINDIR)/lua$(LUA_SUFFIX)" > src/bin/$$f ;\
+           echo "package.path = [[$(LUADIR)/?.lua;$(LUADIR)/?/init.lua;]]..package.path" >> src/bin/$$f ;\
+           cat src/bin/$$f.bak >> src/bin/$$f ;\
+           rm src/bin/$$f.bak ;\
+        done
+        cp src/luarocks/cfg.lua src/luarocks/cfg.lua.bak
+        rm src/luarocks/cfg.lua
+        if [ -n "$(PREFIX)" ] ;\
+        then \
+           echo "local LUAROCKS_PREFIX=[[$(PREFIX)]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(LUA_INCDIR)" ] ;\
+        then \
+           echo "local LUA_INCDIR=[[$(LUA_INCDIR)]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(LUA_LIBDIR)" ] ;\
+        then \
+           echo "local LUA_LIBDIR=[[$(LUA_LIBDIR)]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(LUA_BINDIR)" ] ;\
+        then \
+           echo "local LUA_BINDIR=[[$(LUA_BINDIR)]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(LUA_SUFFIX)" ] ;\
+        then \
+           echo "local LUA_INTERPRETER=[[lua$(LUA_SUFFIX)]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(SYSCONFDIR)" ] ;\
+        then \
+           echo "local LUAROCKS_SYSCONFIG=[[$(SYSCONFDIR)/config.lua]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(ROCKS_TREE)" ] ;\
+        then \
+           echo "local LUAROCKS_ROCKS_TREE=[[$(ROCKS_TREE)]]" >> src/luarocks/cfg.lua ;\
+        fi
+        if [ -n "$(FORCE_CONFIG)" ] ;\
+        then \
+           echo "local LUAROCKS_FORCE_CONFIG=true" >> src/luarocks/cfg.lua ;\
+        fi
+        echo "local LUAROCKS_UNAME_S=[[$(LUAROCKS_UNAME_S)]]" >> src/luarocks/cfg.lua
+        echo "local LUAROCKS_UNAME_M=[[$(LUAROCKS_UNAME_M)]]" >> src/luarocks/cfg.lua
+        echo "local LUAROCKS_DOWNLOADER=[[$(LUAROCKS_DOWNLOADER)]]" >> src/luarocks/cfg.lua
+        echo "local LUAROCKS_MD5CHECKER=[[$(LUAROCKS_MD5CHECKER)]]" >> src/luarocks/cfg.lua
+        cat src/luarocks/cfg.lua.bak >> src/luarocks/cfg.lua
+        rm src/luarocks/cfg.lua.bak
+        @echo
+        @echo "Done. Type 'make install' to install into $(PREFIX)."
+        @echo
+
+luadoc:
+        rm -rf doc/luadoc
+        mkdir -p doc/luadoc
+        cd src && luadoc -d ../doc/luadoc --nofiles luarocks/*.lua
+
+check_makefile:
+        echo $(BIN_FILES) | tr " " "\n" | sort > makefile_list.txt
+        ( cd src/bin && ls -d * ) | grep -v "CVS" | sort > luarocks_dir.txt
+        echo $(LUAROCKS_FILES) | tr " " "\n" | sort >> makefile_list.txt
+        ( cd src/luarocks && ls -d *.lua ) | sort >> luarocks_dir.txt
+        diff makefile_list.txt luarocks_dir.txt
+        rm makefile_list.txt luarocks_dir.txt
+        @echo
+        @echo "Makefile is sane."
+        @echo
+
+clean:
+        for f in $(BIN_FILES) ;\
+        do \
+           sed -i.bak "s,^#!.*lua.*,#!/usr/bin/env lua,;/^package.path/d" src/bin/$$f ;\
+           rm src/bin/$$f.bak ;\
+        done
+        sed -i.bak "/^local LUA/d" src/luarocks/cfg.lua
+        rm src/luarocks/cfg.lua.bak
+
+install:
+        mkdir -p "$(DESTDIR)$(BINDIR)"
+        cd src/bin && cp $(BIN_FILES) "$(DESTDIR)$(BINDIR)"
+        mkdir -p "$(DESTDIR)$(LUADIR)/luarocks"
+        cd src/luarocks && for f in $(LUAROCKS_FILES); do d="$(DESTDIR)$(LUADIR)/luarocks"/`dirname "$$f"`; mkdir -p "$$d"; cp "$$f" "$$d"; done
+        mkdir -p "$(DESTDIR)$(ROCKS_TREE)"
+        if [ ! -f "$(DESTDIR)$(CONFIG_FILE)" ] ;\
+        then \
+           mkdir -p `dirname "$(DESTDIR)$(CONFIG_FILE)"` ;\
+           echo 'rocks_servers = {' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           echo '   [[http://luarocks.luaforge.net/rocks]]' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           echo '}' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           echo 'rocks_trees = {' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           if  [ ! -n "$(FORCE_CONFIG)" ] ;\
+           then \
+              echo '   home..[[/.luarocks]],' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           fi ;\
+           echo '   [[$(ROCKS_TREE)]]' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           echo '}' >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           if [ -n "$(SCRIPTS_DIR)" ] ;\
+           then \
+              echo "scripts_dir = [[$(SCRIPTS_DIR)]]" >> "$(DESTDIR)$(CONFIG_FILE)" ;\
+           fi ;\
+        fi
diff --git a/configure b/configure
new file mode 100755
index 00000000..268b7241
--- /dev/null
+++ b/configure
@@ -0,0 +1,362 @@
+#!/bin/sh
+
+# A basic configure script for LuaRocks.
+# Not doing any fancy shell stuff here to keep good compatibility.
+
+# Defaults
+
+PREFIX="/usr/local"
+SYSCONFDIR="$PREFIX/etc/luarocks"
+ROCKS_TREE="$PREFIX/lib/luarocks"
+SCRIPTS_DIR=""
+LUA_SUFFIX=""
+LUA_DIR="/usr"
+LUA_BINDIR="/usr/bin"
+LUA_INCDIR="/usr/include"
+LUA_LIBDIR="/usr/lib"
+
+# ----------------------------------------------------------------------------
+# FUNCTION DEFINITIONS
+# ----------------------------------------------------------------------------
+
+# Help
+
+show_help() {
+cat <<EOF
+Configure LuaRocks.
+
+--help                      This help.
+--prefix=DIR                Prefix where LuaRocks should be installed.
+                            Default is $PREFIX
+--sysconfdir=DIR            Location where the config file should be installed.
+                            Default is \$PREFIX/etc/luarocks
+--rocks-tree=FILE           Root of the local tree of installed rocks.
+                            Default is \$PREFIX/lib/luarocks
+--scripts-dir=DIR           Where to install scripts installed by rocks.
+                            Default is \$ROCKS_TREE/bin. Use this if you
+                            want to modify it so that rocks install scripts
+                            somewhere else (possibly somewhere in your \$PATH),
+                            but if you use a system path such as /usr/bin,
+                            beware of clashes between files installed by
+                            LuaRocks and by your system's package manager.
+                            Example: /usr/local/bin
+--lua-suffix=SUFFIX         Versioning suffix to use in Lua filenames.
+                            Default is "$LUA_SUFFIX" (lua$LUA_SUFFIX...)
+--with-lua=PREFIX           Use Lua from given prefix.
+                            Default is $LUA_DIR
+--with-lua-include=DIR      You can also specify Lua's includes dir.
+                            Default is \$LUA_DIR/include
+--with-lua-lib=DIR          You can also specify Lua's libraries dir.
+                            Default is \$LUA_DIR/lib
+--with-downloader=TOOL      Which tool to use as a downloader.
+                            Valid options are: wget, curl.
+                            Default is to auto-detect.
+--with-md5-checker=TOOL     Which tool to use as a downloader.
+                            Valid options are: md5sum, openssl
+                            Default is to auto-detect.
+--force-config              Use a single config location. Do not use the
+                            \$LUAROCKS_CONFIG variable or the user's home
+                            directory. Useful to avoid conflicts when LuaRocks
+                            is embedded within an application.
+EOF
+}
+
+# Helper functions
+
+find_program() {
+   path="$PATH"
+   item="`echo "$path" | sed 's/\([^:]*\):.*/\1/'`"
+   path="`echo "$path" | sed -n 's/[^:]*::*\(.*\)/\1/p'`"
+   found="no"
+   while [ -n "$item" ]
+   do
+      if [ -f "$item/$1" ]
+      then
+         found="yes"
+         break
+      fi
+      item="`echo "$path" | sed 's/\([^:]*\):.*/\1/'`"
+      path="`echo "$path" | sed -n 's/[^:]*::*\(.*\)/\1/p'`"
+   done
+   if [ "$found" = "yes" ]
+   then
+      echo "$item"
+   else
+      echo ""
+   fi
+}
+
+find_helper() {
+   explanation="$1"
+   shift
+   tried="$*"
+   while [ -n "$1" ]
+   do
+      found=`find_program "$1"`
+      if [ -n "$found" ]
+      then
+         echo "$1 found at $found"
+         HELPER=$1
+         return
+      fi
+      shift
+   done
+   echo "Could not find a $explanation. Tried: $tried."
+   echo "Make sure one of them is installed and available in your PATH."
+   exit 1
+}
+
+case `echo -n x` in
+-n*) echo_n_flag='';;
+*)   echo_n_flag='-n';;
+esac
+
+echo_n() {
+   echo $echo_n_flag "$*"
+}
+
+die() {
+   echo "$*"
+   exit 1
+}
+
+# ----------------------------------------------------------------------------
+# MAIN PROGRAM
+# ----------------------------------------------------------------------------
+
+# Parse options
+
+while [ -n "$1" ]
+do
+   value="`echo $1 | sed 's/[^=]*.\(.*\)/\1/'`"
+   key="`echo $1 | sed 's/=.*//'`"
+   if `echo "$value" | grep "~" >/dev/null 2>/dev/null`
+   then
+      echo
+      echo '*WARNING*: the "~" sign is not expanded in flags.'
+      echo 'If you mean the home directory, use $HOME instead.'
+      echo
+   fi
+   case "$key" in
+   --help)
+      show_help
+      exit 0
+      ;;
+   --prefix)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      PREFIX="$value"
+      PREFIX_SET=yes
+      ;;
+   --sysconfdir)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      SYSCONFDIR="$value"
+      SYSCONFDIR_SET=yes
+      ;;
+   --rocks-tree)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      ROCKS_TREE="$value"
+      ROCKS_TREE_SET=yes
+      ;;
+   --scripts-dir)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      SCRIPTS_DIR="$value"
+      SCRIPTS_DIR_SET=yes
+      ;;
+   --force-config)
+      FORCE_CONFIG=yes
+      ;;
+   --lua-suffix)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      LUA_SUFFIX="$value"
+      LUA_SUFFIX_SET=yes
+      ;;
+   --with-lua)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      LUA_DIR="$value"
+      LUA_DIR_SET=yes
+      ;;
+   --with-lua-include)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      LUA_INCDIR="$value"
+      LUA_INCDIR_SET=yes
+      ;;
+   --with-lua-lib)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      LUA_LIBDIR="$value"
+      LUA_LIBDIR_SET=yes
+      ;;
+   --with-downloader)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      case "$value" in
+      wget|curl) LUAROCKS_DOWNLOADER="$value" ;;
+      *) echo "Invalid option: $value. See --help." ; exit 1 ;;
+      esac
+      LUAROCKS_DOWNLOADER_SET=yes
+      ;;
+   --with-md5-checker)
+      [ -n "$value" ] || die "Missing value in flag $key."
+      case "$value" in
+      md5sum|openssl|md5) LUAROCKS_MD5CHECKER="$value" ;;
+      *) echo "Invalid option: $value. See --help." ; exit 1 ;;
+      esac
+      LUAROCKS_MD5CHECKER_SET=yes
+      ;;
+   *)
+      echo "Error: Unknown flag: $1"
+      exit 1
+      ;;
+   esac
+   shift
+done
+
+
+if [ "$PREFIX_SET" = "yes" -a ! "$SYSCONFDIR_SET" = "yes" ]
+then
+   if [ "$PREFIX" = "/usr" ]
+   then SYSCONFDIR=/etc/luarocks
+   else SYSCONFDIR=$PREFIX/etc/luarocks
+   fi
+fi
+
+
+if [ "$PREFIX_SET" = "yes" -a ! "$ROCKS_TREE_SET" = "yes" ]
+then
+   ROCKS_TREE=$PREFIX/lib/luarocks
+fi
+
+if [ "$LUA_SUFFIX_SET" != "yes" ]
+then
+   for suffix in "" "5.1" "51" ""
+   do
+      LUA_SUFFIX="$suffix"
+      if [ "$LUA_DIR_SET" = "yes" ]
+      then
+         if [ -f "$LUA_DIR/bin/lua$suffix" ]
+         then
+            find_lua="$LUA_DIR"
+         fi
+      else
+         find_lua=`find_program lua$suffix`
+      fi
+      if [ -n "$find_lua" ]
+      then
+         echo "Lua interpreter found: $find_lua/lua$suffix..."
+         break
+      fi
+   done
+fi
+
+if [ "$LUA_DIR_SET" != "yes" ]
+then
+   echo_n "Looking for Lua... "
+   if [ ! -n "$find_lua" ]
+   then
+      find_lua=`find_program lua$LUA_SUFFIX`
+   fi
+
+   if [ -n "$find_lua" ]
+   then
+      LUA_DIR=`dirname $find_lua`
+      LUA_BINDIR="$find_lua"
+      echo "lua$LUA_SUFFIX found in \$PATH: $find_lua"
+   else
+      echo "lua$LUA_SUFFIX not found in \$PATH."
+      echo "You may want to use the flags --with-lua and/or --lua-suffix. See --help."
+      exit 1
+   fi
+fi
+
+if [ "$LUA_INCDIR_SET" != "yes" ]
+then
+   LUA_INCDIR="$LUA_DIR/include"
+fi
+
+if [ "$LUA_LIBDIR_SET" != "yes" ]
+then
+   LUA_LIBDIR="$LUA_DIR/lib"
+fi
+
+if [ "$LUA_DIR_SET" = "yes" ]
+then
+   LUA_BINDIR="$LUA_DIR/bin"
+fi
+
+echo_n "Checking Lua includes... "
+lua_h="$LUA_INCDIR/lua.h"
+if [ -f "$lua_h" ]
+then
+   echo "lua.h found in $lua_h"
+else
+   echo "lua.h not found (looked in $lua_h)"
+   echo "You may want to use the flag --with-lua-include. See --help."
+   exit 1
+fi
+
+if [ "$LUAROCKS_DOWNLOADER_SET" != "yes" ]
+then
+   find_helper "downloader helper program" wget curl fetch
+   LUAROCKS_DOWNLOADER=$HELPER
+fi
+
+if [ "$LUAROCKS_MD5CHECKER_SET" != "yes" ]
+then
+   find_helper "MD5 checksum calculator" md5sum openssl md5
+   LUAROCKS_MD5CHECKER=$HELPER
+fi
+
+echo_n "Configuring for system... "
+if uname -s
+then
+   LUAROCKS_UNAME_S=`uname -s`
+else
+   echo "Could not determine operating system. 'uname -s' failed."
+   exit 1
+fi
+echo_n "Configuring for architecture... "
+if uname -m
+then
+   LUAROCKS_UNAME_M=`uname -m`
+else
+   echo "Could not determine processor architecture. 'uname -m' failed."
+   exit 1
+fi
+
+if [ -f config.unix ]; then
+   rm -f config.unix
+fi
+
+# Write config
+
+echo "Writing configuration..."
+echo
+
+cat <<EOF > config.unix
+# This file was automatically generated by the configure script.
+# Run "./configure --help" for details.
+
+PREFIX=$PREFIX
+SYSCONFDIR=$SYSCONFDIR
+ROCKS_TREE=$ROCKS_TREE
+SCRIPTS_DIR=$SCRIPTS_DIR
+LUA_SUFFIX=$LUA_SUFFIX
+LUA_DIR=$LUA_DIR
+LUA_INCDIR=$LUA_INCDIR
+LUA_LIBDIR=$LUA_LIBDIR
+LUA_BINDIR=$LUA_BINDIR
+FORCE_CONFIG=$FORCE_CONFIG
+LUAROCKS_UNAME_M=$LUAROCKS_UNAME_M
+LUAROCKS_UNAME_S=$LUAROCKS_UNAME_S
+LUAROCKS_DOWNLOADER=$LUAROCKS_DOWNLOADER
+LUAROCKS_MD5CHECKER=$LUAROCKS_MD5CHECKER
+
+EOF
+
+echo "Installation prefix: $PREFIX"
+echo "LuaRocks configuration directory: $SYSCONFDIR"
+echo "Using Lua from: $LUA_DIR"
+
+make clean > /dev/null 2> /dev/null
+
+echo
+echo "Done. You can now run 'make' to build."
+echo
diff --git a/install.bat b/install.bat
new file mode 100644
index 00000000..141fe0f8
--- /dev/null
+++ b/install.bat
@@ -0,0 +1,312 @@
+@ECHO OFF

+

+REM Boy, it feels like 1994 all over again.

+

+SETLOCAL

+

+SET PREFIX=C:\LuaRocks

+SET VERSION=1.0

+SET SYSCONFDIR=C:\LuaRocks

+SET ROCKS_TREE=C:\LuaRocks

+SET SCRIPTS_DIR=

+SET FORCE=OFF

+SET INSTALL_LUA=OFF

+SET LUA_INTERPRETER=

+SET LUA_PREFIX=

+SET LUA_BINDIR=

+SET LUA_INCDIR=

+SET LUA_LIBDIR=

+SET FORCE_CONFIG=

+SET MKDIR=.\bin\mkdir -p

+

+REM ***********************************************************

+REM Option parser

+REM ***********************************************************

+

+:PARSE_LOOP

+IF [%1]==[] GOTO DONE_PARSING

+IF [%1]==[/?] (

+   ECHO Installs LuaRocks.

+   ECHO.

+   ECHO /P [dir]       Where to install.

+   ECHO                Default is %PREFIX%

+   ECHO /CONFIG [dir]  Location where the config file should be installed.

+   ECHO                Default is %SYSCONFDIR%

+   ECHO /TREE [dir]    Root of the local tree of installed rocks.

+   ECHO                Default is %ROCKS_TREE%

+   ECHO /SCRIPTS [dir] Where to install scripts installed by rocks.

+   ECHO                Default is TREE/bin.

+   ECHO.

+   ECHO /L             Install LuaRocks' own copy of Lua even if detected.

+   ECHO /LUA [dir]     Location where Lua is installed - e.g. c:\lua\5.1\

+   ECHO /INC [dir]     Location of Lua includes - e.g. c:\lua\5.1\include

+   ECHO /LIB [dir]     Location of Lua libraries -e.g. c:\lua\5.1\lib

+   ECHO /BIN [dir]     Location of Lua executables - e.g. c:\lua\5.1\bin

+   ECHO.

+   ECHO /FORCECONFIG  Use a single config location. Do not use the

+   ECHO               LUAROCKS_CONFIG variable or the user's home directory.

+   ECHO               Useful to avoid conflicts when LuaRocks

+   ECHO               is embedded within an application.

+   ECHO.

+   ECHO /F            Remove installation directory if it already exists.

+   ECHO.

+   GOTO QUIT

+)

+IF /I [%1]==[/P] (

+   SET PREFIX=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/CONFIG] (

+   SET SYSCONFDIR=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/TREE] (

+   SET ROCKS_TREE=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/SCRIPTS] (

+   SET SCRIPTS_DIR=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/L] (

+   SET INSTALL_LUA=ON

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/LUA] (

+   SET LUA_PREFIX=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/LIB] (

+   SET LUA_LIBDIR=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/INC] (

+   SET LUA_INCDIR=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/BIN] (

+   SET LUA_BINDIR=%2

+   SHIFT /1

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/FORCECONFIG] (

+   SET FORCE_CONFIG=ON

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+IF /I [%1]==[/F] (

+   SET FORCE=ON

+   SHIFT /1

+   GOTO PARSE_LOOP

+)

+ECHO Unrecognized option: %1

+GOTO ERROR

+:DONE_PARSING

+

+SET FULL_PREFIX=%PREFIX%\%VERSION%

+

+SET BINDIR=%FULL_PREFIX%

+SET LIBDIR=%FULL_PREFIX%

+SET LUADIR=%FULL_PREFIX%\lua

+SET INCDIR=%FULL_PREFIX%\include

+

+REM ***********************************************************

+REM Detect Lua

+REM ***********************************************************

+

+IF [%INSTALL_LUA%]==[ON] GOTO USE_OWN_LUA

+

+FOR %%L IN (%LUA_PREFIX% c:\lua\5.1.2 c:\lua c:\kepler\1.1) DO (

+   SET CURR=%%L

+   IF EXIST "%%L" (

+      IF NOT [%LUA_BINDIR%]==[] (

+         IF EXIST %LUA_BINDIR%\lua5.1.exe (

+            SET LUA_INTERPRETER=%LUA_BINDIR%\lua5.1.exe

+            GOTO INTERPRETER_IS_SET

+         )

+         IF EXIST %LUA_BINDIR%\lua.exe (

+            SET LUA_INTERPRETER=%LUA_BINDIR%\lua.exe

+            GOTO INTERPRETER_IS_SET

+         )

+         ECHO Lua executable lua.exe or lua5.1.exe not found in %LUA_BINDIR%

+         GOTO ERROR

+      )

+      SET CURR=%%L

+      FOR %%E IN (\ \bin\) DO (

+         IF EXIST "%%L%%E\lua5.1.exe" (

+            SET LUA_INTERPRETER=%%L%%E\lua5.1.exe

+            SET LUA_BINDIR=%%L%%E

+            GOTO INTERPRETER_IS_SET

+         )

+         IF EXIST "%%L%%E\lua.exe" (

+            SET LUA_INTERPRETER=%%L%%E\lua.exe

+            SET LUA_BINDIR=%%L%%E

+            GOTO INTERPRETER_IS_SET

+         )

+      )

+      GOTO TRY_NEXT_LUA_DIR

+      :INTERPRETER_IS_SET

+      IF NOT "%LUA_LIBDIR%"=="" (

+         IF EXIST %LUA_LIBDIR%\lua5.1.lib GOTO LIBDIR_IS_SET

+         ECHO lua5.1.lib not found in %LUA_LIBDIR%

+         GOTO ERROR

+      )

+      FOR %%E IN (\ \lib\ \bin\) DO (

+         IF EXIST "%CURR%%%E\lua5.1.lib" (

+            SET LUA_LIBDIR=%CURR%%%E

+            GOTO LIBDIR_IS_SET

+         )

+      )

+      GOTO TRY_NEXT_LUA_DIR

+      :LIBDIR_IS_SET

+      IF NOT [%LUA_INCDIR%]==[] (

+         IF EXIST %LUA_INCDIR%\lua.h GOTO INCDIR_IS_SET

+         ECHO lua.h not found in %LUA_INCDIR%

+         GOTO ERROR

+      )

+      FOR %%E IN (\ \include\) DO (

+         IF EXIST "%CURR%%%E\lua.h" (

+            SET LUA_INCDIR=%CURR%%%E

+            GOTO INCDIR_IS_SET

+         )

+      )

+      GOTO TRY_NEXT_LUA_DIR

+      :INCDIR_IS_SET

+        %LUA_INTERPRETER% -v 2>NUL

+      IF NOT ERRORLEVEL 1 (

+         GOTO LUA_IS_SET

+      )

+   )

+:TRY_NEXT_LUA_DIR

+   REM wtf

+)

+ECHO Could not find Lua. Will install its own copy.

+ECHO See /? for options for specifying the location of Lua.

+:USE_OWN_LUA

+SET INSTALL_LUA=ON

+SET LUA_INTERPRETER=lua5.1

+SET LUA_BINDIR=%BINDIR%

+SET LUA_LIBDIR=%LIBDIR%

+SET LUA_INCDIR=%INCDIR%

+:LUA_IS_SET

+ECHO.

+ECHO Will configure LuaRocks with the following paths:

+ECHO Lua interpreter: %LUA_INTERPRETER%

+ECHO Lua binaries:    %LUA_BINDIR%

+ECHO Lua libraries:   %LUA_LIBDIR%

+ECHO Lua includes:    %LUA_INCDIR%

+ECHO.

+

+REM ***********************************************************

+REM Install LuaRocks files

+REM ***********************************************************

+

+IF [%FORCE%]==[ON] (

+   ECHO Removing %FULL_PREFIX%...

+   RD /S /Q "%FULL_PREFIX%"

+)

+

+IF NOT EXIST "%FULL_PREFIX%" GOTO NOT_EXIST_PREFIX

+   ECHO %FULL_PREFIX% exists. Use /F to force removal and reinstallation.

+   GOTO ERROR

+:NOT_EXIST_PREFIX

+

+ECHO Installing LuaRocks in %FULL_PREFIX%...

+IF NOT EXIST "%BINDIR%" %MKDIR% "%BINDIR%"

+IF ERRORLEVEL 1 GOTO ERROR

+IF [%INSTALL_LUA%]==[ON] (

+   IF NOT EXIST "%LUA_BINDIR%" %MKDIR% "%LUA_BINDIR%"

+   IF NOT EXIST "%LUA_INCDIR%" %MKDIR% "%LUA_INCDIR%"

+   COPY lua5.1\bin\*.* "%LUA_BINDIR%" >NUL

+   COPY lua5.1\include\*.* "%LUA_INCDIR%" >NUL

+)

+COPY bin\*.* "%BINDIR%" >NUL

+IF ERRORLEVEL 1 GOTO ERROR

+COPY src\bin\*.* "%BINDIR%" >NUL

+IF ERRORLEVEL 1 GOTO ERROR

+FOR %%C IN (luarocks luarocks-admin) DO (

+   RENAME "%BINDIR%\%%C" %%C.lua

+   IF ERRORLEVEL 1 GOTO ERROR

+   DEL /F /Q "%BINDIR%\%%C.bat" 2>NUL

+   ECHO @ECHO OFF>> "%BINDIR%\%%C.bat"

+   ECHO SETLOCAL>> "%BINDIR%\%%C.bat"

+   ECHO SET LUA_PATH=%LUADIR%\?.lua;%LUADIR%\?\init.lua;%%LUA_PATH%%>> "%BINDIR%\%%C.bat"

+   ECHO SET PATH=%BINDIR%\;%%PATH%%>> "%BINDIR%\%%C.bat"

+   ECHO "%LUA_INTERPRETER%" "%BINDIR%\%%C.lua" %%*>> "%BINDIR%\%%C.bat"

+   ECHO ENDLOCAL>> "%BINDIR%\%%C.bat"

+)

+IF NOT EXIST "%LUADIR%\luarocks" %MKDIR% "%LUADIR%\luarocks"

+IF ERRORLEVEL 1 GOTO ERROR

+XCOPY /S src\luarocks\*.* "%LUADIR%\luarocks" >NUL

+IF ERRORLEVEL 1 GOTO ERROR

+

+RENAME "%LUADIR%\luarocks\cfg.lua" "cfg.lua.bak"

+ECHO local LUA_INCDIR=[[%LUA_INCDIR%]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUA_LIBDIR=[[%LUA_LIBDIR%]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUA_BINDIR=[[%LUA_BINDIR%]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUA_INTERPRETER=[[%LUA_INTERPRETER%]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUAROCKS_UNAME_S=[[WindowsNT]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUAROCKS_UNAME_M=[[x86]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUAROCKS_SYSCONFIG=[[%SYSCONFDIR%/config.lua]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUAROCKS_ROCKS_TREE=[[%ROCKS_TREE%]]>> "%LUADIR%\luarocks\cfg.lua" 

+ECHO local LUAROCKS_PREFIX=[[%PREFIX%]]>> "%LUADIR%\luarocks\cfg.lua" 

+IF NOT [%FORCE_CONFIG%]==[] ECHO local LUAROCKS_FORCE_CONFIG=true>> "%LUADIR%\luarocks\cfg.lua"

+TYPE "%LUADIR%\luarocks\cfg.lua.bak">> "%LUADIR%\luarocks\cfg.lua" 

+

+DEL /F /Q "%LUADIR%\luarocks\cfg.lua.bak" 

+

+SET CONFIG_FILE=%SYSCONFDIR%\config.lua

+

+IF NOT EXIST "%SYSCONFDIR%" %MKDIR% "%SYSCONFDIR%"

+IF NOT EXIST "%CONFIG_FILE%" (

+   ECHO rocks_servers = {>> "%CONFIG_FILE%"

+   ECHO    [[http://luarocks.luaforge.net/rocks]]>> "%CONFIG_FILE%"

+   ECHO }>> "%CONFIG_FILE%"

+   ECHO rocks_trees = {>> "%CONFIG_FILE%"

+   IF [%FORCE_CONFIG%]==[] ECHO    home..[[/luarocks]],>> "%CONFIG_FILE%"

+   ECHO    [[%ROCKS_TREE%]]>> "%CONFIG_FILE%"

+   ECHO }>> "%CONFIG_FILE%"

+   IF NOT [%SCRIPTS_DIR%]==[] ECHO scripts_dir=[[%SCRIPTS_DIR%]]>> "%CONFIG_FILE%"

+)

+

+IF [%SCRIPTS_DIR%]==[] (

+   %MKDIR% "%ROCKS_TREE%"\bin >NUL

+   COPY lua5.1\bin\*.dll "%ROCKS_TREE%"\bin >NUL

+)

+IF NOT [%SCRIPTS_DIR%]==[] (

+   %MKDIR% "%SCRIPTS_DIR%" >NUL

+   COPY lua5.1\bin\*.dll "%SCRIPTS_DIR%" >NUL

+)

+

+IF NOT EXIST "%ROCKS_TREE%" %MKDIR% "%ROCKS_TREE%"

+IF NOT EXIST "%APPDATA%/luarocks" %MKDIR% "%APPDATA%/luarocks"

+

+REM ***********************************************************

+REM Exit handlers

+REM ***********************************************************

+

+ECHO LuaRocks is installed!

+:QUIT

+ENDLOCAL

+EXIT /B 0

+

+:ERROR

+ECHO Failed installing LuaRocks.

+ENDLOCAL

+EXIT /B 1

diff --git a/makedist b/makedist
new file mode 100755
index 00000000..3e78040a
--- /dev/null
+++ b/makedist
@@ -0,0 +1,68 @@
+#!/bin/sh
+
+cvslist() {
+   if [ "$1" ]
+   then local prefix="$1/"
+   fi   
+   cvs list $1 | grep -v "^?" | while read line
+   do
+      local path="$prefix$line"
+      echo "$path"
+      if [ -d "$path" ]
+      then
+         cvslist "$path"
+      fi
+   done
+}
+
+if ! [ "$1" ]
+then
+   echo "usage: $0 <version>"
+   exit 1
+fi
+
+cvs list > /dev/null 2> /dev/null
+if [ $? != 0 ]
+then
+   echo "Your version of CVS may be too old. At least 1.12 is needed."
+   exit 1
+fi
+
+make clean
+
+out="luarocks-$1"
+rm -rf "$out"
+mkdir "$out"
+list=`cvslist`
+rm -f missing_ref
+echo "$list" | while read i
+do
+   if [ -f "$i" ]
+   then
+      dir=`dirname $i`
+      mkdir -p "$out/$dir"
+      cp "$i" "$out/$dir"
+      if echo "$i" | grep -q "^src/"
+      then
+         grep -qw `basename "$i"` Makefile || { 
+            echo "Missing ref in makefile: $i"
+            touch missing_ref
+            exit 1
+         }
+      fi
+   fi
+done
+if [ -e missing_ref ]
+then
+   rm -f missing_ref
+   exit 1
+fi
+rm -f "$out-win32.zip" "$out.tar.gz"
+rm "$out/makedist"
+rm "$out/install.bat"
+tar czvpf "$out.tar.gz" "$out"
+cp install.bat "$out"
+cp -a win32/bin "$out"
+cp -a win32/lua5.1 "$out"
+zip -r "$out-win32.zip" "$out"
+rm -rf "$out"
diff --git a/src/bin/luarocks b/src/bin/luarocks
new file mode 100755
index 00000000..8812ecc8
--- /dev/null
+++ b/src/bin/luarocks
@@ -0,0 +1,19 @@
+#!/usr/bin/env lua
+
+local command_line = require("luarocks.command_line")
+
+program_name = "luarocks"
+program_description = "LuaRocks main command-line interface"
+
+commands = {}
+commands.help = require("luarocks.help")
+commands.pack = require("luarocks.pack")
+commands.unpack = require("luarocks.unpack")
+commands.build = require("luarocks.build")
+commands.install = require("luarocks.install")
+commands.search = require("luarocks.search")
+commands.list = require("luarocks.list")
+commands.remove = require("luarocks.remove")
+commands.make = require("luarocks.make")
+
+command_line.run_command(...)
diff --git a/src/bin/luarocks-admin b/src/bin/luarocks-admin
new file mode 100755
index 00000000..826597f6
--- /dev/null
+++ b/src/bin/luarocks-admin
@@ -0,0 +1,14 @@
+#!/usr/bin/env lua
+
+local command_line = require("luarocks.command_line")
+
+program_name = "luarocks-admin"
+program_description = "LuaRocks repository administration interface"
+
+commands = {
+}
+
+commands.help = require("luarocks.help")
+commands.make_manifest = require("luarocks.make_manifest")
+
+command_line.run_command(...)
diff --git a/src/luarocks/build.lua b/src/luarocks/build.lua
new file mode 100644
index 00000000..f0f7225d
--- /dev/null
+++ b/src/luarocks/build.lua
@@ -0,0 +1,276 @@
+
+--- Module implementing the LuaRocks "build" command.
+-- Builds a rock, compiling its C parts if any.
+module("luarocks.build", package.seeall)
+
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local rep = require("luarocks.rep")
+local fetch = require("luarocks.fetch")
+local fs = require("luarocks.fs")
+local deps = require("luarocks.deps")
+local manif = require("luarocks.manif")
+
+help_summary = "Build/compile a rock."
+help_arguments = "{<rockspec>|<rock>|<name> [<version>]}"
+help = [[
+Build a rock, compiling its C parts if any.
+Argument may be a rockspec file, a source rock file
+or the name of a rock to be fetched from a repository.
+]]
+
+--- Install files to a given location.
+-- Takes a table where the array part is a list of filenames to be copied.
+-- In the hash part, other keys are identifiers in Lua module format,
+-- to indicate which subdirectory the file should be copied to. For example,
+-- install_files({["foo.bar"] = "src/bar.lua"}, "boo") will copy src/bar.lua
+-- to boo/foo.
+-- @param files table or nil: A table containing a list of files to copy in
+-- the format described above. If nil is passed, this function is a no-op.
+-- Directories should be delimited by forward slashes as in internet URLs.
+-- @param location string: The base directory files should be copied to.
+-- @return boolean or (nil, string): True if succeeded or 
+-- nil and an error message.
+local function install_files(files, location) 
+   assert(type(files) == "table" or not files)
+   assert(type(location) == "string")
+   if files then
+      for k, file in pairs(files) do
+         local dest = location
+         if type(k) == "string" then
+            dest = fs.make_path(location, path.module_to_path(k))
+         end
+         fs.make_dir(dest)
+         local ok = fs.copy(fs.make_path(file), dest)
+         if not ok then
+            return nil, "Failed copying "..file
+         end
+      end
+   end
+   return true
+end
+
+--- Write to the current directory the contents of a table,
+-- where each key is a file name and its value is the file content.
+-- @param files table: The table of files to be written.
+local function extract_from_rockspec(files)
+   for name, content in pairs(files) do
+      local fd = io.open(fs.make_path(fs.current_dir(), name), "w+")
+      fd:write(content)
+      fd:close()
+   end
+end
+
+--- Applies patches inlined in the build.patches section
+-- and extracts files inlined in the build.extra_files section
+-- of a rockspec. 
+-- @param rockspec table: A rockspec table.
+-- @return boolean or (nil, string): True if succeeded or 
+-- nil and an error message.
+function apply_patches(rockspec)
+   assert(type(rockspec) == "table")
+
+   local build = rockspec.build
+   if build.extra_files then
+      extract_from_rockspec(build.extra_files)
+   end
+   if build.patches then
+      extract_from_rockspec(build.patches)
+      for patch, _ in util.sortedpairs(build.patches) do
+         print("Applying patch "..patch.."...")
+         local ok, err = fs.patch(tostring(patch))
+         if not ok then
+            return nil, "Failed applying patch "..patch
+         end
+      end
+   end
+   return true
+end
+
+--- Build and install a rock given a rockspec.
+-- @param rockspec_file string: local or remote filename of a rockspec.
+-- @param need_to_fetch boolean: true if sources need to be fetched,
+-- false if the rockspec was obtained from inside a source rock.
+-- @return boolean or (nil, string): True if succeeded or 
+-- nil and an error message.
+function build_rockspec(rockspec_file, need_to_fetch, minimal_mode)
+   assert(type(rockspec_file) == "string")
+   assert(type(need_to_fetch) == "boolean")
+
+   local rockspec, err = fetch.load_rockspec(rockspec_file)
+   if err then
+      return nil, err
+   elseif not rockspec.build then
+      return nil, "Rockspec error: build table not specified"
+   elseif not rockspec.build.type then
+      return nil, "Rockspec error: build type not specified"
+   end
+
+   local ok, err = deps.fulfill_dependencies(rockspec)
+   if err then
+      return nil, err
+   end
+   ok, err = deps.check_external_deps(rockspec, "build")
+   if err then
+      return nil, err
+   end
+
+   local name, version = rockspec.name, rockspec.version
+   if rep.is_installed(name, version) then
+      rep.delete_version(name, version)
+   end
+
+   if not minimal_mode then
+      local _, dir
+      if need_to_fetch then
+         ok, dir = fetch.fetch_sources(rockspec, true)
+         if not ok then
+            return nil, dir
+         end
+         fs.change_dir(dir)
+      elseif rockspec.source.file then
+         local ok, err = fs.unpack_archive(rockspec.source.file)
+         if not ok then
+            return nil, err
+         end
+      end
+      fs.change_dir(rockspec.source.dir)
+   end
+      
+   local dirs = {
+      lua = path.lua_dir(name, version),
+      lib = path.lib_dir(name, version),
+      conf = path.conf_dir(name, version),
+      bin = path.bin_dir(name, version),
+   }
+   
+   for _, dir in pairs(dirs) do
+      fs.make_dir(dir)
+   end
+   local rollback = util.schedule_function(function()
+      fs.delete(path.install_dir(name, version))
+      fs.remove_dir_if_empty(path.versions_dir(name))
+   end)
+
+   local build = rockspec.build
+   
+   if not minimal_mode then
+      ok, err = apply_patches(rockspec)
+      if err then
+         return nil, err
+      end
+   end
+   
+   if build.type ~= "none" then
+
+      -- Temporary compatibility
+      if build.type == "module" then build.type = "builtin" end
+
+      ok, build_type = pcall(require, "luarocks.build." .. build.type)
+      if not ok or not type(build_type) == "table" then
+         return nil, "Failed initializing build back-end for build type '"..build.type.."'"
+      end
+  
+      ok, err = build_type.run(rockspec)
+      if not ok then
+         return nil, "Build error: " .. err
+      end
+   end
+
+   if build.install then
+      for id, dir in pairs(dirs) do
+         ok, err = install_files(build.install[id], dir)
+         if not ok then 
+            return nil, err
+         end
+      end
+   end
+   
+   local copy_directories = build.copy_directories or {"doc"}
+
+   for _, dir in pairs(copy_directories) do
+      if fs.is_dir(dir) then
+         local dest = fs.make_path(path.install_dir(name, version), dir)
+         fs.make_dir(dest)
+         fs.copy_contents(dir, dest)
+      end
+   end
+
+   for _, dir in pairs(dirs) do
+      fs.remove_dir_if_empty(dir)
+   end
+
+   fs.pop_dir()
+   
+   fs.copy(rockspec.local_filename, path.rockspec_file(name, version))
+   if need_to_fetch then
+      fs.pop_dir()
+   end
+
+   ok, err = rep.install_bins(name, version)
+   if not ok then return nil, err end
+
+   ok, err = rep.run_hook(rockspec, "post_install")
+   if err then
+      return nil, err
+   end
+
+   ok, err = manif.update_manifest(name, version)
+   if err then
+      return nil, err
+   end
+   util.remove_scheduled_function(rollback)
+   return true
+end
+
+--- Build and install a rock.
+-- @param rock_file string: local or remote filename of a rock.
+-- @param need_to_fetch boolean: true if sources need to be fetched,
+-- false if the rockspec was obtained from inside a source rock.
+-- @return boolean or (nil, string): True if build was successful,
+-- or false and an error message.
+local function build_rock(rock_file, need_to_fetch)
+   assert(type(rock_file) == "string")
+   assert(type(need_to_fetch) == "boolean")
+  
+   local dir, err = fetch.fetch_and_unpack_rock(rock_file)
+   if not dir then
+      return nil, err
+   end
+   local rockspec_file = path.rockspec_name_from_rock(rock_file)
+   fs.change_dir(dir)
+   local ok, err = build_rockspec(rockspec_file, need_to_fetch)
+   fs.pop_dir()
+   return ok, err
+end
+
+--- Driver function for "build" command.
+-- @param name string: A local or remote rockspec or rock file.
+-- If a package name is given, forwards the request to "search" and,
+-- if returned a result, installs the matching rock.
+-- @param version string: When passing a package name, a version number may
+-- also be given.
+-- @return boolean or (nil, string): True if build was successful; nil and an
+-- error message otherwise.
+function run(...)
+   local flags, name, version = util.parse_flags(...)
+   if type(name) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+   assert(type(version) == "string" or not version)
+
+   if name:match("%.rockspec$") then
+      return build_rockspec(name, true)
+   elseif name:match("%.src%.rock$") then
+      return build_rock(name, false)
+   elseif name:match("%.all%.rock$") then
+      local install = require("luarocks.install")
+      return install.install_binary_rock(name)
+   elseif name:match("%.rock$") then
+      return build_rock(name, true)
+   elseif not name:match(fs.dir_separator) then
+      local search = require("luarocks.search")
+      return search.act_on_src_or_rockspec(run, name, version)
+   end
+   return nil, "Don't know what to do with "..name
+end
diff --git a/src/luarocks/build/builtin.lua b/src/luarocks/build/builtin.lua
new file mode 100644
index 00000000..c93edaa2
--- /dev/null
+++ b/src/luarocks/build/builtin.lua
@@ -0,0 +1,152 @@
+
+--- A builtin build system: back-end to provide a portable way of building C-based Lua modules.
+module("luarocks.build.builtin", package.seeall)
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+
+--- Check if platform was detected
+-- @param query string: The platform name to check.
+-- @return boolean: true if LuaRocks is currently running on queried platform.
+local function is_platform(query)
+   assert(type(query) == "string")
+
+   for _, platform in ipairs(cfg.platforms) do
+      if platform == query then
+         return true
+      end
+   end
+end
+
+--- Run a command displaying its execution on standard output.
+-- @return boolean: true if command succeeds (status code 0), false
+-- otherwise.
+local function execute(...)
+   io.stdout:write(table.concat({...}, " ").."\n")
+   return fs.execute(...)
+end
+
+--- Driver function for the builtin build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+   local compile_object, compile_library
+
+   local build = rockspec.build
+   local variables = rockspec.variables
+
+   local function add_flags(extras, flag, flags)
+      if flags then
+         if type(flags) ~= "table" then
+            flags = { tostring(flags) }
+         end
+         util.variable_substitutions(flags, variables)
+         for _, v in ipairs(flags) do
+            table.insert(extras, flag:format(v))
+         end
+      end
+   end
+
+   if is_platform("win32") then
+      compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-c", "-Fo"..object, "-I"..variables.LUA_INCDIR, source, unpack(extras))
+      end
+      compile_library = function(library, objects, libraries, libdirs, name)
+         local extras = { unpack(objects) }
+         add_flags(extras, "-libpath:%s", libdirs)
+         add_flags(extras, "%s.lib", libraries)
+         local basename = fs.base_name(library):gsub(".[^.]*$", "")
+         local deffile = basename .. ".def"
+         local def = io.open(fs.make_path(fs.current_dir(), deffile), "w+")
+         def:write("EXPORTS\n")
+         def:write("luaopen_"..name:gsub("%.", "_").."\n")
+         def:close()
+         local ok = execute(variables.LD, "-dll", "-def:"..deffile, "-out:"..library, fs.make_path(variables.LUA_LIBDIR, "lua5.1.lib"), unpack(extras))
+         local manifestfile = basename..".dll.manifest"
+         if ok and fs.exists(manifestfile) then
+            ok = execute(variables.MT, "-manifest", manifestfile, "-outputresource:"..basename..".dll;2")
+         end
+         return ok
+      end
+   else
+      compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-I"..variables.LUA_INCDIR, "-c", source, "-o", object, unpack(extras))
+      end
+      compile_library = function (library, objects, libraries, libdirs)
+         local extras = { unpack(objects) }
+         add_flags(extras, "-L%s", libdirs)
+         add_flags(extras, "-l%s", libraries)
+         if is_platform("cygwin") then
+            add_flags(extras, "-l%s", {"lua"})
+         end
+         return execute(variables.LD.." "..variables.LIBFLAG, "-o", library, unpack(extras))
+      end
+   end
+
+   local ok = true
+   local built_modules = {}
+   local luadir = path.lua_dir(rockspec.name, rockspec.version)
+   local libdir = path.lib_dir(rockspec.name, rockspec.version)
+   local docdir = path.doc_dir(rockspec.name, rockspec.version)
+   for name, info in pairs(build.modules) do
+      local moddir = path.module_to_path(name)
+      if type(info) == "string" then
+         local ext = info:match(".([^.]+)$")
+         if ext == "lua" then
+            local dest = fs.make_path(luadir, moddir)
+            built_modules[info] = dest
+         else
+            info = {info}
+         end
+      end
+      if type(info) == "table" then
+         local objects = {}
+         local sources = info.sources
+         if info[1] then sources = info end
+         if type(sources) == "string" then sources = {sources} end
+         for _, source in ipairs(sources) do
+            local object = source:gsub(".[^.]*$", "."..cfg.obj_extension)
+            if not object then
+               object = source.."."..cfg.obj_extension
+            end
+            ok = compile_object(object, source, info.defines, info.incdirs)
+            if not ok then break end
+            table.insert(objects, object)
+         end
+         if not ok then break end
+         local module_name = fs.make_path(moddir, name:match("([^.]*)$").."."..cfg.lib_extension):gsub("//", "/")
+         if moddir ~= "" then
+            fs.make_dir(moddir)
+         end
+         local dest = fs.make_path(libdir, moddir)
+         built_modules[module_name] = dest
+         ok = compile_library(module_name, objects, info.libraries, info.libdirs, name)
+         if not ok then break end
+      end
+   end
+   for name, dest in pairs(built_modules) do
+      fs.make_dir(dest)
+      ok = fs.copy(name, dest)
+      if not ok then break end
+   end
+   if ok then
+      if fs.is_dir("lua") then
+         fs.copy_contents("lua", luadir)
+      end
+   end
+   if ok then
+      return true
+   else
+      return nil, "Build error"
+   end
+end
diff --git a/src/luarocks/build/cmake.lua b/src/luarocks/build/cmake.lua
new file mode 100644
index 00000000..7fd1fcc8
--- /dev/null
+++ b/src/luarocks/build/cmake.lua
@@ -0,0 +1,54 @@
+
+--- Build back-end for CMake-based modules.
+module("luarocks.build.cmake", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+
+--- Driver function for the "cmake" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+   local build = rockspec.build
+   local variables = build.variables or {}
+   
+   -- Pass Env variables
+   build.variables.CMAKE_MODULE_PATH=os.getenv("CMAKE_MODULE_PATH")
+   build.variables.CMAKE_LIBRARY_PATH=os.getenv("CMAKE_LIBRARY_PATH")
+   build.variables.CMAKE_INCLUDE_PATH=os.getenv("CMAKE_INCLUDE_PATH")
+
+   util.variable_substitutions(variables, rockspec.variables)
+   
+   -- If inline cmake is present create CMakeLists.txt from it.
+   if type(build.cmake) == "string" then
+      local cmake = assert(io.open(fs.current_dir().."/CMakeLists.txt", "w"))
+      cmake:write(build.cmake)
+      cmake:close()
+   end
+
+
+   -- Execute cmake with variables.
+   local args = ""
+   if cfg.cmake_generator then
+      args = args .. ' -G"'..cfg.cmake_generator.. '"'
+   end
+   for k,v in pairs(variables) do
+      args = args .. ' -D' ..k.. '="' ..v.. '"'
+   end
+
+   if not fs.execute("cmake . " ..args) then
+      return nil, "Failed cmake."
+   end
+   
+   if not fs.execute("make -fMakefile") then
+      return nil, "Failed building."
+   end
+
+   if not fs.execute("make -fMakefile install") then
+      return nil, "Failed installing."
+   end
+   return true
+end
diff --git a/src/luarocks/build/command.lua b/src/luarocks/build/command.lua
new file mode 100644
index 00000000..72d3de7f
--- /dev/null
+++ b/src/luarocks/build/command.lua
@@ -0,0 +1,30 @@
+
+--- Build back-end for raw listing of commands in rockspec files.
+module("luarocks.build.command", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+
+--- Driver function for the "command" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+
+   local build = rockspec.build
+   
+   util.variable_substitutions(build, rockspec.variables)
+   
+   if build.build_command then
+      if not fs.execute(build.build_command) then
+         return nil, "Failed building."
+      end
+   end
+   if build.install_command then
+      if not fs.execute(build.install_command) then
+         return nil, "Failed installing."
+      end
+   end
+   return true
+end
diff --git a/src/luarocks/build/make.lua b/src/luarocks/build/make.lua
new file mode 100644
index 00000000..b3e553a9
--- /dev/null
+++ b/src/luarocks/build/make.lua
@@ -0,0 +1,84 @@
+
+--- Build back-end for using Makefile-based packages.
+module("luarocks.build.make", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+
+--- Call "make" with given target and variables
+-- @param pass boolean: If true, run make; if false, do nothing.
+-- @param target string: The make target; an empty string indicates 
+-- the default target.
+-- @param variables table: A table containing string-string key-value
+-- pairs representing variable assignments to be passed to make.
+-- @return boolean: false if any errors occurred, true otherwise.
+local function make_pass(pass, target, variables)
+   assert(type(pass) == "boolean")
+   assert(type(target) == "string")
+   assert(type(variables) == "table")
+
+   local assignments = {}
+   for k,v in pairs(variables) do
+      table.insert(assignments, k.."="..v)
+   end
+   if pass then
+      return fs.execute(cfg.make.." "..target, unpack(assignments))
+   else
+      return true
+   end
+end
+
+--- Driver function for the "make" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+
+   local build = rockspec.build
+   
+   if build.build_pass == nil then build.build_pass = true end
+   if build.install_pass == nil then build.install_pass = true end
+   build.build_variables = build.build_variables or {}
+   build.install_variables = build.install_variables or {}
+   build.build_target = build.build_target or ""
+   build.install_target = build.install_target or "install"
+   local makefile = build.makefile or cfg.makefile
+   if makefile then
+      -- Assumes all make's accept -f. True for POSIX make, GNU make and Microsoft nmake.
+      build.build_target = "-f "..makefile.." "..build.build_target
+      build.install_target = "-f "..makefile.." "..build.install_target
+   end
+
+   if build.variables then   
+      for var, val in pairs(build.variables) do
+         build.build_variables[var] = val 
+         build.install_variables[var] = val
+      end
+   end
+
+   util.variable_substitutions(build.build_variables, rockspec.variables)
+   util.variable_substitutions(build.install_variables, rockspec.variables)
+   
+   local auto_variables = { "CC" }
+   
+   for _, variable in pairs(auto_variables) do
+      if not build.build_variables[variable] then
+         build.build_variables[variable] = rockspec.variables[variable]
+      end
+      if not build.install_variables[variable] then
+         build.install_variables[variable] = rockspec.variables[variable]
+      end
+   end
+
+   local ok = make_pass(build.build_pass, build.build_target, build.build_variables)
+   if not ok then
+      return nil, "Failed building."
+   end
+   ok = make_pass(build.install_pass, build.install_target, build.install_variables)
+   if not ok then
+      return nil, "Failed installing."
+   end
+   return true
+end
diff --git a/src/luarocks/cfg.lua b/src/luarocks/cfg.lua
new file mode 100644
index 00000000..3c4c5aed
--- /dev/null
+++ b/src/luarocks/cfg.lua
@@ -0,0 +1,242 @@
+
+local rawset, next, table, pairs, print, require, io, os, setmetatable =
+      rawset, next, table, pairs, print, require, io, os, setmetatable
+
+--- Configuration for LuaRocks.
+-- Tries to load the user's configuration file and
+-- defines defaults for unset values. See the
+-- <a href="http://luarocks.org/en/Config_file_format">config
+-- file format documentation</a> for details.
+module("luarocks.cfg")
+
+local persist = require("luarocks.persist")
+
+local detected = {}
+local system,proc
+
+-- A proper installation of LuaRocks will hardcode the system
+-- and proc values with LUAROCKS_UNAME_S and LUAROCKS_UNAME_M,
+-- so that this detection does not run every time. When it is
+-- performed, we use the Unix way to identify the system,
+-- even on Windows (assuming UnxUtils or Cygwin).
+system = LUAROCKS_UNAME_S or io.popen("uname -s"):read("*l")
+proc = LUAROCKS_UNAME_M or io.popen("uname -m"):read("*l")
+if proc:match("i[%d]86") then
+   proc = "x86"
+elseif proc:match("amd64") or proc:match("x86_64") then
+   proc = "x86_64"
+elseif proc:match("Power Macintosh") then
+   proc = "powerpc"
+end
+
+if system == "FreeBSD" then
+   detected.unix = true
+   detected.freebsd = true
+elseif system == "Darwin" then
+   detected.unix = true
+   detected.macosx = true
+elseif system == "Linux" then
+   detected.unix = true
+   detected.linux = true
+elseif system and system:match("^CYGWIN") then
+   detected.unix = true
+   detected.cygwin = true
+elseif system and system:match("^Windows") then
+   detected.windows = true
+else
+   detected.unix = true
+   -- Fall back to Unix in unknown systems.
+end
+
+local sys_config_file, home_config_file, home_tree
+if detected.windows then
+   home = os.getenv("APPDATA") or "c:"
+   sys_config_file = "c:/luarocks/config.lua"
+   home_config_file = home.."/luarocks/config.lua"
+   home_tree = home.."/luarocks/"
+else
+   home = os.getenv("HOME") or ""
+   sys_config_file = "/etc/luarocks/config.lua"
+   home_config_file = home.."/.luarocks/config.lua"
+   home_tree = home.."/.luarocks/"
+end
+
+variables = {}
+rocks_trees = {}
+
+persist.load_into_table(LUAROCKS_SYSCONFIG or sys_config_file, _M)
+
+if not LUAROCKS_FORCE_CONFIG then
+   home_config_file = os.getenv("LUAROCKS_CONFIG") or home_config_file
+   local home_overrides = persist.load_into_table(home_config_file, { home = home })
+   if home_overrides then
+      local util = require("luarocks.util")
+      util.deep_merge(_M, home_overrides)
+   end
+end
+
+local defaults = {
+   arch = "unknown",
+   lib_extension = "unknown",
+   obj_extension = "unknown",
+   rocks_servers = {
+      "http://luarocks.luaforge.net/rocks"
+   },
+   lua_extension = "lua",
+   lua_interpreter = LUA_INTERPRETER or "lua",
+   downloader = LUAROCKS_DOWNLOADER or "wget",
+   md5checker = LUAROCKS_MD5CHECKER or "md5sum",
+   variables = {}
+}
+
+defaults.external_deps_subdirs = {
+   bin = "bin",
+   lib = "lib",
+   include = "include"
+}
+defaults.runtime_external_deps_subdirs = defaults.external_deps_subdirs
+
+if detected.windows then
+   home_config_file = home_config_file:gsub("\\","/")
+   defaults.lib_extension = "dll"
+   defaults.obj_extension = "obj"
+   local rootdir = LUAROCKS_ROCKS_TREE or home_tree
+   defaults.root_dir = rootdir
+   defaults.rocks_dir = rootdir.."/rocks/"
+   defaults.scripts_dir = rootdir.."/bin/"
+   defaults.external_deps_dirs = { "c:/external/" }
+   defaults.variables.LUA_BINDIR = LUA_BINDIR and LUA_BINDIR:gsub("\\", "/") or "c:/lua5.1/bin"
+   defaults.variables.LUA_INCDIR = LUA_INCDIR and LUA_INCDIR:gsub("\\", "/") or "c:/lua5.1/include"
+   defaults.variables.LUA_LIBDIR = LUA_LIBDIR and LUA_LIBDIR:gsub("\\", "/") or "c:/lua5.1/lib"
+   defaults.arch = "win32-"..proc
+   defaults.platforms = {"win32", "windows" }
+   defaults.cmake_generator = "MinGW Makefiles"
+   -- TODO: Split Windows flavors between mingw and msvc
+   -- defaults.make = "make"
+   -- defaults.makefile = "Makefile"
+   defaults.make = "nmake"
+   defaults.makefile = "Makefile.win"
+   defaults.variables.CC = "cl"
+   defaults.variables.LD = "link"
+   defaults.variables.MT = "mt"
+   defaults.variables.CFLAGS = "/MD /O2"
+   defaults.variables.LIBFLAG = "/dll"
+   defaults.external_deps_patterns = {
+      bin = { "?.exe", "?.bat" },
+      lib = { "?.lib", "?.dll" },
+      include = { "?.h" }
+   }
+   defaults.runtime_external_deps_patterns = {
+      bin = { "?.exe", "?.bat" },
+      lib = { "?.dll" },
+      include = { "?.h" }
+   }
+end
+
+if detected.unix then
+   defaults.lib_extension = "so"
+   defaults.obj_extension = "o"
+   local rootdir = LUAROCKS_ROCKS_TREE or home_tree
+   defaults.root_dir = rootdir
+   defaults.rocks_dir = rootdir.."/rocks/"
+   defaults.scripts_dir = rootdir.."/bin/"
+   defaults.external_deps_dirs = { "/usr/local", "/usr" }
+   defaults.variables.LUA_BINDIR = LUA_BINDIR or "/usr/local/bin"
+   defaults.variables.LUA_INCDIR = LUA_INCDIR or "/usr/local/include"
+   defaults.variables.LUA_LIBDIR = LUA_LIBDIR or "/usr/local/lib"
+   defaults.variables.CFLAGS = "-O2"
+   defaults.cmake_generator = "Unix Makefiles"
+   defaults.make = "make"
+   defaults.platforms = { "unix" }
+   defaults.variables.CC = "cc"
+   defaults.variables.LD = "ld"
+   defaults.variables.LIBFLAG = "-shared"
+   defaults.external_deps_patterns = {
+      bin = { "?" },
+      lib = { "lib?.a", "lib?.so" },
+      include = { "?.h" }
+   }
+   defaults.runtime_external_deps_patterns = {
+      bin = { "?" },
+      lib = { "lib?.so" },
+      include = { "?.h" }
+   }
+end
+
+if detected.cygwin then
+   defaults.lib_extension = "so" -- can be overridden in the config file for mingw builds
+   defaults.arch = "cygwin-"..proc
+   defaults.platforms = {"unix", "cygwin"}
+   defaults.cmake_generator = "Unix Makefiles"
+   defaults.variables.CC = "echo -llua | xargs gcc"
+   defaults.variables.LD = "echo -llua | xargs gcc"
+   defaults.variables.LIBFLAG = "-shared"
+end
+
+defaults.external_lib_extension = defaults.lib_extension
+
+if detected.macosx then
+   defaults.external_lib_extension = "dylib"
+   defaults.arch = "macosx-"..proc
+   defaults.platforms = {"unix", "macosx"}
+   defaults.variables.CC = "export MACOSX_DEPLOYMENT_TARGET=10.3; gcc"
+   defaults.variables.LD = "export MACOSX_DEPLOYMENT_TARGET=10.3; gcc"
+   defaults.variables.LIBFLAG = "-bundle -undefined dynamic_lookup -all_load"
+end
+
+if detected.linux then
+   defaults.arch = "linux-"..proc
+   defaults.platforms = {"unix", "linux"}
+   defaults.variables.CC = "gcc"
+   defaults.variables.LD = "gcc"
+   defaults.variables.LIBFLAG = "-shared"
+end
+
+if detected.freebsd then
+   defaults.arch = "freebsd-"..proc
+   defaults.make = "gmake"
+   defaults.platforms = {"unix", "freebsd"}
+   defaults.variables.CC = "gcc"
+   defaults.variables.LD = "gcc"
+   defaults.variables.LIBFLAG = "-shared"
+end
+
+if proc == "x86_64" and not defaults.variables.CFLAGS:match("-fPIC") then
+   defaults.variables.CFLAGS = defaults.variables.CFLAGS.." -fPIC"
+end
+
+-- Expose some more values detected by LuaRocks for use by rockspec authors.
+defaults.variables.LUA = defaults.lua_interpreter
+defaults.variables.LIB_EXTENSION = defaults.lib_extension
+defaults.variables.OBJ_EXTENSION = defaults.obj_extension
+defaults.variables.LUAROCKS_PREFIX = LUAROCKS_PREFIX
+
+local cfg_mt = {
+   __index = function(t, k)
+      local default = defaults[k]
+      if default then
+         rawset(t, k, default)
+      end
+      return default
+   end
+}
+
+if not _M.variables then
+   _M.variables = {}
+end
+for k,v in pairs(defaults.variables) do
+   if not _M.variables[k] then
+      _M.variables[k] = v
+   end
+end
+
+setmetatable(_M, cfg_mt)
+
+if not next(rocks_trees) then
+   if home_tree then
+      table.insert(rocks_trees, home_tree)
+   end
+   if LUAROCKS_ROCKS_TREE then
+      table.insert(rocks_trees, LUAROCKS_ROCKS_TREE)
+   end
+end
diff --git a/src/luarocks/command_line.lua b/src/luarocks/command_line.lua
new file mode 100644
index 00000000..b3020284
--- /dev/null
+++ b/src/luarocks/command_line.lua
@@ -0,0 +1,133 @@
+
+program_version = "1.0"
+
+--- Functions for command-line scripts.
+module("luarocks.command_line", package.seeall)
+
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local fs = require("luarocks.fs")
+
+--- Display an error message and exit.
+-- @param message string: The error message.
+local function die(message)
+   assert(type(message) == "string")
+
+   local ok, err = pcall(util.run_scheduled_functions)
+   if not ok then
+      print("\nLuaRocks "..program_version.." internal bug (please report at luarocks-developers@lists.luaforge.net):\n"..err)
+   end
+   print("\nError: "..message)
+   os.exit(1)
+end
+
+--- Main command-line processor.
+-- Parses input arguments and calls the appropriate driver function
+-- to execute the action requested on the command-line, forwarding
+-- to it any additional arguments passed by the user.
+-- Uses the global table "commands", which contains
+-- the loaded modules representing commands.
+-- @param ... string: Arguments given on the command-line.
+function run_command(...)
+   local args = {...}
+   local cmdline_vars = {}
+   for i = #args, 1, -1 do
+      local arg = args[i]
+      if arg:match("^[^-][^=]*=") then
+         local var, val = arg:match("^([A-Z_][A-Z0-9_]*)=(.*)")
+         if val then
+            cmdline_vars[var] = val
+            table.remove(args, i)
+         else
+            die("Invalid assignment: "..arg)
+         end
+      end
+   end
+   local nonflags = { util.parse_flags(unpack(args)) }
+   local flags = table.remove(nonflags, 1)
+   
+   if flags["to"] then
+      if flags["to"] == true then
+         die("Argument error: use --to=<path>")
+      end
+      local root_dir = fs.absolute_name(flags["to"])
+      cfg.root_dir = root_dir
+      cfg.rocks_dir = root_dir.."/rocks"
+      cfg.scripts_dir = root_dir.."/bin"
+   else
+      local trees = cfg.rocks_trees
+      for i = #trees, 1, -1 do
+         local tree = trees[i]
+         if fs.make_dir(tree) and fs.is_writable(tree) then
+            cfg.root_dir = tree
+            cfg.rocks_dir = tree.."/rocks"
+            cfg.scripts_dir = rawget(cfg, "scripts_dir") or tree.."/bin"
+            break
+         end
+      end
+   end
+
+   cfg.root_dir = cfg.root_dir:gsub("/+$", "")
+   cfg.rocks_dir = cfg.rocks_dir:gsub("/+$", "")
+   cfg.scripts_dir = cfg.scripts_dir:gsub("/+$", "")
+   
+   cfg.variables.ROCKS_TREE = cfg.root_dir
+   cfg.variables.SCRIPTS_DIR = cfg.scripts_dir
+
+   if flags["from"] then
+      if flags["from"] == true then
+         die("Argument error: use --from=<url>")
+      end
+      local protocol, path = fs.split_url(flags["from"])
+      table.insert(cfg.rocks_servers, 1, protocol.."://"..path)
+   end
+   
+   if flags["only-from"] then
+      if flags["only-from"] == true then
+         die("Argument error: use --only-from=<url>")
+      end
+      cfg.rocks_servers = { flags["only-from"] }
+   end
+   
+   local command
+   
+   if flags["version"] then
+      print(program_name.." "..program_version)
+      print(program_description)
+      print()
+      os.exit(0)
+   elseif flags["help"] or #nonflags == 0 then
+      command = "help"
+      args = nonflags
+   else
+      command = nonflags[1]
+      for i, arg in ipairs(args) do
+         if arg == command then
+            table.remove(args, i)
+            break
+         end
+      end
+   end
+   
+   if command ~= "help" then
+      for k, v in pairs(cmdline_vars) do
+         cfg.variables[k] = v
+      end
+   end
+   
+   command = command:gsub("-", "_")
+   if commands[command] then
+      local xp, ok, err = xpcall(function() return commands[command].run(unpack(args)) end, function(err)
+         die(debug.traceback("LuaRocks "..program_version
+            .." bug (please report at luarocks-developers@lists.luaforge.net).\n"
+            ..err, 2))
+      end)
+      if xp and (not ok) then
+         die(err)
+      end
+   else
+      die("Unknown command: "..command)
+   end
+   
+   util.run_scheduled_functions()
+end
diff --git a/src/luarocks/deps.lua b/src/luarocks/deps.lua
new file mode 100644
index 00000000..d5a64e52
--- /dev/null
+++ b/src/luarocks/deps.lua
@@ -0,0 +1,618 @@
+
+--- Dependency handling functions.
+-- Dependencies are represented in LuaRocks through strings with
+-- a package name followed by a comma-separated list of constraints.
+-- Each constraint consists of an operator and a version number.
+-- In this string format, version numbers are represented as
+-- naturally as possible, like they are used by upstream projects
+-- (e.g. "2.0beta3"). Internally, LuaRocks converts them to a purely
+-- numeric representation, allowing comparison following some
+-- "common sense" heuristics. The precise specification of the
+-- comparison criteria is the source code of this module, but the
+-- test/test_deps.lua file included with LuaRocks provides some
+-- insights on what these criteria are.
+module("luarocks.deps", package.seeall)
+
+local rep = require("luarocks.rep")
+local search = require("luarocks.search")
+local install = require("luarocks.install")
+local cfg = require("luarocks.cfg")
+local manif = require("luarocks.manif")
+local fs = require("luarocks.fs")
+local fetch = require("luarocks.fetch")
+local path = require("luarocks.path")
+
+local operators = {
+   ["=="] = "==",
+   ["~="] = "~=",
+   [">"] = ">",
+   ["<"] = "<",
+   [">="] = ">=",
+   ["<="] = "<=",
+   ["~>"] = "~>",
+   -- plus some convenience translations
+   [""] = "==",
+   ["="] = "==",
+   ["!="] = "~="
+}
+
+local deltas = {
+   scm =    1000,
+   cvs =    1000,
+   rc =    -1000,
+   pre =   -10000,
+   beta =  -100000,
+   alpha = -1000000
+}
+
+local version_mt = {
+   --- Equality comparison for versions.
+   -- All version numbers must be equal.
+   -- If both versions have revision numbers, they must be equal;
+   -- otherwise the revision number is ignored.
+   -- @param v1 table: version table to compare.
+   -- @param v2 table: version table to compare.
+   -- @return boolean: true if they are considered equivalent.
+   __eq = function(v1, v2)
+      if #v1 ~= #v2 then
+         return false
+      end
+      for i = 1, #v1 do
+         if v1[i] ~= v2[i] then
+            return false
+         end
+      end
+      if v1.revision and v2.revision then
+         return (v1.revision == v2.revision)
+      end
+      return true
+   end,
+   --- Size comparison for versions.
+   -- All version numbers are compared.
+   -- If both versions have revision numbers, they are compared;
+   -- otherwise the revision number is ignored.
+   -- @param v1 table: version table to compare.
+   -- @param v2 table: version table to compare.
+   -- @return boolean: true if v1 is considered lower than v2.
+   __lt = function(v1, v2)
+      for i = 1, math.max(#v1, #v2) do
+         local v1i, v2i = v1[i] or 0, v2[i] or 0
+         if v1i ~= v2i then
+            return (v1i < v2i)
+         end
+      end
+      if v1.revision and v2.revision then
+         return (v1.revision < v2.revision)
+      end
+      return false
+   end
+}
+
+local version_cache = {}
+setmetatable(version_cache, {
+   __mode = "kv"
+})
+
+--- Parse a version string, converting to table format.
+-- A version table contains all components of the version string
+-- converted to numeric format, stored in the array part of the table.
+-- If the version contains a revision, it is stored numerically
+-- in the 'revision' field. The original string representation of
+-- the string is preserved in the 'string' field.
+-- Returned version tables use a metatable
+-- allowing later comparison through relational operators.
+-- @param vstring string: A version number in string format.
+-- @return table or nil: A version table or nil
+-- if the input string contains invalid characters.
+function parse_version(vstring)
+   if not vstring then return nil end
+   assert(type(vstring) == "string")
+
+   local cached = version_cache[vstring]
+   if cached then
+      return cached
+   end
+
+   local version = {}
+   local i = 1
+
+   local function add_token(number)
+      version[i] = version[i] and version[i] + number/100000 or number
+      i = i + 1
+   end
+   
+   -- trim leading and trailing spaces
+   vstring = vstring:match("^%s*(.*)%s*$")
+   version.string = vstring
+   -- store revision separately if any
+   local main, revision = vstring:match("(.*)%-(%d+)$")
+   if revision then
+      vstring = main
+      version.revision = tonumber(revision)
+   end
+   while #vstring > 0 do
+      -- extract a number
+      local token, rest = vstring:match("^(%d+)[%.%-%_]*(.*)")
+      if token then
+         add_token(tonumber(token))
+      else
+         -- extract a word
+         token, rest = vstring:match("^(%a+)[%.%-%_]*(.*)")
+         if not token then
+            return nil
+         end
+         local last = #version
+         version[i] = deltas[token] or (token:byte() / 1000)
+      end
+      vstring = rest
+   end
+   setmetatable(version, version_mt)
+   version_cache[vstring] = version
+   return version
+end
+
+--- Utility function to compare version numbers given as strings.
+-- @param a string: one version.
+-- @param b string: another version.
+-- @return boolean: True if a > b.
+function compare_versions(a, b)
+   return parse_version(a) > parse_version(b)
+end
+
+--- Consumes a constraint from a string, converting it to table format.
+-- For example, a string ">= 1.0, > 2.0" is converted to a table in the
+-- format {op = ">=", version={1,0}} and the rest, "> 2.0", is returned
+-- back to the caller.
+-- @param input string: A list of constraints in string format.
+-- @return (table, string) or nil: A table representing the same
+-- constraints and the string with the unused input, or nil if the
+-- input string is invalid.
+local function parse_constraint(input)
+   assert(type(input) == "string")
+
+   local no_upgrade, op, version, rest = input:match("^(@?)([<>=~!]*)%s*([%w%.%_%-]+)[%s,]*(.*)")
+   op = operators[op]
+   version = parse_version(version)
+   if not op or not version then return nil end
+   return { op = op, version = version, no_upgrade = no_upgrade=="@" and true or nil }, rest
+end
+
+--- Convert a list of constraints from string to table format.
+-- For example, a string ">= 1.0, < 2.0" is converted to a table in the format
+-- {{op = ">=", version={1,0}}, {op = "<", version={2,0}}}.
+-- Version tables use a metatable allowing later comparison through
+-- relational operators.
+-- @param input string: A list of constraints in string format.
+-- @return table or nil: A table representing the same constraints,
+-- or nil if the input string is invalid.
+function parse_constraints(input)
+   assert(type(input) == "string")
+
+   local constraints, constraint = {}, nil
+   while #input > 0 do
+      constraint, input = parse_constraint(input)
+      if constraint then
+         table.insert(constraints, constraint)
+      else
+         return nil
+      end
+   end
+   return constraints
+end
+
+--- Convert a dependency from string to table format.
+-- For example, a string "foo >= 1.0, < 2.0"
+-- is converted to a table in the format
+-- {name = "foo", constraints = {{op = ">=", version={1,0}},
+-- {op = "<", version={2,0}}}}. Version tables use a metatable
+-- allowing later comparison through relational operators.
+-- @param dep string: A dependency in string format
+-- as entered in rockspec files.
+-- @return table or nil: A table representing the same dependency relation,
+-- or nil if the input string is invalid.
+function parse_dep(dep)
+   assert(type(dep) == "string")
+
+   local name, rest = dep:match("^%s*(%a[%w%-]*%w)%s*(.*)")
+   if not name then return nil end
+   local constraints = parse_constraints(rest)
+   if not constraints then return nil end
+   return { name = name, constraints = constraints }
+end
+
+--- Convert a version table to a string.
+-- @param v table: The version table
+-- @param internal boolean or nil: Whether to display versions in their
+-- internal representation format or how they were specified.
+-- @return string: The dependency information pretty-printed as a string.
+function show_version(v, internal)
+   assert(type(v) == "table")
+   assert(type(internal) == "boolean" or not internal)
+
+   return (internal
+           and table.concat(v, ":")..(v.revision and tostring(v.revision) or "")
+           or v.string)
+end
+
+--- Convert a dependency in table format to a string.
+-- @param dep table: The dependency in table format
+-- @param internal boolean or nil: Whether to display versions in their
+-- internal representation format or how they were specified.
+-- @return string: The dependency information pretty-printed as a string.
+function show_dep(dep, internal)
+   assert(type(dep) == "table")
+   assert(type(internal) == "boolean" or not internal)
+   
+   local pretty = {}
+   for _, c in ipairs(dep.constraints) do
+      table.insert(pretty, c.op .. " " .. show_version(c.version, internal))
+   end
+   return dep.name.." "..table.concat(pretty, ", ")
+end
+
+--- A more lenient check for equivalence between versions.
+-- This returns true if the requested components of a version
+-- match and ignore the ones that were not given. For example,
+-- when requesting "2", then "2", "2.1", "2.3.5-9"... all match.
+-- When requesting "2.1", then "2.1", "2.1.3" match, but "2.2"
+-- doesn't.
+-- @param version string or table: Version to be tested; may be
+-- in string format or already parsed into a table.
+-- @param requested string or table: Version requested; may be
+-- in string format or already parsed into a table.
+-- @return boolean: True if the tested version matches the requested
+-- version, false otherwise.
+local function partial_match(version, requested)
+   assert(type(version) == "string" or type(version) == "table")
+   assert(type(requested) == "string" or type(version) == "table")
+
+   if type(version) ~= "table" then version = parse_version(version) end
+   if type(requested) ~= "table" then requested = parse_version(requested) end
+   if not version or not requested then return false end
+   
+   for i, ri in ipairs(requested) do
+      local vi = version[i] or 0
+      if ri ~= vi then return false end
+   end
+   if requested.revision then
+      return requested.revision == version.revision
+   end
+   return true
+end
+
+--- Check if a version satisfies a set of constraints.
+-- @param version table: A version in table format
+-- @param constraints table: An array of constraints in table format.
+-- @return boolean: True if version satisfies all constraints,
+-- false otherwise.
+function match_constraints(version, constraints)
+   assert(type(version) == "table")
+   assert(type(constraints) == "table")
+   local ok = true
+   setmetatable(version, version_mt)
+   for _, constr in pairs(constraints) do
+      local constr_version = constr.version
+      setmetatable(constr.version, version_mt)
+      if     constr.op == "==" then ok = version == constr_version
+      elseif constr.op == "~=" then ok = version ~= constr_version
+      elseif constr.op == ">"  then ok = version >  constr_version
+      elseif constr.op == "<"  then ok = version <  constr_version
+      elseif constr.op == ">=" then ok = version >= constr_version
+      elseif constr.op == "<=" then ok = version <= constr_version
+      elseif constr.op == "~>" then ok = partial_match(version, constr_version)
+      end
+      if not ok then break end
+   end
+   return ok
+end
+
+--- Attempt to match a dependency to an installed rock.
+-- @param dep table: A dependency parsed in table format.
+-- @param blacklist table: Versions that can't be accepted. Table where keys
+-- are program versions and values are 'true'.
+-- @return table or nil: A table containing fields 'name' and 'version'
+-- representing an installed rock which matches the given dependency,
+-- or nil if it could not be matched.
+local function match_dep(dep, blacklist)
+   assert(type(dep) == "table")
+
+   local versions
+   if dep.name == "lua" then
+      versions = { "5.1" }
+   else
+      versions = manif.get_versions(dep.name)
+   end
+   if not versions then
+      return nil
+   end
+   if blacklist then
+      local i = 1
+      while versions[i] do
+         if blacklist[versions[i]] then
+            table.remove(versions, i)
+         else
+            i = i + 1
+         end
+      end
+   end
+   local candidates = {}
+   for _, vstring in ipairs(versions) do
+      local version = parse_version(vstring)
+      if match_constraints(version, dep.constraints) then
+         table.insert(candidates, version)
+      end
+   end
+   if #candidates == 0 then
+      return nil
+   else
+      table.sort(candidates)
+      return {
+         name = dep.name,
+         version = candidates[#candidates].string
+      }
+   end
+end
+
+--- Attempt to match dependencies of a rockspec to installed rocks.
+-- @param rockspec table: The rockspec loaded as a table.
+-- @param blacklist table or nil: Program versions to not use as valid matches.
+-- Table where keys are program names and values are tables where keys
+-- are program versions and values are 'true'.
+-- @return table, table: A table where keys are dependencies parsed
+-- in table format and values are tables containing fields 'name' and
+-- version' representing matches, and a table of missing dependencies
+-- parsed as tables.
+function match_deps(rockspec, blacklist)
+   assert(type(rockspec) == "table")
+   assert(type(blacklist) == "table" or not blacklist)
+   local matched, missing, no_upgrade = {}, {}, {}
+
+   for _, dep in ipairs(rockspec.dependencies) do
+      local found = match_dep(dep, blacklist and blacklist[dep.name] or nil)
+      if found then
+         if dep.name ~= "lua" then 
+            matched[dep] = found
+         end
+      else
+         if dep.constraints[1] and dep.constraints[1].no_upgrade then
+            no_upgrade[dep.name] = dep
+         else
+            missing[dep.name] = dep
+         end
+      end
+   end
+   return matched, missing, no_upgrade
+end
+
+--- Return a set of values of a table.
+-- @param tbl table: The input table.
+-- @return table: The array of keys.
+local function values_set(tbl)
+   local set = {}
+   for _, v in pairs(tbl) do
+      set[v] = true
+   end
+   return set
+end
+
+--- Check dependencies of a rock and attempt to install any missing ones.
+-- Packages are installed using the LuaRocks "install" command.
+-- Aborts the program if a dependency could not be fulfilled.
+-- @param rockspec table: A rockspec in table format.
+-- @return boolean or (nil, string): True if no errors occurred, or
+-- nil and an error message if any test failed.
+function fulfill_dependencies(rockspec)
+
+   if rockspec.supported_platforms then
+      if not platforms_set then
+         platforms_set = values_set(cfg.platforms)
+      end
+      local supported = nil
+      for _, plat in pairs(rockspec.supported_platforms) do
+         local neg, plat = plat:match("^(!?)(.*)")
+         if neg == "!" then
+            if platforms_set[plat] then
+               return nil, "This rockspec for "..rockspec.package.." does not support "..plat.." platforms."
+            end
+         else
+            if platforms_set[plat] then
+               supported = true
+            else
+               if supported == nil then
+                  supported = false
+               end
+            end
+         end
+      end
+      if supported == false then
+         local plats = table.concat(cfg.platforms, ", ")
+         return nil, "This rockspec for "..rockspec.package.." does not support "..plats.." platforms."
+      end
+   end
+
+   local matched, missing, no_upgrade = match_deps(rockspec)
+
+   if next(no_upgrade) then
+      print("Missing dependencies for "..rockspec.name.." "..rockspec.version..":")
+      for _, dep in pairs(no_upgrade) do
+         print(show_dep(dep))
+      end
+      if next(missing) then
+         for _, dep in pairs(missing) do
+            print(show_dep(dep))
+         end
+      end
+      print()
+      for _, dep in pairs(no_upgrade) do
+         print("This version of "..rockspec.name.." is designed for use with")
+         print(show_dep(dep)..", but is configured to avoid upgrading it")
+         print("automatically. Please upgrade "..dep.name.." with")
+         print("   luarocks install "..dep.name)
+         print("or choose an older version of "..rockspec.name.." with")
+         print("   luarocks search "..rockspec.name)
+      end
+      return nil, "Failed matching dependencies."
+   end
+
+   if next(missing) then
+      print()
+      print("Missing dependencies for "..rockspec.name..":")
+      for _, dep in pairs(missing) do
+         print(show_dep(dep))
+      end
+      print()
+
+      for _, dep in pairs(missing) do
+         -- Double-check in case dependency was filled during recursion.
+         if not match_dep(dep) then
+            local rock = search.find_suitable_rock(dep)
+            if not rock then
+               return nil, "Could not find a rock to satisfy dependency: "..show_dep(dep)
+            end
+            local ok, err = install.run(rock)
+            if not ok then
+               return nil, "Failed installing dependency: "..rock.." - "..err
+            end
+         end
+      end
+   end
+   return true
+end
+
+--- Set up path-related variables for external dependencies.
+-- For each key in the external_dependencies table in the
+-- rockspec file, four variables are created: <key>_DIR, <key>_BINDIR,
+-- <key>_INCDIR and <key>_LIBDIR. These are not overwritten
+-- if already set (e.g. by the LuaRocks config file or through the
+-- command-line). Values in the external_dependencies table
+-- are tables that may contain a "header" or a "library" field,
+-- with filenames to be tested for existence.
+-- @param rockspec table: The rockspec table.
+-- @param mode string: if "build" is given, checks all files;
+-- if "install" is given, do not scan for headers.
+-- @return boolean or (nil, string): True if no errors occurred, or
+-- nil and an error message if any test failed.
+function check_external_deps(rockspec, mode)
+   assert(type(rockspec) == "table")
+   
+   local vars = rockspec.variables
+   local patterns = cfg.external_deps_patterns
+   local subdirs = cfg.external_deps_subdirs
+   if mode == "install" then
+      patterns = cfg.runtime_external_deps_patterns
+      subdirs = cfg.runtime_external_deps_subdirs
+   end
+   local dirs = {
+      BINDIR = { subdir = subdirs.bin, testfile = "program", pattern = patterns.bin },
+      INCDIR = { subdir = subdirs.include, testfile = "header", pattern = patterns.include },
+      LIBDIR = { subdir = subdirs.lib, testfile = "library", pattern = patterns.lib }
+   }
+   if mode == "install" then
+      dirs.INCDIR = nil
+   end
+   if rockspec.external_dependencies then
+      for name, files in pairs(rockspec.external_dependencies) do
+         local ok = true
+         local failed_file = nil
+         for _, extdir in ipairs(cfg.external_deps_dirs) do
+            ok = true
+            local prefix = vars[name.."_DIR"]
+            if not prefix then
+               prefix = extdir
+            end
+            for dirname, dirdata in pairs(dirs) do
+               dirdata.dir = vars[name.."_"..dirname] or fs.make_path(prefix, dirdata.subdir)
+               local file = files[dirdata.testfile]
+               if file then
+                  local files = {}
+                  if not file:match("%.") then
+                     for _, pattern in ipairs(dirdata.pattern) do
+                        table.insert(files, pattern:gsub("?", file))
+                     end
+                  else
+                     table.insert(files, file)
+                  end
+                  local found = false
+                  failed_file = nil
+                  for _, f in pairs(files) do
+                     if f:match("%.so$") or f:match("%.dylib$") or f:match("%.dll$") then
+                        f = f:gsub("%.[^.]+$", "."..cfg.external_lib_extension)
+                     end
+                     local testfile = fs.make_path(dirdata.dir, f)
+                     if fs.exists(testfile) then
+                        found = true
+                        break
+                     else
+                        if failed_file then
+                           failed_file = failed_file .. ", or " .. f
+                        else
+                           failed_file = f
+                        end
+                     end
+                  end
+                  if not found then
+                     ok = false
+                     break
+                  end
+               end
+            end
+            if ok then
+               for dirname, dirdata in pairs(dirs) do
+                  vars[name.."_"..dirname] = dirdata.dir
+               end
+               vars[name.."_DIR"] = prefix
+               break
+            end
+         end
+         if not ok then
+            return nil, "Could not find expected file "..failed_file.." for "..name.." -- you may have to install "..name.." in your system and/or set the "..name.."_DIR variable"
+         end
+      end
+   end
+   return true
+end
+
+--- Recursively scan dependencies, to build a transitive closure of all
+-- dependent packages.
+-- @param results table: The results table being built.
+-- @param name string: Package name.
+-- @param version string: Package version.
+-- @return (table, table): The results and a table of missing dependencies.
+function scan_deps(results, missing, manifest, name, version)
+   assert(type(results) == "table")
+   assert(type(missing) == "table")
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+
+   local err
+   if results[name] then
+      return results, missing
+   end
+   if not manifest.dependencies then manifest.dependencies = {} end
+   local dependencies = manifest.dependencies
+   if not dependencies[name] then dependencies[name] = {} end
+   local dependencies_name = dependencies[name]
+   local deplist = dependencies_name[version]
+   local rockspec, err
+   if not deplist then
+      rockspec, err = fetch.load_local_rockspec(path.rockspec_file(name, version))
+      if err then
+         missing[name.." "..version] = true
+         return results, missing
+      end
+      dependencies_name[version] = rockspec.dependencies
+   else
+      rockspec = { dependencies = deplist }
+   end
+   local matched, failures = match_deps(rockspec)
+   for _, match in pairs(matched) do
+      results, missing = scan_deps(results, missing, manifest, match.name, match.version)
+   end
+   if next(failures) then
+      for _, failure in pairs(failures) do
+         missing[show_dep(failure)] = true
+      end
+   end
+   results[name] = version
+   return results, missing
+end
diff --git a/src/luarocks/fetch.lua b/src/luarocks/fetch.lua
new file mode 100644
index 00000000..b61fab28
--- /dev/null
+++ b/src/luarocks/fetch.lua
@@ -0,0 +1,284 @@
+
+--- Functions related to fetching and loading local and remote files.
+module("luarocks.fetch", package.seeall)
+
+local fs = require("luarocks.fs")
+local type_check = require("luarocks.type_check")
+local path = require("luarocks.path")
+local deps = require("luarocks.deps")
+local persist = require("luarocks.persist")
+local util = require("luarocks.util")
+
+--- Fetch a local or remote file.
+-- Make a remote or local URL/pathname local, fetching the file if necessary.
+-- Other "fetch" and "load" functions use this function to obtain files.
+-- If a local pathname is given, it is returned as a result.
+-- @param url string: a local pathname or a remote URL.
+-- @param filename string or nil: this function attempts to detect the
+-- resulting local filename of the remote file as the basename of the URL;
+-- if that is not correct (due to a redirection, for example), the local
+-- filename can be given explicitly as this second argument.
+-- @return string or (nil, string): the absolute local pathname for the
+-- fetched file, or nil and a message in case of errors.
+function fetch_url(url, filename)
+   assert(type(url) == "string")
+   assert(type(filename) == "string" or not filename)
+
+   local protocol, pathname = fs.split_url(url)
+   if protocol == "file" then
+      return fs.absolute_name(pathname)
+   elseif protocol == "http" or protocol == "ftp" or protocol == "https" then
+      local ok = fs.download(url)
+      if not ok then
+         return nil, "Failed downloading "..url
+      end
+      return fs.make_path(fs.current_dir(), filename or fs.base_name(url))
+   else
+      return nil, "Unsupported protocol "..protocol
+   end
+end
+
+--- For remote URLs, create a temporary directory and download URL inside it.
+-- This temporary directory will be deleted on program termination.
+-- For local URLs, just return the local pathname and its directory.
+-- @param url string: URL to be downloaded
+-- @param tmpname string: name pattern to use for avoiding conflicts
+-- when creating temporary directory.
+-- @param filename string or nil: local filename of URL to be downloaded,
+-- in case it can't be inferred from the URL.
+-- @return (string, string) or (nil, string): absolute local pathname of
+-- the fetched file and temporary directory name; or nil and an error message.
+function fetch_url_at_temp_dir(url, tmpname, filename)
+   assert(type(url) == "string")
+   assert(type(tmpname) == "string")
+   assert(type(filename) == "string" or not filename)
+   filename = filename or fs.base_name(url)
+
+   local protocol, pathname = fs.split_url(url)
+   if protocol == "file" then
+      return pathname, fs.dir_name(pathname)
+   else
+      local dir = fs.make_temp_dir(tmpname)
+      if not dir then
+         return nil, "Failed creating temporary directory."
+      end
+      util.schedule_function(fs.delete, dir)
+      fs.change_dir(dir)
+      local file, err = fetch_url(url, filename)
+      if not file then
+         return nil, "Error fetching file: "..err
+      end
+      fs.pop_dir()
+      return file, dir
+   end
+end
+
+--- Obtain a rock and unpack it.
+-- If a directory is not given, a temporary directory will be created,
+-- which will be deleted on program termination.
+-- @param rock_file string: URL or filename of the rock.
+-- @param dest string or nil: if given, directory will be used as
+-- a permanent destination.
+-- @return string or (nil, string): the directory containing the contents
+-- of the unpacked rock.
+function fetch_and_unpack_rock(rock_file, dest)
+   assert(type(rock_file) == "string")
+   assert(type(dest) == "string" or not dest)
+
+   local name = fs.base_name(rock_file):match("(.*)%.[^.]*%.rock")
+   
+   local rock_file, err = fetch_url_at_temp_dir(rock_file,"luarocks-rock-"..name)
+   if not rock_file then
+      return nil, "Could not fetch rock file: " .. err
+   end
+
+   rock_file = fs.absolute_name(rock_file)
+   local dir
+   if dest then
+      dir = dest
+      fs.make_dir(dir)
+   else
+      dir = fs.make_temp_dir(name)
+   end
+   if not dest then
+      util.schedule_function(fs.delete, dir)
+   end
+   fs.change_dir(dir)
+   local ok = fs.unzip(rock_file)
+   if not ok then
+      return nil, "Failed unpacking rock file: " .. rock_file
+   end
+   fs.pop_dir()
+   return dir
+end
+
+--- Back-end function that actually loads the local rockspec.
+-- Performs some validation and postprocessing of the rockspec contents.
+-- @param file string: The local filename of the rockspec file.
+-- @return table or (nil, string): A table representing the rockspec
+-- or nil followed by an error message.
+function load_local_rockspec(filename)
+   assert(type(filename) == "string")
+
+   local rockspec, err = persist.load_into_table(filename)
+   if not rockspec then
+      return nil, "Could not load rockspec file "..filename.." ("..err..")"
+   end
+
+   local ok, err = type_check.type_check_rockspec(rockspec)
+   if not ok then
+      return nil, filename..": "..err
+   end
+   
+   if rockspec.rockspec_format then
+      if deps.compare_versions(rockspec.rockspec_format, type_check.rockspec_format) then
+         return nil, "Rockspec format "..rockspec.rockspec_format.." is not supported, please upgrade LuaRocks."
+      end
+   end
+
+   util.platform_overrides(rockspec.build)
+   util.platform_overrides(rockspec.dependencies)
+   util.platform_overrides(rockspec.external_dependencies)
+   util.platform_overrides(rockspec.source)
+   util.platform_overrides(rockspec.hooks)
+
+   local basename = fs.base_name(filename)
+   rockspec.name = basename:match("(.*)-[^-]*-[0-9]*")
+   if not rockspec.name then
+      return nil, "Expected filename in format 'name-version-revision.rockspec'."
+   end
+
+   local protocol, pathname = fs.split_url(rockspec.source.url)
+   if protocol == "http" or protocol == "https" or protocol == "ftp" or protocol == "file" then
+      rockspec.source.file = rockspec.source.file or fs.base_name(rockspec.source.url)
+   end
+   rockspec.source.protocol, rockspec.source.pathname = protocol, pathname
+
+   -- Temporary compatibility
+   if not rockspec.source.module then
+      rockspec.source.module = rockspec.source.cvs_module
+      rockspec.source.tag = rockspec.source.cvs_tag
+   end
+
+   local name_version = rockspec.package:lower() .. "-" .. rockspec.version
+   if basename ~= name_version .. ".rockspec" then
+      return nil, "Inconsistency between rockspec filename ("..basename..") and its contents ("..name_version..".rockspec)."
+   end
+
+   rockspec.local_filename = filename
+   local filebase = rockspec.source.file or rockspec.source.url
+   local base = fs.base_name(filebase)
+   base = base:gsub("%.[^.]*$", ""):gsub("%.tar$", "")
+   rockspec.source.dir = rockspec.source.dir
+                      or rockspec.source.module
+                      or ((filebase:match(".lua$") or filebase:match(".c$")) and ".")
+                      or base
+   if rockspec.dependencies then
+      for i = 1, #rockspec.dependencies do
+         local parsed = deps.parse_dep(rockspec.dependencies[i])
+         if not parsed then
+            return nil, "Parse error processing dependency '"..rockspec.dependencies[i].."'"
+         end
+         rockspec.dependencies[i] = parsed
+      end
+   else
+      rockspec.dependencies = {}
+   end
+   local ok, err = path.configure_paths(rockspec)
+   if err then
+      return nil, "Error verifying paths: "..err
+   end
+
+   return rockspec
+end
+
+--- Load a local or remote rockspec into a table.
+-- This is the entry point for the LuaRocks tools. 
+-- Only the LuaRocks runtime loader should use
+-- load_local_rockspec directly.
+-- @param filename string: Local or remote filename of a rockspec.
+-- @return table or (nil, string): A table representing the rockspec
+-- or nil followed by an error message.
+function load_rockspec(filename)
+   assert(type(filename) == "string")
+
+   local name = fs.base_name(filename):match("(.*)%.rockspec")
+   if not name then
+      return nil, "Filename '"..filename.."' does not look like a rockspec."
+   end
+   
+   local filename, err = fetch_url_at_temp_dir(filename,"luarocks-rockspec-"..name)
+   if not filename then
+      return nil, err
+   end
+
+   return load_local_rockspec(filename)
+end
+
+--- Download sources for building a rock using the basic URL downloader.
+-- @param rockspec table: The rockspec table
+-- @param extract boolean: Whether to extract the sources from
+-- the fetched source tarball or not.
+-- @param dest_dir string or nil: If set, will extract to the given directory.
+-- @return (string, string) or (nil, string): The absolute pathname of
+-- the fetched source tarball and the temporary directory created to
+-- store it; or nil and an error message.
+function get_sources(rockspec, extract, dest_dir)
+   assert(type(rockspec) == "table")
+   assert(type(extract) == "boolean")
+   assert(type(dest_dir) == "string" or not dest_dir)
+
+   local url = rockspec.source.url
+   local name = rockspec.name.."-"..rockspec.version
+   local filename = rockspec.source.file
+   local source_file, dir, err
+   if dest_dir then
+      fs.change_dir(dest_dir)
+      source_file, err = fetch_url(url, filename)
+      fs.pop_dir()
+      dir = dest_dir
+   else
+      source_file, dir = fetch_url_at_temp_dir(url, "luarocks-source-"..name, filename)
+   end
+   if not source_file then
+      return nil, err or dir
+   end
+   if rockspec.source.md5 then
+      if not fs.check_md5(source_file, rockspec.source.md5) then
+         return nil, "MD5 check for "..filename.." has failed."
+      end
+   end
+   if extract then
+      fs.change_dir(dir)
+      fs.unpack_archive(rockspec.source.file)
+      fs.pop_dir()
+   end
+   return source_file, dir
+end
+
+--- Download sources for building a rock, calling the appropriate protocol method.
+-- @param rockspec table: The rockspec table
+-- @param extract boolean: When downloading compressed formats, whether to extract
+-- the sources from the fetched archive or not.
+-- @param dest_dir string or nil: If set, will extract to the given directory.
+-- @return (string, string) or (nil, string): The absolute pathname of
+-- the fetched source tarball and the temporary directory created to
+-- store it; or nil and an error message.
+function fetch_sources(rockspec, extract, dest_dir)
+   assert(type(rockspec) == "table")
+   assert(type(extract) == "boolean")
+   assert(type(dest_dir) == "string" or not dest_dir)
+
+   local protocol = rockspec.source.protocol
+   local proto
+   if protocol == "http" or protocol == "https" or protocol == "ftp" or protocol == "file" then
+      proto = require("luarocks.fetch")
+   else
+      ok, proto = pcall(require, "luarocks.fetch."..protocol)
+      if not ok then
+         return nil, "Unknown protocol "..protocol
+      end
+   end
+   
+   return proto.get_sources(rockspec, extract, dest_dir)
+end
diff --git a/src/luarocks/fetch/cvs.lua b/src/luarocks/fetch/cvs.lua
new file mode 100644
index 00000000..291388cb
--- /dev/null
+++ b/src/luarocks/fetch/cvs.lua
@@ -0,0 +1,43 @@
+
+--- Fetch back-end for retrieving sources from CVS.
+module("luarocks.fetch.cvs", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+
+--- Download sources for building a rock, using CVS.
+-- @param rockspec table: The rockspec table
+-- @param extract boolean: Unused in this module (required for API purposes.)
+-- @param dest_dir string or nil: If set, will extract to the given directory.
+-- @return (string, string) or (nil, string): The absolute pathname of
+-- the fetched source tarball and the temporary directory created to
+-- store it; or nil and an error message.
+function get_sources(rockspec, extract, dest_dir)
+   assert(type(rockspec) == "table")
+   assert(type(dest_dir) == "string" or not dest_dir)
+
+   local name_version = rockspec.name .. "-" .. rockspec.version
+   local module = rockspec.source.module or fs.base_name(rockspec.source.url)
+   local command = {"cvs", "-d"..rockspec.source.pathname, "export", module}
+   if rockspec.source.tag then
+      table.insert(command, 4, "-r")
+      table.insert(command, 5, rockspec.source.tag)
+   end
+   local dir
+   if not dest_dir then
+      dir = fs.make_temp_dir(name_version)
+      if not dir then
+         return nil, "Failed creating temporary directory."
+      end
+      util.schedule_function(fs.delete, dir)
+   else
+      dir = dest_dir
+   end
+   fs.change_dir(dir)
+   if not fs.execute(unpack(command)) then
+      return nil, "Failed fetching files from CVS."
+   end
+   fs.pop_dir()
+   return module, dir
+end
+
diff --git a/src/luarocks/fetch/git.lua b/src/luarocks/fetch/git.lua
new file mode 100644
index 00000000..d0d204a9
--- /dev/null
+++ b/src/luarocks/fetch/git.lua
@@ -0,0 +1,53 @@
+
+--- Fetch back-end for retrieving sources from GIT.
+module("luarocks.fetch.git", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+
+--- Download sources for building a rock, using git.
+-- @param rockspec table: The rockspec table
+-- @param extract boolean: Unused in this module (required for API purposes.)
+-- @param dest_dir string or nil: If set, will extract to the given directory.
+-- @return (string, string) or (nil, string): The absolute pathname of
+-- the fetched source tarball and the temporary directory created to
+-- store it; or nil and an error message.
+function get_sources(rockspec, extract, dest_dir)
+   assert(type(rockspec) == "table")
+   assert(type(dest_dir) == "string" or not dest_dir)
+
+   local name_version = rockspec.name .. "-" .. rockspec.version
+   local module = fs.base_name(rockspec.source.url)
+   -- Strip off .git from base name if present
+   module = module:gsub("%.git$", "")
+   local command = {"git", "clone", rockspec.source.url, module}
+   local checkout_command
+   local tag_or_branch = rockspec.source.tag or rockspec.source.branch
+   if tag_or_branch then
+      checkout_command = {"git", "checkout", tag_or_branch}
+   end
+   local dir
+   if not dest_dir then
+      dir = fs.make_temp_dir(name_version)
+      if not dir then
+         return nil, "Failed creating temporary directory."
+      end
+      util.schedule_function(fs.delete, dir)
+   else
+      dir = dest_dir
+   end
+   fs.change_dir(dir)
+   if not fs.execute(unpack(command)) then
+      return nil, "Failed fetching files from GIT while cloning."
+   end
+   if checkout_command then
+      fs.change_dir(module)
+      if not fs.execute(unpack(checkout_command)) then
+         return nil, "Failed fetching files from GIT while getting tag/branch."
+      end
+      fs.pop_dir()
+   end
+   fs.pop_dir()
+   return module, dir
+end
+
diff --git a/src/luarocks/fetch/sscm.lua b/src/luarocks/fetch/sscm.lua
new file mode 100644
index 00000000..a2c70b96
--- /dev/null
+++ b/src/luarocks/fetch/sscm.lua
@@ -0,0 +1,40 @@
+
+--- Fetch back-end for retrieving sources from Surround SCM Server
+module("luarocks.fetch.sscm", package.seeall)
+
+local fs = require("luarocks.fs")
+
+--- Download sources via Surround SCM Server for building a rock.
+-- @param rockspec table: The rockspec table
+-- @param extract boolean: Unused in this module (required for API purposes.)
+-- @param dest_dir string or nil: If set, will extract to the given directory.
+-- @return (string, string) or (nil, string): The absolute pathname of
+-- the fetched source tarball and the temporary directory created to
+-- store it; or nil and an error message.
+function get_sources(rockspec, extract, dest_dir)
+   assert(type(rockspec) == "table")
+   assert(type(dest_dir) == "string" or not dest_dir)
+
+   local module = rockspec.source.module or fs.base_name(rockspec.source.url)
+   local branch, repository = string.match(rockspec.source.pathname, "^([^/]*)/(.*)")
+   if not branch or not repository then
+      return nil, "Error retrieving branch and repository from rockspec."
+   end
+   -- Search for working directory.
+   local working_dir
+   local tmp = io.popen(string.format([[sscm property "/" -d -b%s -p%s]], branch, repository))
+   for line in tmp:lines() do
+      --%c because a chr(13) comes in the end.
+      working_dir = string.match(line, "Working directory:[%s]*(.*)%c$")
+      if working_dir then break end
+   end
+   tmp:close()
+   if not working_dir then
+      return nil, "Error retrieving working directory from SSCM."
+   end
+   if not fs.execute([["sscm"]], "get", "*", "-e" , "-r", "-b"..branch, "-p"..repository, "-tmodify", "-wreplace") then
+      return nil, "Failed fetching files from SSCM."
+   end
+   -- FIXME: This function does not honor the dest_dir parameter.
+   return module, working_dir
+end
diff --git a/src/luarocks/fs.lua b/src/luarocks/fs.lua
new file mode 100644
index 00000000..7027167a
--- /dev/null
+++ b/src/luarocks/fs.lua
@@ -0,0 +1,43 @@
+
+local rawset = rawset
+
+--- Proxy module for filesystem and platform abstractions.
+-- All code using "fs" code should require "luarocks.fs",
+-- and not the various platform-specific implementations.
+-- However, see the documentation of the implementation
+-- for the API reference.
+module("luarocks.fs", package.seeall)
+
+local cfg = require("luarocks.cfg")
+
+local fs_impl = nil
+for _, platform in ipairs(cfg.platforms) do
+   local ok, result = pcall(require, "luarocks.fs."..platform)
+   if ok then
+      fs_impl = result
+      if fs_impl then
+         break
+      end
+   end
+end
+
+local fs_unix = require("luarocks.fs.unix")
+
+local fs_mt = {
+   __index = function(t, k)
+      local impl = fs_impl and fs_impl[k]
+      if not impl then
+         impl = fs_unix[k]
+      end
+      rawset(t, k, impl)
+      return impl
+   end
+}
+
+setmetatable(luarocks.fs, fs_mt)
+
+fs_unix.init_fs_functions(luarocks.fs)
+if fs_impl then
+   fs_impl.init_fs_functions(luarocks.fs)
+end
+
diff --git a/src/luarocks/fs/unix.lua b/src/luarocks/fs/unix.lua
new file mode 100644
index 00000000..2a849329
--- /dev/null
+++ b/src/luarocks/fs/unix.lua
@@ -0,0 +1,519 @@
+
+local assert, type, table, io, package, math, os, ipairs =
+      assert, type, table, io, package, math, os, ipairs
+
+--- Unix implementation of filesystem and platform abstractions.
+module("luarocks.fs.unix", package.seeall)
+
+local cfg = require("luarocks.cfg")
+
+math.randomseed(os.time())
+
+dir_stack = {}
+
+local fs_absolute_name,
+      fs_base_name,
+      fs_copy,
+      fs_current_dir,
+      fs_dir_stack,
+      fs_execute,
+      fs_execute_string,
+      fs_is_dir,
+      fs_make_dir,
+      fs_make_path,
+      fs_exists,
+      fs_find,
+      fs_Q
+
+function init_fs_functions(impl)
+   fs_absolute_name = impl.absolute_name
+   fs_base_name = impl.base_name
+   fs_copy = impl.copy
+   fs_current_dir = impl.current_dir
+   fs_dir_stack = impl.dir_stack
+   fs_execute = impl.execute
+   fs_execute_string = impl.execute_string
+   fs_is_dir = impl.is_dir
+   fs_make_dir = impl.make_dir
+   fs_make_path = impl.make_path
+   fs_exists = impl.exists
+   fs_find = impl.find
+   fs_Q = impl.Q
+end
+
+dir_separator = "/"
+
+--- Quote argument for shell processing.
+-- Adds single quotes and escapes.
+-- @param arg string: Unquoted argument.
+-- @return string: Quoted argument.
+function Q(arg)
+   assert(type(arg) == "string")
+
+   return "'" .. arg:gsub("\\", "\\\\"):gsub("'", "'\\''") .. "'"
+end
+
+--- Obtain current directory.
+-- Uses the module's internal dir stack.
+-- @return string: the absolute pathname of the current directory.
+function current_dir()
+   local current = os.getenv("PWD")
+   if not current then
+      local pipe = io.popen("pwd")
+      current = pipe:read("*l")
+      pipe:close()
+   end
+   for _, dir in ipairs(fs_dir_stack) do
+      current = fs_absolute_name(dir, current)
+   end
+   return current
+end
+
+--- Run the given command.
+-- The command is executed in the current directory in the dir stack.
+-- @param cmd string: No quoting/escaping is applied to the command.
+-- @return boolean: true if command succeeds (status code 0), false
+-- otherwise.
+function execute_string(cmd)
+   if os.execute("cd " .. fs_Q(fs_current_dir()) .. " && " .. cmd) == 0 then
+      return true
+   else
+      return false
+   end
+end
+
+--- Run the given command, quoting its arguments.
+-- The command is executed in the current directory in the dir stack.
+-- @param command string: The command to be executed. No quoting/escaping
+-- is applied.
+-- @param ... Strings containing additional arguments, which are quoted.
+-- @return boolean: true if command succeeds (status code 0), false
+-- otherwise.
+function execute(command, ...)
+   assert(type(command) == "string")
+   
+   for _, arg in ipairs({...}) do
+      assert(type(arg) == "string")
+      command = command .. " " .. fs_Q(arg)
+   end
+   return fs_execute_string(command)
+end
+
+--- Change the current directory.
+-- Uses the module's internal dir stack. This does not have exact
+-- semantics of chdir, as it does not handle errors the same way,
+-- but works well for our purposes for now.
+-- @param dir string: The directory to switch to.
+function change_dir(dir)
+   assert(type(dir) == "string")
+   table.insert(fs_dir_stack, dir)
+end
+
+--- Change directory to root.
+-- Allows leaving a directory (e.g. for deleting it) in
+-- a crossplatform way.
+function change_dir_to_root()
+   table.insert(fs_dir_stack, "/")
+end
+
+--- Change working directory to the previous in the dir stack.
+function pop_dir()
+   table.remove(fs_dir_stack)
+end
+
+--- Create a directory if it does not already exist.
+-- If any of the higher levels in the path name does not exist
+-- too, they are created as well.
+-- @param dir string: pathname of directory to create.
+-- @return boolean: true on success, false on failure.
+function make_dir(dir)
+   assert(dir)
+   return fs_execute("mkdir -p", dir)
+end
+
+--- Remove a directory if it is empty.
+-- Does not return errors (for example, if directory is not empty or
+-- if already does not exist)
+-- @param dir string: pathname of directory to remove.
+function remove_dir_if_empty(dir)
+   assert(dir)
+   fs_execute_string("rmdir "..fs_Q(dir).." 1> /dev/null 2> /dev/null")
+end
+
+--- Copy a file.
+-- @param src string: Pathname of source
+-- @param dest string: Pathname of destination
+-- @return boolean or (boolean, string): true on success, false on failure,
+-- plus an error message.
+function copy(src, dest)
+   assert(src and dest)
+   if fs_execute("cp", src, dest) then
+      return true
+   else
+      return false, "Failed copying "..src.." to "..dest
+   end
+end
+
+--- Recursively copy the contents of a directory.
+-- @param src string: Pathname of source
+-- @param dest string: Pathname of destination
+-- @return boolean or (boolean, string): true on success, false on failure,
+-- plus an error message.
+function copy_contents(src, dest)
+   assert(src and dest)
+   if fs_execute_string("cp -a "..fs_Q(src).."/* "..fs_Q(dest).." 1> /dev/null 2>/dev/null") then
+      return true
+   else
+      return false, "Failed copying "..src.." to "..dest
+   end
+end
+
+--- Delete a file or a directory and all its contents.
+-- For safety, this only accepts absolute paths.
+-- @param arg string: Pathname of source
+-- @return boolean: true on success, false on failure.
+function delete(arg)
+   assert(arg)
+   assert(arg:sub(1,1) == "/")
+   return fs_execute_string("rm -rf " .. fs_Q(arg) .. " 1> /dev/null 2>/dev/null")
+end
+
+--- List the contents of a directory. 
+-- @param at string or nil: directory to list (will be the current
+-- directory if none is given).
+-- @return table: an array of strings with the filenames representing
+-- the contents of a directory.
+function dir(at)
+   assert(type(at) == "string" or not at)
+   if not at then
+      at = fs_current_dir()
+   end
+   if not fs_is_dir(at) then
+      return {}
+   end
+   local result = {}
+   local pipe = io.popen("cd "..fs_Q(at).." && ls")
+   for file in pipe:lines() do
+      table.insert(result, file)
+   end
+   pipe:close()
+   return result
+end
+
+--- Recursively scan the contents of a directory. 
+-- @param at string or nil: directory to scan (will be the current
+-- directory if none is given).
+-- @return table: an array of strings with the filenames representing
+-- the contents of a directory.
+function find(at)
+   assert(type(at) == "string" or not at)
+   if not at then
+      at = fs_current_dir()
+   end
+   if not fs_is_dir(at) then
+      return {}
+   end
+   local result = {}
+   local pipe = io.popen("cd "..fs_Q(at).." && find * 2>/dev/null") 
+   for file in pipe:lines() do
+      table.insert(result, file)
+   end
+   pipe:close()
+   return result
+end
+
+--- Compress files in a .zip archive.
+-- @param zipfile string: pathname of .zip archive to be created.
+-- @param ... Filenames to be stored in the archive are given as
+-- additional arguments.
+-- @return boolean: true on success, false on failure.
+function zip(zipfile, ...)
+   return fs_execute("zip -r", zipfile, ...)
+end
+
+--- Uncompress files from a .zip archive.
+-- @param zipfile string: pathname of .zip archive to be extracted.
+-- @return boolean: true on success, false on failure.
+function unzip(zipfile)
+   assert(zipfile)
+   return fs_execute("unzip", zipfile)
+end
+
+--- Test for existance of a file.
+-- @param file string: filename to test
+-- @return boolean: true if file exists, false otherwise.
+function exists(file)
+   assert(file)
+   return fs_execute("test -r", file)
+end
+
+--- Test is file/dir is writable.
+-- @param file string: filename to test
+-- @return boolean: true if file exists, false otherwise.
+function is_writable(file)
+   assert(file)
+   return fs_execute("test -w", file)
+end
+
+--- Test is pathname is a directory.
+-- @param file string: pathname to test
+-- @return boolean: true if it is a directory, false otherwise.
+function is_dir(file)
+   assert(file)
+   return fs_execute("test -d", file)
+end
+
+--- Download a remote file.
+-- @param url string: URL to be fetched.
+-- @param filename string or nil: this function attempts to detect the
+-- resulting local filename of the remote file as the basename of the URL;
+-- if that is not correct (due to a redirection, for example), the local
+-- filename can be given explicitly as this second argument.
+-- @return boolean: true on success, false on failure.
+function download(url, filename)
+   assert(type(url) == "string")
+   assert(type(filename) == "string" or not filename)
+
+   if cfg.downloader == "wget" then
+      if filename then   
+         return fs_execute("wget --quiet --continue --output-document ", filename, url)
+      else
+         return fs_execute("wget --quiet --continue ", url)
+      end
+   elseif cfg.downloader == "curl" then
+      filename = filename or fs_base_name(url)
+      return fs_execute_string("curl "..fs_Q(url).." 2> /dev/null 1> "..fs_Q(filename))
+   end
+end
+
+--- Strip the path off a path+filename.
+-- @param pathname string: A path+name, such as "/a/b/c".
+-- @return string: The filename without its path, such as "c".
+function base_name(pathname)
+   assert(type(pathname) == "string")
+
+   local base = pathname:match(".*/([^/]*)")
+   return base or pathname
+end
+
+--- Strip the name off a path+filename.
+-- @param pathname string: A path+name, such as "/a/b/c".
+-- @return string: The filename without its path, such as "/a/b/".
+-- For entries such as "/a/b/", "/a/" is returned. If there are
+-- no directory separators in input, "" is returned.
+function dir_name(pathname)
+   assert(type(pathname) == "string")
+
+   local dir = pathname:gsub("/*$", ""):match("(.*/)[^/]*")
+   return dir or ""
+end
+
+--- Create a temporary directory.
+-- @param name string: name pattern to use for avoiding conflicts
+-- when creating temporary directory.
+-- @return string or nil: name of temporary directory or nil on failure.
+function make_temp_dir(name)
+   assert(type(name) == "string")
+
+   local temp_dir = (os.getenv("TMP") or "/tmp") .. "/" .. name .. "-" .. tostring(math.floor(math.random() * 10000))
+   if fs_make_dir(temp_dir) then
+      return temp_dir
+   else
+      return nil
+   end
+end
+
+--- Apply a patch.
+-- @param patchname string: The filename of the patch.
+function patch(patchname)
+   return fs_execute("patch -p1 -f -i ", patchname)
+end
+
+--- Unpack an archive.
+-- Extract the contents of an archive, detecting its format by
+-- filename extension.
+-- @param archive string: Filename of archive.
+-- @return boolean or (boolean, string): true on success, false and an error message on failure.
+function unpack_archive(archive)
+   assert(type(archive) == "string")
+
+   local ok
+   if archive:match("%.tar%.gz$") or archive:match("%.tgz$") then
+      -- ok = fs_execute("tar zxvpf ", archive)
+         ok = fs_execute_string("gunzip -c "..archive.."|tar -xf -")
+   elseif archive:match("%.tar%.bz2$") then
+      -- ok = fs_execute("tar jxvpf ", archive)
+         ok = fs_execute_string("bunzip2 -c "..archive.."|tar -xf -")
+   elseif archive:match("%.zip$") then
+      ok = fs_execute("unzip ", archive)
+   elseif archive:match("%.lua$") or archive:match("%.c$") then
+      -- Ignore .lua and .c files; they don't need to be extracted.
+      return true
+   else
+      local ext = archive:match(".*(%..*)")
+      return false, "Unrecognized filename extension "..(ext or "")
+   end
+   if not ok then
+      return false, "Failed extracting "..archive
+   end
+   return true
+end
+
+--- Check the MD5 checksum for a file.
+-- @param file string: The file to be checked.
+-- @param md5sum string: The string with the expected MD5 checksum.
+-- @return boolean: true if the MD5 checksum for 'file' equals 'md5sum', false if not
+-- or if it could not perform the check for any reason.
+function check_md5(file, md5sum)
+   file = fs_absolute_name(file)
+   local computed
+   if cfg.md5checker == "md5sum" then
+      local pipe = io.popen("md5sum "..file)
+      computed = pipe:read("*l"):gsub("[^%x]+", "")
+      pipe:close()
+      if computed then
+         computed = computed:sub(1,32)
+      end
+   elseif cfg.md5checker == "openssl" then
+      local pipe = io.popen("openssl md5 "..file)
+      computed = pipe:read("*l")
+      pipe:close()
+      if computed then
+         computed = computed:sub(-32)
+      end
+   elseif cfg.md5checker == "md5" then
+      local pipe = io.popen("md5 "..file)
+      computed = pipe:read("*l")
+      pipe:close()
+      if computed then
+         computed = computed:sub(-32)
+      end
+   end
+   if not computed then
+      return false
+   end
+   if computed:match("^"..md5sum) then
+      return true
+   else
+      return false
+   end
+end
+
+--- Return an absolute pathname from a potentially relative one.
+-- @param pathname string: pathname to convert.
+-- @param relative_to string or nil: path to prepend when making
+-- pathname absolute, or the current dir in the dir stack if
+-- not given.
+-- @return string: The pathname converted to absolute.
+function absolute_name(pathname, relative_to)
+   assert(type(pathname) == "string")
+   assert(type(relative_to) == "string" or not relative_to)
+
+   relative_to = relative_to or fs_current_dir()
+   if pathname:sub(1,1) == "/" then
+      return pathname
+   else
+      return relative_to .. "/" .. pathname
+   end
+end
+
+--- Describe a path in a cross-platform way.
+-- Use this function to avoid platform-specific directory
+-- separators in other modules. If the first item contains a 
+-- protocol descriptor (e.g. "http:"), paths are always constituted
+-- with forward slashes.
+-- @param ... strings representing directories
+-- @return string: a string with a platform-specific representation
+-- of the path.
+function make_path(...)
+   local items = {...}
+   local i = 1
+   while items[i] do
+      if items[i] == "" then
+         table.remove(items, i)
+      else
+         i = i + 1
+      end
+   end
+   return table.concat(items, "/")
+end
+
+--- Split protocol and path from an URL or local pathname.
+-- URLs should be in the "protocol://path" format.
+-- For local pathnames, "file" is returned as the protocol.
+-- @param url string: an URL or a local pathname.
+-- @return string, string: the protocol, and the absolute pathname without the protocol.
+function split_url(url)
+   assert(type(url) == "string")
+   
+   local protocol, pathname = url:match("^([^:]*)://(.*)")
+   if not protocol then
+      protocol = "file"
+      pathname = url
+   end
+   if protocol == "file" then
+      pathname = fs_absolute_name(pathname)
+   end
+   return protocol, pathname
+end
+
+--- Create a wrapper to make a script executable from the command-line.
+-- @param file string: Pathname of script to be made executable.
+-- @param dest string: Directory where to put the wrapper.
+-- @return boolean or (nil, string): True if succeeded, or nil and
+-- an error message.
+function wrap_script(file, dest)
+   assert(type(file) == "string")
+   assert(type(dest) == "string")
+   
+   local base = fs_base_name(file)
+   local wrapname = dest.."/"..base
+   local wrapper = io.open(wrapname, "w")
+   if not wrapper then
+      return nil, "Could not open "..wrapname.." for writing."
+   end
+   wrapper:write("#!/bin/sh\n\n")
+   wrapper:write('LUA_PATH="'..package.path..';$LUA_PATH"\n')
+   wrapper:write('LUA_CPATH="'..package.cpath..';$LUA_CPATH"\n')
+   wrapper:write('export LUA_PATH LUA_CPATH\n')
+   wrapper:write('exec "'..fs_make_path(cfg.variables["LUA_BINDIR"], cfg.lua_interpreter)..'" -lluarocks.require "'..file..'" "$@"\n')
+   wrapper:close()
+   if fs_execute("chmod +x",wrapname) then
+      return true
+   else
+      return nil, "Could not make "..wrapname.." executable."
+   end
+end
+
+--- Check if a file (typically inside path.bin_dir) is an actual binary
+-- or a Lua wrapper.
+-- @param filename string: the file name with full path.
+-- @return boolean: returns true if file is an actual binary
+-- (or if it couldn't check) or false if it is a Lua wrapper.
+local function is_actual_binary(filename)
+   local file = io.open(filename)
+   if file then
+      local found = false
+      if file:read():match("#!/bin/sh") then
+         local line = file:read()
+         line = file:read()
+         if not(line and line:match("LUA_PATH")) then
+            found = true
+         end
+      end
+      file:close()
+      if found then
+         return false
+      else
+         return true
+      end
+   else
+      return true
+   end
+   return false
+end
+
+function copy_binary(filename, dest) 
+   return fs_copy(filename, dest)
+end
+
diff --git a/src/luarocks/fs/win32.lua b/src/luarocks/fs/win32.lua
new file mode 100644
index 00000000..5702a3aa
--- /dev/null
+++ b/src/luarocks/fs/win32.lua
@@ -0,0 +1,369 @@
+--- Windows implementation of filesystem and platform abstractions.
+-- Download http://unxutils.sourceforge.net/ for Windows GNU utilities
+-- used by this module.
+module("luarocks.fs.win32", package.seeall)
+
+local cfg = require("luarocks.cfg")
+
+local fs_base_name,
+      fs_copy,
+      fs_current_dir,
+      fs_execute,
+      fs_execute_string,
+      fs_is_dir,
+      fs_make_path,
+      fs_Q
+
+function init_fs_functions(impl)
+   fs_base_name = impl.base_name
+   fs_copy = impl.copy
+   fs_current_dir = impl.current_dir
+   fs_execute = impl.execute
+   fs_execute_string = impl.execute_string
+   fs_is_dir = impl.is_dir
+   fs_make_path = impl.make_path
+   fs_Q = impl.Q
+end
+
+--- Quote argument for shell processing. Fixes paths on Windows.
+-- Adds single quotes and escapes.
+-- @param arg string: Unquoted argument.
+-- @return string: Quoted argument.
+function Q(arg)
+   assert(type(arg) == "string")
+   -- Quote DIR for Windows
+    if arg:match("^[\.a-zA-Z]?:?[\\/]")  then
+        return '"' .. arg:gsub("/", "\\"):gsub('"', '\\"') .. '"'
+    end
+    -- URLs and anything else
+   return '"' .. arg:gsub('"', '\\"') .. '"'
+end
+
+local function command_at(dir, cmd)
+   local drive = dir:match("^([A-Za-z]:)")
+   cmd = "cd " .. fs_Q(dir) .. " & " .. cmd
+   if drive then
+      cmd = drive .. " & " .. cmd
+   end
+   return cmd
+end
+
+--- Run the given command.
+-- The command is executed in the current directory in the dir stack.
+-- @param cmd string: No quoting/escaping is applied to the command.
+-- @return boolean: true if command succeeds (status code 0), false
+-- otherwise.
+function execute_string(cmd)
+   if os.execute(command_at(fs_current_dir(), cmd)) == 0 then
+      return true
+   else
+      return false
+   end
+end
+
+--- Test for existance of a file.
+-- @param file string: filename to test
+-- @return boolean: true if file exists, false otherwise.
+function exists(file)
+   assert(file)
+   return fs_execute("if not exist " .. fs_Q(file) ..
+                     " invalidcommandname 2>NUL 1>NUL")
+end
+
+--- Test is pathname is a directory.
+-- @param file string: pathname to test
+-- @return boolean: true if it is a directory, false otherwise.
+function is_dir(file)
+   assert(file)
+   return fs_execute("chdir /D " .. fs_Q(file) .. " 2>NUL 1>NUL")
+end
+
+--- Test is file/dir is writable.
+-- @param file string: filename to test
+-- @return boolean: true if file exists, false otherwise.
+function is_writable(file)
+   assert(file)
+   local result
+   if is_dir(file) then
+      local file2 = file .. '/.tmpluarockstestwritable'
+      local fh = io.open(file2, 'w')
+      result = fh ~= nil
+      if fh then fh:close() end
+      os.remove(file2)
+   else
+      local fh = io.open(file, 'r+')
+      result = fh ~= nil
+      if fh then fh:close() end
+   end
+   return result
+end
+
+
+--- Create a directory if it does not already exist.
+-- If any of the higher levels in the path name does not exist
+-- too, they are created as well.
+-- @param dir string: pathname of directory to create.
+-- @return boolean: true on success, false on failure.
+function make_dir(dir)
+   assert(dir)
+   fs_execute("mkdir "..fs_Q(dir).." 1> NUL 2> NUL")
+   return 1
+end
+
+--- Remove a directory if it is empty.
+-- Does not return errors (for example, if directory is not empty or
+-- if already does not exist)
+-- @param dir string: pathname of directory to remove.
+function remove_dir_if_empty(dir)
+   assert(dir)
+   fs_execute_string("rmdir "..fs_Q(dir).." 1> NUL 2> NUL")
+end
+
+--- Copy a file.
+-- @param src string: Pathname of source
+-- @param dest string: Pathname of destination
+-- @return boolean or (boolean, string): true on success, false on failure,
+-- plus an error message.
+function copy(src, dest)
+   assert(src and dest)
+   if dest:match("[/\\]$") then dest = dest:sub(1, -2) end
+   if fs_execute("cp", src, dest) then
+      return true
+   else
+      return false, "Failed copying "..src.." to "..dest
+   end
+end
+
+--- Recursively copy the contents of a directory.
+-- @param src string: Pathname of source
+-- @param dest string: Pathname of destination
+-- @return boolean or (boolean, string): true on success, false on failure,
+-- plus an error message.
+function copy_contents(src, dest)
+   assert(src and dest)
+   if fs_execute_string("cp -a "..src.."\\*.* "..fs_Q(dest).." 1> NUL 2> NUL") then
+      return true
+   else
+      return false, "Failed copying "..src.." to "..dest
+   end
+end
+
+--- Delete a file or a directory and all its contents.
+-- For safety, this only accepts absolute paths.
+-- @param arg string: Pathname of source
+-- @return boolean: true on success, false on failure.
+function delete(arg)
+   assert(arg)
+   assert(arg:match("^[\a-zA-Z]?:?[\\/]"))
+   fs_execute("chmod a+rw -R ", arg)
+   return fs_execute_string("rm -rf " .. fs_Q(arg) .. " 1> NUL 2> NUL")
+end
+
+--- List the contents of a directory. 
+-- @param at string or nil: directory to list (will be the current
+-- directory if none is given).
+-- @return table: an array of strings with the filenames representing
+-- the contents of a directory.
+function dir(at)
+   assert(type(at) == "string" or not at)
+   if not at then
+      at = fs_current_dir()
+   end
+   if not fs_is_dir(at) then
+      return {}
+   end
+   local result = {}
+   local pipe = io.popen(command_at(at, "ls"))
+   for file in pipe:lines() do
+      table.insert(result, file)
+   end
+   pipe:close()
+
+   return result
+end
+
+--- Recursively scan the contents of a directory. 
+-- @param at string or nil: directory to scan (will be the current
+-- directory if none is given).
+-- @return table: an array of strings with the filenames representing
+-- the contents of a directory. Paths are returned with forward slashes.
+function find(at)
+   assert(type(at) == "string" or not at)
+   if not at then
+      at = fs_current_dir()
+   end
+   if not fs_is_dir(at) then
+      return {}
+   end
+   local result = {}
+   local pipe = io.popen(command_at(at, "find 2> NUL")) 
+   for file in pipe:lines() do
+      -- Windows find is a bit different
+      if file:sub(1,2)==".\\" then file=file:sub(3) end
+      if file ~= "." then
+         table.insert(result, (file:gsub("\\", "/")))
+      end
+   end
+   return result
+end
+
+
+--- Download a remote file.
+-- @param url string: URL to be fetched.
+-- @param filename string or nil: this function attempts to detect the
+-- resulting local filename of the remote file as the basename of the URL;
+-- if that is not correct (due to a redirection, for example), the local
+-- filename can be given explicitly as this second argument.
+-- @return boolean: true on success, false on failure.
+function download(url, filename)
+   assert(type(url) == "string")
+   assert(type(filename) == "string" or not filename)
+
+   if filename then   
+      return fs_execute("wget --quiet --continue --output-document ", filename, url)
+   else
+      return fs_execute("wget --quiet --continue ", url)
+   end
+end
+
+--- Strip the path off a path+filename.
+-- @param pathname string: A path+name, such as "/a/b/c".
+-- @return string: The filename without its path, such as "c".
+function base_name(pathname)
+   assert(type(pathname) == "string")
+
+   local base = pathname:match(".*[/\\]([^/\\]*)")
+   return base or pathname
+end
+
+--- Strip the last extension of a filename.
+-- Example: "foo.tar.gz" becomes "foo.tar".
+-- If filename has no dots, returns it unchanged.
+-- @param filename string: The file name to strip.
+-- @return string: The stripped name.
+local function strip_extension(filename)
+   assert(type(filename) == "string")
+
+   return (filename:gsub("%.[^.]+$", "")) or filename
+end
+
+--- Uncompress gzip file.
+-- @param archive string: Filename of archive.
+-- @return boolean : success status
+local function gunzip(archive)
+   local cmd = fs_execute("gunzip -h 1>NUL 2>NUL") and 'gunzip' or
+               fs_execute("gzip   -h 1>NUL 2>NUL") and 'gzip -d'
+   local ok = fs_execute(cmd, archive)
+   return ok
+end
+
+--- Unpack an archive.
+-- Extract the contents of an archive, detecting its format by
+-- filename extension.
+-- @param archive string: Filename of archive.
+-- @return boolean or (boolean, string): true on success, false and an error message on failure.
+function unpack_archive(archive)
+   assert(type(archive) == "string")
+   
+   local ok
+   if archive:match("%.tar%.gz$") then
+      ok = gunzip(archive)
+      if ok then
+         ok = fs_execute("tar -xf ", strip_extension(archive))
+      end
+   elseif archive:match("%.tgz$") then
+      ok = gunzip(archive)
+      if ok then
+         ok = fs_execute("tar -xf ", strip_extension(archive)..".tar")
+      end
+   elseif archive:match("%.tar%.bz2$") then
+      ok = fs_execute("bunzip2 ", archive)
+      if ok then
+         ok = fs_execute("tar -xf ", strip_extension(archive))
+      end
+   elseif archive:match("%.zip$") then
+      ok = fs_execute("unzip ", archive)
+   elseif archive:match("%.lua$") or archive:match("%.c$") then
+      -- Ignore .lua and .c files; they don't need to be extracted.
+      return true
+   else
+      local ext = archive:match(".*(%..*)")
+      return false, "Unrecognized filename extension "..(ext or "")
+   end
+   if not ok then
+      return false, "Failed extracting "..archive
+   end
+   return true
+end
+
+--- Return an absolute pathname from a potentially relative one.
+-- @param pathname string: pathname to convert.
+-- @param relative_to string or nil: path to prepend when making
+-- pathname absolute, or the current dir in the dir stack if
+-- not given.
+-- @return string: The pathname converted to absolute.
+function absolute_name(pathname, relative_to)
+   assert(type(pathname) == "string")
+   assert(type(relative_to) == "string" or not relative_to)
+
+   relative_to = relative_to or fs_current_dir()
+   if pathname:match("^[\.a-zA-Z]?:?[\\/]") then
+      return pathname
+   else
+      return relative_to .. "/" .. pathname
+   end
+end
+
+--- Create a wrapper to make a script executable from the command-line.
+-- @param file string: Pathname of script to be made executable.
+-- @param dest string: Directory where to put the wrapper.
+-- @return boolean or (nil, string): True if succeeded, or nil and
+-- an error message.
+function wrap_script(file, dest)
+   assert(type(file) == "string")
+   assert(type(dest) == "string")
+
+   local base = fs_base_name(file)
+   local wrapname = dest.."/"..base..".bat"
+   local wrapper = io.open(wrapname, "w")
+   if not wrapper then
+      return nil, "Could not open "..wrapname.." for writing."
+   end
+   wrapper:write("@echo off\n")
+   wrapper:write("setlocal\n")
+   wrapper:write('set LUA_PATH='..package.path..";%LUA_PATH%\n")
+   wrapper:write('set LUA_CPATH='..package.cpath..";%LUA_CPATH%\n")
+   wrapper:write('"'..fs_make_path(cfg.variables["LUA_BINDIR"], cfg.lua_interpreter)..'" -lluarocks.require "'..file..'" %*\n')
+   wrapper:write("endlocal\n")
+   wrapper:close()
+   return true
+end
+
+function is_actual_binary(name)
+   name = name:lower()
+   if name:match("%.bat$") or name:match("%.exe$") then
+      return true
+   end
+   return false
+end
+
+function copy_binary(filename, dest) 
+   local ok, err = fs_copy(filename, dest)
+   if not ok then
+      return nil, err
+   end
+   local exe_pattern = "%.[Ee][Xx][Ee]$"
+   local base = fs_base_name(filename)
+   if base:match(exe_pattern) then
+      base = base:gsub(exe_pattern, ".lua")
+      local helpname = dest.."/"..base
+      local helper = io.open(helpname, "w")
+      if not helper then
+         return nil, "Could not open "..helpname.." for writing."
+      end
+      helper:write('package.path=\"'..package.path:gsub("\\","\\\\")..';\"..package.path\n')
+      helper:write('package.cpath=\"'..package.path:gsub("\\","\\\\")..';\"..package.cpath\n')
+      helper:close()
+   end
+   return true
+end
diff --git a/src/luarocks/help.lua b/src/luarocks/help.lua
new file mode 100644
index 00000000..76e77a33
--- /dev/null
+++ b/src/luarocks/help.lua
@@ -0,0 +1,69 @@
+
+--- Module implementing the LuaRocks "help" command.
+-- This is a generic help display module, which
+-- uses a global table called "commands" to find commands
+-- to show help for; each command should be represented by a
+-- table containing "help" and "help_summary" fields.
+module("luarocks.help", package.seeall)
+
+local util = require("luarocks.util")
+
+help_summary = "Help on commands."
+
+help_arguments = "[<command>]"
+help = [[
+<command> is the command to show help for.
+]]
+
+--- Driver function for the "help" command.
+-- @param command string or nil: command to show help for; if not
+-- given, help summaries for all commands are shown.
+-- @return boolean or (nil, string): true if there were no errors
+-- or nil and an error message if an invalid command was requested.
+function run(...)
+   local flags, command = util.parse_flags(...)
+
+   if not command then
+      print([[
+LuaRocks ]]..program_version..[[, a module deployment system for Lua
+
+]]..program_name..[[ - ]]..program_description..[[
+
+usage: ]]..program_name..[[ [--from=<server> | --only-from=<server>] [--to=<tree>] [VAR=VALUE]... <command> [<argument>]
+
+Variables from the "variables" table of the configuration file
+can be overriden with VAR=VALUE assignments.
+
+--from=<server>       Fetch rocks/rockspecs from this server
+                      (takes priority over config file)
+--only-from=<server>  Fetch rocks/rockspecs from this server only
+                      (overrides any entries in the config file)
+--to=<tree>           Which tree to operate on.
+
+Supported commands:
+]])
+      local names = {}
+      for name, command in pairs(commands) do
+         table.insert(names, name)
+      end
+      table.sort(names)
+      for _, name in ipairs(names) do
+         local command = commands[name]
+         print(name, command.help_summary)
+      end
+   else
+      command = command:gsub("-", "_")
+      if commands[command] then
+         local arguments = commands[command].help_arguments or "<argument>"
+         print()
+         print(program_name.." "..command.." "..arguments)
+         print()
+         print(command.." - "..commands[command].help_summary)
+         print()
+         print(commands[command].help)
+      else
+         return nil, "Unknown command '"..command.."'"
+      end
+   end
+   return true
+end
diff --git a/src/luarocks/install.lua b/src/luarocks/install.lua
new file mode 100644
index 00000000..b115a8a8
--- /dev/null
+++ b/src/luarocks/install.lua
@@ -0,0 +1,115 @@
+
+--- Module implementing the LuaRocks "install" command.
+-- Installs binary rocks.
+module("luarocks.install", package.seeall)
+
+local path = require("luarocks.path")
+local rep = require("luarocks.rep")
+local fetch = require("luarocks.fetch")
+local util = require("luarocks.util")
+local fs = require("luarocks.fs")
+local deps = require("luarocks.deps")
+local manif = require("luarocks.manif")
+local cfg = require("luarocks.cfg")
+
+help_summary = "Install a rock."
+
+help_arguments = "{<rock>|<name> [<version>]}"
+
+help = [[
+Argument may be the name of a rock to be fetched from a repository
+or a filename of a locally available rock.
+]]
+
+--- Install a binary rock.
+-- @param rock_file string: local or remote filename of a rock.
+-- @return boolean or (nil, string): True if succeeded or 
+-- nil and an error message.
+function install_binary_rock(rock_file)
+   local name, version, arch = path.parse_rock_name(rock_file)
+   if not name then
+      return nil, "Filename "..rock_file.." does not match format 'name-version-revision.arch.rock'."
+   end
+   if arch ~= "all" and arch ~= cfg.arch then
+      return nil, "Incompatible architecture "..arch
+   end
+   if rep.is_installed(name, version) then
+      rep.delete_version(name, version)
+   end
+   local rollback = util.schedule_function(function()
+      fs.delete(path.install_dir(name, version))
+      fs.remove_dir_if_empty(path.versions_dir(name))
+   end)
+   local ok, err = fetch.fetch_and_unpack_rock(rock_file, path.install_dir(name, version))
+   if not ok then return nil, err end
+   ok, err = rep.install_bins(name, version)
+
+   local rockspec, err = fetch.load_rockspec(path.rockspec_file(name, version))
+   if err then
+      return nil, "Failed loading rockspec for installed package: "..err
+   end
+
+   ok, err = deps.check_external_deps(rockspec, "install")
+   if err then
+      return nil, err
+   end
+
+   ok, err = deps.fulfill_dependencies(rockspec)
+   if err then
+      return nil, err
+   end
+
+   ok, err = rep.run_hook(rockspec, "post_install")
+   if err then
+      return nil, err
+   end
+   
+   ok, err = manif.update_manifest(name, version)
+   if err then
+      return nil, err
+   end
+   util.remove_scheduled_function(rollback)
+   return true
+end
+
+--- Driver function for the "install" command.
+-- @param name string: name of a binary rock. If an URL or pathname
+-- to a binary rock is given, fetches and installs it. If a rockspec or a
+-- source rock is given, forwards the request to the "build" command.
+-- If a package name is given, forwards the request to "search" and,
+-- if returned a result, installs the matching rock.
+-- @param version string: When passing a package name, a version number
+-- may also be given.
+-- @return boolean or (nil, string): True if installation was
+-- successful, nil and an error message otherwise.
+function run(...)
+   local flags, name, version = util.parse_flags(...)
+   if type(name) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+
+   if name:match("%.rockspec$") or name:match("%.src%.rock$") then
+      local build = require("luarocks.build")
+      return build.run(name)
+   elseif name:match("%.rock$") then
+      return install_binary_rock(name)
+   else
+      local search = require("luarocks.search")
+      local results, err = search.find_suitable_rock(search.make_query(name, version))
+      if err then
+         return nil, err
+      elseif type(results) == "string" then
+         local url = results
+         print("Installing "..url.."...")
+         return run(url)
+      else
+         print()
+         print("Could not determine which rock to install.")
+         print()
+         print("Search results:")
+         print("---------------")
+         search.print_results(results)
+         return nil, (next(results) and "Please narrow your query." or "No results found.")
+      end
+   end
+end
diff --git a/src/luarocks/list.lua b/src/luarocks/list.lua
new file mode 100644
index 00000000..1251653c
--- /dev/null
+++ b/src/luarocks/list.lua
@@ -0,0 +1,35 @@
+
+--- Module implementing the LuaRocks "list" command.
+-- Lists currently installed rocks.
+module("luarocks.list", package.seeall)
+
+local search = require("luarocks.search")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+local fs = require("luarocks.fs")
+
+help_summary = "Lists currently installed rocks."
+
+help = [[
+<argument> is a substring of a rock name to filter by.
+]]
+
+--- Driver function for "list" command.
+-- @param filter string or nil: A substring of a rock name to filter by.
+-- @param version string or nil: a version may also be passed.
+-- @return boolean: True if succeeded, nil on errors.
+function run(...)
+   local flags, filter, version = util.parse_flags(...)
+   local results = {}
+   local query = search.make_query(filter or "", version)
+   query.exact_name = false
+   for _, tree in ipairs(cfg.rocks_trees) do
+      search.manifest_search(results, fs.make_path(tree, "rocks"), query)
+   end
+   print()
+   print("Installed rocks:")
+   print("----------------")
+   print()
+   search.print_results(results, false)
+   return true
+end
diff --git a/src/luarocks/make.lua b/src/luarocks/make.lua
new file mode 100644
index 00000000..1c116cdb
--- /dev/null
+++ b/src/luarocks/make.lua
@@ -0,0 +1,54 @@
+
+--- Module implementing the LuaRocks "make" command.
+-- Builds sources in the current directory, but unlike "build",
+-- it does not fetch sources, etc., assuming everything is 
+-- available in the current directory.
+module("luarocks.make", package.seeall)
+
+local build = require("luarocks.build")
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+
+help_summary = "Compile package in current directory using a rockspec."
+help_arguments = "[<rockspec>]"
+help = [[
+Builds sources in the current directory, but unlike "build",
+it does not fetch sources, etc., assuming everything is 
+available in the current directory. If no argument is given,
+look for a rockspec in the current directory. If more than one
+is found, you must specify which to use, through the command-line.
+
+This command is useful as a tool for debugging rockspecs. 
+To install rocks, you'll normally want to use the "install" and
+"build" commands. See the help on those for details.
+]]
+
+--- Driver function for "make" command.
+-- @param name string: A local rockspec.
+-- @return boolean or (nil, string): True if build was successful; nil and an
+-- error message otherwise.
+function run(...)
+   local flags, rockspec = util.parse_flags(...)
+   assert(type(rockspec) == "string" or not rockspec)
+   
+   if not rockspec then
+      local files = fs.dir(fs.current_dir())
+      for _, file in pairs(files) do
+         if file:match(".rockspec$") then
+            if rockspec then
+               return nil, "Please specify which rockspec file to use."
+            else
+               rockspec = file
+            end
+         end
+      end
+      if not rockspec then
+         return nil, "Argument missing: please specify a rockspec to use on current directory."
+      end
+   end
+   if not rockspec:match("%.rockspec$") then
+      return nil, "Invalid argument: 'make' takes a rockspec as a parameter. See help."
+   end
+
+   return build.build_rockspec(rockspec, false, true)
+end
diff --git a/src/luarocks/make_manifest.lua b/src/luarocks/make_manifest.lua
new file mode 100644
index 00000000..6edbd14b
--- /dev/null
+++ b/src/luarocks/make_manifest.lua
@@ -0,0 +1,32 @@
+
+--- Module implementing the luarocks-admin "make_manifest" command.
+-- Compile a manifest file for a repository.
+module("luarocks.make_manifest", package.seeall)
+
+local manif = require("luarocks.manif")
+local cfg = require("luarocks.cfg")
+
+help_summary = "Compile a manifest file for a repository."
+
+help = [[
+<argument>, if given, is a local repository pathname.
+]]
+
+--- Driver function for "make_manifest" command.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository configured as cfg.rocks_dir is used.
+-- @return boolean or (nil, string): True if manifest was generated,
+-- or nil and an error message.
+function run(repo)
+   assert(type(repo) == "string" or not repo)
+   repo = repo or cfg.rocks_dir
+  
+   print("Making manifest for "..repo)
+   
+   ok = manif.make_manifest(repo)
+   if ok then
+      print("Generating index.html for "..repo)
+      manif.make_index(repo)
+   end
+   return ok
+end
diff --git a/src/luarocks/manif.lua b/src/luarocks/manif.lua
new file mode 100644
index 00000000..98772319
--- /dev/null
+++ b/src/luarocks/manif.lua
@@ -0,0 +1,439 @@
+
+--- Functions for querying and manipulating manifest files.
+module("luarocks.manif", package.seeall)
+
+local util = require("luarocks.util")
+local fs = require("luarocks.fs")
+local search = require("luarocks.search")
+local rep = require("luarocks.rep")
+local deps = require("luarocks.deps")
+local cfg = require("luarocks.cfg")
+local persist = require("luarocks.persist")
+local fetch = require("luarocks.fetch")
+local type_check = require("luarocks.type_check")
+
+manifest_cache = {}
+
+--- Get all versions of a package listed in a manifest file.
+-- @param name string: a package name.
+-- @param manifest table or nil: a manifest table; if not given, the
+-- default local manifest table is used.
+-- @return table: An array of strings listing installed
+-- versions of a package.
+function get_versions(name, manifest)
+   assert(type(name) == "string")
+   assert(type(manifest) == "table" or not manifest)
+   
+   if not manifest then
+      manifest = load_local_manifest(cfg.rocks_dir)
+      if not manifest then
+         return {}
+      end
+   end
+   
+   local item = manifest.repository[name]
+   if item then
+      return util.keys(item)
+   end
+   return {}
+end
+
+--- Back-end function that actually loads the manifest
+-- and stores it in the manifest cache.
+-- @param file string: The local filename of the manifest file.
+-- @param repo_url string: The repository identifier.
+local function manifest_loader(file, repo_url, quick)
+   local manifest = persist.load_into_table(file)
+   if not manifest then
+      return nil, "Failed loading manifest for "..repo_url
+   end
+   if not quick then
+      local ok, err = type_check.type_check_manifest(manifest)
+      if not ok then
+         return nil, "Error checking manifest: "..err
+      end
+   end
+
+   manifest_cache[repo_url] = manifest
+   return manifest
+end
+
+--- Load a local or remote manifest describing a repository.
+-- All functions that use manifest tables assume they were obtained
+-- through either this function or load_local_manifest.
+-- @param repo_url string: URL or pathname for the repository.
+-- @return table or (nil, string): A table representing the manifest,
+-- or nil followed by an error message.
+function load_manifest(repo_url)
+   assert(type(repo_url) == "string")
+   
+   if manifest_cache[repo_url] then
+      return manifest_cache[repo_url]
+   end
+
+   local protocol, pathname = fs.split_url(repo_url)
+   if protocol == "file" then
+      pathname = fs.make_path(pathname, "manifest")
+   else
+      local url = fs.make_path(repo_url, "manifest")
+      local name = repo_url:gsub("[/:]","_")
+      local file, dir = fetch.fetch_url_at_temp_dir(url, "luarocks-manifest-"..name)
+      if not file then
+         return nil, "Failed fetching manifest for "..repo_url
+      end
+      pathname = file
+   end
+   return manifest_loader(pathname, repo_url)
+end
+
+--- Load a local manifest describing a repository.
+-- All functions that use manifest tables assume they were obtained
+-- through either this function or load_manifest.
+-- @param repo_url string: URL or pathname for the repository.
+-- @return table or (nil, string): A table representing the manifest,
+-- or nil followed by an error message.
+function load_local_manifest(repo_url)
+   assert(type(repo_url) == "string")
+
+   if manifest_cache[repo_url] then
+      return manifest_cache[repo_url]
+   end
+
+   local pathname = fs.make_path(repo_url, "manifest")
+
+   return manifest_loader(pathname, repo_url, true)
+end
+
+--- Sort function for ordering rock identifiers in a manifest's
+-- modules table. Rocks are ordered alphabetically by name, and then
+-- by version which greater first.
+-- @param a string: Version to compare.
+-- @param b string: Version to compare.
+-- @return boolean: The comparison result, according to the
+-- rule outlined above.
+local function sort_pkgs(a, b)
+   assert(type(a) == "string")
+   assert(type(b) == "string")
+
+   local na, va = a:match("(.*)/(.*)$")
+   local nb, vb = b:match("(.*)/(.*)$")
+   
+   return (na == nb) and deps.compare_versions(va, vb) or na < nb
+end
+
+--- Output a table listing items of a package.
+-- @param itemsfn function: a function for obtaining items of a package.
+-- pkg and version will be passed to it; it should return a table with
+-- items as keys.
+-- @param pkg string: package name
+-- @param version string: package version
+-- @param tbl table: the package matching table: keys should be item names
+-- and values arrays of strings with packages names in "name/version" format.
+local function store_package_items(itemsfn, pkg, version, tbl)
+   assert(type(itemsfn) == "function")
+   assert(type(pkg) == "string")
+   assert(type(version) == "string")
+   assert(type(tbl) == "table")
+
+   local path = pkg.."/"..version
+   local result = {}
+   for item, _ in pairs(itemsfn(pkg, version)) do
+      table.insert(result, item)
+      if not tbl[item] then
+         tbl[item] = {}
+      end
+      table.insert(tbl[item], path)
+   end
+   return result
+end
+
+--- Sort items of a package matching table by version number (higher versions first).
+-- @param tbl table: the package matching table: keys should be strings
+-- and values arrays of strings with packages names in "name/version" format.
+local function sort_package_matching_table(tbl)
+   assert(type(tbl) == "table")
+   
+   if next(tbl) then
+      for item, pkgs in pairs(tbl) do
+         if #pkgs > 1 then
+            table.sort(pkgs, sort_pkgs)
+            -- Remove duplicates from the sorted array.
+            local prev = nil
+            local i = 1
+            while pkgs[i] do
+               local curr = pkgs[i]
+               if curr == prev then
+                  table.remove(pkgs, i)
+               else
+                  prev = curr
+                  i = i + 1
+               end
+            end
+         end
+      end
+   end
+end
+
+--- Commit manifest to disk in given local repository.
+-- @param repo string: The directory of the local repository.
+-- @param manifest table: The manifest table
+-- @return boolean or (nil, string): true if successful, or nil and a
+-- message in case of errors.
+local function save_manifest(repo, manifest)
+   assert(type(repo) == "string")
+   assert(type(manifest) == "table")
+
+   local filename = fs.make_path(repo, "manifest")
+   return persist.save_from_table(filename, manifest)
+end
+
+--- Process the dependencies of a package to determine its dependency
+-- chain for loading modules.
+-- @param name string: Package name.
+-- @param version string: Package version.
+-- @return (table, table): A table listing dependencies as string-string pairs
+-- of names and versions, and a similar table of missing dependencies.
+local function update_dependencies(manifest)
+   for pkg, versions in pairs(manifest.repository) do
+      for version, repos in pairs(versions) do
+         local current = pkg.." "..version
+         for _, repo in ipairs(repos) do
+            if repo.arch == "installed" then
+               local missing
+               repo.dependencies, missing = deps.scan_deps({}, {}, manifest, pkg, version)
+               repo.dependencies[pkg] = nil
+               if missing then
+                  for miss, _ in pairs(missing) do
+                     if miss == current then
+                        print("Tree inconsistency detected: "..current.." has no rockspec.")
+                     else
+                        print("Missing dependency for "..pkg.." "..version..": "..miss)
+                     end
+                  end
+               end
+            end
+         end
+      end
+   end
+end
+
+--- Store search results in a manifest table.
+-- @param results table: The search results as returned by search.disk_search.
+-- @param manifest table: A manifest table (must contain repository, modules, commands tables).
+local function store_results(results, manifest)
+   assert(type(results) == "table")
+   assert(type(manifest) == "table")
+
+   for pkg, versions in pairs(results) do
+      local pkgtable = manifest.repository[pkg] or {}
+      for version, repos in pairs(versions) do
+         local versiontable = {}
+         for _, repo in ipairs(repos) do
+            local repotable = {}
+            repotable.arch = repo.arch
+            if repo.arch == "installed" then
+               repotable.modules = store_package_items(rep.package_modules, pkg, version, manifest.modules)
+               repotable.commands = store_package_items(rep.package_commands, pkg, version, manifest.commands)
+            end
+            table.insert(versiontable, repotable)
+         end
+         pkgtable[version] = versiontable
+      end
+      manifest.repository[pkg] = pkgtable
+   end
+   update_dependencies(manifest)
+   sort_package_matching_table(manifest.modules)
+   sort_package_matching_table(manifest.commands)
+end
+
+--- Load a manifest file from a local repository and add to the repository
+-- information with regard to the given name and version.
+-- A file called 'manifest' will be written in the root of the given
+-- repository directory.
+-- @param name string: Name of a package from the repository.
+-- @param version string: Version of a package from the repository.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository configured as cfg.rocks_dir is used.
+-- @return boolean or (nil, string): True if manifest was generated,
+-- or nil and an error message.
+function update_manifest(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(repo) == "string" or not repo)
+   repo = repo or cfg.rocks_dir
+
+   print("Updating manifest for "..repo)
+
+   local manifest, err = load_manifest(repo)
+   if not manifest then
+      print("No existing manifest. Attempting to rebuild...")
+      local ok, err = make_manifest(repo)
+      if not ok then
+         return nil, err
+      end
+      manifest, err = load_manifest(repo)
+      if not manifest then
+         return nil, err
+      end
+   end
+
+   local results = {[name] = {[version] = {{arch = "installed", repo = repo}}}}
+   
+   store_results(results, manifest)
+   return save_manifest(repo, manifest)
+end
+
+--- Scan a LuaRocks repository and output a manifest file.
+-- A file called 'manifest' will be written in the root of the given
+-- repository directory.
+-- @param repo A local repository directory.
+-- @return boolean or (nil, string): True if manifest was generated,
+-- or nil and an error message.
+function make_manifest(repo)
+   assert(type(repo) == "string")
+
+   if not fs.is_dir(repo) then
+      return nil, "Cannot access repository at "..repo
+   end
+
+   local query = search.make_query("")
+   query.exact_name = false
+   query.arch = "any"
+   local results = search.disk_search(repo, query)
+
+   local manifest = { repository = {}, modules = {}, commands = {} }
+   manifest_cache[repo] = manifest
+   store_results(results, manifest)
+   return save_manifest(repo, manifest)
+end
+
+local index_header = [[
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<title>Available rocks</title>
+<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
+<style>
+body {
+   background-color: white;
+   font-family: "bitstream vera sans", "verdana", "sans";
+   font-size: 14px;
+}
+a {
+   color: #0000c0;
+   text-decoration: none;
+}
+a:hover {
+   text-decoration: underline;
+}
+td.main {
+   border-style: none;
+}
+blockquote {
+   font-size: 12px;
+}
+td.package {
+   background-color: #f0f0f0;
+   vertical-align: top;
+}
+td.spacer {
+   height: 5px;
+}
+td.version {
+   background-color: #d0d0d0;
+   vertical-align: top;
+   text-align: left;
+   padding: 5px;
+   width: 100px;
+}
+p.manifest {
+   font-size: 8px;
+}
+</style>
+</head>
+<body>
+<h1>Available rocks</h1>
+<p>
+Lua modules avaliable from this location for use with <a href="http://www.luarocks.org">LuaRocks</a>:
+</p>
+<table class="main">
+]]
+
+local index_package_start = [[
+<td class="package">
+<p><a name="$anchor"></a><b>$package</b> - $summary<br/>
+</p><blockquote><p>$detailed<br/>
+<font size="-1"><a href="$original">latest sources</a> | <a href="$homepage">project homepage</a> | License: $license</font></p>
+</blockquote></a></td>
+<td class="version">
+]]
+
+local index_package_end = [[
+</td></tr>
+<tr><td colspan="2" class="spacer"></td></tr>
+]]
+
+local index_footer = [[
+</table>
+<p class="manifest">
+<a href="manifest">manifest file</a>
+</p>
+</body>
+</html>
+]]
+
+function make_index(repo)
+   if not fs.is_dir(repo) then
+      return nil, "Cannot access repository at "..repo
+   end
+   local manifest = load_manifest(repo)
+   files = fs.find(repo)
+   local out = io.open(fs.make_path(repo, "index.html"), "w")
+   out:write(index_header)
+   for package, version_list in util.sortedpairs(manifest.repository) do
+      local latest_rockspec = nil
+      local output = index_package_start
+      for version, data in util.sortedpairs(version_list, deps.compare_versions) do
+         local out_versions = {}
+         local arches = 0
+         output = output..version
+         local sep = ':&nbsp;'
+         for _, item in ipairs(data) do
+            output = output .. sep .. '<a href="$url">'..item.arch..'</a>'
+            sep = ',&nbsp;'
+            if item.arch == 'rockspec' then
+               local rs = ("%s-%s.rockspec"):format(package, version)
+               if not latest_rockspec then latest_rockspec = rs end
+               output = output:gsub("$url", rs)
+            else
+               output = output:gsub("$url", ("%s-%s.%s.rock"):format(package, version, item.arch))
+            end
+         end
+         output = output .. '<br/>'
+         output = output:gsub("$na", arches)
+      end
+      output = output .. index_package_end
+      if latest_rockspec then
+         local rockspec = persist.load_into_table(fs.make_path(repo, latest_rockspec))
+         local vars = {
+            anchor = package,
+            package = rockspec.package,
+            original = rockspec.source.url,
+            summary = rockspec.description.summary or "",
+            detailed = rockspec.description.detailed or "",
+            license = rockspec.description.license or "N/A",
+            homepage = rockspec.description.homepage or ""
+         }
+         vars.detailed = vars.detailed:gsub("\n\n", "</p><p>"):gsub("%s+", " ")
+         output = output:gsub("$(%w+)", vars)
+      else
+         output = output:gsub("$anchor", package)
+         output = output:gsub("$package", package)
+         output = output:gsub("$(%w+)", "")
+      end
+      out:write(output)
+   end
+   out:write(index_footer)
+   out:close()
+end
+
diff --git a/src/luarocks/pack.lua b/src/luarocks/pack.lua
new file mode 100644
index 00000000..3f64b1c0
--- /dev/null
+++ b/src/luarocks/pack.lua
@@ -0,0 +1,116 @@
+
+--- Module implementing the LuaRocks "pack" command.
+-- Creates a rock, packing sources or binaries.
+module("luarocks.pack", package.seeall)
+
+local path = require("luarocks.path")
+local rep = require("luarocks.rep")
+local fetch = require("luarocks.fetch")
+local fs = require("luarocks.fs")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+
+help_summary = "Create a rock, packing sources or binaries."
+help_arguments = "{<rockspec>|<name> [<version>]}"
+help = [[
+Argument may be a rockspec file, for creating a source rock,
+or the name of an installed package, for creating a binary rock.
+In the latter case, the app version may be given as a second
+argument.
+]]
+
+--- Create a source rock.
+-- Packages a rockspec and its required source files in a rock
+-- file with the .src.rock extension, which can later be built and
+-- installed with the "build" command.
+-- @param rockspec_file string: An URL or pathname for a rockspec file.
+-- @return string or (nil, string): The filename of the resulting
+-- .src.rock file; or nil and an error message.
+local function pack_source_rock(rockspec_file)
+   assert(type(rockspec_file) == "string")
+
+   rockspec_file = fs.absolute_name(rockspec_file)
+   local rockspec, err = fetch.load_rockspec(rockspec_file)
+   if err then
+      return nil, "Error loading rockspec: "..err
+   end
+
+   local name_version = rockspec.name .. "-" .. rockspec.version
+   local rock_file = fs.absolute_name(name_version .. ".src.rock")
+
+   local source_file, dir = fetch.fetch_sources(rockspec, false)
+   if not source_file then
+      return nil, dir
+   end
+   fs.change_dir(dir)
+
+   fs.delete(rock_file)
+   fs.copy(rockspec_file, dir)
+   if not fs.zip(rock_file, fs.base_name(rockspec_file), fs.base_name(source_file)) then
+      return nil, "Failed packing "..rock_file
+   end
+   fs.pop_dir()
+
+   return rock_file
+end
+
+-- @param name string: Name of package to pack.
+-- @param version string or nil: A version number may also be passed.
+-- @return string or (nil, string): The filename of the resulting
+-- .src.rock file; or nil and an error message.
+local function pack_binary_rock(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string" or not version)
+   
+   local versions = rep.get_versions(name)
+   
+   if not versions then
+      return nil, "'"..name.."' does not seem to be an installed rock."
+   end
+   if not version then
+      if #versions > 1 then
+         return nil, "Please specify which version of '"..name.."' to pack."
+      end
+      version = versions[1]
+   end
+   if not version:match("[^-]+%-%d+") then
+      return nil, "Expected version "..version.." in version-revision format."
+   end
+   local prefix = path.install_dir(name, version)
+   if not fs.exists(prefix) then
+      return nil, "'"..name.." "..version.."' does not seem to be an installed rock."
+   end
+   local name_version = name .. "-" .. version
+   local rock_file = fs.absolute_name(name_version .. "."..cfg.arch..".rock")
+   fs.change_dir(prefix)
+   if not rep.is_binary_rock(name, version) then
+      rock_file = rock_file:gsub("%."..cfg.arch:gsub("%-","%%-").."%.", ".all.")
+   end
+   fs.delete(rock_file)
+   if not fs.zip(rock_file, unpack(fs.dir())) then
+      return nil, "Failed packing "..rock_file
+   end
+   fs.pop_dir()
+   return rock_file
+end
+
+--- Driver function for the "pack" command.
+-- @param arg string:  may be a rockspec file, for creating a source rock,
+-- or the name of an installed package, for creating a binary rock.
+-- @param version string or nil: if the name of a package is given, a
+-- version may also be passed.
+-- @return boolean or (nil, string): true if successful or nil followed
+-- by an error message.
+function run(...)
+   local flags, arg, version = util.parse_flags(...)
+   assert(type(version) == "string" or not version)
+   if type(arg) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+
+   if arg:match(".*%.rockspec") then
+      return pack_source_rock(arg)
+   else
+      return pack_binary_rock(arg, version)
+   end
+end
diff --git a/src/luarocks/path.lua b/src/luarocks/path.lua
new file mode 100644
index 00000000..e236db01
--- /dev/null
+++ b/src/luarocks/path.lua
@@ -0,0 +1,224 @@
+
+--- Path and filename handling functions.
+-- All paths are configured in this module, making it a single
+-- point where the layout of the local installation is defined in LuaRocks.
+module("luarocks.path", package.seeall)
+
+local fs = require("luarocks.fs")
+local cfg = require("luarocks.cfg")
+
+--- Infer rockspec filename from a rock filename.
+-- @param rock_name string: Pathname of a rock file.
+-- @return string: Filename of the rockspec, without path.
+function rockspec_name_from_rock(rock_name)
+   assert(type(rock_name) == "string")
+   local base_name = fs.base_name(rock_name)
+   return base_name:match("(.*)%.[^.]*.rock") .. ".rockspec"
+end
+
+--- Get the repository directory for all versions of a package.
+-- @param name string: The package name. 
+-- @return string: The resulting path -- does not guarantee that
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- the package (and by extension, the path) exists.
+function versions_dir(name, repo)
+   assert(type(name) == "string")
+   assert(not repo or type(repo) == "string")
+   
+   return fs.make_path(repo or cfg.rocks_dir, name)
+end
+
+--- Get the local installation directory (prefix) for a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function install_dir(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+   
+   return fs.make_path(repo or cfg.rocks_dir, name, version)
+end
+
+--- Get the local filename of the rockspec of an installed rock.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the file) exists.
+function rockspec_file(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+   
+   return fs.make_path(repo or cfg.rocks_dir, name, version, name.."-"..version..".rockspec")
+end
+
+--- Get the local installation directory for C libraries of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function lib_dir(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+   
+   return fs.make_path(repo or cfg.rocks_dir, name, version, "lib")
+end
+
+--- Get the local installation directory for Lua modules of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function lua_dir(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+
+   return fs.make_path(repo or cfg.rocks_dir, name, version, "lua")
+end
+
+--- Get the local installation directory for documentation of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function doc_dir(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+
+   return fs.make_path(repo or cfg.rocks_dir, name, version, "doc")
+end
+
+--- Get the local installation directory for configuration files of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function conf_dir(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+   
+   return fs.make_path(repo or cfg.rocks_dir, name, version, "conf")
+end
+
+--- Get the local installation directory for command-line scripts
+-- of a package.
+-- @param name string: The package name. 
+-- @param version string: The package version.
+-- @param repo string or nil: If given, specifies the local repository to use.
+-- @return string: The resulting path -- does not guarantee that
+-- the package (and by extension, the path) exists.
+function bin_dir(name, version, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(not repo or type(repo) == "string")
+   
+   return fs.make_path(repo or cfg.rocks_dir, name, version, "bin")
+end
+
+--- Extract name, version and arch of a rock filename.
+-- @param rock_file string: pathname of a rock
+-- @return (string, string, string) or nil: name, version and arch
+-- of rock, or nil if name could not be parsed
+function parse_rock_name(rock_file)
+   assert(type(rock_file) == "string")
+   return fs.base_name(rock_file):match("(.*)-([^-]+-%d+)%.([^.]+)%.rock$")
+end
+
+--- Extract name and version of a rockspec filename.
+-- @param rockspec_file string: pathname of a rockspec
+-- @return (string, string) or nil: name and version
+-- of rockspec, or nil if name could not be parsed
+function parse_rockspec_name(rockspec_file)
+   assert(type(rockspec_file) == "string")
+   return fs.base_name(rockspec_file):match("(.*)-([^-]+-%d+)%.(rockspec)")
+end
+
+--- Make a rockspec or rock URL.
+-- @param pathname string: Base URL or pathname.
+-- @param name string: Package name.
+-- @param version string: Package version.
+-- @param arch string: Architecture identifier, or "rockspec" or "installed".
+-- @return string: A URL or pathname following LuaRocks naming conventions.
+function make_url(pathname, name, version, arch)
+   assert(type(pathname) == "string")
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(arch) == "string")
+
+   local filename = name.."-"..version
+   if arch == "installed" then
+      filename = fs.make_path(name, version, filename..".rockspec")
+   elseif arch == "rockspec" then
+      filename = filename..".rockspec"
+   else
+      filename = filename.."."..arch..".rock"
+   end
+   return fs.make_path(pathname, filename)
+end
+
+--- Convert a pathname to a module identifier.
+-- In Unix, for example, a path "foo/bar/baz.lua" is converted to
+-- "foo.bar.baz"; "bla/init.lua" returns "bla"; "foo.so" returns "foo".
+-- @param file string: Pathname of module
+-- @return string: The module identifier, or nil if given path is
+-- not a conformant module path (the function does not check if the
+-- path actually exists).
+function path_to_module(file)
+   assert(type(file) == "string")
+
+   local name = file:match("(.*)%."..cfg.lua_extension.."$")
+   if name then
+      name = name:gsub(fs.dir_separator, ".")
+      local init = name:match("(.*)%.init$")
+      if init then
+         name = init
+      end
+   else
+      name = file:match("(.*)%."..cfg.lib_extension.."$")
+      if name then
+         name = name:gsub(fs.dir_separator, ".")
+      end
+   end
+   return name
+end
+
+--- Obtain the directory name where a module should be stored.
+-- For example, on Unix, "foo.bar.baz" will return "foo/bar".
+-- @param mod string: A module name in Lua dot-separated format.
+-- @return string: A directory name using the platform's separator.
+function module_to_path(mod)
+   assert(type(mod) == "string")
+   return (mod:gsub("[^.]*$", ""):gsub("%.", fs.dir_separator))
+end
+
+--- Set up path-related variables for a given rock.
+-- Create a "variables" table in the rockspec table, containing
+-- adjusted variables according to the configuration file.
+-- @param rockspec table: The rockspec table.
+function configure_paths(rockspec)
+   assert(type(rockspec) == "table")
+   local vars = {}
+   for k,v in pairs(cfg.variables) do
+      vars[k] = v
+   end
+   local name, version = rockspec.name, rockspec.version
+   vars.PREFIX = install_dir(name, version)
+   vars.LUADIR = lua_dir(name, version)
+   vars.LIBDIR = lib_dir(name, version)
+   vars.CONFDIR = conf_dir(name, version)
+   vars.BINDIR = bin_dir(name, version)
+   vars.DOCDIR = doc_dir(name, version)
+   rockspec.variables = vars
+end
diff --git a/src/luarocks/persist.lua b/src/luarocks/persist.lua
new file mode 100644
index 00000000..4f69184c
--- /dev/null
+++ b/src/luarocks/persist.lua
@@ -0,0 +1,91 @@
+
+--- Utility module for loading files into tables and
+-- saving tables into files.
+-- Implemented separately to avoid interdependencies,
+-- as it is used in the bootstrapping stage of the cfg module.
+module("luarocks.persist", package.seeall)
+
+--- Load a Lua file containing assignments, storing them in a table.
+-- The global environment is not propagated to the loaded file.
+-- @param filename string: the name of the file.
+-- @param tbl table or nil: if given, this table is used to store
+-- loaded values.
+-- @return table or (nil, string): a table with the file's assignments
+-- as fields, or nil and a message in case of errors.
+function load_into_table(filename, tbl)
+   assert(type(filename) == "string")
+   assert(type(tbl) == "table" or not tbl)
+
+   local chunk, err = loadfile(filename)
+   if not chunk then
+      return nil, err
+   end
+   local result = {}
+   if tbl then result = tbl end
+   setfenv(chunk, result)
+   chunk()
+   return result
+end
+
+--- Write a table as Lua code representing a table to disk
+-- (that is, in curly brackets notation).
+-- This function handles only numbers, strings and tables
+-- are keys (tables are handled recursively).
+-- @param out userdata: a file object, open for writing.
+-- @param tbl table: the table to be written.
+local function write_table(out, tbl)
+   out:write("{")
+   local size = table.getn(tbl)
+   local sep = ""
+   local i = 1
+   for k, v in pairs(tbl) do
+      out:write(sep)
+      if type(k) == "number" then
+         if k ~= i then
+            out:write(tostring(k).."=")
+         else
+            i = i + 1
+         end
+      elseif type(k) == "table" then
+         out:write("[")
+         write_table(out, k)
+         out:write("]=")
+      else
+         if k:match("^[a-z_]+$") then
+            out:write(k.."=")
+         else
+            out:write("['"..k:gsub("'", "\\'").."']=") 
+         end
+      end
+      local typ = type(v)
+      if typ == "table" then
+         write_table(out, v)
+      elseif typ == "string" then
+         out:write("'"..v:gsub("'", "\\'").."'")
+      else
+         out:write(tostring(v))
+      end
+      sep = ", "
+   end
+   out:write("}\n")
+end
+
+--- Save the contents of a table in a file.
+-- Each element of the table is saved as a global assignment.
+-- Only numbers, strings and tables (containing numbers, strings
+-- or other recursively processed tables) are supported.
+-- @return boolean or (nil, string): true if successful, or nil and a
+-- message in case of errors.
+function save_from_table(filename, tbl)
+   local out = io.open(filename, "w")
+   if not out then
+      return nil, "Cannot create file at "..filename
+   end
+   for k, v in pairs(tbl) do
+      out:write(k.." = ")
+      write_table(out, v)
+      out:write("\n")
+   end
+   out:close()
+   return true
+end
diff --git a/src/luarocks/remove.lua b/src/luarocks/remove.lua
new file mode 100644
index 00000000..d7162336
--- /dev/null
+++ b/src/luarocks/remove.lua
@@ -0,0 +1,163 @@
+
+--- Module implementing the LuaRocks "remove" command.
+-- Uninstalls rocks.
+module("luarocks.remove", package.seeall)
+
+local search = require("luarocks.search")
+local deps = require("luarocks.deps")
+local fetch = require("luarocks.fetch")
+local rep = require("luarocks.rep")
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local manif = require("luarocks.manif")
+
+help_summary = "Uninstall a rock."
+help_arguments = "[--force] <name> [<version>]"
+help = [[
+Argument is the name of a rock to be uninstalled.
+If a version is not given, try to remove all versions at once.
+Will only perform the removal if it does not break dependencies.
+To override this check and force the removal, use --force.
+]]
+
+--- Obtain a list of packages that depend on the given set of packages
+-- (where all packages of the set are versions of one program).
+-- @param name string: the name of a program
+-- @param versions array of string: the versions to be deleted.
+-- @return array of string: an empty table if no packages depend on any
+-- of the given list, or an array of strings in "name/version" format.
+local function check_dependents(name, versions)
+   local dependents = {}
+   local blacklist = {}
+   blacklist[name] = {}
+   for version, _ in pairs(versions) do
+      blacklist[name][version] = true
+   end
+   local local_rocks = {}
+   local query_all = search.make_query("")
+   query_all.exact_name = false
+   search.manifest_search(local_rocks, cfg.rocks_dir, query_all)
+   local_rocks[name] = nil
+   for rock_name, rock_versions in pairs(local_rocks) do
+      for rock_version, _ in pairs(rock_versions) do
+         local rockspec, err = fetch.load_rockspec(path.rockspec_file(rock_name, rock_version))
+         if rockspec then
+            local _, missing = deps.match_deps(rockspec, blacklist)
+            if missing[name] then
+               table.insert(dependents, { name = rock_name, version = rock_version })
+            end
+         end
+      end
+   end
+   return dependents
+end
+
+--- Delete given versions of a program.
+-- @param name string: the name of a program
+-- @param versions array of string: the versions to be deleted.
+-- @return boolean or (nil, string): true on success or nil and an error message.
+local function delete_versions(name, versions) 
+
+   local manifest, err = manif.load_manifest(cfg.rocks_dir)
+   if not manifest then
+      return nil, err
+   end
+
+   local commands = {}
+   for version, data in pairs(versions) do
+      for _, command in pairs(manifest.repository[name][version][1].commands) do
+         if not commands[command] then commands[command] = {} end
+         table.insert(commands[command], name.."/"..version)
+      end
+   end
+   
+   if next(commands) then
+      for command, users in pairs(commands) do
+         local providers_of_command = manifest.commands[command]
+         for _, user in ipairs(users) do
+            for i, value in ipairs(providers_of_command) do
+               if providers_of_command[i] == user then
+                  table.remove(providers_of_command, i)
+                  break
+               end
+            end
+         end
+         local remaining = next(providers_of_command)
+         if remaining then
+            local name, version = remaining:match("^([^/]*)/(.*)$")
+            rep.install_bins(name, version, command)
+         else
+            rep.delete_bin(command)
+         end
+      end
+   end
+
+   for version, _ in pairs(versions) do
+      print("Removing "..name.." "..version.."...")
+      rep.delete_version(name, version)
+   end
+   
+   return true
+end
+
+--- Driver function for the "install" command.
+-- @param name string: name of a rock. If a version is given, refer to
+-- a specific version; otherwise, try to remove all versions.
+-- @param version string: When passing a package name, a version number
+-- may also be given.
+-- @return boolean or (nil, string): True if removal was
+-- successful, nil and an error message otherwise.
+function run(...)
+   local flags, name, version = util.parse_flags(...)
+   
+   if type(name) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+   local results = {}
+   search.manifest_search(results, cfg.rocks_dir, search.make_query(name, version))
+   
+   local versions = results[name]
+   if not versions then
+      return nil, "Could not find rock '"..name..(version and " "..version or "").."' in local tree."
+   else
+      local version = next(versions)
+      local second = next(versions, version)
+      
+      print("Checking stability of dependencies on the absence of")
+      print(name.." "..table.concat(util.keys(versions), ", ").."...")
+      print()
+      
+      local dependents = check_dependents(name, versions)
+      
+      if #dependents == 0 or flags["force"] then
+         if #dependents > 0 then
+            print("The following packages may be broken by this forced removal:")
+            for _, dependent in ipairs(dependents) do
+               print(dependent.name.." "..dependent.version)
+            end
+            print()
+         end
+         local ok, err1 = delete_versions(name, versions)
+         local ok, err2 = manif.make_manifest(cfg.rocks_dir)
+         if err1 or err2 then
+            return nil, err1 or err2
+         end
+      else
+         if not second then
+            print("Will not remove "..name.." "..version..".")
+            print("Removing it would break dependencies for: ")
+         else
+            print("Will not remove all versions of "..name..".")
+            print("Removing them would break dependencies for: ")
+         end
+         for _, dependent in ipairs(dependents) do
+            print(dependent.name.." "..dependent.version)
+         end
+         print()
+         print("Use --force to force removal (warning: this may break modules).")
+         return nil, "Failed removing."
+      end
+   end
+   return true
+end
diff --git a/src/luarocks/rep.lua b/src/luarocks/rep.lua
new file mode 100644
index 00000000..b5797803
--- /dev/null
+++ b/src/luarocks/rep.lua
@@ -0,0 +1,187 @@
+
+--- Functions for managing the repository on disk.
+module("luarocks.rep", package.seeall)
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+
+--- Get all installed versions of a package.
+-- @param name string: a package name.
+-- @return table or nil: An array of strings listing installed
+-- versions of a package, or nil if none is available.
+function get_versions(name)
+   assert(type(name) == "string")
+   
+   local dirs = fs.dir(path.versions_dir(name))
+   return (dirs and #dirs > 0) and dirs or nil
+end
+
+--- Check if a package exists in a local repository.
+-- Version numbers are compared as exact string comparison.
+-- @param name string: name of package
+-- @param version string: package version in string format
+-- @return boolean: true if a package is installed,
+-- false otherwise.
+function is_installed(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+      
+   return fs.is_dir(path.install_dir(name, version))
+end
+         
+--- Delete a package from the local repository.
+-- Version numbers are compared as exact string comparison.
+-- @param name string: name of package
+-- @param version string: package version in string format
+function delete_version(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+
+   fs.delete(path.install_dir(name, version))
+   if not get_versions(name) then
+      fs.delete(fs.make_path(cfg.rocks_dir, name))
+   end
+end
+
+--- Delete a command-line item from the bin directory.
+-- @param command string: name of script
+function delete_bin(command)
+   assert(type(command) == "string")
+
+   fs.delete(fs.make_path(cfg.scripts_dir, command))
+end
+
+--- Install bin entries in the repository bin dir.
+-- @param name string: name of package
+-- @param version string: package version in string format
+-- @param single_file string or nil: optional parameter, indicating the name
+-- of a single file to install; if not given, all bin files from the package
+-- are installed.
+-- @return boolean or (nil, string): True if succeeded or nil and
+-- and error message.
+function install_bins(name, version, single_file)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+
+   local bindir = path.bin_dir(name, version)
+   if fs.exists(bindir) then
+      local ok, err = fs.make_dir(cfg.scripts_dir)
+      if not ok then
+         return nil, "Could not create "..cfg.scripts_dir
+      end
+      local files = single_file and {single_file} or fs.dir(bindir)
+      for _, file in pairs(files) do
+         local fullname = fs.make_path(bindir, file)
+         local match = file:match("%.lua$")
+         local file
+         if not match then
+            file = io.open(fullname)
+         end
+         if match or (file and file:read():match("#!.*lua.*")) then
+            ok, err = fs.wrap_script(fullname, cfg.scripts_dir)
+         else
+            ok, err = fs.copy_binary(fullname, cfg.scripts_dir)
+         end
+         if file then file:close() end
+         if not ok then
+            return nil, err
+         end
+      end
+   end
+   return true
+end
+
+--- Obtain a list of modules within an installed package.
+-- @param package string: The package name; for example "luasocket"
+-- @param version string: The exact version number including revision;
+-- for example "2.0.1-1".
+-- @return table: A table of modules where keys are module identifiers
+-- in "foo.bar" format and values are pathnames in architecture-dependent
+-- "foo/bar.so" format. If no modules are found or if package or version
+-- are invalid, an empty table is returned.
+function package_modules(package, version)
+   assert(type(package) == "string")
+   assert(type(version) == "string")
+
+   local result = {}
+   local luas = fs.find(path.lua_dir(package, version))
+   local libs = fs.find(path.lib_dir(package, version))
+   for _, file in ipairs(luas) do
+      local name = path.path_to_module(file)
+      if name then
+         result[name] = file
+      end
+   end
+   for _, file in ipairs(libs) do
+      local name = path.path_to_module(file)
+      if name then
+         result[name] = file
+      end
+   end
+   return result
+end
+
+--- Obtain a list of command-line scripts within an installed package.
+-- @param package string: The package name; for example "luasocket"
+-- @param version string: The exact version number including revision;
+-- for example "2.0.1-1".
+-- @return table: A table of items where keys are command names
+-- as strings and values are pathnames in architecture-dependent
+-- ".../bin/foo" format. If no modules are found or if package or version
+-- are invalid, an empty table is returned.
+function package_commands(package, version)
+   assert(type(package) == "string")
+   assert(type(version) == "string")
+
+   local result = {}
+   local bindir = path.bin_dir(package, version)
+   local bins = fs.find(bindir)
+   for _, file in ipairs(bins) do
+      if file then
+         result[file] = fs.make_path(bindir, file)
+      end
+   end
+   return result
+end
+
+--- Check if a rock contains binary parts or if it is pure Lua.
+-- @param name string: name of an installed rock
+-- @param version string: version of an installed rock
+-- @return boolean: returns true if rock contains platform-specific
+-- binary code, or false if it is a pure-Lua rock.
+function is_binary_rock(name, version)
+   local bin_dir = path.bin_dir(name, version)
+   local lib_dir = path.lib_dir(name, version)
+   if fs.exists(lib_dir) then
+      return true
+   end
+   if fs.exists(bin_dir) then
+      for _, name in pairs(fs.find(bin_dir)) do
+         if fs.is_actual_binary(fs.make_path(bin_dir, name)) then
+            return true
+         end
+      end
+   end
+   return false
+end
+
+function run_hook(rockspec, hook_name)
+   local hooks = rockspec.hooks
+   if not hooks then
+      return true
+   end
+   if not hooks.substituted_variables then
+      util.variable_substitutions(hooks, rockspec.variables)
+      hooks.substituted_variables = true
+   end
+   local hook = hooks[hook_name]
+   if hook then
+      print(hook)
+      if not fs.execute(hook) then
+         return nil, "Failed running "..hook_name.." hook."
+      end
+   end
+   return true
+end
diff --git a/src/luarocks/require.lua b/src/luarocks/require.lua
new file mode 100644
index 00000000..f5d26078
--- /dev/null
+++ b/src/luarocks/require.lua
@@ -0,0 +1,263 @@
+
+local global_env = _G
+local plain_require = require
+local plain_package_path = package.path
+local plain_package_cpath = package.cpath
+local package, assert, ipairs, pairs, os, print, table, type, next =
+      package, assert, ipairs, pairs, os, print, table, type, next
+
+--- Application interface with LuaRocks.
+-- Load this module to LuaRocks-enable an application:
+-- this overrides the require() function, making it able to
+-- load modules installed as rocks.
+module("luarocks.require")
+
+local path = plain_require("luarocks.path")
+local manif = plain_require("luarocks.manif")
+local deps = plain_require("luarocks.deps")
+local cfg = plain_require("luarocks.cfg")
+
+context = {}
+
+-- Contains a table when rocks trees are loaded,
+-- or 'false' to indicate rocks trees failed to load.
+-- 'nil' indicates rocks trees were not attempted to be loaded yet.
+rocks_trees = nil
+
+local function load_rocks_trees() 
+   local any_ok = false
+   local trees = {}
+   for _, tree in pairs(cfg.rocks_trees) do
+      local rocks_dir = tree .. "/rocks/"
+      local manifest, err = manif.load_local_manifest(rocks_dir)
+      if manifest then
+         any_ok = true
+         table.insert(trees, {rocks_dir=rocks_dir, manifest=manifest})
+      end
+   end
+   if not any_ok then
+      rocks_trees = false
+      return false
+   end
+   rocks_trees = trees
+   return true
+end
+
+--- Process the dependencies of a package to determine its dependency
+-- chain for loading modules.
+-- @parse name string: The name of an installed rock.
+-- @parse version string: The version of the rock, in string format
+-- @parse manifest table: The local manifest table where this rock
+-- is installed.
+local function add_context(name, version, manifest)
+   -- assert(type(name) == "string")
+   -- assert(type(version) == "string")
+   -- assert(type(manifest) == "table")
+
+   if context[name] then
+      return
+   end
+   context[name] = version
+
+   local pkgdeps = manifest.dependencies and manifest.dependencies[name][version]
+   if pkgdeps then
+      for _, dep in ipairs(pkgdeps) do
+         local package, constraints = dep.name, dep.constraints
+   
+         for _, tree in pairs(rocks_trees) do
+            local entries = tree.manifest.repository[package]
+            if entries then
+               for version, packages in pairs(entries) do
+                  if (not constraints) or deps.match_constraints(deps.parse_version(version), constraints) then
+                     add_context(package, version, tree.manifest)
+                  end
+               end
+            end
+         end
+      end
+   end
+end
+
+--- Internal sorting function.
+-- @param a table: A provider table.
+-- @param b table: Another provider table.
+-- @return boolean: True if the version of a is greater than that of b.
+local function sort_versions(a,b)
+   return a.version > b.version
+end
+
+--- Specify a dependency chain for LuaRocks.
+-- In the presence of multiple versions of packages, it is necessary to,
+-- at some point, indicate which dependency chain we're following.
+-- set_context does this by allowing one to pick a package to be the
+-- root of this dependency chain. Once a dependency chain is picked it's
+-- easy to know which modules to load ("I want to use *this* version of
+-- A, which requires *that* version of B, which requires etc etc etc").
+-- @param name string: The package name of an installed rock.
+-- @param version string or nil: Optionally, a version number
+-- When a version is not given, it picks the highest version installed.
+-- @return boolean: true if succeeded, false otherwise.
+function set_context(name, version)
+   --assert(type(name) == "string")
+   --assert(type(version) == "string" or not version)
+
+   if rocks_trees == false or (not rocks_trees and not load_rocks_trees()) then
+      return false
+   end
+
+   local manifest
+   local vtables = {}
+   for _, tree in ipairs(rocks_trees) do
+      if version then
+         local manif_repo = tree.manifest.repository
+         if manif_repo[name] and manif_repo[name][version] then
+            manifest = tree.manifest
+            break
+         end
+      else
+         local versions = manif.get_versions(name, tree.manifest)
+         for _, version in ipairs(versions) do
+            table.insert(vtables, {version = deps.parse_version(version), manifest = tree.manifest})
+         end
+      end
+   end
+   if not version then
+      if not next(vtables) then
+         table.sort(vtables, sort_versions)
+         local highest = vtables[#vtables]
+         version = highest.version.string
+         manifest = highest.manifest
+      end
+   end
+   if not manifest then
+      return false
+   end
+
+   add_context(name, version, manifest)
+   -- TODO: platform independence
+   local lpath, cpath = "", ""
+   for name, version in pairs(context) do
+      lpath = lpath .. path.lua_dir(name, version) .. "/?.lua;"
+      lpath = lpath .. path.lua_dir(name, version) .. "/?/init.lua;"
+      cpath = cpath .. path.lib_dir(name, version) .."/?."..cfg.lib_extension..";"
+   end
+   global_env.package.path = lpath .. plain_package_path
+   global_env.package.cpath = cpath .. plain_package_cpath
+end
+
+--- Call the vanilla require() function using specially constructed 
+-- package paths so that it finds exactly the version we want it to find.
+-- @param name string: The rock name.
+-- @param version string: The rock version.
+-- @param module string: The module name, in require() notation.
+-- @return The result returned by require().
+local function plain_require_on(module, name, version, rocks_dir, ...)
+   --assert(type(module) == "string")
+   --assert(type(name) == "string")
+   --assert(type(version) == "string")
+
+   local global_package = global_env.package
+   local save_path = global_package.path
+   local save_cpath = global_package.cpath
+   global_package.path = path.lua_dir(name, version, rocks_dir) .. "/?.lua;"
+               .. path.lua_dir(name, version, rocks_dir) .. "/?/init.lua;" .. save_path
+   global_package.cpath = path.lib_dir(name, version, rocks_dir) .. "/?."..cfg.lib_extension..";" .. save_cpath
+   local result = plain_require(module, ...)
+   global_package.path = save_path
+   global_package.cpath = save_cpath
+   return result
+end
+
+local function pick_module(module, constraints)
+   --assert(type(module) == "string")
+   --assert(not constraints or type(constraints) == "string")
+
+   if not rocks_trees and not load_rocks_trees() then
+      return nil
+   end
+   
+   if constraints then
+      if type(constraints) == "string" then
+         constraints = deps.parse_constraints(constraints)
+      else
+         constraints = nil
+      end
+   end
+
+   local providers = {}
+   for _, tree in pairs(rocks_trees) do
+      local entries = tree.manifest.modules[module]
+      if entries then
+         for _, entry in pairs(entries) do
+            local name, version = entry:match("^([^/]*)/(.*)$")
+            if context[name] == version then
+               return name, version, tree
+            end
+            version = deps.parse_version(version)
+            if (not constraints) or deps.match_constraints(version, constraints) then
+               table.insert(providers, {name = name, version = version, repo = tree})
+            end
+         end
+      end
+   end
+
+   if next(providers) then
+      table.sort(providers, sort_versions)
+      local first = providers[1]
+      return first.name, first.version.string, first.repo
+   end
+end
+
+--- Inform which rock LuaRocks would use if require() is called
+-- with the given arguments.
+-- @param module string: The module name, like in plain require().
+-- @param constraints string or nil: An optional comma-separated
+-- list of version constraints.
+-- @return (string, string) or nil: Rock name and version if the
+-- requested module can be supplied by LuaRocks, or nil if it can't.
+function get_rock_from_module(module, constraints) 
+   --assert(type(module) == "string")
+   --assert(not constraints or type(constraints) == "string")
+   local name, version = pick_module(module, constraints)
+   return name, version
+end
+
+--- Function that overloads require(), adding LuaRocks support.
+-- This function wraps around Lua's standard require() call,
+-- allowing it to find modules installed by LuaRocks.
+-- A module is searched in installed rocks that match the
+-- current LuaRocks context. If module is not part of the
+-- context, or if a context has not yet been set, the module
+-- in the package with the highest version is used.
+-- If a module is not available in any installed rock, plain
+-- require() is called, using the original package.path and
+-- package.cpath lookup locations.
+-- Additionally, version constraints for the matching rock may
+-- be given as a second parameter. If version constraints could
+-- not be fulfilled, this equates to the rock not being
+-- available: as such, plain require() with the default paths
+-- is called as a fallback.
+-- @param module string: The module name, like in plain require().
+-- @param constraints string or nil: An optional comma-separated
+-- list of version constraints.
+-- @return table: The module table (typically), like in plain
+-- require(). See <a href="http://www.lua.org/manual/5.1/manual.html#pdf-require">require()</a>
+-- in the Lua reference manual for details.
+function require(module, ...)
+   --assert(type(module) == "string")
+
+   if package.loaded[module] or rocks_trees == false or (not rocks_trees and not load_rocks_trees()) then
+      return plain_require(module, ...)
+   end
+
+   local name, version, repo = pick_module(module, ...)
+   
+   if not name then
+      return plain_require(module, ...)
+   else
+      add_context(name, version, repo.manifest)
+      return plain_require_on(module, name, version, repo.rocks_dir, ...)
+   end
+end
+
+global_env.require = require
diff --git a/src/luarocks/search.lua b/src/luarocks/search.lua
new file mode 100644
index 00000000..a3ac68f3
--- /dev/null
+++ b/src/luarocks/search.lua
@@ -0,0 +1,394 @@
+
+--- Module implementing the LuaRocks "search" command.
+-- Queries LuaRocks servers.
+module("luarocks.search", package.seeall)
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local manif = require("luarocks.manif")
+local deps = require("luarocks.deps")
+local cfg = require("luarocks.cfg")
+local util = require("luarocks.util")
+
+help_summary = "Query the LuaRocks servers."
+help_arguments = "[--source] [--binary] { <name> [<version>] | --all }"
+help = [[
+--source  Return only rockspecs and source rocks,
+          to be used with the "build" command.
+--binary  Return only pure Lua and binary rocks (rocks that can be used
+          with the "install" command without requiring a C toolchain).
+--all     List all contents of the server that are suitable to
+          this platform, do not filter by name.
+]]
+
+--- Convert the arch field of a query table to table format.
+-- @param query table: A query table.
+local function query_arch_as_table(query)
+   local format = type(query.arch)
+   if format == "table" then
+      return
+   elseif format == "nil" then
+      local accept = {}
+      accept["src"] = true
+      accept["all"] = true
+      accept["rockspec"] = true
+      accept["installed"] = true
+      accept[cfg.arch] = true
+      query.arch = accept
+   elseif format == "string" then
+      local accept = {}
+      for a in string.gmatch(query.arch, "[%w_]+") do
+         accept[a] = true
+      end
+      query.arch = accept
+   end
+end
+
+--- Store a search result (a rock or rockspec) in the results table.
+-- @param results table: The results table, where keys are package names and
+-- versions are tables matching version strings to an array of servers.
+-- @param name string: Package name.
+-- @param version string: Package version.
+-- @param arch string: Architecture of rock ("all", "src" or platform
+-- identifier), "rockspec" or "installed"
+-- @param repo string: Pathname of a local repository of URL of
+-- rocks server.
+local function store_result(results, name, version, arch, repo)
+   assert(type(results) == "table")
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(arch) == "string")
+   assert(type(repo) == "string")
+   
+   if not results[name] then results[name] = {} end
+   if not results[name][version] then results[name][version] = {} end
+   table.insert(results[name][version], {
+      arch = arch,
+      repo = repo
+   })
+end
+
+--- Test the name field of a query.
+-- If query has a boolean field exact_name set to false,
+-- then substring match is performed; otherwise, exact string
+-- comparison is done.
+-- @param query table: A query in dependency table format.
+-- @param name string: A package name.
+-- @return boolean: True if names match, false otherwise.
+local function match_name(query, name)
+   assert(type(query) == "table")
+   assert(type(name) == "string")
+   if query.exact_name == false then
+      return name:find(query.name, 0, true) and true or false
+   else
+      return name == query.name
+   end
+end
+
+--- Store a match in a results table if version matches query.
+-- Name, version, arch and repository path are stored in a given
+-- table, optionally checking if version and arch (if given) match
+-- a query.
+-- @param results table: The results table, where keys are package names and
+-- versions are tables matching version strings to an array of servers.
+-- @param repo string: URL or pathname of the repository.
+-- @param name string: The name of the package being tested.
+-- @param version string: The version of the package being tested.
+-- @param arch string: The arch of the package being tested.
+-- @param query table: A table describing the query in dependency
+-- format (for example, {name = "filesystem", exact_name = false,
+-- constraints = {op = "~>", version = {1,0}}}, arch = "rockspec").
+-- If the arch field is omitted, the local architecture (cfg.arch)
+-- is used. The special value "any" is also recognized, returning all
+-- matches regardless of architecture.
+local function store_if_match(results, repo, name, version, arch, query)
+   if match_name(query, name) then
+      if query.arch[arch] or query.arch["any"] then
+         if deps.match_constraints(deps.parse_version(version), query.constraints) then
+            store_result(results, name, version, arch, repo)
+         end
+      end
+   end
+end
+
+--- Perform search on a local repository.
+-- @param repo string: The pathname of the local repository.
+-- @param query table: A table describing the query in dependency
+-- format (for example, {name = "filesystem", exact_name = false,
+-- constraints = {op = "~>", version = {1,0}}}, arch = "rockspec").
+-- If the arch field is omitted, the local architecture (cfg.arch)
+-- is used. The special value "any" is also recognized, returning all
+-- matches regardless of architecture.
+-- @param results table or nil: If given, this table will store the
+-- results; if not given, a new table will be created.
+-- @param table: The results table, where keys are package names and
+-- versions are tables matching version strings to an array of servers.
+-- If a table was given in the "results" parameter, that is the result value.
+function disk_search(repo, query, results)
+   assert(type(repo) == "string")
+   assert(type(query) == "table")
+   assert(type(results) == "table" or not results)
+   if not results then
+      results = {}
+   end
+   query_arch_as_table(query)
+   
+   for _, name in pairs(fs.dir(repo)) do
+      local pathname = fs.make_path(repo, name)
+      local rname, rversion, rarch = path.parse_rock_name(name)
+      if not rname then
+         rname, rversion, rarch = path.parse_rockspec_name(name)
+      end
+      if fs.is_dir(pathname) then
+         for _, version in pairs(fs.dir(pathname)) do
+            if version:match("-%d+$") then
+               store_if_match(results, repo, name, version, "installed", query)
+            end
+         end
+      elseif rname then
+         store_if_match(results, repo, rname, rversion, rarch, query)
+      end
+   end
+   return results
+end
+
+--- Perform search on a rocks server.
+-- @param results table: The results table, where keys are package names and
+-- versions are tables matching version strings to an array of servers.
+-- @param repo string: The URL of the rocks server.
+-- @param query table: A table describing the query in dependency
+-- format (for example, {name = "filesystem", exact_name = false,
+-- constraints = {op = "~>", version = {1,0}}}, arch = "rockspec").
+-- If the arch field is omitted, the local architecture (cfg.arch)
+-- is used. The special value "any" is also recognized, returning all
+-- matches regardless of architecture.
+function manifest_search(results, repo, query)
+   assert(type(results) == "table")
+   assert(type(repo) == "string")
+   assert(type(query) == "table")
+   
+   query_arch_as_table(query)
+   local manifest, err = manif.load_manifest(repo)
+   if not manifest then
+      print(err)
+      return 
+   end
+   for name, versions in pairs(manifest.repository) do
+      for version, items in pairs(versions) do
+         for _, item in ipairs(items) do
+            store_if_match(results, repo, name, version, item.arch, query)
+         end
+      end
+   end
+end
+
+--- Search on all configured rocks servers.
+-- @param query table: A dependency query.
+-- @return table or (nil, string): A table where keys are package names
+-- and values are tables matching version strings to an array of
+-- rocks servers; if no results are found, an empty table is returned.
+-- In case of errors, nil and and error message are returned.
+local function search_repos(query)
+   assert(type(query) == "table")
+
+   local results = {}
+   for _, repo in ipairs(cfg.rocks_servers) do
+      local protocol, pathname = fs.split_url(repo)
+      if protocol == "file" then
+         repo = pathname
+      end
+      manifest_search(results, repo, query)
+   end
+   return results
+end
+
+--- Prepare a query in dependency table format.
+-- @param name string: The query name.
+-- @param version string or nil: 
+-- @return table: A query in table format
+function make_query(name, version)
+   assert(type(name) == "string")
+   assert(type(version) == "string" or not version)
+   
+   local query = {
+      name = name,
+      constraints = {}
+   }
+   if version then
+      table.insert(query.constraints, { op = "~>", version = deps.parse_version(version)})
+   end
+   return query
+end
+
+--- Get the URL for the latest in a set of versions.
+-- @param name string: The package name to be used in the URL.
+-- @param versions table: An array of version informations, as stored
+-- in search results tables.
+-- @return string or nil: the URL for the latest version if one could
+-- be picked, or nil.
+local function pick_latest_version(name, versions)
+   assert(type(name) == "string")
+   assert(type(versions) == "table")
+
+   local vtables = {}
+   for v, _ in pairs(versions) do
+      table.insert(vtables, deps.parse_version(v))
+   end
+   table.sort(vtables)
+   local version = vtables[#vtables].string
+   local items = versions[version]
+   if items then
+      local pick = 1
+      for i, item in ipairs(items) do
+         if (item.arch == 'src' and items[pick].arch == 'rockspec')
+         or (item.arch ~= 'src' and item.arch ~= 'rockspec') then
+            pick = i
+         end
+      end
+      return path.make_url(items[pick].repo, name, version, items[pick].arch)
+   end
+   return nil
+end
+
+--- Attempt to get a single URL for a given search.
+-- @param query table: A dependency query.
+-- @return string or table or (nil, string): URL for matching rock if
+-- a single one was found, a table of candidates if it could not narrow to
+-- a single result, or nil followed by an error message.
+function find_suitable_rock(query)
+   assert(type(query) == "table")
+   
+   local results, err = search_repos(query)
+   if not results then
+      return nil, err
+   end
+   local first = results and next(results)
+   if first and next(results, first) == nil then
+      return pick_latest_version(query.name, results[first])
+   elseif not first then
+      return nil, "No results matching query were found."
+   else
+      return results
+   end
+end
+
+--- Print a list of rocks/rockspecs on standard output.
+-- @param results table: A table where keys are package names and versions
+-- are tables matching version strings to an array of rocks servers.
+-- @param show_repo boolean or nil: Whether to show repository
+-- information or not. Default is true.
+function print_results(results, show_repo)
+   assert(type(results) == "table")
+   assert(type(show_repo) == "boolean" or not show_repo)
+   -- Force display of repo location for the time being
+   show_repo = true -- show_repo == nil and true or show_repo
+   
+   for package, versions in util.sortedpairs(results) do
+      print(package)
+      for version, repos in util.sortedpairs(versions, deps.compare_versions) do
+         if show_repo then
+            for _, repo in ipairs(repos) do
+               print("   "..version.." ("..repo.arch..") - "..repo.repo)
+            end
+         else
+            print("   "..version)
+         end
+      end
+      print()
+   end
+end
+
+--- Splits a list of search results into two lists, one for "source" results
+-- to be used with the "build" command, and one for "binary" results to be
+-- used with the "install" command.
+-- @param results table: A search results table.
+-- @return (table, table): Two tables, one for source and one for binary
+-- results.
+local function split_source_and_binary_results(results)
+   local sources, binaries = {}, {}
+   for name, versions in pairs(results) do
+      for version, repos in pairs(versions) do
+         for _, repo in ipairs(repos) do
+            local where = sources
+            if repo.arch == "all" or repo.arch == cfg.arch then
+               where = binaries
+            end
+            store_result(where, name, version, repo.arch, repo.repo)
+         end
+      end
+   end
+   return sources, binaries
+end
+
+--- Given a name and optionally a version, try to find in the rocks
+-- servers a single .src.rock or .rockspec file that satisfies
+-- the request, and run the given function on it; or display to the
+-- user possibilities if it couldn't narrow down a single match.
+-- @param action function: A function that takes a .src.rock or
+-- .rockspec URL as a parameter.
+-- @string name string: A rock name
+-- @string version string or nil: A version number may also be given.
+-- @return The result of the action function, or nil and an error message. 
+function act_on_src_or_rockspec(action, name, version)
+   assert(type(action) == "function")
+   assert(type(name) == "string")
+   assert(type(version) == "string" or not version)
+
+   local query = make_query(name, version)
+   query.arch = "src|rockspec"
+   local results, err = find_suitable_rock(query)
+   if type(results) == "string" then
+      return action(results)
+   elseif type(results) == "table" and next(results) then
+      print("Multiple search results were returned.")
+      print()
+      print("Search results:")
+      print("---------------")
+      print_results(results)
+      return nil, "Please narrow your query."
+   else
+      return nil, "Could not find a result named "..name.."."
+   end
+end
+
+--- Driver function for "search" command.
+-- @param name string: A substring of a rock name to search.
+-- @param version string or nil: a version may also be passed.
+-- @return boolean or (nil, string): True if build was successful; nil and an
+-- error message otherwise.
+function run(...)
+   local flags, name, version = util.parse_flags(...)
+   
+   if flags["all"] then
+      name, version = "", ""
+   end
+
+   if type(name) ~= "string" and not flags["all"] then
+      return nil, "Enter name and version or use --all; see help."
+   end
+   
+   local query = make_query(name, version)
+   query.exact_name = false
+   local results, err = search_repos(query)
+   if not results then
+      return nil, err
+   end
+   print()
+   print("Search results:")
+   print("===============")
+   print()
+   local sources, binaries = split_source_and_binary_results(results)
+   if next(sources) and not flags["binary"] then
+      print("Rockspecs and source rocks:")
+      print("---------------------------")
+      print()
+      print_results(sources, true)
+   end
+   if next(binaries) and not flags["source"] then    
+      print("Binary and pure-Lua rocks:")
+      print("--------------------------")
+      print()
+      print_results(binaries, true)
+   end
+   return true
+end
diff --git a/src/luarocks/type_check.lua b/src/luarocks/type_check.lua
new file mode 100644
index 00000000..ec9d6c5c
--- /dev/null
+++ b/src/luarocks/type_check.lua
@@ -0,0 +1,233 @@
+
+--- Type-checking functions.
+-- Functions and definitions for doing a basic lint check on files
+-- loaded by LuaRocks.
+module("luarocks.type_check", package.seeall)
+
+rockspec_format = "1.0"
+
+rockspec_types = {
+   rockspec_format = "string",
+   MUST_package = "string",
+   MUST_version = "string",
+   description = {
+      summary = "string",
+      detailed = "string",
+      homepage = "string",
+      license = "string",
+      maintainer = "string"
+   },
+   dependencies = {
+      platforms = {},
+      ANY = "string"
+   },
+   supported_platforms = {
+      ANY = "string"
+   },
+   external_dependencies = {
+      platforms = {},
+      ANY = {
+         program = "string",
+         header = "string",
+         library = "string"
+      }
+   },
+   MUST_source = {
+      platforms = {},
+      MUST_url = "string",
+      md5 = "string",
+      file = "string",
+      dir = "string",
+      tag = "string",
+      branch = "string",
+      cvs_tag = "string",
+      cvs_module = "string"
+   },
+   build = {
+      platforms = {},
+      type = "string",
+      install = {
+         lua = {
+            MORE = true
+         },
+         lib = {
+            MORE = true
+         },
+         conf = {
+            MORE = true
+         },
+         bin = {
+            MORE = true
+         }
+      },
+      copy_directories = {
+         ANY = "string"
+      },
+      MORE = true
+   },
+   hooks = {
+      platforms = {},
+      post_install = "string"
+   }
+}
+
+rockspec_types.build.platforms.ANY = rockspec_types.build
+rockspec_types.dependencies.platforms.ANY = rockspec_types.dependencies
+rockspec_types.external_dependencies.platforms.ANY = rockspec_types.external_dependencies
+rockspec_types.MUST_source.platforms.ANY = rockspec_types.MUST_source
+rockspec_types.hooks.platforms.ANY = rockspec_types.hooks
+
+manifest_types = {
+   MUST_repository = {
+      -- packages
+      ANY = {
+         -- versions
+         ANY = {
+            -- items
+            ANY = {
+               MUST_arch = "string",
+               modules = { ANY = "string" },
+               commands = { ANY = "string" },
+               dependencies = { ANY = "string" },
+               -- TODO: to be extended with more metadata.
+            }
+         }
+      }
+   },
+   MUST_modules = {
+      -- modules
+      ANY = {
+         -- providers
+         ANY = "string"
+      }
+   },
+   MUST_commands = {
+      -- modules
+      ANY = {
+         -- commands
+         ANY = "string"
+      }
+   },
+   dependencies = {
+      -- each module
+      ANY = {
+         -- each version
+         ANY = {
+            -- each dependency
+            ANY = {
+               name = "string",
+               constraints = {
+                  ANY = {
+                     no_upgrade = "boolean",
+                     op = "string",
+                     version = {
+                        string = "string",
+                        ANY = 0,
+                     }
+                  }
+               }
+            }
+         }
+      }
+   }
+}
+
+local type_check_table
+
+--- Type check an object.
+-- The object is compared against an archetypical value
+-- matching the expected type -- the actual values don't matter,
+-- only their types. Tables are type checked recursively.
+-- @param name any: The object name (for error messages).
+-- @param item any: The object being checked.
+-- @param expected any: The reference object. In case of a table,
+-- its is structured as a type reference table.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+-- @see type_check_table
+local function type_check_item(name, item, expected, context)
+   name = tostring(name)
+
+   local item_type = type(item)
+   local expected_type = type(expected)
+   if expected_type == "number" then
+      if not tonumber(item) then
+         return nil, "Type mismatch on field "..context..name..": expected a number"
+      end
+   elseif expected_type == "table" then
+      if item_type ~= expected_type then
+         return nil, "Type mismatch on field "..context..name..": expected a table"
+      else
+         return type_check_table(item, expected, context..name..".")
+      end
+   elseif item_type ~= expected_type then
+      return nil, "Type mismatch on field "..context..name..": expected a "..expected_type
+   end
+   return true
+end
+
+--- Type check the contents of a table.
+-- The table's contents are compared against a reference table,
+-- which contains the recognized fields, with archetypical values
+-- matching the expected types -- the actual values of items in the
+-- reference table don't matter, only their types (ie, for field x
+-- in tbl that is correctly typed, type(tbl.x) == type(types.x)).
+-- If the reference table contains a field called MORE, then
+-- unknown fields in the checked table are accepted.
+-- If it contains a field called ANY, then its type will be 
+-- used to check any unknown fields. If a field is prefixed
+-- with MUST_, it is mandatory; its absence from the table is
+-- a type error.
+-- Tables are type checked recursively.
+-- @param tbl table: The table to be type checked.
+-- @param types table: The reference table, containing
+-- values for recognized fields in the checked table.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+type_check_table = function(tbl, types, context)
+   assert(type(tbl) == "table")
+   assert(type(types) == "table")
+
+   for k, v in pairs(tbl) do
+      local t = types[k] or (type(k) == "string" and types["MUST_"..k]) or types.ANY
+      if t then 
+         local ok, err = type_check_item(k, v, t, context)
+         if not ok then return nil, err end
+      elseif types.MORE then
+         -- Accept unknown field
+      else
+         return nil, "Unknown field "..k
+      end
+   end
+   for k, v in pairs(types) do
+      local mandatory_key = k:match("^MUST_(.+)")
+      if mandatory_key then
+         if not tbl[mandatory_key] then
+            return nil, "Mandatory field "..context..mandatory_key.." is missing."
+         end
+      end
+   end
+   return true
+end
+
+--- Type check a rockspec table.
+-- Verify the correctness of elements from a 
+-- rockspec table, reporting on unknown fields and type
+-- mismatches.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+function type_check_rockspec(rockspec)
+   assert(type(rockspec) == "table")
+   return type_check_table(rockspec, rockspec_types, "")
+end
+
+--- Type check a manifest table.
+-- Verify the correctness of elements from a 
+-- manifest table, reporting on unknown fields and type
+-- mismatches.
+-- @return boolean or (nil, string): true if type checking
+-- succeeded, or nil and an error message if it failed.
+function type_check_manifest(manifest)
+   assert(type(manifest) == "table")
+   return type_check_table(manifest, manifest_types, "")
+end
diff --git a/src/luarocks/unpack.lua b/src/luarocks/unpack.lua
new file mode 100644
index 00000000..60bc1295
--- /dev/null
+++ b/src/luarocks/unpack.lua
@@ -0,0 +1,148 @@
+
+--- Module implementing the LuaRocks "unpack" command.
+-- Unpack the contents of a rock.
+module("luarocks.unpack", package.seeall)
+
+local fetch = require("luarocks.fetch")
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local build = require("luarocks.build")
+
+help_summary = "Unpack the contents of a rock."
+help_arguments = "{<rock>|<name> [<version>]}"
+help = [[
+Unpacks the contents of a rock in a newly created directory.
+Argument may be a rock file, or the name of a rock in a rocks server.
+In the latter case, the app version may be given as a second argument.
+]]
+
+--- Load a rockspec file to the given directory, fetches the source
+-- files specified in the rockspec, and unpack them inside the directory.
+-- @param rockspec_file string: The URL for a rockspec file.
+-- @param dir_name string: The directory where to store and unpack files.
+-- @return table or (nil, string): the loaded rockspec table or 
+-- nil and an error message.
+local function unpack_rockspec(rockspec_file, dir_name)
+   assert(type(rockspec_file) == "string")
+   assert(type(dir_name) == "string")
+   
+   local rockspec = fetch.load_rockspec(rockspec_file)
+   if not rockspec then
+      return nil, "Failed loading rockspec "..rockspec_file
+   end
+   fs.change_dir(dir_name)
+   local ok, sources_dir = fetch.fetch_sources(rockspec, true, ".")
+   if not ok then
+      return nil, sources_dir
+   end
+   fs.change_dir(dir_name)
+   build.apply_patches(rockspec)
+   fs.pop_dir()
+   return rockspec
+end
+
+--- Load a .rock file to the given directory and unpack it inside it.
+-- @param rock_file string: The URL for a .rock file.
+-- @param dir_name string: The directory where to unpack.
+-- @return table or (nil, string): the loaded rockspec table or 
+-- nil and an error message.
+local function unpack_rock(rock_file, dir_name, kind)
+   assert(type(rock_file) == "string")
+   assert(type(dir_name) == "string")
+   
+   local ok, err = fetch.fetch_and_unpack_rock(rock_file, dir_name)
+   if not ok then
+      return nil, "Failed unzipping rock "..rock_file
+   end
+   fs.change_dir(dir_name)
+   local rockspec_file = dir_name..".rockspec"
+   local rockspec, err = fetch.load_rockspec(rockspec_file)
+   if not rockspec then
+      return nil, "Failed loading rockspec "..rockspec_file..": "..err
+   end
+   if kind == "src" then
+      if rockspec.source.file then
+         local ok, err = fs.unpack_archive(rockspec.source.file)
+         if not ok then
+            return nil, err
+         end
+         fs.change_dir(rockspec.source.dir)
+         build.apply_patches(rockspec)
+         fs.pop_dir()
+      end
+   end
+   return rockspec
+end
+
+--- Create a directory and perform the necessary actions so that
+-- the sources for the rock and its rockspec are unpacked inside it,
+-- laid out properly so that the 'make' command is able to build the module.
+-- @param file string: A rockspec or .rock URL.
+-- @return boolean or (nil, string): true if successful or nil followed
+-- by an error message.
+local function run_unpacker(file)
+   assert(type(file) == "string")
+   
+   local base_name = fs.base_name(file)
+   local dir_name, kind, extension = base_name:match("(.*)%.([^.]+)%.(rock)$")
+   if not extension then
+      dir_name, extension = base_name:match("(.*)%.(rockspec)$")
+      kind = "rockspec"
+   end
+   if not extension then
+      return nil, file.." does not seem to be a valid filename."
+   end
+   
+   if (fs.exists(dir_name)) then
+      return nil, "Directory "..dir_name.." already exists."
+   end
+   fs.make_dir(dir_name)
+   local rollback = util.schedule_function(fs.delete, fs.absolute_name(dir_name))
+
+   local rockspec, err
+   if extension == "rock" then
+      rockspec, err = unpack_rock(file, dir_name, kind)
+   elseif extension == "rockspec" then
+      rockspec, err = unpack_rockspec(file, dir_name)
+   end
+   if not rockspec then
+      return nil, err
+   end
+   if kind == "src" or kind == "rockspec" then
+      if rockspec.source.dir ~= "." then
+         local ok = fs.copy(rockspec.local_filename, rockspec.source.dir)
+         if not ok then
+            return nil, "Failed copying unpacked rockspec into unpacked source directory."
+         end
+      end
+      print()   
+      print("Done. You may now enter directory ")
+      print(fs.make_path(dir_name, rockspec.source.dir))
+      print("and type 'luarocks make' to build.")
+   end
+   util.remove_scheduled_function(rollback)
+   return true
+end
+
+--- Driver function for the "unpack" command.
+-- @param name string: may be a rock filename, for unpacking a 
+-- rock file or the name of a rock to be fetched and unpacked.
+-- @param version string or nil: if the name of a package is given, a
+-- version may also be passed.
+-- @return boolean or (nil, string): true if successful or nil followed
+-- by an error message.
+function run(...)
+   local flags, name, version = util.parse_flags(...)
+
+   assert(type(version) == "string" or not version)
+   if type(name) ~= "string" then
+      return nil, "Argument missing, see help."
+   end
+
+   if name:match(".*%.rock") or name:match(".*%.rockspec") then
+      return run_unpacker(name)
+   else
+      local search = require("luarocks.search")
+      return search.act_on_src_or_rockspec(run_unpacker, name, version)
+   end
+end
diff --git a/src/luarocks/util.lua b/src/luarocks/util.lua
new file mode 100644
index 00000000..50efaa9d
--- /dev/null
+++ b/src/luarocks/util.lua
@@ -0,0 +1,180 @@
+
+local global_env = _G
+
+--- Utility functions shared by other modules.
+-- Does not requires modules directly (only as locals
+-- inside specific functions) to avoid interdependencies,
+-- as this is used in the bootstrapping stage of luarocks.cfg.
+module("luarocks.util", package.seeall)
+
+local scheduled_functions = {}
+
+--- Schedule a function to be executed upon program termination.
+-- This is useful for actions such as deleting temporary directories
+-- or failure rollbacks.
+-- @param f function: Function to be executed.
+-- @param ... arguments to be passed to function.
+-- @return table: A token representing the scheduled execution,
+-- which can be used to remove the item later from the list.
+function schedule_function(f, ...)
+   assert(type(f) == "function")
+   
+   local item = { fn = f, args = {...} }
+   table.insert(scheduled_functions, item)
+   return item
+end
+
+--- Unschedule a function.
+-- This is useful for cancelling a rollback of a completed operation.
+-- @param table: The token representing the scheduled function that was
+-- returned from the schedule_function call.
+function remove_scheduled_function(item)
+   for k, v in pairs(scheduled_functions) do
+      if v == item then
+         table.remove(scheduled_functions, k)
+         return
+      end
+   end
+end
+
+--- Execute scheduled functions.
+-- Some calls create temporary files and/or directories and register
+-- corresponding cleanup functions. Calling this function will run
+-- these function, erasing temporaries.
+-- Functions are executed in the inverse order they were scheduled.
+function run_scheduled_functions()
+   local fs = require("luarocks.fs")
+   fs.change_dir_to_root()
+   for i = #scheduled_functions, 1, -1 do
+      local item = scheduled_functions[i]
+      item.fn(unpack(item.args))
+   end
+end
+
+--- Extract flags from an arguments list.
+-- Given string arguments, extract flag arguments into a flags set.
+-- For example, given "foo", "--tux=beep", "--bla", "bar", "--baz",
+-- it would return the following:
+-- {["bla"] = true, ["tux"] = "beep", ["baz"] = true}, "foo", "bar".
+function parse_flags(...)
+   local args = {...}
+   local flags = {}
+   for i = #args, 1, -1 do
+      local flag = args[i]:match("^%-%-(.*)")
+      if flag then
+         local var,val = flag:match("([a-z_%-]*)=(.*)")
+         if val then
+            flags[var] = val
+         else
+            flags[flag] = true
+         end
+         table.remove(args, i)
+      end
+   end
+   return flags, unpack(args)
+end
+
+--- Merges contents of src on top of dst's contents.
+-- @param dst Destination table, which will receive src's contents.
+-- @param src Table which provides new contents to dst.
+-- @see platform_overrides
+function deep_merge(dst, src)
+   for k, v in pairs(src) do
+      if type(v) == "table" then
+         if not dst[k] then
+            dst[k] = {}
+         end
+         deep_merge(dst[k], v)
+      else
+         dst[k] = v
+      end
+   end
+end
+
+--- Perform platform-specific overrides on a table.
+-- Overrides values of table with the contents of the appropriate
+-- subset of its "platforms" field. The "platforms" field should
+-- be a table containing subtables keyed with strings representing
+-- platform names. Names that match the contents of the global
+-- cfg.platforms setting are used. For example, if
+-- cfg.platforms= {"foo"}, then the fields of
+-- tbl.platforms.foo will overwrite those of tbl with the same
+-- names. For table values, the operation is performed recursively
+-- (tbl.platforms.foo.x.y.z overrides tbl.x.y.z; other contents of
+-- tbl.x are preserved).
+-- @param tbl table or nil: Table which may contain a "platforms" field;
+-- if it doesn't (or if nil is passed), this function does nothing.
+function platform_overrides(tbl)
+   assert(type(tbl) == "table" or not tbl)
+   
+   local cfg = require("luarocks.cfg")
+   
+   if not tbl then return end
+   
+   if tbl.platforms then
+      for _, platform in ipairs(cfg.platforms) do
+         local platform_tbl = tbl.platforms[platform]
+         if platform_tbl then
+            deep_merge(tbl, platform_tbl)
+         end
+      end
+   end
+   tbl.platforms = nil
+end
+
+--- Perform make-style variable substitutions on string values of a table.
+-- For every string value tbl.x which contains a substring of the format
+-- "$(XYZ)" will have this substring replaced by vars["XYZ"], if that field
+-- exists in vars. Only string values are processed; this function
+-- does not scan subtables recursively.
+-- @param tbl table: Table to have its string values modified.
+-- @param vars table: Table containing string-string key-value pairs 
+-- representing variables to replace in the strings values of tbl.
+function variable_substitutions(tbl, vars)
+   assert(type(tbl) == "table")
+   assert(type(vars) == "table")
+   
+   local updated = {}
+   for k, v in pairs(tbl) do
+      if type(v) == "string" then
+         updated[k] = v:gsub("%$%((%a[%a%d_]+)%)", vars)
+      end
+   end
+   for k, v in pairs(updated) do
+      tbl[k] = v
+   end
+end
+
+--- Return an array of keys of a table.
+-- @param tbl table: The input table.
+-- @return table: The array of keys.
+function keys(tbl)
+   local ks = {}
+   for k,_ in pairs(tbl) do
+      table.insert(ks, k)
+   end
+   return ks
+end
+
+-- The iterator function used internally by util.sortedpairs.
+-- @param tbl table: The table to be iterated.
+-- @param sort_function function or nil: An optional comparison function
+-- to be used by table.sort when sorting keys.
+-- @see sortedpairs
+local function sortedpairs_iterator(tbl, sort_function)
+   local ks = keys(tbl)
+   table.sort(ks, sort_function)
+   for _, k in ipairs(ks) do
+      coroutine.yield(k, tbl[k])
+   end
+end
+
+--- A table iterator generator that returns elements sorted by key,
+-- to be used in "for" loops.
+-- @param tbl table: The table to be iterated.
+-- @param sort_function function or nil: An optional comparison function
+-- to be used by table.sort when sorting keys.
+-- @return function: the iterator function.
+function sortedpairs(tbl, sort_function)
+   return coroutine.wrap(function() sortedpairs_iterator(tbl, sort_function) end)
+end
diff --git a/test/run_tests.sh b/test/run_tests.sh
new file mode 100755
index 00000000..aa06854f
--- /dev/null
+++ b/test/run_tests.sh
@@ -0,0 +1,76 @@
+#!/bin/bash
+
+if [ -e ./run_tests.sh ]
+then
+   cd ../src
+elif [ -d src ]
+then
+   cd src
+elif ! [ -d luarocks ]
+then
+   echo "Go to the src directory and run this."
+   exit 1
+fi
+
+if [ ! -d ../rocks ]
+then
+   echo "Downloading entire rocks repository for tests"
+   cd ..
+   wget -r -nH -np -R"index.*" http://luarocks.luaforge.net/rocks/
+   cd src
+fi
+
+rocks=(
+   `ls ../rocks/*.rockspec | grep -v luacom`
+   `ls ../rocks/*.src.rock | grep -v luacom`
+)
+
+bin/luarocks-admin make-manifest ../rocks || exit 1
+
+[ "$1" ] && rocks=("$1")
+
+TRY() {
+   "$@" || {
+      echo "Failed running: $@"
+      exit 1
+   }
+}
+
+list_search() {
+   bin/luarocks list $name | grep $version
+}
+
+for rock in "${rocks[@]}"
+do
+   base=`basename $rock`
+   baserockspec=`basename $rock .rockspec`
+   basesrcrock=`basename $rock .src.rock`
+   if [ "$base" != "$baserockspec" ]
+   then
+      base=$baserockspec
+      name=`echo $base | sed 's/\(.*\)-[^-]*-[^-]*$/\1/'`
+      version=`echo $base | sed 's/.*-\([^-]*-[^-]*\)$/\1/'`
+      TRY bin/luarocks pack $rock
+      TRY bin/luarocks build $base.src.rock
+      TRY rm $base.src.rock
+   else
+      base=$basesrcrock
+      name=`echo $base | sed 's/\(.*\)-[^-]*-[^-]*$/\1/'`
+      version=`echo $base | sed 's/.*-\([^-]*-[^-]*\)$/\1/'`
+      TRY bin/luarocks build $rock
+   fi
+   TRY bin/luarocks pack $name $version
+   TRY bin/luarocks install $base.*.rock
+   TRY rm $base.*.rock
+   TRY list_search $name $version
+   bin/luarocks remove $name $version
+   # TODO: differentiate between error and dependency block.
+done
+
+if bin/luarocks install nonexistant | grep "No results"
+then echo "OK, got expected error."
+else exit 1
+fi
+
+TRY ../test/test_deps.lua
+TRY ../test/test_require.lua
diff --git a/test/test_deps.lua b/test/test_deps.lua
new file mode 100644
index 00000000..7236273c
--- /dev/null
+++ b/test/test_deps.lua
@@ -0,0 +1,67 @@
+#!/usr/bin/env lua
+
+deps = require "luarocks.deps"
+
+print(deps.show_dep(deps.parse_dep("lfs 2.1.9pre5"), true))
+print(deps.show_dep(deps.parse_dep("cgilua cvs-2"), true))
+print(deps.show_dep(deps.parse_dep("foobar 0.0.1beta"), true))
+print(deps.show_dep(deps.parse_dep("foobar 0.0.1a"), true))
+
+print(deps.show_dep(deps.parse_dep("foobar 1"), true))
+print(deps.show_dep(deps.parse_dep("foobar 2.0"), true))
+print(deps.show_dep(deps.parse_dep("foobar 3.5a4"), true))
+print(deps.show_dep(deps.parse_dep("foobar 1.1pre2"), true))
+print(deps.show_dep(deps.parse_dep("foobar 2.0-beta3"), true))
+print(deps.show_dep(deps.parse_dep("foobar 5.3"), true))
+print(deps.show_dep(deps.parse_dep("foobar 3.5rc2"), true))
+print(deps.show_dep(deps.parse_dep("foobar 4.19p"), true))
+
+print()
+comparisons = {
+--  first       second      eq     le
+   {"Vista",   "XP",       false, true},
+   {"XP",      "3.1",       false, true},
+   {"1.0",      "1.0",      true,  false},
+   {"2.2.10",   "2.2-10",   false, false},
+   {"2.2",      "2.2-10",   true,  false},
+   {"1.0beta1", "1.0rc3",   false, true},
+   {"2.0beta3", "2.0",      false, true},
+   {"2.0beta", "2.0beta2",  false, true},
+   {"2.0beta4", "2.0beta3", false, false},
+   {"2.1alpha1", "2.0beta1", false, false},
+   {"1.5p3",    "1.5.1",    false, true},
+   {"1.1.3",    "1.1.3a",   false, true},
+   {"1.5a100",  "1.5b1",    false, true},
+   {"2.0alpha100", "2.0beta1", false, true},
+   {"2.0.0beta3", "2.0beta2", false, false},
+   {"2.0-1", "2.0-2", false, true},
+   {"2.0-2", "2.0-1", false, false},
+   --[[
+   -- Corner cases I don't wish to handle by now.
+   {"2.0.0beta2", "2.0beta2", true, true},
+   {"2.0.0beta2", "2.0beta3", false, true},
+   ]]
+}
+
+local v1, v2
+
+err = false
+
+function result(test, expected)
+   if test == expected then
+      print(test, "OK")
+   else
+      print(test, "ERROR", deps.show_version(v1, true), deps.show_version(v2, true))
+      err = true
+   end
+end
+
+for _, c in ipairs(comparisons) do
+   v1, v2 = deps.parse_version(c[1]), deps.parse_version(c[2])
+   print(c[1].." == "..c[2].." ?")
+   result(v1 == v2, c[3])
+   print(c[1].." < "..c[2].." ?")
+   result(v1 < v2, c[4])
+end
+
+if err then os.exit(1) end
diff --git a/test/test_require.lua b/test/test_require.lua
new file mode 100755
index 00000000..2a652d29
--- /dev/null
+++ b/test/test_require.lua
@@ -0,0 +1,25 @@
+#!/usr/bin/env lua
+
+local luarocks = require("luarocks.require")
+
+luarocks.set_context("cgilua", "cvs-2")
+
+print(package.path)
+
+print(package.cpath)
+
+local socket = require("socket")
+if not socket then os.exit(1) end
+print(socket, socket._VERSION)
+
+local socket2 = require("socket")
+if not socket2 then os.exit(1) end
+print(socket2, socket2._VERSION)
+
+local mime = require("mime")
+if not mime then os.exit(1) end
+print(mime, mime._VERSION)
+
+local socket = require("lfs")
+if not lfs then os.exit(1) end
+print(lfs, lfs._VERSION)