Merge branch 'import' into 'master'HEADmaster

Import from specing's attoconf branch

See merge request legacy/attobuild!1

22 files changed, 2253 insertions, 0 deletions

diff --git a/attoconf/__init__.py b/attoconf/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/attoconf/__init__.py
diff --git a/attoconf/_version.py b/attoconf/_version.py
new file mode 100644
index 0000000..d4930e4
--- /dev/null
+++ b/attoconf/_version.py
@@ -0,0 +1,18 @@
+# Implementation of Semantic Versioning
+# This file should change in every single commit.
+
+# Incremented for releases with incompatible API changes.
+# 0 is special, for initial releases with no real guarantees.
+major = 0
+
+# Incremented for releases with compatible API additions.
+# This is the number that is usually incremented.
+minor = 10
+
+# Incremented if there is a bugfix release.
+# Might not be contiguous.
+patch = 0
+
+# Reserved for distributors and forks.
+# Contains arbitrary text, but no parentheses or newlines.
+distributor = 'Vanilla'
diff --git a/attoconf/classy.py b/attoconf/classy.py
new file mode 100644
index 0000000..33c9c40
--- /dev/null
+++ b/attoconf/classy.py
@@ -0,0 +1,157 @@
+#   Copyright 2013-2015 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+from .core import Project, Build
+
+class PolymorphicSlotMergerMetaclass(type):
+
+    def __new__(meta, name, bases, dct):
+        if '__slots__' not in dct:
+            s = ()
+            for b in bases:
+                s2 = b.__dict__.get('_merge_slots_', ())
+                if isinstance(s2, str):
+                    s2 = (s2,)
+                s += s2
+            s += dct.get('_merge_slots_', ())
+            dct['__slots__'] = s
+        else:
+            assert dct['__slots__'] == ()
+        return type.__new__(meta, name, bases, dct)
+
+    # TODO: remove *args for 1.0
+    def __call__(cls, *args, **kwargs):
+        instance = type.__call__(cls, *args, **kwargs)
+        if 'package' in kwargs or not isinstance(instance,
+                __import__('attoconf.lib.install', fromlist=['Install']).Install):
+            instance._do_jiggle()
+        return instance
+
+
+# TODO: remove this for 1.0
+def add_slots(cls):
+    return cls
+
+class ClassyProject(Project, metaclass=PolymorphicSlotMergerMetaclass):
+    ''' A more convenient, objectish, way of setting up a project.
+    '''
+    __slots__ = ()
+    _merge_slots_ = ()
+
+    def __init__(self, srcdir):
+        super(ClassyProject, self).__init__(srcdir)
+
+    # TODO: remove this for 1.0
+    def jiggle(self):
+        pass
+
+    def _do_jiggle(self):
+        self.order.append(None)
+        self.general()
+        self.order.append(None)
+        self.paths()
+        self.order.append(None)
+        self.arches()
+        self.order.append(None)
+        self.vars()
+        self.order.append(None)
+        self.features()
+        self.order.append(None)
+        self.packages()
+        self.order.append(None)
+
+        if 0:
+            self.tests()
+            self.order.append(None)
+        self.post()
+        self.order.append(None)
+
+    def general(self):
+        ''' Registration hook for general options (usually unneeded).
+        '''
+        self.add_help('General:', hidden=False)
+        self.add_alias('--help', ['--help=default'],
+                help='display standard help, then exit', hidden=False)
+        self.add_option('--help', init='none',
+                type=self.do_help, check=None,
+                help='just display some kind of help instead of configuring', hidden=False,
+                help_var='KIND')
+        self.help.add_option('--help=hidden',
+                help='display help you should never ever ever care about',
+                hidden=False)
+
+    def paths(self):
+        ''' Registration hook for path-related options.
+            (--prefix, --bindir, etc)
+
+            Probably only used by attoconf.lib.install.
+        '''
+
+    def arches(self):
+        ''' Registration hook for arch-related options.
+            (--build, --host, and sometimes --target)
+
+            Typically this changes the prefix of the compiler.
+        '''
+
+    def vars(self):
+        ''' Environment variables (usually capital, don't start with a --).
+
+            Usually there is one or two of these for every program needed.
+        '''
+        self.add_help('Environment Variables:', hidden=False)
+
+    def features(self):
+        ''' Customizations for this package (--enable-*).
+        '''
+        self.add_help('Optional Features:', hidden=False)
+        # TODO add '--disable-option-checking'
+        self.help.add_option('--disable-FEATURE',
+                help='do not include FEATURE (same as --enable-FEATURE=no)',
+                hidden=False)
+        self.help.add_option('--enable-FEATURE',
+                help='include FEATURE (same as --enable-FEATURE=yes)',
+                hidden=False)
+
+    def packages(self):
+        ''' Settings related to dependencies (--with-*).
+        '''
+        self.add_help('Optional Packages:', hidden=False)
+        self.help.add_option('--with-PACKAGE',
+                help='use PACKAGE (same as --with-PACKAGE=yes)',
+                hidden=False)
+        self.help.add_option('--without-PACKAGE',
+                help='do not use PACKAGE (same as --with-PACKAGE=no)',
+                hidden=False)
+
+    if 0: # not sure if really needed
+        def tests(self):
+            ''' Late tests, but still before post.
+
+            '''
+
+    def post(self):
+        ''' Special hook for things that need to be done at the very end.
+
+            attoconf.post.make
+        '''
+
+    # okay, no more registration hooks
+    def build(self, bindir):
+        return Build(self, bindir)
diff --git a/attoconf/core.py b/attoconf/core.py
new file mode 100644
index 0000000..efc952b
--- /dev/null
+++ b/attoconf/core.py
@@ -0,0 +1,239 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+from collections import namedtuple, OrderedDict
+import os
+import sys
+
+from .help import Help
+
+# Nothing to see here. Move along.
+Option = namedtuple('Option', ['type', 'init'])
+class ArgumentError(Exception): pass
+
+def as_var(name):
+    return name.lstrip('-').replace('-', '_').upper()
+
+def trim_trailing_slashes(path):
+    p, s = os.path.split(path)
+    if not s:
+        return p
+    return path
+
+class Project(object):
+    ''' A Project is a directory and the list of options that can be set.
+    '''
+    __slots__ = (
+            'srcdir',
+            'aliases',
+            'options',
+            'help',
+            'order',
+            'checks',
+    )
+    def __init__(self, srcdir):
+        ''' A Project is initially constructed from just the source directory
+        '''
+        self.srcdir = trim_trailing_slashes(srcdir)
+        self.aliases = {}
+        self.options = {}
+        self.help = Help()
+        self.order = []
+        self.checks = []
+
+    def add_help(self, text, hidden):
+        ''' Directly add a line of text to the help.
+        '''
+        self.help.add_text(text, hidden)
+
+    def add_alias(self, key, expansion, help, hidden):
+        ''' Add an alias.
+
+            This is necessary for anything to appear without an =.
+
+            The expansion is a list of other options, which may be aliases.
+        '''
+        if key in self.aliases:
+            raise KeyError(key)
+        expansion = list(expansion)
+        self.aliases[key] = expansion
+        if help is None:
+            help = 'alias for ' + ' '.join(expansion)
+        self.help.add_option(key, help, hidden)
+
+    def add_option(self, name, init, type, check,
+            help, hidden,
+            help_var=None, help_def=None):
+        ''' Add an actual option.
+
+            This must be passed with a =.
+
+            In the builder, the var will first be set to init.
+
+            If the argument is passed, the type hook is called immediately
+            to validate the argument.
+
+            The check hooks will be called at final time,
+            in the order they were added.
+
+            Additionally, a line of help is added, with additional formatting.
+        '''
+        if name in self.options:
+            raise KeyError(name)
+        var = as_var(name)
+        if check is not None:
+            assert type.__module__ == 'attoconf.types'
+        else:
+            # used by some tests ... should this be fixed there instead?
+            if help_var is None:
+                help_var = var
+        assert init is not None
+        init = type(init)
+        assert init is not None
+        self.options[name] = Option(init=init, type=type)
+        if check is not None:
+            self.order.append(var)
+            self.checks.append(
+                    lambda bld: check(bld, **{help_var: bld.vars[var]}))
+
+        if help_var is None:
+            help_var = var
+
+        if help_def is None:
+            help_def = init
+        assert help_def is not None
+        help = '%s [%s]' % (help, help_def)
+
+        if help_var != name:
+            help_opt = '%s=%s' % (name, help_var)
+        else:
+            help_opt = name
+        self.help.add_option(help_opt, help, hidden)
+
+    def do_help(self, opt):
+        ''' Pseudo type-hook to be registered for --help (calls sys.exit).
+        '''
+        if opt == 'none':
+            return opt
+        if opt == 'default':
+            hidden = False
+        elif opt == 'hidden':
+            hidden = True
+        else:
+            raise ValueError('Unknown value for opt: %r' % opt)
+        self.help.print(sys.stdout, hidden)
+        sys.exit()
+# sneaky
+Project.do_help.__module__ = 'attoconf.types'
+#Project.do_help.__func__.__module__ = 'attoconf.types'
+
+class Build(object):
+    ''' A Build is a directory and set of options applied to a Project.
+    '''
+    __slots__ = (
+            'builddir',
+            'project',
+            'vars',
+            '_seen_args',
+    )
+    def __init__(self, project, builddir):
+        ''' A Build is initially constructed from a project and a build dir.
+        '''
+        self.project = project
+        self.builddir = trim_trailing_slashes(builddir)
+        self.vars = {as_var(k): o.init
+                for (k, o) in project.options.items()}
+        self._seen_args = OrderedDict()
+
+    def apply_arg(self, arg):
+        ''' Parse a single argument, expanding aliases.
+        '''
+        alias = self.project.aliases.get(arg)
+        if alias is not None:
+            for e in alias:
+                # TODO: catch recursive aliases
+                # or should they be caught earlier?
+                self.apply_arg(e)
+            return
+
+        if '=' not in arg:
+            if arg in self.project.options:
+                raise ArgumentError('Option %s requires an argument' % arg)
+            elif arg.startswith('-'):
+                raise ArgumentError('Unknown option %s' % arg)
+            else:
+                raise ArgumentError('Unknown environment variable %s' % arg)
+
+        k, a = arg.split('=', 1)
+        if k in self._seen_args:
+            del self._seen_args[k]
+        self._seen_args[k] = a
+        opt = self.project.options.get(k)
+        if opt is None:
+            raise sys.exit('Unknown option %s' % k)
+        self.vars[as_var(k)] = opt.type(a)
+
+    def finish(self):
+        ''' With the current set of variables, run all the checks
+            and presumably produce some sort of output.
+        '''
+        for check in self.project.checks:
+            check(self)
+        status_file = os.path.join(self.builddir, 'config.status')
+        # open fd to control +x mode
+        status_fd = os.open(status_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o777)
+        with os.fdopen(status_fd, 'w') as status:
+            print('Generating config.status')
+            status.write('#!%s\n' % sys.executable)
+            status.write('import os\n')
+            status.write('import sys\n')
+            status.write('old_build_dir = os.path.dirname(sys.argv[0])\n')
+            status.write('configure = os.path.join(old_build_dir, %r, "configure")\n'
+                    % self.relative_source())
+            seen_args = ['='.join(kv) for kv in self._seen_args.items()]
+            status.write('os.execvp(configure, [configure] + %r + sys.argv[1:])\n'
+                    % seen_args)
+
+    def configure(self, args, env):
+        ''' First apply variables from the environment,
+            then call apply_arg() a bunch of times, then finish().
+        '''
+        for k in self.project.options:
+            if k != as_var(k):
+                continue
+            val = env.get(k)
+            if val is not None:
+                self._seen_args[k] = val
+                opt = self.project.options[k]
+                self.vars[as_var(k)] = opt.type(val)
+
+        for arg in args:
+            self.apply_arg(arg)
+
+        self.finish()
+
+    def relative_source(self):
+        ''' Return a relative path from the build tree to the source tree.
+        '''
+        srcdir = self.project.srcdir
+        builddir = self.builddir
+        if os.path.isabs(srcdir) or os.path.isabs(builddir):
+            return os.path.realpath(srcdir)
+        return os.path.relpath(os.path.realpath(srcdir),
+                os.path.realpath(builddir))
diff --git a/attoconf/help.py b/attoconf/help.py
new file mode 100644
index 0000000..a2379a6
--- /dev/null
+++ b/attoconf/help.py
@@ -0,0 +1,164 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+def put_line_in_width(file, line, width, indent):
+    ''' Print a line with wrapping.
+    '''
+    line = line.rstrip(' ')
+    if len(line) <= width or ' ' not in line.lstrip(' '):
+        # this is not just an optimization
+        file.writelines([line, '\n'])
+        return
+    line += ' '
+    indents = indent * ' '
+
+    initial_spaces = len(line) - len(line.lstrip(' '))
+    while line.lstrip():
+        space = line.rfind(' ', initial_spaces, width + 1)
+        if space == -1:
+            space = line.find(' ', initial_spaces)
+        if space == -1:
+            space = len(line)
+        file.writelines([line[:space], '\n'])
+        line = indents + line[space+1:].lstrip(' ')
+        initial_spaces = indent
+
+
+class HelpSection(object):
+    ''' A help section contains some header lines and some related options.
+    '''
+    __slots__ = (
+            'headers',
+            'options',
+    )
+    def __init__(self):
+        ''' Create an empty help section.
+        '''
+        self.headers = []
+        self.options = []
+
+    def add_text(self, text, hidden):
+        ''' Add a header line.
+        '''
+        self.headers.append((hidden, text))
+
+    def add_option(self, name, text, hidden):
+        ''' Add an option with its description.
+        '''
+        self.options.append((hidden, name, text))
+
+    def print(self, file, hidden, width):
+        ''' Format (some of) the help text prettily.
+        '''
+        if self.options:
+            for oh, name, ht in self.options:
+                if oh <= hidden:
+                    break
+            else:
+                return False
+
+        # options longer than this will be split into multiple lines
+        split_width = width / 4 - 2
+        # longest option
+        longest_opt = 0
+        for oh, name, ht in self.options:
+            if oh > hidden:
+                continue
+            l = len(name) + 2
+            if l > split_width:
+                continue
+            if l > longest_opt:
+                longest_opt = l
+        if longest_opt == 0:
+            longest_opt = int(split_width)
+
+        for oh, ht in self.headers:
+            if oh > hidden:
+                continue
+            put_line_in_width(file, ht, width, 0)
+
+        for oh, name, ht in self.options:
+            if oh > hidden:
+                continue
+            # no, it's not really that simple
+            if len(name) > longest_opt:
+                file.writelines(['  ', name, '\n'])
+                name = ''
+            line = '  %-*s%s' % (longest_opt, name, ht)
+            put_line_in_width(file, line, width, longest_opt + 2)
+
+        return True
+
+
+def detect_terminal_width(fd, DEFAULT_WIDTH=float('inf')):
+    ''' Detect the width of a terminal.
+    '''
+    import os
+    import shutil
+
+    if isinstance(fd, int):
+        try:
+            return os.get_terminal_size(fd)
+        except OSError(...):
+            return DEFAULT_WIDTH
+    else:
+        return shutil.get_terminal_size(fallback=(DEFAULT_WIDTH, 24)).columns
+
+
+class Help(object):
+    ''' Help collects the set of flavor text and option descriptions
+        related to arguments.
+    '''
+    __slots__ = (
+            'sections',
+    )
+    def __init__(self):
+        ''' Help does not take any arguments during construction.
+        '''
+        self.sections = []
+
+    def add_text(self, help, hidden):
+        ''' Add a header line.
+
+            This creates a new section if the last line wasn't a header.
+        '''
+        if not self.sections or self.sections[-1].options:
+            self.sections.append(HelpSection())
+        self.sections[-1].add_text(help, hidden)
+
+    def add_option(self, name, help, hidden):
+        ''' Add an option with its description to the current section.
+
+            This creates a new section only if it is first.
+        '''
+        if not self.sections:
+            self.sections.append(HelpSection())
+        self.sections[-1].add_option(name, help, hidden)
+
+    def print(self, file, hidden, width=0):
+        ''' Print all the help at the given level of hidden-ness.
+        '''
+        if width == 0:
+            width = detect_terminal_width(file)
+        if width < 20:
+            width = 80
+
+        for s in self.sections:
+            if s.print(file, hidden, width):
+                file.write('\n')
diff --git a/attoconf/lib/__init__.py b/attoconf/lib/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/attoconf/lib/__init__.py
diff --git a/attoconf/lib/arches.py b/attoconf/lib/arches.py
new file mode 100644
index 0000000..67a84bd
--- /dev/null
+++ b/attoconf/lib/arches.py
@@ -0,0 +1,60 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+from ..classy import ClassyProject
+from ..types import triple, maybe
+
+
+def build(build, BUILD):
+    pass
+
+def host(build, HOST):
+    if not HOST:
+        BUILD = build.vars['BUILD']
+        build.vars['HOST'] = BUILD
+
+def target(build, TARGET):
+    if not TARGET:
+        HOST = build.vars['HOST']
+        build.vars['TARGET'] = HOST
+
+class Arches2(ClassyProject):
+    __slots__ = ()
+
+    def arches(self):
+        super(Arches2, self).arches()
+        self.add_help('System types:', hidden=False)
+        self.add_option('--build', init='',
+                type=maybe(triple), check=build,
+                help='configure for building on BUILD', hidden=False,
+                help_def='native')
+        self.add_option('--host', init='',
+                type=maybe(triple), check=host,
+                help='cross-compile to build programs to run on HOST',
+                hidden=False, help_def='BUILD')
+
+# TODO figure out the mro implications when I use this
+class Arches3(Arches2):
+    __slots__ = ()
+    def arches(self):
+        super(Arches3, self).arches()
+        self.add_option('--target', init='',
+                type=maybe(triple), check=target,
+                help='configure for building compilers for TARGET',
+                hidden=False, help_def='HOST')
diff --git a/attoconf/lib/c.py b/attoconf/lib/c.py
new file mode 100644
index 0000000..98d88df
--- /dev/null
+++ b/attoconf/lib/c.py
@@ -0,0 +1,281 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import errno
+import os
+import subprocess
+
+from .arches import Arches2
+from ..types import ShellList
+
+class TestError(Exception):
+    pass
+
+def do_exec(build, args):
+    p = subprocess.Popen(args.list, cwd=build.builddir,
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT)
+    out, _ = p.communicate()
+    retcode = p.wait()
+    return retcode, out
+
+
+class TempFile:
+    ''' context manager that optionally creates and then removes a file
+    '''
+    __slots__ = ('filename')
+
+    def __init__(self, filename, content):
+        self.filename = filename
+        if content is not None:
+            with open(filename, 'x') as of:
+                of.write(content)
+        else:
+            # TODO: raise OSError(errno.EEXIST) if file already exists
+            pass
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, type, value, traceback):
+        try:
+            os.remove(self.filename)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+
+
+def try_compile_c(build, body, CFLAGS=[], CPPFLAGS=[]):
+    CC = build.vars['CC']
+    CFLAGS = build.vars['CFLAGS'] + CFLAGS
+    CPPFLAGS = build.vars['CPPFLAGS'] + CPPFLAGS
+    in_ = 'atto-test.c'
+    ins = [in_]
+    out = 'atto-test.o'
+
+    args = CC + CFLAGS + CPPFLAGS + ['-c', '-o', out, in_]
+    with TempFile(in_, body), TempFile(out, None):
+        status, error = do_exec(build, args)
+    if status:
+        raise TestError(error)
+
+def try_compile_link_c(build, body, CFLAGS=[], CPPFLAGS=[], LDFLAGS=[], LIBS=[]):
+    CC = build.vars['CC']
+    CFLAGS = build.vars['CFLAGS'] + CFLAGS
+    CPPFLAGS = build.vars['CPPFLAGS'] + CPPFLAGS
+    LDFLAGS = build.vars['LDFLAGS'] + LDFLAGS
+    LIBS = build.vars['LIBS'] + LIBS
+    in_ = 'atto-test.c'
+    ins = [in_]
+    out = 'atto-test'
+
+    args = CC + CFLAGS + CPPFLAGS + LDFLAGS + ins + LIBS + ['-o', out]
+    with TempFile(in_, body), TempFile(out, None):
+        status, error = do_exec(build, args)
+    if status:
+        raise TestError(error)
+
+def try_compile_cxx(build, body, CXXFLAGS=[], CPPFLAGS=[]):
+    CXX = build.vars['CXX']
+    CXXFLAGS = build.vars['CXXFLAGS'] + CXXFLAGS
+    CPPFLAGS = build.vars['CPPFLAGS'] + CPPFLAGS
+    in_ = 'atto-test.cxx'
+    out = 'atto-test.o'
+
+    args = CXX + CXXFLAGS + CPPFLAGS + ['-c', '-o', out, in_]
+    with TempFile(in_, body), TempFile(out, None):
+        status, error = do_exec(build, args)
+    if status:
+        raise TestError(error)
+
+def try_compile_link_cxx(build, body, CXXFLAGS=[], CPPFLAGS=[], LDFLAGS=[], LIBS=[]):
+    CXX = build.vars['CXX']
+    CXXFLAGS = build.vars['CXXFLAGS'] + CXXFLAGS
+    CPPFLAGS = build.vars['CPPFLAGS'] + CPPFLAGS
+    LDFLAGS = build.vars['LDFLAGS'] + LDFLAGS
+    LIBS = build.vars['LIBS'] + LIBS
+    in_ = 'atto-test.cxx'
+    ins = [in_]
+    out = 'atto-test'
+
+    args = CXX + CXXFLAGS + CPPFLAGS + LDFLAGS + ins + LIBS + ['-o', out]
+    with TempFile(in_, body), TempFile(out, None):
+        status, error = do_exec(build, args)
+    if status:
+        raise TestError(error)
+
+if 0:
+    def try_linkonly_c(build, ins, LDFLAGS=[], LIBS=[]):
+        CC = build.vars['CC']
+        LDFLAGS = build.vars['LDFLAGS'] + LDFLAGS
+        LIBS = build.vars['LIBS'] + LIBS
+        out = 'atto-test'
+
+        args = CC + LDFLAGS + ins + LIBS + ['-o', out]
+        with TempFile(out, None):
+            status, error = do_exec(build, args)
+        if status:
+            raise TestError(error)
+
+def try_compile_link2_c(build, body, CFLAGS=[], CPPFLAGS=[], LDFLAGS=[], LIBS=[]):
+    CC = build.vars['CC']
+    CFLAGS = build.vars['CFLAGS'] + CFLAGS
+    CPPFLAGS = build.vars['CPPFLAGS'] + CPPFLAGS
+    LDFLAGS = build.vars['LDFLAGS'] + LDFLAGS
+    LIBS = build.vars['LIBS'] + LIBS
+    in_ = 'atto-test.c'
+    ins = [in_]
+    mid = 'atto-test.o'
+    mids = [mid]
+    out = 'atto-test'
+
+    args1 = CC + CFLAGS + CPPFLAGS + ['-c', '-o', mid, in_]
+    args2 = CC + LDFLAGS + mids + LIBS + ['-o', out]
+    with TempFile(mid, None):
+        with TempFile(in_, body):
+            status, error = do_exec(build, args1)
+        if status:
+            raise TestError(error)
+
+        with TempFile(out, None):
+            status, error = do_exec(build, args2)
+        if status:
+            raise TestError(error)
+
+if 0:
+    def try_linkonly_cxx(build, ins, LDFLAGS=[], LIBS=[]):
+        CXX = build.vars['CXX']
+        LDFLAGS = build.vars['LDFLAGS'] + LDFLAGS
+        LIBS = build.vars['LIBS'] + LIBS
+        out = 'atto-test'
+
+        args = CXX + LDFLAGS + ins + LIBS + ['-o', out]
+        with TempFile(out, None):
+            status, error = do_exec(build, args)
+        if status:
+            raise TestError(error)
+
+def try_compile_link2_cxx(build, body, CXXFLAGS=[], CPPFLAGS=[], LDFLAGS=[], LIBS=[]):
+    CXX = build.vars['CXX']
+    CXXFLAGS = build.vars['CXXFLAGS'] + CXXFLAGS
+    CPPFLAGS = build.vars['CPPFLAGS'] + CPPFLAGS
+    LDFLAGS = build.vars['LDFLAGS'] + LDFLAGS
+    LIBS = build.vars['LIBS'] + LIBS
+    in_ = 'atto-test.cxx'
+    ins = [in_]
+    mid = 'atto-test.o'
+    mids = [mid]
+    out = 'atto-test'
+
+    args1 = CXX + CXXFLAGS + CPPFLAGS + ['-c', '-o', mid, in_]
+    args2 = CXX + LDFLAGS + mids + LIBS + ['-o', out]
+    with TempFile(mid, None):
+        with TempFile(in_, body):
+            status, error = do_exec(build, args1)
+        if status:
+            raise TestError(error)
+
+        with TempFile(out, None):
+            status, error = do_exec(build, args2)
+        if status:
+            raise TestError(error)
+
+
+def ldflags(build, LDFLAGS):
+    pass
+
+def libs(build, LIBS):
+    # compatibility
+    build.vars['LDLIBS'] = LIBS
+
+def cppflags(build, CPPFLAGS):
+    pass
+
+def cc(build, CC):
+    if CC.list == []:
+        HOST = build.vars['HOST']
+        if HOST:
+            build.vars['CC'].list = [HOST + '-gcc']
+        else:
+            build.vars['CC'].list = ['gcc']
+
+def cflags(build, CFLAGS):
+    try_compile_c(build, 'int main() {}\n')
+    try_compile_link_c(build, 'int main() {}\n')
+    try_compile_link2_c(build, 'int main() {}\n')
+
+def cxx(build, CXX):
+    if CXX.list == []:
+        HOST = build.vars['HOST']
+        if HOST:
+            build.vars['CXX'].list = [HOST + '-g++']
+        else:
+            build.vars['CXX'].list = ['g++']
+
+def cxxflags(build, CXXFLAGS):
+    try_compile_cxx(build, 'int main() {}\n')
+    try_compile_link_cxx(build, 'int main() {}\n')
+    try_compile_link2_cxx(build, 'int main() {}\n')
+
+class Link(Arches2):
+    __slots__ = ()
+    def vars(self):
+        super(Link, self).vars()
+        self.add_option('LDFLAGS', init=[],
+                type=ShellList, check=ldflags,
+                help='linker flags, e.g. -L<lib dir> if you have libraries in a nonstandard directory <lib dir>',
+                hidden=False)
+        self.add_option('LIBS', init=[],
+                type=ShellList, check=libs,
+                help='libraries to pass to the linker, e.g. -l<library>',
+                hidden=False)
+        self.order.append('LDLIBS') #TODO remove for 1.0
+
+class Preprocess(Arches2):
+    __slots__ = ()
+    def vars(self):
+        super(Preprocess, self).vars()
+        self.add_option('CPPFLAGS', init=[],
+                type=ShellList, check=cppflags,
+                help='C/C++/Objective C preprocessor flags, e.g. -I<include dir> if you have headers in a nonstandard directory <include dir>',
+                hidden=False)
+
+class C(Link, Preprocess):
+    __slots__ = ()
+    def vars(self):
+        super(C, self).vars()
+        self.add_option('CC', init=[],
+                type=ShellList, check=cc,
+                help='C compiler command', hidden=False,
+                help_def='HOST-gcc')
+        self.add_option('CFLAGS', init=['-O2', '-g'],
+                type=ShellList, check=cflags,
+                help='C compiler flags', hidden=False)
+
+class Cxx(Link, Preprocess):
+    __slots__ = ()
+    def vars(self):
+        super(Cxx, self).vars()
+        self.add_option('CXX', init=[],
+                type=ShellList, check=cxx,
+                help='C++ compiler command', hidden=False,
+                help_def='HOST-g++')
+        self.add_option('CXXFLAGS', init=['-O2', '-g'],
+                type=ShellList, check=cxxflags,
+                help='C++ compiler flags', hidden=False)
diff --git a/attoconf/lib/config_hash.py b/attoconf/lib/config_hash.py
new file mode 100644
index 0000000..b3cb423
--- /dev/null
+++ b/attoconf/lib/config_hash.py
@@ -0,0 +1,48 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+from hashlib import md5
+import os
+
+from ..classy import ClassyProject
+
+
+def calc_hash(build):
+    hash = md5()
+    for var, val in sorted(build.vars.items()):
+        hash.update(('%s = %s\n' % (var, val)).encode(encoding = 'UTF-8', errors = 'strict'))
+    return hash.hexdigest()
+
+
+def add_config_hash(build):
+    print('Generating a hash of config options ...')
+    build.vars['CONFIG_HASH'] = calc_hash(build)
+
+
+class ConfigHash(ClassyProject):
+    ''' Post hook add the build hash.
+
+        This should be run before any other post hooks.
+    '''
+    __slots__ = ()
+
+    def post(self):
+        self.order.insert(0, 'CONFIG_HASH')
+        self.checks.append(add_config_hash)
+        super(ConfigHash, self).post()
diff --git a/attoconf/lib/install.py b/attoconf/lib/install.py
new file mode 100644
index 0000000..04b5c5a
--- /dev/null
+++ b/attoconf/lib/install.py
@@ -0,0 +1,271 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import os
+
+from ..classy import ClassyProject
+from ..types import shell_word, filepath, quoted_string, maybe
+
+
+def package(build, PACKAGE):
+    pass
+
+def package_name(build, NAME):
+    pass
+
+def prefix(build, PREFIX):
+    pass
+
+def exec_prefix(build, EPREFIX):
+    if not EPREFIX:
+        PREFIX = build.vars['PREFIX']
+        build.vars['EXEC_PREFIX'] = PREFIX
+    build.vars['EPREFIX'] = build.vars['EXEC_PREFIX']
+
+def bindir(build, DIR):
+    if not DIR:
+        EPREFIX = build.vars['EPREFIX']
+        build.vars['BINDIR'] = os.path.join(EPREFIX, 'bin')
+
+def sbindir(build, DIR):
+    if not DIR:
+        EPREFIX = build.vars['EPREFIX']
+        build.vars['SBINDIR'] = os.path.join(EPREFIX, 'sbin')
+
+def libexecdir(build, DIR):
+    if not DIR:
+        EPREFIX = build.vars['EPREFIX']
+        build.vars['LIBEXECDIR'] = os.path.join(EPREFIX, 'libexec')
+
+def sysconfdir(build, DIR):
+    if not DIR:
+        PREFIX = build.vars['PREFIX']
+        build.vars['SYSCONFDIR'] = os.path.join(PREFIX, 'etc')
+
+def sharedstatedir(build, DIR):
+    if not DIR:
+        PREFIX = build.vars['PREFIX']
+        build.vars['SHAREDSTATEDIR'] = os.path.join(PREFIX, 'com')
+
+def localstatedir(build, DIR):
+    if not DIR:
+        PREFIX = build.vars['PREFIX']
+        build.vars['LOCALSTATEDIR'] = os.path.join(PREFIX, 'var')
+
+def libdir(build, DIR):
+    if not DIR:
+        EPREFIX = build.vars['EPREFIX']
+        build.vars['LIBDIR'] = os.path.join(EPREFIX, 'lib')
+
+def includedir(build, DIR):
+    if not DIR:
+        PREFIX = build.vars['PREFIX']
+        build.vars['INCLUDEDIR'] = os.path.join(PREFIX, 'include')
+
+def oldincludedir(build, DIR):
+    pass
+
+def datarootdir(build, DIR):
+    if not DIR:
+        PREFIX = build.vars['PREFIX']
+        build.vars['DATAROOTDIR'] = os.path.join(PREFIX, 'share')
+
+def datadir(build, DIR):
+    if not DIR:
+        DATAROOTDIR = build.vars['DATAROOTDIR']
+        build.vars['DATADIR'] = DATAROOTDIR
+
+def packagedatadir(build, DIR):
+    if not DIR:
+        DATADIR = build.vars['DATADIR']
+        PACKAGE = build.vars['PACKAGE']
+        build.vars['PACKAGEDATADIR'] = os.path.join(DATADIR, PACKAGE)
+
+def infodir(build, DIR):
+    if not DIR:
+        DATAROOTDIR = build.vars['DATAROOTDIR']
+        build.vars['INFODIR'] = os.path.join(DATAROOTDIR, 'info')
+
+def localedir(build, DIR):
+    if not DIR:
+        DATAROOTDIR = build.vars['DATAROOTDIR']
+        build.vars['LOCALEDIR'] = os.path.join(DATAROOTDIR, 'locale')
+
+def mandir(build, DIR):
+    if not DIR:
+        DATAROOTDIR = build.vars['DATAROOTDIR']
+        build.vars['MANDIR'] = os.path.join(DATAROOTDIR, 'man')
+
+def docdir(build, DIR):
+    if not DIR:
+        DATAROOTDIR = build.vars['DATAROOTDIR']
+        PACKAGE = build.vars['PACKAGE']
+        build.vars['DOCDIR'] = os.path.join(DATAROOTDIR, 'doc', PACKAGE)
+
+def htmldir(build, DIR):
+    if not DIR:
+        DOCDIR = build.vars['DOCDIR']
+        build.vars['HTMLDIR'] = DOCDIR
+
+def dvidir(build, DIR):
+    if not DIR:
+        DOCDIR = build.vars['DOCDIR']
+        build.vars['DVIDIR'] = DOCDIR
+
+def pdfdir(build, DIR):
+    if not DIR:
+        DOCDIR = build.vars['DOCDIR']
+        build.vars['PDFDIR'] = DOCDIR
+
+def psdir(build, DIR):
+    if not DIR:
+        DOCDIR = build.vars['DOCDIR']
+        build.vars['PSDIR'] = DOCDIR
+
+
+class Install(ClassyProject):
+    __slots__ = ()
+    _merge_slots_ = ('package', 'package_name')
+
+    # Compatibility with configure written for attoconf < 0.7
+    # In attoconf 1.0, the positional srcdir argument will go away,
+    # the None default and the .set_package function will be removed.
+    # (Note: when bisecting, always force checkout attoconf!)
+    def __init__(self, srcdir, package=None, package_name=None, **kwargs):
+        super(Install, self).__init__(srcdir=srcdir, **kwargs)
+        self.set_package(package, package_name)
+
+    def set_package(self, package, package_name):
+        if package is not None:
+            assert self.package is None
+        self.package = package
+        self.package_name = package_name
+        if package is not None:
+            self._do_jiggle()
+
+    def general(self):
+        super(Install, self).general()
+        self.add_option('--package', init=self.package,
+                type=shell_word, check=package,
+                help='Short name of this package (don\'t change!)',
+                hidden=True)
+        self.add_option('--package-name', init=self.package_name,
+                type=quoted_string, check=package_name,
+                help='Long name of this package (don\'t change)',
+                hidden=True,
+                help_var='NAME')
+
+    def paths(self):
+        super(Install, self).paths()
+
+        self.add_help('Installation directories:', hidden=False)
+        self.add_option('--prefix', init='/usr/local',
+                type=filepath, check=prefix,
+                help='install architecture-independent files in PREFIX',
+                hidden=False)
+        self.add_option('--exec-prefix', init='',
+                type=maybe(filepath), check=exec_prefix,
+                help='install architecture-dependent files in EPREFIX',
+                hidden=False,
+                help_var='EPREFIX', help_def='PREFIX')
+        self.order.append('EPREFIX') # TODO remove for 1.0
+        self.order.append(None)
+
+        self.add_help('Fine tuning of the installation directories:',
+                hidden=False)
+        self.add_option('--bindir', init='',
+                type=maybe(filepath), check=bindir,
+                help='user executables', hidden=False,
+                help_var='DIR', help_def='EPREFIX/bin')
+        self.add_option('--sbindir', init='',
+                type=maybe(filepath), check=sbindir,
+                help='system admin executables', hidden=False,
+                help_var='DIR', help_def='EPREFIX/sbin')
+        self.add_option('--libexecdir', init='',
+                type=maybe(filepath), check=libexecdir,
+                help='program executables', hidden=False,
+                help_var='DIR', help_def='EPREFIX/libexec')
+        self.add_option('--sysconfdir', init='',
+                type=maybe(filepath), check=sysconfdir,
+                help='read-only single-machine data', hidden=False,
+                help_var='DIR', help_def='PREFIX/etc')
+        self.add_option('--sharedstatedir', init='',
+                type=maybe(filepath), check=sharedstatedir,
+                help='modifiable architecture-independent data', hidden=False,
+                help_var='DIR', help_def='PREFIX/com')
+        self.add_option('--localstatedir', init='',
+                type=maybe(filepath), check=localstatedir,
+                help='modifiable single-machine data', hidden=False,
+                help_var='DIR', help_def='PREFIX/var')
+        self.add_option('--libdir', init='',
+                type=maybe(filepath), check=libdir,
+                help='object code libraries', hidden=False,
+                help_var='DIR', help_def='EPREFIX/lib')
+        self.add_option('--includedir', init='',
+                type=maybe(filepath), check=includedir,
+                help='C header files', hidden=False,
+                help_var='DIR', help_def='PREFIX/include')
+        self.add_option('--oldincludedir', init='/usr/include',
+                type=filepath, check=oldincludedir,
+                help='C header files for non-gcc', hidden=False,
+                help_var='DIR')
+        self.add_option('--datarootdir', init='',
+                type=maybe(filepath), check=datarootdir,
+                help='read-only arch.-independent data root', hidden=False,
+                help_var='DIR', help_def='PREFIX/share')
+        self.add_option('--datadir', init='',
+                type=maybe(filepath), check=datadir,
+                help='read-only architecture-independent data', hidden=False,
+                help_var='DIR', help_def='DATAROOTDIR')
+        self.add_option('--packagedatadir', init='',
+                type=maybe(filepath), check=packagedatadir,
+                help='data specific to this package (please set datadir instead)', hidden=False,
+                help_var='DIR', help_def='DATADIR/PACKAGE')
+        self.add_option('--infodir', init='',
+                type=maybe(filepath), check=infodir,
+                help='info documentation', hidden=False,
+                help_var='DIR', help_def='DATAROOTDIR/info')
+        self.add_option('--localedir', init='',
+                type=maybe(filepath), check=localedir,
+                help='locale-dependent data', hidden=False,
+                help_var='DIR', help_def='DATAROOTDIR/locale')
+        self.add_option('--mandir', init='',
+                type=maybe(filepath), check=mandir,
+                help='man documentation', hidden=False,
+                help_var='DIR', help_def='DATAROOTDIR/man')
+        self.add_option('--docdir', init='',
+                type=maybe(filepath), check=docdir,
+                help='documentation root', hidden=False,
+                help_var='DIR', help_def='DATAROOTDIR/doc/PACKAGE')
+        self.add_option('--htmldir', init='',
+                type=maybe(filepath), check=htmldir,
+                help='html documentation', hidden=False,
+                help_var='DIR', help_def='DOCDIR')
+        self.add_option('--dvidir', init='',
+                type=maybe(filepath), check=dvidir,
+                help='dvi documentation', hidden=False,
+                help_var='DIR', help_def='DOCDIR')
+        self.add_option('--pdfdir', init='',
+                type=maybe(filepath), check=pdfdir,
+                help='pdf documentation', hidden=False,
+                help_var='DIR', help_def='DOCDIR')
+        self.add_option('--psdir', init='',
+                type=maybe(filepath), check=psdir,
+                help='ps documentation', hidden=False,
+                help_var='DIR', help_def='DOCDIR')
diff --git a/attoconf/lib/lex.py b/attoconf/lib/lex.py
new file mode 100644
index 0000000..27c2a7e
--- /dev/null
+++ b/attoconf/lib/lex.py
@@ -0,0 +1,34 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+from ..classy import ClassyProject
+from ..types import ShellList
+
+def flex(build, FLEX):
+    # TODO actually test it
+    pass
+
+class Flex(ClassyProject):
+    __slots__ = ()
+    def vars(self):
+        super(Flex, self).vars()
+        self.add_option('FLEX', init=['flex'],
+                type=ShellList, check=flex,
+                help='Lexical analyzer command',
+                hidden=False)
diff --git a/attoconf/lib/make.py b/attoconf/lib/make.py
new file mode 100644
index 0000000..ca70f34
--- /dev/null
+++ b/attoconf/lib/make.py
@@ -0,0 +1,87 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import os
+import sys
+
+from ..classy import ClassyProject
+from ..version import full_version
+
+blacklist = frozenset(''.join(chr(i) for i in range(0x20)) + '#$')
+def validate(s):
+    return s == s.strip() and not frozenset(s) & blacklist
+
+
+class MakeHook(object):
+    __slots__ = ('infile', 'outfile')
+    def __init__(self, infile, outfile):
+        self.infile = infile
+        self.outfile = outfile
+
+    def __call__(self, build):
+        if self.outfile is None:
+            # if there are multiple backends
+            print('Skipping generation of a makefile')
+            return
+        with open(os.path.join(build.builddir, self.outfile), 'w') as out:
+            print('Generating a makefile ...')
+            out.write('# This part was generated by %s\n' % full_version)
+            build.vars['SRC_DIR'] = build.relative_source()
+            for var in build.project.order:
+                if var is None:
+                    out.write('\n')
+                    continue
+                val = build.vars[var]
+                out.write('%s = %s\n' % (var, val))
+            if self.infile is not None:
+                out.write('# The rest was copied from %s\n' % self.infile)
+                infile = os.path.join(build.project.srcdir, self.infile)
+                with open(infile) as in_:
+                    for line in in_:
+                        assert line.endswith('\n')
+                        out.write(line)
+
+
+class Make(ClassyProject):
+    ''' Post hook to generate a Makefile from Makefile.in
+    '''
+    __slots__ = ()
+    _merge_slots_ = ('make_in', 'make_out')
+
+    # compatibility with attoconf < 0.7
+    def __init__(self, srcdir,
+            make_infile='Makefile.in',
+            make_outfile='Makefile',
+            **kwargs):
+        super(Make, self).__init__(srcdir=srcdir, **kwargs)
+        self.set_make_infile(make_infile)
+        self.set_make_outfile(make_outfile) # relative to build dir
+
+    def set_make_infile(self, ipath):
+        self.make_in = ipath
+
+    def set_make_outfile(self, opath):
+        self.make_out = opath
+
+    def post(self):
+        super(Make, self).post()
+        if 'SRC_DIR' in self.order:
+            sys.exit('ERROR: Incompatible generator hooks!')
+        self.order.insert(0, 'SRC_DIR')
+        self.checks.append(MakeHook(self.make_in, self.make_out))
diff --git a/attoconf/lib/pkg_config.py b/attoconf/lib/pkg_config.py
new file mode 100644
index 0000000..5bc846b
--- /dev/null
+++ b/attoconf/lib/pkg_config.py
@@ -0,0 +1,97 @@
+#   Copyright 2015 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import os
+import sys
+
+from ..classy import ClassyProject
+from ..types import enum, ShellList
+
+from .c import do_exec, TestError, C, Cxx
+
+
+yesno = enum('yes', 'no')
+
+def run_pkg_config(build, *args):
+    PKG_CONFIG = build.vars['PKG_CONFIG']
+    status, output = do_exec(build, PKG_CONFIG + list(args))
+    if status:
+        raise TestError(output)
+    return output.strip()
+
+def check_pkg_config(build, PKG_CONFIG):
+    version = run_pkg_config(build, '--version')
+    print('Found pkg-config: %s' % version)
+
+def package_check(build, package, **var):
+    assert len(var) == 1
+    _package, enabled = var.popitem()
+    enabled = enabled == 'yes'
+    modversion = run_pkg_config(build, '--modversion', package)
+    print("Found dependency '%s': %s" % (package, modversion))
+    cppflags = run_pkg_config(build, '--cflags-only-I', package)
+    cflags = run_pkg_config(build, '--cflags-only-other', package)
+    ldflags = run_pkg_config(build, '--libs-only-L', '--libs-only-other', package)
+    libs = run_pkg_config(build, '--libs-only-l', package)
+
+    build.vars['CPPFLAGS'] += cppflags
+    if 'CFLAGS' in build.vars:
+        build.vars['CFLAGS'] += cflags
+    if 'CXXFLAGS' in build.vars:
+        build.vars['CXXFLAGS'] += cflags
+    build.vars['LDFLAGS'] += ldflags
+    build.vars['LIBS'] += libs
+
+class PkgConfig(ClassyProject):
+    ''' Fill CFLAGS etc by pkg-config for dependencies.
+    '''
+    __slots__ = ()
+    _merge_slots_ = ('required_packages', 'optional_packages')
+
+    def __init__(self, required_packages, optional_packages, **kwargs):
+        assert isinstance(self, (C, Cxx))
+        super(PkgConfig, self).__init__(**kwargs)
+        self.required_packages = required_packages
+        self.optional_packages = optional_packages
+
+    def vars(self):
+        super(PkgConfig, self).vars()
+        self.add_option('PKG_CONFIG', init=['pkg-config'],
+                type=ShellList, check=check_pkg_config,
+                help='Tool to find dependencies', hidden=False)
+
+    def packages(self):
+        super(PkgConfig, self).packages()
+        for package in self.required_packages:
+            self._pkg_config_add_package(package, True)
+        for package in self.optional_packages:
+            self._pkg_config_add_package(package, False)
+
+    def _pkg_config_add_package(self, package, hidden):
+        positive = '--with-' + package
+        negative = '--without-' + package
+        #check = package_required_check if hidden else package_optional_check
+        check = lambda build, **kwargs: package_check(build, package, **kwargs)
+        level = 'required' if hidden else 'optional'
+        help = "Build with %s dependency '%s'" % (level, package)
+        self.add_option(positive, type=yesno, hidden=hidden, init='yes', check=check, help=help)
+        # TODO: instead reveal one of the aliases and hide the main
+        # this requires messing with help slightly
+        self.add_alias(positive, [positive + '=yes'], help=None, hidden=True)
+        self.add_alias(negative, [positive + '=no'], help=None, hidden=True)
diff --git a/attoconf/lib/templates.py b/attoconf/lib/templates.py
new file mode 100644
index 0000000..7c26133
--- /dev/null
+++ b/attoconf/lib/templates.py
@@ -0,0 +1,77 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import os
+import sys
+
+from ..classy import ClassyProject
+
+
+class TemplateHook(object):
+    __slots__ = ('outfiles')
+    def __init__(self, outfiles):
+        self.outfiles = outfiles
+
+    def __call__(self, build):
+        build.vars['SRC_DIR'] = build.relative_source()
+        unseen = set(build.project.order)
+        if None in unseen:
+            unseen.remove(None)
+        for outfile in self.outfiles:
+            infile = outfile + '.in'
+            print('Generating %s from %s' % (outfile, infile))
+            # by replacing all instances of @VARIABLE@ with the value
+
+            slurpee = open(os.path.join(build.project.srcdir, infile)).read()
+            for var in build.project.order:
+                if var is None:
+                    continue
+                val = build.vars[var]
+                key = '@' + var + '@'
+                if key not in slurpee:
+                    continue
+                if var in unseen:
+                    unseen.remove(var)
+                slurpee = slurpee.replace(key, str(val))
+            with open(os.path.join(build.builddir, outfile), 'w') as out:
+                out.write(slurpee)
+        if unseen:
+            print('WARNING: variables not used:')
+            print('  ' + '\n  '.join(unseen))
+        # lone @s may legitimately appear in the makefile.
+        # paired @s, which would be a forgotten subst, will be obvious.
+
+
+class Templates(ClassyProject):
+    ''' Post hook to generate output files from *.in templates
+    '''
+    __slots__ = ()
+    _merge_slots_ = ('template_files')
+
+    # this class didn't exist in attoconf < 0.7, no need for compatibility
+    def __init__(self, template_files, **kwargs):
+        super(Templates, self).__init__(**kwargs)
+        self.template_files = template_files
+
+    def post(self):
+        super(Templates, self).post()
+        if 'SRC_DIR' in self.order:
+            sys.exit('ERROR: Incompatible generator hooks!')
+        self.order.insert(0, 'SRC_DIR')
+        self.checks.append(TemplateHook(self.template_files))
diff --git a/attoconf/lib/yacc.py b/attoconf/lib/yacc.py
new file mode 100644
index 0000000..c3fd1de
--- /dev/null
+++ b/attoconf/lib/yacc.py
@@ -0,0 +1,34 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+from ..classy import ClassyProject
+from ..types import ShellList
+
+def bison(build, BISON):
+    # TODO actually test it
+    pass
+
+class Bison(ClassyProject):
+    __slots__ = ()
+    def vars(self):
+        super(Bison, self).vars()
+        self.add_option('BISON', init=['bison'],
+                type=ShellList, check=bison,
+                help='Lexical analyzer command',
+                hidden=False)
diff --git a/attoconf/tests/__init__.py b/attoconf/tests/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/attoconf/tests/__init__.py
diff --git a/attoconf/tests/test_core.py b/attoconf/tests/test_core.py
new file mode 100644
index 0000000..93aeaaf
--- /dev/null
+++ b/attoconf/tests/test_core.py
@@ -0,0 +1,139 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import unittest
+
+from attoconf.core import Project, Build
+from attoconf.types import uint, shell_word, shell_partial_word, maybe
+
+import os
+from io import StringIO
+import sys
+
+class ReplacingStdout(object):
+    __slots__ = ('old', 'new')
+    def __init__(self, new):
+        self.old = None
+        self.new = new
+    def __enter__(self):
+        self.old = sys.stdout
+        sys.stdout = self.new
+    def __exit__(self, type, value, traceback):
+        sys.stdout = self.old
+        del self.old
+
+class TestProject(unittest.TestCase):
+    def test_help(self):
+        proj = Project('foo')
+        proj.add_help('General:', False)
+        proj.add_alias('--help', ['--help=default'],
+                help='display standard help, then exit', hidden=False)
+        proj.add_option('--help', init='none',
+                type=proj.do_help, check=None,
+                help='display some subset of help', hidden=False,
+                help_var='TYPE')
+        proj.help.add_option('--help=hidden',
+                help='display help you should never ever ever care about',
+                hidden=True)
+        proj.add_option('--foo', init='asdf',
+                type=shell_word, check=None,
+                help='set frob target', hidden=False)
+        proj.add_option('--bar', init='',
+                type=maybe(shell_word), check=None,
+                help='set frob source', hidden=False,
+                help_def='FOO')
+
+        build = Build(proj, 'bar')
+
+        out = StringIO()
+        with ReplacingStdout(out):
+            with self.assertRaises(SystemExit):
+                build.apply_arg('--help')
+        self.assertEqual(out.getvalue(), '''
+General:
+  --help       display standard help, then exit
+  --help=TYPE  display some subset of help [none]
+  --foo=FOO    set frob target [asdf]
+  --bar=BAR    set frob source [FOO]
+
+'''[1:])
+
+        out = StringIO()
+        with ReplacingStdout(out):
+            with self.assertRaises(SystemExit):
+                build.apply_arg('--help=hidden')
+        self.assertEqual(out.getvalue(), '''
+General:
+  --help         display standard help, then exit
+  --help=TYPE    display some subset of help [none]
+  --help=hidden  display help you should never ever ever care about
+  --foo=FOO      set frob target [asdf]
+  --bar=BAR      set frob source [FOO]
+
+'''[1:])
+
+    def test_path(self):
+        proj = Project('foo/')
+        build = Build(proj, 'bar/')
+        self.assertEqual(build.project.srcdir, 'foo')
+        self.assertEqual(build.builddir, 'bar')
+        self.assertEqual(build.relative_source(), '../foo')
+
+    def test_configure(self):
+        def check_foo(bld, FOO):
+            self.assertEqual(FOO, 'B')
+        def check_bar(bld, BAR):
+            self.assertEqual(BAR, 1)
+        def check_qux(bld, QUX):
+            self.assertEqual(QUX, '')
+        def check_var(bld, VAR):
+            self.assertEqual(VAR, 'value')
+
+        proj = Project('.')
+        proj.add_alias('--alias', ['--foo=A', '--bar=1', '--foo=B'],
+                help=None, hidden=False)
+        proj.add_option('--foo', init='X',
+                type=shell_word, check=check_foo,
+                help='help for string foo', hidden=False)
+        proj.add_option('--bar', init=0,
+                type=uint, check=check_bar,
+                help='help for int bar', hidden=False)
+        proj.add_option('--qux', init='',
+                type=maybe(uint), check=check_qux,
+                help='help for int qux', hidden=False,
+                help_def='auto')
+        proj.add_option('VAR', init='',
+                type=shell_partial_word, check=check_var,
+                help='help for string VAR', hidden=False)
+
+        build = Build(proj, '.')
+        build.configure(['--alias'],
+                {
+                    'VAR': 'value',
+                    'QUX': 'a',
+                    '--qux': 'b',
+                })
+        os.remove('config.status')
+        self.assertEqual(build.vars,
+                {
+                    'FOO': 'B',
+                    'BAR': 1,
+                    'QUX': '',
+                    'VAR': 'value',
+                })
diff --git a/attoconf/tests/test_help.py b/attoconf/tests/test_help.py
new file mode 100644
index 0000000..60a9e49
--- /dev/null
+++ b/attoconf/tests/test_help.py
@@ -0,0 +1,195 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import unittest
+
+from attoconf.help import Help, HelpSection, put_line_in_width
+
+from io import StringIO
+
+class TestHelpSection(unittest.TestCase):
+    def test_basic(self):
+        sec = HelpSection()
+        sec.add_text('foo', False)
+        sec.add_option('--foo', 'FOO', True)
+        sec.add_text('bar', True)
+        sec.add_option('--bar', 'BAR', False)
+        self.assertEqual(sec.headers, [(False, 'foo'), (True, 'bar')])
+        self.assertEqual(sec.options, [(True, '--foo', 'FOO'), (False, '--bar', 'BAR')])
+
+        out = StringIO()
+        sec.print(out, False, float('inf'))
+        self.assertEqual(out.getvalue(), '''foo
+  --bar  BAR
+''')
+
+        out = StringIO()
+        sec.print(out, True, float('inf'))
+        self.assertEqual(out.getvalue(), '''foo
+bar
+  --foo  FOO
+  --bar  BAR
+''')
+
+    def test_width(self):
+        out = StringIO()
+        put_line_in_width(out, 'foo bar baz', float('inf'), 0)
+        self.assertEqual(out.getvalue(), 'foo bar baz\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'foo bar baz', 10, 0)
+        self.assertEqual(out.getvalue(), 'foo bar\nbaz\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'foo bar baz', 10, 2)
+        self.assertEqual(out.getvalue(), 'foo bar\n  baz\n')
+
+        out = StringIO()
+        put_line_in_width(out, '   foo bar baz', 10, 0)
+        self.assertEqual(out.getvalue(), '   foo bar\nbaz\n')
+
+        out = StringIO()
+        put_line_in_width(out, '    foo bar baz', 10, 0)
+        self.assertEqual(out.getvalue(), '    foo\nbar baz\n')
+
+        out = StringIO()
+        put_line_in_width(out, '    foo bar baz', 10, 3)
+        self.assertEqual(out.getvalue(), '    foo\n   bar baz\n')
+
+        out = StringIO()
+        put_line_in_width(out, '    foo bar baz', 10, 4)
+        self.assertEqual(out.getvalue(), '    foo\n    bar\n    baz\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'really-long-string', float('inf'), 0)
+        self.assertEqual(out.getvalue(), 'really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, '  really-long-string', float('inf'), 0)
+        self.assertEqual(out.getvalue(), '  really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'really-long-string', 10, 0)
+        self.assertEqual(out.getvalue(), 'really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, '  really-long-string', 10, 0)
+        self.assertEqual(out.getvalue(), '  really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'short really-long-string', float('inf'), 0)
+        self.assertEqual(out.getvalue(), 'short really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, '  short really-long-string', float('inf'), 0)
+        self.assertEqual(out.getvalue(), '  short really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'short really-long-string', 10, 0)
+        self.assertEqual(out.getvalue(), 'short\nreally-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, '  short really-long-string', 10, 0)
+        self.assertEqual(out.getvalue(), '  short\nreally-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, 'short really-long-string', 10, 1)
+        self.assertEqual(out.getvalue(), 'short\n really-long-string\n')
+
+        out = StringIO()
+        put_line_in_width(out, '  short really-long-string', 10, 1)
+        self.assertEqual(out.getvalue(), '  short\n really-long-string\n')
+
+    def test_print(self):
+        sec = HelpSection()
+        sec.add_option('--abcdefghijklmnopqrstuvwxyz',
+                'ABCDEFGHIJKLMNOPQRSTUVWXYZ', False)
+
+        out = StringIO()
+        sec.print(out, False, 80)
+        self.assertEqual(out.getvalue(), '''
+  --abcdefghijklmnopqrstuvwxyz
+                    ABCDEFGHIJKLMNOPQRSTUVWXYZ
+'''[1:])
+
+        sec.add_option('--foo', 'FOO', False)
+        sec.add_option('--frob', 'FROB', False)
+
+        out = StringIO()
+        sec.print(out, False, 80)
+        self.assertEqual(out.getvalue(), '''
+  --abcdefghijklmnopqrstuvwxyz
+          ABCDEFGHIJKLMNOPQRSTUVWXYZ
+  --foo   FOO
+  --frob  FROB
+'''[1:])
+
+        out = StringIO()
+        sec.print(out, False, float('inf'))
+        self.assertEqual(out.getvalue(), '''
+  --abcdefghijklmnopqrstuvwxyz  ABCDEFGHIJKLMNOPQRSTUVWXYZ
+  --foo                         FOO
+  --frob                        FROB
+'''[1:])
+
+
+class TestHelp(unittest.TestCase):
+    def test_print(self):
+        help = Help()
+        help.add_option('--invisible', 'You can\'t see this', True)
+        help.add_text('General:', False)
+        help.add_option('--help', 'show this', False)
+        help.add_option('--version', 'show that', True)
+        help.add_text('Other stuff:', False)
+        help.add_text('with long header:', True)
+        help.add_option('--foo-lets-make-it-long-just-because', 'I\'m bored', False)
+        help.add_text('Visibility:', False)
+        help.add_option('--sneaky', 'This may be surprising. It also works as a demonstration of multi-line wrapping, just because.', True)
+
+        out = StringIO()
+        help.print(out, True, 80)
+        self.assertEqual(out.getvalue(), '''
+  --invisible  You can't see this
+
+General:
+  --help     show this
+  --version  show that
+
+Other stuff:
+with long header:
+  --foo-lets-make-it-long-just-because
+                    I'm bored
+
+Visibility:
+  --sneaky  This may be surprising. It also works as a demonstration of
+            multi-line wrapping, just because.
+
+'''[1:])
+
+        out = StringIO()
+        help.print(out, False, 80)
+        self.assertEqual(out.getvalue(), '''
+General:
+  --help  show this
+
+Other stuff:
+  --foo-lets-make-it-long-just-because
+                    I'm bored
+
+'''[1:])
diff --git a/attoconf/tests/test_types.py b/attoconf/tests/test_types.py
new file mode 100644
index 0000000..14926ef
--- /dev/null
+++ b/attoconf/tests/test_types.py
@@ -0,0 +1,62 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import unittest
+
+from attoconf.types import enum, ShellList
+
+class TestEnum(unittest.TestCase):
+    def test_stuff(self):
+        foobar = enum('foo', 'bar')
+        foobar('foo')
+        foobar('bar')
+        with self.assertRaisesRegex(ValueError, "'baz' not in {foo, bar}"):
+            foobar('baz')
+
+class TestShell(unittest.TestCase):
+    def test_str(self):
+        sh0 = ShellList('\\ ')
+        self.assertEqual("' '", str(sh0))
+        self.assertEqual([' '], sh0.list)
+        sh1 = ShellList(' foo ')
+        self.assertEqual('foo', str(sh1))
+        self.assertEqual(['foo'], sh1.list)
+        sh2 = ShellList(' "foo bar " baz')
+        self.assertEqual("'foo bar ' baz", str(sh2))
+        self.assertEqual(['foo bar ', 'baz'], sh2.list)
+        sh3 = ShellList(""" "foo\\ bar\\"" 'baz\\ qux' ''\\''' frob\\ it """)
+        self.assertEqual("""'foo\\ bar"' 'baz\\ qux' ''"'"'' 'frob it'""", str(sh3))
+        self.assertEqual(['foo\\ bar"', 'baz\\ qux', "'", 'frob it'], sh3.list)
+
+    def test_list(self):
+        sh1 = ShellList(['foo'])
+        self.assertEqual('foo', str(sh1))
+        sh2 = ShellList(['foo bar ', 'baz'])
+        self.assertEqual("'foo bar ' baz", str(sh2))
+        sh3 = ShellList(['foo\\ bar"', 'baz\\ qux', "'", 'frob it'])
+        self.assertEqual('\'foo\\ bar"\' \'baz\\ qux\' \'\'"\'"\'\' \'frob it\'', str(sh3))
+
+    def test_add(self):
+        sh0 = ShellList('')
+        self.assertEqual(str(sh0 + sh0), '')
+        self.assertEqual((sh0 + sh0).list, [])
+        sh1 = ShellList(['foo bar', 'baz'])
+        self.assertEqual(str(sh0 + sh1), "'foo bar' baz")
+        self.assertEqual((sh0 + sh1).list, sh1.list)
+        self.assertEqual(str(sh1 + sh1), "'foo bar' baz 'foo bar' baz")
diff --git a/attoconf/tests/test_version.py b/attoconf/tests/test_version.py
new file mode 100644
index 0000000..9967283
--- /dev/null
+++ b/attoconf/tests/test_version.py
@@ -0,0 +1,95 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import unittest
+
+from attoconf.version import require_version, full_version, part_version
+
+class TestVersion(unittest.TestCase):
+    def test_parse(self):
+        # don't do this
+        name, version, dist = full_version.split(' ', 2)
+        self.assertEqual(name, 'attoconf')
+        self.assertEqual(version, part_version)
+        major, minor, patch = [int(x) for x in version.split('.')]
+        assert dist.startswith('(')
+        assert dist.endswith(')')
+        dist = dist[1:-1]
+        assert '(' not in dist
+        assert ')' not in dist
+        assert '\n' not in dist
+        from attoconf._version import distributor
+        self.assertEqual(dist, distributor)
+
+    def test_check(self):
+        from attoconf._version import major, minor, patch
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor - 1, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor - 1, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor - 1, patch + 1)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor + 0, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor + 0, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor + 0, patch + 1)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor + 1, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor + 1, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major - 1, minor + 1, patch + 1)
+        if 1:
+            require_version(major + 0, minor - 1, patch - 1)
+        if 1:
+            require_version(major + 0, minor - 1, patch + 0)
+        if 1:
+            require_version(major + 0, minor - 1, patch + 1)
+        if 1:
+            require_version(major + 0, minor + 0, patch - 1)
+        if 1:
+            require_version(major + 0, minor + 0, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major + 0, minor + 0, patch + 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 0, minor + 1, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 0, minor + 1, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major + 0, minor + 1, patch + 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor - 1, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor - 1, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor - 1, patch + 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor + 0, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor + 0, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor + 0, patch + 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor + 1, patch - 1)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor + 1, patch + 0)
+        with self.assertRaises(SystemExit):
+            require_version(major + 1, minor + 1, patch + 1)
diff --git a/attoconf/types.py b/attoconf/types.py
new file mode 100644
index 0000000..e1af528
--- /dev/null
+++ b/attoconf/types.py
@@ -0,0 +1,129 @@
+#   Copyright 2013-2014 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import os
+from pipes import quote as shell_quote
+from shlex import split as shell_split
+
+from .core import trim_trailing_slashes
+
+
+class IntRange(object):
+    def __init__(self, min, max):
+        self.min = min
+        self.max = max
+
+    def __call__(self, s):
+        i = int(s)
+        if self.min <= i <= self.max:
+            return i
+        raise ValueError('%d is out of range' % i)
+
+sint = IntRange(float('-inf'), float('inf'))
+uint = IntRange(0, float('inf'))
+
+
+class enum(object):
+    __slots__ = ('args',)
+
+    def __init__(self, *args):
+        self.args = args
+
+    def __call__(self, s):
+        if s in self.args:
+            return s
+        raise ValueError('%r not in {%s}' % (s, ', '.join(self.args)))
+
+
+class maybe(object):
+    __slots__ = ('inferior')
+
+    def __init__(self, inferior):
+        self.inferior = inferior
+
+    def __call__(self, s):
+        if not s:
+            return s
+        return (self.inferior)(s)
+
+
+class ShellList(object):
+    ''' An argument type representing a sequence of 0 or more arguments
+    '''
+    __slots__ = ('list',)
+    def __init__(self, arg):
+        if isinstance(arg, str):
+            self.list = shell_split(arg)
+        elif isinstance(arg, list):
+            self.list = arg[:]
+        elif isinstance(arg, ShellList):
+            self.list = arg.list[:]
+        else:
+            raise TypeError('arg is an instance of %s' % type(arg).__name__)
+
+    def __str__(self):
+        return ' '.join(shell_quote(a) for a in self.list)
+
+    def __add__(self, other):
+        if isinstance(other, str):
+            other = shell_split(other)
+        elif isinstance(other, ShellList):
+            other = other.list
+        elif not isinstance(other, list):
+            raise TypeError('arg is an instance of %s' % type(arg).__name__)
+        return ShellList(self.list + other)
+
+
+def shell_word(s):
+    if s != shell_quote(s):
+        raise ValueError('not a word: %r' % s)
+    return s
+
+
+def shell_partial_word(s):
+    if s == '':
+        return s
+    return shell_word(s)
+
+
+def quoted_string(s):
+    return shell_quote(s)
+
+
+def filepath(s):
+    s = trim_trailing_slashes(s)
+    # must be absolute *and* canonical, except joinable
+    a = os.path.abspath(s)
+    if a == '/':
+        # filepaths often directly cat a subpath
+        # @me@/whatever is invalid if @me@ == /
+        a = '/.'
+    if s != a:
+        raise ValueError('Not an absolute, canonical (except joinable) pathname: %r != %r' % (s, a))
+    return s
+
+
+def triple(s):
+    # Triples do not, in fact, follow a regular pattern.
+    # Some have only two segments, some appear to have four ...
+    # Also, sometimes a wrong thing is used as a triple.
+    # All we *really* care about is generating the tool names.
+    if s.startswith('-') or s.endswith('-') or '-' not in s[1:-1]:
+        raise ValueError('Probably not a triple')
+    return s
diff --git a/attoconf/version.py b/attoconf/version.py
new file mode 100644
index 0000000..96db3e5
--- /dev/null
+++ b/attoconf/version.py
@@ -0,0 +1,66 @@
+#   Copyright 2013 Ben Longbons <b.r.longbons@gmail.com>
+#
+#   This file is part of attoconf.
+#
+#   attoconf is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   attoconf is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with attoconf.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+import sys
+
+from . import _version
+
+if sys.version_info[0] != 3 or sys.version_info[1] < 6:
+    sys.exit('Unsupported Python version: %s\nattoconf requires Python 3.6+' % sys.version)
+
+def require_version(major, minor, patch=0):
+    ''' Check that this is the right version of attoconf, or die trying.
+    '''
+    if major != _version.major:
+        # Once I release attoconf 1.0, I *probably* won't ever
+        # do another major upgrade - that would be difficult to package.
+        sys.exit(
+'''
+This configure script requires a different major version of attoconf.
+Major version changes are rare, and software written against the one
+version is likely to need changes to work with the other version.
+
+Current version: %s
+Minimum required version: %d.%d.%d
+''' % (full_version, major, minor, patch))
+    if minor > _version.minor:
+        # In the interest of good style, it sometimes *should* be rewritten.
+        sys.exit(
+'''
+This configure script requires a newer minor version of attoconf.
+Minor version changes are common, and software written against the one
+minor version will work with all later minor versions.
+
+Current version: %s
+Minimum required version: %d.%d.%d
+''' % (full_version, major, minor, patch))
+    if minor == _version.minor and patch > _version.patch:
+        sys.exit(
+'''
+This configure script requires a newer patch version of attoconf.
+Patch versions are usually not released unless there is a bug in a minor
+version, but it is possible that someone is using experimental features.
+If there is one, upgrade to the latest minor version instead.
+
+Current version: %s
+Minimum required version: %d.%d.%d
+''' % (full_version, major, minor, patch))
+
+part_version = '%d.%d.%d' % (_version.major, _version.minor, _version.patch)
+full_version = 'attoconf %s (%s)' % (part_version, _version.distributor)