diff --git a/src/hammer.cxx b/src/hammer.cxx
deleted file mode 100644
index e7f3cb7..0000000
--- a/src/hammer.cxx
+++ /dev/null
@@ -1,164 +0,0 @@
-#include "hammer.hxx"
-
-namespace hammer {
-
-  typedef variant<BytesResult, UintResult, IntResult, NullResult, SequenceResult> AnyResult;
-
-  const BytesResult::result_type BytesResult::result() { return _bytes; }
-  const UintResult::result_type UintResult::result() { return _uint; }
-  const IntResult::result_type IntResult::result() { return _sint; }
-  const SequenceResult::result_type SequenceResult::result() { return _seq; }
-
-  template<>
-  BytesResult Parser<BytesResult>::parse(const string &input) {
-    HParseResult *res = h_parse(_parser, reinterpret_cast<const uint8_t*>(input.c_str()), input.size());
-    return BytesResult(vector<uint8_t>(res->ast->bytes.token, res->ast->bytes.token+res->ast->bytes.len));
-  }
-
-  template<>
-  BytesResult Parser<BytesResult>::parse(const uint8_t *input, size_t length) {
-    HParseResult *res = h_parse(_parser, input, length);
-    return BytesResult(vector<uint8_t>(res->ast->bytes.token, res->ast->bytes.token+res->ast->bytes.len));
-  }
-
-  template<>
-  UintResult Parser<UintResult>::parse(const string &input) {
-    HParseResult *res = h_parse(_parser, reinterpret_cast<const uint8_t*>(input.c_str()), input.size());
-    return UintResult(res->ast->uint);
-  }
-
-  template<>
-  UintResult Parser<UintResult>::parse(const uint8_t *input, size_t length) {
-    HParseResult *res = h_parse(_parser, input, length);
-    return UintResult(res->ast->uint);
-  }
-
-  template<>
-  IntResult Parser<IntResult>::parse(const string &input) {
-    HParseResult *res = h_parse(_parser, reinterpret_cast<const uint8_t*>(input.c_str()), input.size());
-    return IntResult(res->ast->sint);
-  }
-
-  template<>
-  IntResult Parser<IntResult>::parse(const uint8_t *input, size_t length) {
-    HParseResult *res = h_parse(_parser, input, length);
-    return IntResult(res->ast->sint);
-  }
-
-  template<>
-  NullResult Parser<NullResult>::parse(const string &input) {
-    HParseResult *res = h_parse(_parser, reinterpret_cast<const uint8_t*>(input.c_str()), input.size());
-    return NullResult();
-  }
-
-  template<>
-  NullResult Parser<NullResult>::parse(const uint8_t *input, size_t length) {
-    HParseResult *res = h_parse(_parser, input, length);
-    return NullResult();
-  }
-
-  vector<AnyResult> make_seq(HCountedArray *seq) {
-    vector<AnyResult> ret;
-    for (size_t i=0; i<seq->used; ++i) {
-      switch(seq->elements[i]->token_type) {
-      case TT_NONE:
-	ret.push_back(NullResult());
-	break;
-      case TT_BYTES:
-	ret.push_back(BytesResult(vector<uint8_t>(seq->elements[i]->bytes.token, seq->elements[i]->bytes.token+seq->elements[i]->bytes.len)));
-	break;
-      case TT_SINT:
-	ret.push_back(IntResult(seq->elements[i]->sint));
-	break;
-      case TT_UINT:
-	ret.push_back(UintResult(seq->elements[i]->uint));
-	break;
-      case TT_SEQUENCE:
-	ret.push_back(make_seq(seq->elements[i]->seq));
-	break;
-      default:
-	//TODO some kind of error
-	break;
-      }
-    }
-    return ret;
-  }
-
-  template<>
-  SequenceResult Parser<SequenceResult>::parse(const string &input) {
-    HParseResult *res = h_parse(_parser, reinterpret_cast<const uint8_t*>(input.c_str()), input.size());
-    return SequenceResult(make_seq(res->ast->seq));
-  }
-
-  template<>
-  SequenceResult Parser<SequenceResult>::parse(const uint8_t *input, size_t length) {
-    HParseResult *res = h_parse(_parser, input, length);
-    return SequenceResult(make_seq(res->ast->seq));
-  }
-
-  template<class T>
-  Many<T> Parser<T>::many() {
-    return Many<T>(*this);
-  }
-
-  template<>
-  Many<UintResult> Parser<UintResult>::many() {
-    return Many<UintResult>(*this);
-  }
-
-  template<class T>
-  RepeatN Parser<T>::many(size_t n) {
-    return RepeatN(this, n);
-  }
-
-  template<class T>
-  Optional<T> Parser<T>::optional() {
-    return Optional<T>(this);
-  }
-
-  template<class T>
-  RepeatN Parser<T>::operator[](size_t n) {
-    return RepeatN(this, n);
-  }
-
-  IntRange<IntResult> Int64::in_range(const int64_t lower, const int64_t upper) {
-    Int64 p = Int64();
-    return IntRange<IntResult>(p, lower, upper);
-  }
-
-  IntRange<IntResult> Int32::in_range(const int32_t lower, const int32_t upper) {
-    Int32 p = Int32();
-    return IntRange<IntResult>(p, lower, upper);
-  }
-
-  IntRange<IntResult> Int16::in_range(const int16_t lower, const int16_t upper) {
-    Int16 p = Int16();
-    return IntRange<IntResult>(p, lower, upper);
-  }
-
-  IntRange<IntResult> Int8::in_range(const int8_t lower, const int8_t upper) {
-    Int8 p = Int8();
-    return IntRange<IntResult>(p, lower, upper);
-  }
-
-  IntRange<UintResult> Uint64::in_range(const uint64_t lower, const uint64_t upper) {
-    Uint64 p = Uint64();
-    return IntRange<UintResult>(p, lower, upper);
-  }
-
-  IntRange<UintResult> Uint32::in_range(const uint32_t lower, const uint32_t upper) {
-    Uint32 p = Uint32();
-    return IntRange<UintResult>(p, lower, upper);
-  }
-
-  IntRange<UintResult> Uint16::in_range(const uint16_t lower, const uint16_t upper) {
-    Uint16 p = Uint16();
-    return IntRange<UintResult>(p, lower, upper);
-  }
-
-  IntRange<UintResult> Uint8::in_range(const uint8_t lower, const uint8_t upper) {
-    Uint8 p = Uint8();
-    return IntRange<UintResult>(p, lower, upper);
-  }
-  
-}
diff --git a/src/hammer.hxx b/src/hammer.hxx
deleted file mode 100644
index 8f3200c..0000000
--- a/src/hammer.hxx
+++ /dev/null
@@ -1,491 +0,0 @@
-#ifndef HAMMER_HAMMER__HXX
-#define HAMMER_HAMMER__HXX
-
-#include "hammer.h"
-#include <list>
-#include <string>
-#include <vector>
-#include <boost/variant.hpp>
-
-using std::list; using std::string; using std::vector;
-using boost::variant;
-
-namespace hammer {
-
-  template<typename T>
-  class ParseResult {
-  public:
-    typedef T result_type;
-  protected:
-    ParseResult() { }
-  };
-
-  class BytesResult : public ParseResult<vector<uint8_t> > {
-  public:
-    typedef vector<uint8_t> result_type;
-    BytesResult(const vector<uint8_t> res) : _bytes(res) { }
-    const result_type result();
-  private:
-    BytesResult() { }
-    result_type _bytes;
-  };
-
-  class UintResult : public ParseResult<uint64_t> {
-  public:
-    typedef uint64_t result_type;
-    UintResult(const uint64_t res) : _uint(res) { }
-    const result_type result();
-  private:
-    UintResult() { }
-    result_type _uint;
-  };
-
-  class IntResult : public ParseResult<int64_t> {
-  public:
-    typedef int64_t result_type;
-    IntResult(const int64_t res) : _sint(res) { }
-    const result_type result();
-  private:
-    IntResult() { }
-    result_type _sint;
-  };
-
-  class NullResult: public ParseResult<void*> {
-  public:
-    NullResult() { }
-    typedef void* result_type;
-    const result_type result() { return NULL; }
-  };
-
-  class SequenceResult : public ParseResult<vector<variant<BytesResult, UintResult, IntResult, NullResult, SequenceResult> > > {
-  public:
-    typedef vector<variant<BytesResult, UintResult, IntResult, NullResult, SequenceResult> > result_type;
-    SequenceResult(result_type res) : _seq(res) { }
-    const result_type result();
-  private:
-    SequenceResult() { }
-    result_type _seq;
-  };
-
-  /* forward declarations */
-  template<class T> class Many;
-  class Many1;
-  template<class T> class Optional;
-  class RepeatN;
-  template<class T> class IntRange;
-
-  template<typename T>
-  class Parser {
-  public:
-    typedef T result_type;
-    result_type parse(const string &input);
-    result_type parse(const uint8_t *input, size_t length);
-    Many<T> many();
-    RepeatN many(size_t n);
-    Optional<T> optional();
-    RepeatN operator[](size_t n);
-    HParser* parser() { return _parser; }
-  protected:
-    HParser* _parser;
-    Parser() { }
-    //    Parser(const Parser &p) : _parser(p.parser()) { } // hopefully we don't need a copy constructor...
-  };
-
-  class Token : public Parser<BytesResult> {
-  public:
-    Token(string &str) : _tok(str) { 
-      _parser = h_token(reinterpret_cast<const uint8_t*>(str.c_str()), str.size());
-    }
-    Token(const uint8_t *str, size_t length) : _tok(reinterpret_cast<const char*>(str), length) {
-      _parser = h_token(str, length);
-    }
-  private:
-    string _tok;
-  };
-
-  class Ch : public Parser<UintResult> {
-  public:
-    friend class Parser;
-    Ch(const uint8_t c) : _c(c) {
-      _parser = h_ch(c);
-    }
-  private:
-    uint8_t _c;
-  };
-
-  class ChRange : public Parser<UintResult> {
-  public:
-    ChRange(const uint8_t lower, const uint8_t upper) : _lower(lower), _upper(upper) { 
-      _parser = h_ch_range(lower, upper); 
-    }
-  private:
-    uint8_t _lower, _upper;
-  };
-
-  class SignedBits : public Parser<IntResult> {
-  public:
-    SignedBits(size_t len) : _len(len) {
-      _parser = h_bits(len, true);
-    }
-  private:
-    size_t _len;
-  };
-
-  class UnsignedBits : public Parser<UintResult> {
-  public:
-    UnsignedBits(size_t len) : _len(len) {
-      _parser = h_bits(len, false);
-    }
-  private:
-    size_t _len;
-  };
-
-  class Int64 : public Parser<IntResult> {
-  public:
-    Int64() {
-      _parser = h_int64();
-    }
-    IntRange<IntResult> in_range(const int64_t lower, const int64_t upper);
-  };
-
-  class Int32 : public Parser<IntResult> {
-  public:
-    Int32() {
-      _parser = h_int32();
-    }
-    IntRange<IntResult> in_range(const int32_t lower, const int32_t upper);
-  };
-
-  class Int16 : public Parser<IntResult> {
-  public:
-    Int16() { 
-      _parser = h_int16();
-    }
-    IntRange<IntResult> in_range(const int16_t lower, const int16_t upper);
-  };
-
-  class Int8 : public Parser<IntResult> {
-  public:
-    Int8() {
-      _parser = h_int8();
-    }
-    IntRange<IntResult> in_range(const int8_t lower, const int8_t upper);
-  };
-
-  class Uint64 : public Parser<UintResult> {
-  public:
-    Uint64() {
-      _parser = h_uint64(); 
-    }
-    IntRange<UintResult> in_range(const uint64_t lower, const uint64_t upper);
-  };
-
-  class Uint32 : public Parser<UintResult> {
-  public:
-    Uint32() { 
-      _parser = h_uint32();
-    }
-    IntRange<UintResult> in_range(const uint32_t lower, const uint32_t upper);
-  };
-
-  class Uint16 : public Parser<UintResult> {
-  public:
-    Uint16() {
-      _parser = h_uint16(); 
-    }
-    IntRange<UintResult> in_range(const uint16_t lower, const uint16_t upper);
-  };
-
-  class Uint8 : public Parser<UintResult> {
-  public:
-    Uint8() { 
-      _parser = h_uint8();
-    } 
-    IntRange<UintResult> in_range(const uint8_t lower, const uint8_t upper);
-  };
-
-  template<class T>
-  class IntRange : public Parser<T> {
-  public:
-    IntRange(Parser<T> &p, const int64_t lower, const int64_t upper) : _p(p), _lower(lower), _upper(upper) {
-      this->_parser = h_int_range(p.parser(), lower, upper);
-    }
-  private:
-    Parser<T> _p;
-    int64_t _lower, _upper;
-  };
-
-  template<class T>
-  class Whitespace : public Parser<T> {
-  public:
-    typedef typename T::result_type result_type;
-    Whitespace(Parser<T> &p) : _p(p) {
-      this->_parser = h_whitespace(p.parser()); 
-    }
-  private: 
-    Parser<T> _p;
-  };
-
-  template<class T, class U>
-  class Left : public Parser<T> {
-  public:
-    typedef typename T::result_type result_type;
-    Left(Parser<T> &p, Parser<U> &q) : _p(p), _q(q) {
-      this->_parser = h_left(p.parser(), q.parser());
-    }
-  private:
-    Parser<T> _p;
-    Parser<U> _q;
-  };
-
-  template<class T, class U>
-  class Right : public Parser<U> {
-  public:
-    typedef typename U::result_type result_type;
-    Right(Parser<T> &p, Parser<U> &q) : _p(p), _q(q) {
-      this->_parser = h_right(p.parser(), q.parser());
-    }
-  private:
-    Parser<T> _p;
-    Parser<U> _q;
-  };
-
-  template <class T, class U, class V>
-  class Middle : public Parser<U> {
-  public:
-    typedef typename U::result_type result_type;
-    Middle(Parser<T> &p, Parser<U> &x, Parser<V> &q) : _p(p), _x(x), _q(q) {
-      this->_parser = h_middle(p.parser(), x.parser(), q.parser()); 
-    }
-  private:
-    Parser<T> _p;
-    Parser<U> _x;
-    Parser<V> _q;
-  };
-
-  /* what are we doing about h_action? */
-
-  class In : public Parser<UintResult> {
-  public:
-    In(string &charset) : _charset(charset) {
-      _parser = h_in(reinterpret_cast<const uint8_t*>(charset.c_str()), charset.size());
-    }
-    In(const uint8_t *charset, size_t length) : _charset(reinterpret_cast<const char*>(charset), length) {
-	_parser = h_in(charset, length);
-      }
-  private:
-    string _charset;
-  };
-
-  class NotIn : public Parser<UintResult> {
-  public:
-    NotIn(string &charset) : _charset(charset) {
-      _parser = h_not_in(reinterpret_cast<const uint8_t*>(charset.c_str()), charset.size());
-    }
-    NotIn(const uint8_t *charset, size_t length) : _charset(reinterpret_cast<const char*>(charset), length) {
-      _parser = h_not_in(charset, length);
-    }
-  private:
-    string _charset;
-  };
-
-  class End : public Parser<NullResult> {
-  public:
-    End() {
-      _parser = h_end_p();
-    }
-  };
-
-  class Nothing : public Parser<NullResult> {
-  public:
-    Nothing() {
-      _parser = h_nothing_p();
-    } 
-  };
-
-  class Sequence : public Parser<SequenceResult> {
-    friend class Parser;
-  public:
-    Sequence(list<Parser> &ps) : _ps(ps) { 
-      void *parsers[ps.size()];
-      size_t i = 0;
-      for (list<Parser>::iterator it=ps.begin(); it != ps.end(); ++it, ++i) {
-	parsers[i] = const_cast<HParser*>(it->parser());
-      }
-      _parser = h_sequence__a(parsers);
-    }
-    // maybe also a begin and end iterator version
-  private:
-    list<Parser> _ps;
-  };
-
-  class Choice : public Parser<SequenceResult> {
-  public:
-    Choice(list<Parser<SequenceResult> > &ps) : _ps(ps) { 
-      void *parsers[ps.size()];
-      size_t i = 0;
-      for (list<Parser<SequenceResult> >::iterator it=ps.begin(); it != ps.end(); ++it, ++i) {
-	parsers[i] = const_cast<HParser*>(it->parser());
-      }
-      _parser = h_choice__a(parsers);      
-    }
-  private:
-    list<Parser<SequenceResult> > _ps;
-  };
-
-  template<class T, class U>
-  class ButNot : public Parser<T> {
-  public:
-    typedef typename T::result_type result_type;
-    ButNot(Parser<T> &p, Parser<U> &q) : _p(p), _q(q) {
-      this->_parser = h_butnot(p.parser(), q.parser());
-    }
-  private:
-    Parser<T> _p;
-    Parser<U> _q;
-  };
-
-  template<class T, class U>
-  class Difference : public Parser<T> {
-  public:
-    typedef typename T::result_type result_type;
-    Difference(Parser<T> &p, Parser<U> &q) : _p(p), _q(q) {
-      this->_parser = h_difference(p.parser(), q.parser());
-    }
-  private:
-    Parser<T> _p;
-    Parser<U> _q;
-  };
-
-  template<class T, class U>
-  class Xor : public Parser<variant<T, U> > {
-  public:
-    typedef variant<T, U> result_type;
-    Xor(Parser<T> &p, Parser<U> &q) : _p(p), _q(q) {
-      this->_parser = h_xor(p.parser(), q.parser());
-    }
-  private:
-    Parser<T> _p;
-    Parser<U> _q;
-  };
-
-  template<class T>
-  class Many : public Parser<SequenceResult> {
-  public:
-    Many(Parser<T> &p) : _p(p) {
-      _parser = h_many(p.parser());
-    }
-  private:
-    Parser<T> _p;
-  };
-
-  class Many1 : public Parser<SequenceResult> {
-  public:
-    Many1(Parser &p) : _p(p) {
-      _parser = h_many1(p.parser());
-    }
-  private:
-    Parser _p;
-  };
-
-  class RepeatN: public Parser<SequenceResult> {
-  public:
-    RepeatN(Parser &p, const size_t n) : _p(p), _n(n) {
-      _parser = h_repeat_n(p.parser(), n);
-    }
-  private:
-    Parser _p;
-    size_t _n;
-  };
-  
-  template<class T>
-  class Optional : public Parser<T> {
-  public:
-    typedef typename T::result_type result_type;
-    Optional(Parser<T> &p) : _p(p) { 
-      this->_parser = h_optional(p.parser());
-    }
-  private:
-    Parser<T> _p;
-  };
-
-  class Ignore : public Parser<NullResult> {
-  public:
-    Ignore(Parser &p) : _p(p) {
-      _parser = h_ignore(p.parser());
-    }
-  private:
-    Parser _p;
-  };
-
-  class SepBy : public Parser<SequenceResult> {
-  public:
-    SepBy(Parser &p, Parser &sep) : _p(p), _sep(sep) {
-      _parser = h_sepBy(p.parser(), sep.parser()); 
-    }
-  private:
-    Parser _p, _sep;
-  };
-
-  class SepBy1 : public Parser<SequenceResult> {
-  public:
-    SepBy1(Parser &p, Parser &sep) : _p(p), _sep(sep) {
-      _parser = h_sepBy1(p.parser(), sep.parser());
-    }
-  private:
-    Parser _p, _sep;
-  };
-
-  class Epsilon : public Parser<NullResult> {
-  public:
-    Epsilon() {
-      _parser = h_epsilon_p();
-    }
-  };
-
-  template<class T>
-  class LengthValue : public Parser<SequenceResult> {
-  public:
-    LengthValue(Parser<UintResult> &length, Parser<T> &value) : _length(length), _value(value) {
-      _parser = h_length_value(length.parser(), value.parser());
-    }
-  private:
-    Parser<UintResult> _length;
-    Parser<T> _value;
-  };
-
-  /* FIXME attr_bool */
-
-  class And : public Parser<NullResult> {
-  public:
-    And(Parser &p) : _p(p) {
-      _parser = h_and(p.parser());
-    }
-  private:
-    Parser _p;
-  };
-
-  class Not : public Parser<NullResult> {
-  public:
-    Not(Parser &p) : _p(p) {
-      _parser = h_not(p.parser());
-    }
-  private:
-    Parser _p;
-  };
-
-  template<class T>
-  class Indirect : public Parser<T> {
-  public:
-    typedef typename T::result_type result_type;
-    Indirect(Parser<T> &p) : _p(p) {
-      this->_parser = h_indirect();
-      h_bind_indirect(this->_parser, p.parser());
-    }
-  private:
-    Parser<T> _p;
-  };
-
-}
-
-#endif