Index: trunk/lttoolbox/lttoolbox/stdint_shim.h
===================================================================
--- trunk/lttoolbox/lttoolbox/stdint_shim.h	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/stdint_shim.h	(nonexistent)
@@ -1,6 +0,0 @@
-#ifdef _MSC_VER
-typedef unsigned __int64 uint64_t;
-typedef signed __int64 int64_t;
-#else
-#include <stdint.h>
-#endif
Index: trunk/lttoolbox/lttoolbox/deserialiser.h
===================================================================
--- trunk/lttoolbox/lttoolbox/deserialiser.h	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/deserialiser.h	(revision 71881)
@@ -18,7 +18,7 @@
 
 #include "exception.h"
 
-#include <lttoolbox/stdint_shim.h>
+#include <stdint.h>
 #include <cstddef>
 #include <limits>
 #include <istream>
@@ -31,7 +31,10 @@
 
 #include <typeinfo>
 
+
 template <typename T>
+struct remove_const;
+template <typename T>
 struct remove_const
 {
     typedef T type;
@@ -58,16 +61,26 @@
   deserialise(std::istream &Stream_);
 };
 
-template <> class Deserialiser<signed int> {
+template <> class Deserialiser<int64_t> {
 public:
-  inline static signed int deserialise(std::istream &Stream_);
+  inline static int64_t deserialise(std::istream &Stream_);
 };
 
-template <> class Deserialiser<size_t> {
+template <> class Deserialiser<uint64_t> {
 public:
-  inline static size_t deserialise(std::istream &Stream_);
+  inline static uint64_t deserialise(std::istream &Stream_);
 };
 
+template <> class Deserialiser<int32_t> {
+public:
+  inline static int32_t deserialise(std::istream &Stream_);
+};
+
+template <> class Deserialiser<uint32_t> {
+public:
+  inline static uint32_t deserialise(std::istream &Stream_);
+};
+
 template <> class Deserialiser<wchar_t> {
 public:
   inline static wchar_t deserialise(std::istream &Stream_);
@@ -93,8 +106,7 @@
 std::basic_string<value_type>
 Deserialiser<std::basic_string<value_type> >::deserialise(
     std::istream &Stream_) {
-  std::size_t SerialisedValueCount =
-      Deserialiser<std::size_t>::deserialise(Stream_);
+  uint64_t SerialisedValueCount = Deserialiser<uint64_t>::deserialise(Stream_);
   std::basic_string<value_type> SerialisedType_;
 
   for (; SerialisedValueCount != 0; --SerialisedValueCount) {
@@ -139,22 +151,28 @@
   }
 }
 
-signed int Deserialiser<signed int>::deserialise(std::istream &Stream_) {
-  // Assumes size_t >= int and signed int != size_t
-  return Deserialiser<size_t>::deserialise(Stream_);
+int64_t Deserialiser<int64_t>::deserialise(std::istream &Stream_) {
+  return int_deserialise<int64_t>(Stream_);
 }
 
-size_t Deserialiser<size_t>::deserialise(std::istream &Stream_) {
-  // Assumes size_t == uint64_t, ie it is fixed across platforms
-  return int_deserialise<size_t>(Stream_);
+uint64_t Deserialiser<uint64_t>::deserialise(std::istream &Stream_) {
+  return int_deserialise<uint64_t>(Stream_);
 }
 
+int32_t Deserialiser<int32_t>::deserialise(std::istream &Stream_) {
+  return int_deserialise<int32_t>(Stream_);
+}
+
+uint32_t Deserialiser<uint32_t>::deserialise(std::istream &Stream_) {
+  return int_deserialise<uint32_t>(Stream_);
+}
+
 wchar_t Deserialiser<wchar_t>::deserialise(std::istream &Stream_) {
-  return int_deserialise<wchar_t>(Stream_);
+  return int_deserialise<uint32_t>(Stream_);
 }
 
 char Deserialiser<char>::deserialise(std::istream &Stream_) {
-  return int_deserialise<char>(Stream_);
+  return int_deserialise<uint8_t>(Stream_);
 }
 
 double Deserialiser<double>::deserialise(std::istream &Stream_) {
@@ -169,8 +187,8 @@
 template <typename Container>
 Container
 Deserialiser<Container>::deserialise(std::istream &Stream_) {
-  std::size_t SerialisedValueCount =
-      Deserialiser<std::size_t>::deserialise(Stream_);
+  uint64_t SerialisedValueCount =
+      Deserialiser<uint64_t>::deserialise(Stream_);
   typename remove_const<Container>::type SerialisedType_;
   std::insert_iterator<typename remove_const<Container>::type> insert_it =
       std::inserter(SerialisedType_, SerialisedType_.begin());
Index: trunk/lttoolbox/lttoolbox/alphabet.cc
===================================================================
--- trunk/lttoolbox/lttoolbox/alphabet.cc	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/alphabet.cc	(revision 71881)
@@ -104,6 +104,16 @@
   return slexic[s];
 }
 
+int
+Alphabet::operator()(wstring const &s) const
+{
+  map<wstring, int, Ltstr>::const_iterator it = slexic.find(s);
+  if (it == slexic.end()) {
+    return -1;
+  }
+  return it->second;
+}
+
 bool
 Alphabet::isSymbolDefined(wstring const &s)
 {
Index: trunk/lttoolbox/lttoolbox/alphabet.h
===================================================================
--- trunk/lttoolbox/lttoolbox/alphabet.h	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/alphabet.h	(revision 71881)
@@ -99,6 +99,7 @@
    * @return code for (c1, c2).
    */
   int operator()(int const c1, int const c2);
+  int operator()(wstring const &s) const;
   
   /**
    * Gets the individual symbol identifier. Assumes it already exists!
Index: trunk/lttoolbox/lttoolbox/pattern_list.cc
===================================================================
--- trunk/lttoolbox/lttoolbox/pattern_list.cc	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/pattern_list.cc	(revision 71881)
@@ -418,7 +418,7 @@
 }
 
 MatchExe *
-PatternList::newMatchExe()
+PatternList::newMatchExe() const
 {
   return new MatchExe(transducer, final_type);
 }
@@ -428,3 +428,9 @@
 {
   return alphabet;
 }
+
+const Alphabet &
+PatternList::getAlphabet() const
+{
+  return alphabet;
+}
Index: trunk/lttoolbox/lttoolbox/pattern_list.h
===================================================================
--- trunk/lttoolbox/lttoolbox/pattern_list.h	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/pattern_list.h	(revision 71881)
@@ -144,7 +144,7 @@
    * Create a new MatchExe from PatternList, must be freed with 'delete'
    * @return the new MatchExe object
    */
-  MatchExe * newMatchExe();
+  MatchExe * newMatchExe() const;
   
   /**
    * Get the alphabet of this PatternList object
@@ -151,6 +151,7 @@
    * @return the alphabet
    */
   Alphabet & getAlphabet();
+  const Alphabet & getAlphabet() const;
 };
 
 #endif
Index: trunk/lttoolbox/lttoolbox/serialiser.h
===================================================================
--- trunk/lttoolbox/lttoolbox/serialiser.h	(revision 71878)
+++ trunk/lttoolbox/lttoolbox/serialiser.h	(revision 71881)
@@ -18,7 +18,7 @@
 
 #include "exception.h"
 
-#include <lttoolbox/stdint_shim.h>
+#include <stdint.h>
 #include <cstddef>
 #include <limits>
 #include <ios>
@@ -64,18 +64,30 @@
             std::ostream &Output);
 };
 
-template <> class Serialiser<signed int> {
+template <> class Serialiser<int64_t> {
 public:
-  inline static void serialise(const signed int &SerialisedType_,
+  inline static void serialise(const int64_t &SerialisedType_,
                                std::ostream &Output);
 };
 
-template <> class Serialiser<size_t> {
+template <> class Serialiser<uint64_t> {
 public:
-  inline static void serialise(const size_t &SerialisedType_,
+  inline static void serialise(const uint64_t &SerialisedType_,
                                std::ostream &Output);
 };
 
+template <> class Serialiser<int32_t> {
+public:
+  inline static void serialise(const int32_t &SerialisedType_,
+                               std::ostream &Output);
+};
+
+template <> class Serialiser<uint32_t> {
+public:
+  inline static void serialise(const uint32_t &SerialisedType_,
+                               std::ostream &Output);
+};
+
 template <> class Serialiser<wchar_t> {
 public:
   inline static void serialise(const wchar_t &SerialisedType_,
@@ -166,26 +178,34 @@
   }
 }
 
-void Serialiser<signed int>::serialise(const signed int &SerialisedType_,
+void Serialiser<int64_t>::serialise(const int64_t &SerialisedType_,
                                    std::ostream &Output) {
-  // Assumes size_t >= int and signed int != size_t
-  Serialiser<size_t>::serialise(SerialisedType_, Output);
+  Serialiser<int64_t>::serialise(SerialisedType_, Output);
 }
 
-void Serialiser<size_t>::serialise(const size_t &SerialisedType_,
+void Serialiser<uint64_t>::serialise(const uint64_t &SerialisedType_,
                                    std::ostream &Output) {
-  // Assumes size_t == uint64_t, ie it is fixed across platforms
   int_serialise(SerialisedType_, Output);
 }
 
-void Serialiser<wchar_t>::serialise(const wchar_t &SerialisedType_,
+void Serialiser<int32_t>::serialise(const int32_t &SerialisedType_,
                                     std::ostream &Output) {
+  Serialiser<int32_t>::serialise(SerialisedType_, Output);
+}
+
+void Serialiser<uint32_t>::serialise(const uint32_t &SerialisedType_,
+                                     std::ostream &Output) {
   int_serialise(SerialisedType_, Output);
 }
 
+void Serialiser<wchar_t>::serialise(const wchar_t &SerialisedType_,
+                                    std::ostream &Output) {
+  int_serialise((uint32_t)SerialisedType_, Output);
+}
+
 void Serialiser<char>::serialise(const char &SerialisedType_,
                                  std::ostream &Output) {
-  int_serialise(SerialisedType_, Output);
+  int_serialise((uint8_t)SerialisedType_, Output);
 }
 
 void Serialiser<double>::serialise(const double &SerialisedType_,
@@ -201,7 +221,8 @@
 template <typename Container>
 void Serialiser<Container>::serialise(
     const Container &SerialisedType_, std::ostream &Output) {
-  ::serialise(SerialisedType_.size(), Output);
+  uint64_t size = SerialisedType_.size();
+  ::serialise(size, Output);
 
   for (typename Container::const_iterator value_type_ =
            SerialisedType_.begin();