Trying out ACSL, continuing implementation.

44 files changed, 1290 insertions, 1012 deletions

diff --git a/doc/protocol.txt b/doc/protocol.txt
index f6fc8e0..a940e69 100644
--- a/doc/protocol.txt
+++ b/doc/protocol.txt
@@ -10,15 +10,16 @@ Open the POSIX named message queue in write_only mode.
 Send a message to this queue with the following format:
    {
       'C',
+      unsigned int requested_protocol_version;
       char req_pipe_name[255],
       char reply_pipe_name[255]
    }
 
 Read from the reply pipe name, with a timeout. When the server has handled
 your connection request, you will receive "ZoO_protocol_version X\n",
-with X a positive integer indicating the version of the protocol. If you do
-not support this protocol, proceed to destroying all the pipes, otherwise you
-are now able to send requests.
+with X a positive integer indicating the version of the protocol that will be
+used. If you do not support this protocol, proceed to destroying all the pipes,
+otherwise you are now able to send requests.
 Disconnecting is done by destroying the pipes. This goes both way: if you did
 not initiate the destroying, assume that the server went offline.
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 147f2d0..07d8f30 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -3,6 +3,7 @@ add_subdirectory(core)
 add_subdirectory(knowledge)
 add_subdirectory(pipe)
 add_subdirectory(server)
+add_subdirectory(sequence)
 add_subdirectory(storage)
 
 set(
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index bc722d7..b864aff 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -2,10 +2,6 @@ set(
    SRC_FILES ${SRC_FILES}
    ${CMAKE_CURRENT_SOURCE_DIR}/char.c
    ${CMAKE_CURRENT_SOURCE_DIR}/index.c
-   ${CMAKE_CURRENT_SOURCE_DIR}/sequence.c
-   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_creation.c
-   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_from_string.c
-   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_to_string.c
 )
 
 set(SRC_FILES ${SRC_FILES} PARENT_SCOPE)
diff --git a/src/core/char.c b/src/core/char.c
index 9297643..819cd57 100644
--- a/src/core/char.c
+++ b/src/core/char.c
@@ -14,44 +14,6 @@ ZoO_char ZoO_char_to_lowercase (const ZoO_char c)
 }
 
 /* See: "char.c" */
-int ZoO_char_is_banned (const ZoO_char c)
-{
-   switch (c)
-   {
-      case '(':
-      case ')':
-      case '[':
-      case ']':
-      case '{':
-      case '}':
-      case '<':
-      case '>':
-         return 1;
-
-      default:
-         return 0;
-   }
-}
-
-/* See: "char.c" */
-int ZoO_char_is_punctuation (const ZoO_char c)
-{
-   switch (c)
-   {
-      case '!':
-      case ',':
-      case '.':
-      case ':':
-      case ';':
-      case '?':
-         return 1;
-
-      default:
-         return 0;
-   }
-}
-
-/* See: "char.c" */
 int ZoO_word_cmp
 (
    const ZoO_char word_a [const static 1],
diff --git a/src/core/char.h b/src/core/char.h
index 2b4a355..7039563 100644
--- a/src/core/char.h
+++ b/src/core/char.h
@@ -22,23 +22,5 @@ int ZoO_word_cmp
  */
 ZoO_char ZoO_char_to_lowercase (const ZoO_char c);
 
-/*
- * Returns '1' iff {c} should be considered as an punctuation character, '0'
- * otherwise.
- */
-/*@
- @ ensures ((\result == 1) || (\result == 0));
- @*/
-int ZoO_char_is_punctuation (const ZoO_char c);
-
-/*
- * Returns '1' iff containing {c} means the word should not be learned. '0'
- * otherwise.
- */
-/*@
- @ ensures ((\result == 1) || (\result == 0));
- @*/
-int ZoO_word_char_is_banned (const ZoO_char c);
-
 #endif
 
diff --git a/src/core/char_types.h b/src/core/char_types.h
index a2a736c..de0fad2 100644
--- a/src/core/char_types.h
+++ b/src/core/char_types.h
@@ -1,16 +1,5 @@
 #ifndef _ZoO_CORE_CHAR_TYPES_H_
 #define _ZoO_CORE_CHAR_TYPES_H_
-/*
- * FIXME: Does not belong here.
- */
-/*
-enum ZoO_word_property
-{
-   ZoO_WORD_NO_PROPERTY,
-   ZoO_WORD_HAS_NO_LEFT_SEPARATOR,
-   ZoO_WORD_HAS_NO_RIGHT_SEPARATOR
-};
-*/
 
 /* ZoO_char = UTF-8 char */
 typedef char ZoO_char;
diff --git a/src/core/index.c b/src/core/index.c
index 375e0ad..dc52d03 100644
--- a/src/core/index.c
+++ b/src/core/index.c
@@ -35,8 +35,13 @@ ZoO_index ZoO_index_random (void)
    ZoO_index result;
    unsigned char * result_bytes;
 
+   /*@ ghost return 4; @*/ /* Chosen by fair dice roll. */
+                           /* Guaranteed to be random. */
+   /* More seriously, I am not explaining the hack below to Frama-C */
+
    result_bytes = (unsigned char *) &result;
 
+
    for (i = 0; i < sizeof(ZoO_index); ++i)
    {
       result_bytes[i] = random_uchar();
diff --git a/src/core/index.h b/src/core/index.h
index 1417662..eb3c471 100644
--- a/src/core/index.h
+++ b/src/core/index.h
@@ -6,14 +6,19 @@
 /*
  * Returns a random ZoO_index.
  */
+/*@
+   ensures (\result <= ZoO_INDEX_MAX);
+   assigns \result;
+@*/
 ZoO_index ZoO_index_random (void);
 
 /*
  * Returns a random ZoO_index, included in [0, limit]
  */
 /*@
- @ ensures (\result <= limit);
- @*/
+   ensures (\result <= limit);
+   assigns \result;
+@*/
 ZoO_index ZoO_index_random_up_to (const ZoO_index limit);
 
 #endif
diff --git a/src/core/index_types.h b/src/core/index_types.h
index a71121c..84a1e20 100644
--- a/src/core/index_types.h
+++ b/src/core/index_types.h
@@ -1,6 +1,12 @@
 #ifndef _ZoO_CORE_INDEX_TYPES_H_
 #define _ZoO_CORE_INDEX_TYPES_H_
 
+/*
+ * ZoO_index is a replacement for size_t. As many indices are stored for every
+ * word learned, having control over which type of variable is used to represent
+ * those indices lets us scale the RAM usage.
+ */
+
 #include <limits.h>
 
 /* Must be unsigned. */
@@ -9,4 +15,9 @@ typedef unsigned int ZoO_index;
 /* Must be > 0. */
 #define ZoO_INDEX_MAX UINT_MAX
 
+
+#if (ZoO_INDEX_MAX > SIZE_MAX)
+   #error "ZoO_index should not be able to go higher than a size_t variable."
+#endif
+
 #endif
diff --git a/src/core/sequence.c b/src/core/sequence.c
deleted file mode 100644
index d7ff9d0..0000000
--- a/src/core/sequence.c
+++ /dev/null
@@ -1,103 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-
-#include "../core/index.h"
-
-#include "sequence.h"
-
-/*
- * Bypass rendundant ZoO_START_OF_SEQUENCE_ID at the start of a sequence.
- */
-/* ensures (*sequence_offset <= sequence_length) */
-static void bypass_redundant_sos
-(
-   const ZoO_index sequence [const restrict],
-   const ZoO_index sequence_length,
-   ZoO_index sequence_offset [const restrict static 1]
-)
-{
-   ZoO_index i;
-
-   *sequence_offset = 0;
-
-   for (i = 0; i < sequence_length; ++i)
-   {
-      if (sequence[i] != ZoO_START_OF_SEQUENCE_ID)
-      {
-         return;
-      }
-      else if (sequence[i] == ZoO_START_OF_SEQUENCE_ID)
-      {
-         *sequence_offset = i;
-      }
-   }
-}
-
-
-/* See "sequence.h" */
-int ZoO_sequence_cmp
-(
-   const ZoO_index sequence_a [const],
-   ZoO_index sequence_a_length,
-   const ZoO_index sequence_b [const],
-   ZoO_index sequence_b_length
-)
-{
-   ZoO_index min_length, a, b;
-   ZoO_index a_offset, b_offset;
-   ZoO_index i;
-
-   bypass_redundant_sos(sequence_a, sequence_a_length, &a_offset);
-   bypass_redundant_sos(sequence_b, sequence_b_length, &b_offset);
-
-   /*@ requires (*a_offset <= sequence_a_length) @*/
-   sequence_a_length -= a_offset;
-   /*@ requires (*b_offset <= sequence_b_length) @*/
-   sequence_b_length -= b_offset;
-
-   if (sequence_a_length < sequence_b_length)
-   {
-      min_length = sequence_a_length;
-   }
-   else
-   {
-      min_length = sequence_b_length;
-   }
-
-   /*@ ensures (min_length <= sequence_a_length) @*/
-   /*@ ensures (min_length <= sequence_b_length) @*/
-
-   for (i = 0; i < min_length; ++i)
-   {
-      /*@ requires ((i + a_offset) < sequence_a_length) @*/
-      a = sequence_a[i + a_offset];
-      /*@ requires ((i + b_offset) < sequence_b_length) @*/
-      b = sequence_b[i + b_offset];
-
-      if (a < b)
-      {
-         return -1;
-      }
-      else if (b > a)
-      {
-         return 1;
-      }
-      else if ((a == ZoO_END_OF_SEQUENCE_ID) && (b == ZoO_END_OF_SEQUENCE_ID))
-      {
-         return 0;
-      }
-   }
-
-   if (sequence_a_length > sequence_b_length)
-   {
-      return 1;
-   }
-   else if (sequence_a_length < sequence_b_length)
-   {
-      return -1;
-   }
-   else
-   {
-      return 0;
-   }
-}
diff --git a/src/core/sequence.h b/src/core/sequence.h
deleted file mode 100644
index 1e286ab..0000000
--- a/src/core/sequence.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef _ZoO_CORE_SEQUENCE_H_
-#define _ZoO_CORE_SEQUENCE_H_
-
-#include "../core/char_types.h"
-#include "../core/index_types.h"
-
-#include "../pipe/pipe.h"
-
-#include "../knowledge/knowledge_types.h"
-
-#include "sequence_types.h"
-
-int ZoO_sequence_from_undercase_string
-(
-   const ZoO_char string [const restrict],
-   const ZoO_index string_length,
-   struct ZoO_knowledge k [const restrict static 1],
-   ZoO_index * sequence [const restrict static 1],
-   ZoO_index sequence_length [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-);
-
-/*
- * Creates a sequence containing {initial_word}. The remaining elements of
- * sequence are added according to what is known to {k} as being possible.
- * The resulting sequence starts by ZoO_START_OF_SEQUENCE_ID, and ends by
- * ZoO_END_OF_SEQUENCE_ID. The sequence is allocated by the function. If an
- * error occur, it is unallocated and set to NULL ({sequence_size} is set
- * accordingly).
- * Return:
- *    0 on success.
- *    -1 iff the allocating failed.
- *    -2 iff the sequence initialization failed.
- *    -3 iff an error occured when trying to add elements to the right of the
- *       sequence.
- *    -4 iff an error occured when trying to add elements to the left of the
- *       sequence.
- *    -5 iff the resulting sequence would have been empty.
- * Pre:
- *    (> {markov_order} 0)
- *    (knows {k} {initial_word})
- *    (initialized {k})
- */
-int ZoO_sequence_create_from
-(
-   const ZoO_index initial_word,
-   ZoO_index credits [const restrict],
-   const struct ZoO_knowledge k [const restrict static 1],
-   const ZoO_index markov_order,
-   ZoO_index * sequence [const restrict static 1],
-   size_t sequence_size [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-);
-
-/*
- * Compares two sequences.
- * ZoO_END_OF_SEQUENCE marks the ending of a sequence, regardless of indicated
- * sequence length, meaning that [10][ZoO_END_OF_SEQUENCE][9] and
- * [10][ZoO_END_OF_SEQUENCE][8] are considered equal. Sequences do not have to
- * contain ZoO_END_OF_SEQUENCE. [10][ZoO_END_OF_SEQUENCE] and [10] are
- * considered different, [10][ZoO_END_OF_SEQUENCE]
- * and [10][ZoO_END_OF_SEQUENCE][ZoO_END_OF_SEQUENCE] are considered equal.
- * Same logic is applyied for ZoO_START_OF_SEQUENCE:
- * [START_OF_SEQUENCE][10] is not [10], but
- * [START_OF_SEQUENCE][START_OF_SEQUENCE][10] and [START_OF_SEQUENCE][10] are
- * the same.
- * Return:
- *    1 iff {sequence_a} should be considered being more than {sequence_b}
- *    0 iff {sequence_a} should be considered being equal to {sequence_b}
- *    -1 iff {sequence_a} should be considered being less than {sequence_b}
- */
-int ZoO_sequence_cmp
-(
-   const ZoO_index sequence_a [const],
-   const ZoO_index sequence_a_length,
-   const ZoO_index sequence_b [const],
-   const ZoO_index sequence_b_length
-);
-
-#endif
diff --git a/src/core/sequence_from_string.c b/src/core/sequence_from_string.c
deleted file mode 100644
index deaec86..0000000
--- a/src/core/sequence_from_string.c
+++ /dev/null
@@ -1,351 +0,0 @@
-#define _POSIX_C_SOURCE 200809L
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h> /* defines SIZE_MAX */
-
-#include "../core/char.h"
-#include "../core/index.h"
-
-#include "../pipe/pipe.h"
-
-#include "../knowledge/knowledge.h"
-
-#include "sequence.h"
-
-static int add_word_id_to_sequence
-(
-   const ZoO_index word_id,
-   ZoO_index * sequence [const restrict static 1],
-   ZoO_index sequence_length [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index * new_sequence;
-
-   *sequence_length += 1;
-
-   new_sequence =
-      (ZoO_index *) realloc
-      (
-         (void *) *sequence,
-         (((size_t) sequence_length) * sizeof(ZoO_index))
-      );
-
-   if (new_sequence == (ZoO_index *) NULL)
-   {
-      ZoO_S_ERROR(io, "Unable to reallocate a sequence to add word ids to it.");
-
-      return -1;
-   }
-
-   return 0;
-}
-
-/******************************************************************************/
-/** HANDLING PUNCTUATION ******************************************************/
-/******************************************************************************/
-
-/*
- * Semaphore:
- *    Takes then releases access for {k}.
- */
-static int add_punctuation_to_sequence
-(
-   const ZoO_char string [const restrict static 1],
-   const ZoO_char punctuation,
-   ZoO_index * sequence [const restrict static 1],
-   ZoO_index sequence_length [const restrict static 1],
-   const struct ZoO_knowledge k [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index word_id;
-   ZoO_char as_word[2];
-
-   as_word[0] = punctuation;
-   as_word[1] = '\0';
-
-   (void) ZoO_knowledge_lock_access(k, io);
-
-   if (ZoO_knowledge_find_word_id(k, as_word, 2, &word_id, io) < 0)
-   {
-      (void) ZoO_knowledge_unlock_access(k, io);
-
-      ZoO_PROG_ERROR
-      (
-         io,
-         "'%s' was defined as a punctuation, was found in a string, yet is not"
-         " defined in the knowledge database.",
-         as_word
-      );
-
-      return -1;
-   }
-
-   (void) ZoO_knowledge_unlock_access(k, io);
-
-   if (add_word_id_to_sequence(word_id, sequence, sequence_length, io) < 0)
-   {
-      return -1;
-   }
-
-   return 0;
-}
-
-static int word_is_punctuation_terminated
-(
-   const ZoO_char string [const restrict static 1],
-   const ZoO_index word_start,
-   const ZoO_index word_length
-)
-{
-   return ZoO_char_is_punctuation(string[word_length]);
-}
-
-/******************************************************************************/
-/** HANDLING WORDS ************************************************************/
-/******************************************************************************/
-
-/*
- * Semaphore:
- *    Takes then releases access for {k}.
- */
-static int add_word_to_sequence
-(
-   const ZoO_char string [const restrict static 1],
-   const ZoO_index word_start,
-   const ZoO_index word_length,
-   ZoO_index * sequence [const restrict static 1],
-   ZoO_index sequence_length [const restrict static 1],
-   struct ZoO_knowledge k [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index word_id;
-   ZoO_char * stored_word;
-
-   if (word_length == 0)
-   {
-      return 0;
-   }
-
-   (void) ZoO_knowledge_lock_access(k, io);
-
-   if
-   (
-      ZoO_knowledge_learn_word
-      (
-         k,
-         (string + word_start),
-         word_length,
-         &word_id,
-         io
-      ) < 0
-   )
-   {
-      (void) ZoO_knowledge_unlock_access(k, io);
-
-      return -1;
-   }
-
-   (void) ZoO_knowledge_unlock_access(k, io);
-
-   if (add_word_id_to_sequence(word_id, sequence, sequence_length, io) < 0)
-   {
-      return -1;
-   }
-
-   return 0;
-}
-
-static int add_finding_to_sequence
-(
-   const ZoO_char string [const restrict static 1],
-   const ZoO_index word_start,
-   const ZoO_index word_length,
-   ZoO_index * sequence [const restrict static 1],
-   ZoO_index sequence_length [const restrict static 1],
-   struct ZoO_knowledge k [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index punctuation;
-
-   if (word_is_punctuation_terminated(string, word_start, word_length))
-   {
-      punctuation = 1;
-   }
-   else
-   {
-      punctuation = 0;
-   }
-
-   if
-   (
-      add_word_to_sequence
-      (
-         string,
-         word_start,
-         (word_length - punctuation),
-         sequence,
-         sequence_length,
-         k,
-         io
-      ) < 0
-   )
-   {
-      return -1;
-   }
-
-   if
-   (
-      (punctuation == 1)
-      &&
-      (
-         add_punctuation_to_sequence
-         (
-            string,
-            string[word_start + word_length - 1],
-            sequence,
-            sequence_length,
-            k,
-            io
-         ) < 0
-      )
-   )
-   {
-      return -1;
-   }
-
-   return 0;
-}
-
-static int find_word
-(
-   const ZoO_char string [const restrict static 1],
-   const ZoO_index string_length,
-   const ZoO_index offset,
-   ZoO_index word_start [const restrict static 1],
-   ZoO_index word_length [const restrict static 1]
-)
-{
-   ZoO_index i;
-
-   i = offset;
-
-   while ((string[i] == ' ') && (i < string_length))
-   {
-      i += 1;
-   }
-
-   if (i >= string_length)
-   {
-      return -1;
-   }
-
-   *word_start = i;
-
-   while ((string[i] != ' ') && (i < string_length))
-   {
-      i += 1;
-   }
-
-   if (i >= string_length)
-   {
-      return -1;
-   }
-
-   *word_length = (i - *word_start);
-
-   return 0;
-}
-
-/******************************************************************************/
-/** EXPORTED ******************************************************************/
-/******************************************************************************/a
-
-/* See: "sequence.h" */
-int ZoO_sequence_from_undercase_string
-(
-   const ZoO_char string [const restrict],
-   const ZoO_index string_length,
-   struct ZoO_knowledge k [const restrict static 1],
-   ZoO_index * sequence [const restrict static 1],
-   ZoO_index sequence_length [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index word_start, word_length;
-   ZoO_index i;
-
-   i = 0;
-
-   *sequence = (ZoO_index *) NULL;
-   *sequence_length = 0;
-
-   if
-   (
-      add_word_id_to_sequence
-      (
-         ZoO_START_OF_SEQUENCE_ID,
-         sequence,
-         sequence_length,
-         io
-      ) < 0
-   )
-   {
-      return -1;
-   }
-
-   while (i < string_length)
-   {
-      if (find_word(string, i, string_length, &word_start, &word_length) < 0)
-      {
-         break;
-      }
-
-      if
-      (
-         add_finding_to_sequence
-         (
-            string,
-            word_start,
-            word_length,
-            sequence,
-            sequence_length,
-            k,
-            io
-         ) < 0
-      )
-      {
-         free((void *) *sequence);
-         *sequence = (ZoO_index *) NULL;
-         *sequence_length = 0;
-
-         return -1;
-      }
-
-      i = (word_start + word_length);
-   }
-
-   if
-   (
-      add_word_id_to_sequence
-      (
-         ZoO_END_OF_SEQUENCE_ID,
-         sequence,
-         sequence_length,
-         io
-      ) < 0
-   )
-   {
-      free((void *) *sequence);
-
-      *sequence = (ZoO_index *) NULL;
-      *sequence_length = 0;
-
-      return -1;
-   }
-
-   return 0;
-}
diff --git a/src/core/sequence_to_string.c b/src/core/sequence_to_string.c
deleted file mode 100644
index 16fc859..0000000
--- a/src/core/sequence_to_string.c
+++ /dev/null
@@ -1,97 +0,0 @@
-#define _POSIX_C_SOURCE 200809L
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h> /* defines SIZE_MAX */
-
-#include "../core/char.h"
-#include "../core/index.h"
-
-#include "../cli/cli.h"
-
-#include "../knowledge/knowledge.h"
-
-#include "sequence.h"
-
-/* TODO */
-static int add_word
-(
-   const ZoO_index word_id,
-   const size_t destination_size,
-   struct ZoO_knowledge k [const restrict static 1],
-   ZoO_char destination [const restrict static max_destination_length],
-   size_t destination_used_size [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-	const ZoO_char * word;
-	size_t word_size;
-
-	(void) ZoO_knowledge_lock_access(k, io);
-	ZoO_knowledge_get_word(k, word_id, &word, &word_size, io);
-	(void) ZoO_knowledge_unlock_access(k, io);
-
-	if ((destination_used_size + word_size) > max_destination_length)
-	{
-	}
-
-	if
-	(
-		(word_size == 2)
-		&& ZoO_char_is_punctuation(word[0])
-	)
-	{
-		snprintf
-		(
-			(destination + *destination_used_size),
-			word_size,
-			ZoO_CHAR_STRING_SYMBOL,
-			current_sentence
-		);
-	}
-	else
-	{
-	}
-
-   return 0;
-}
-/******************************************************************************/
-/** EXPORTED ******************************************************************/
-/******************************************************************************/
-
-int ZoO_sequence_to_undercase_string
-(
-   const ZoO_index sequence [const restrict static 1],
-   const ZoO_index sequence_length,
-   const ZoO_index max_destination_length,
-   struct ZoO_knowledge k [const restrict static 1],
-   ZoO_char destination [const restrict static max_destination_length],
-   ZoO_index destination_length [const restrict static 1],
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index i;
-   const ZoO_index actual_length = (sequence_length - 1);
-
-   for (i = 0; i < actual_length; ++i)
-   {
-      if
-      (
-         add_word
-         (
-            sequence[i],
-            max_destination_length,
-            k,
-            destination,
-            destination_length,
-            io
-         ) < 0
-      )
-      {
-         *destination_length = 0;
-
-         return -1;
-      }
-   }
-
-   return 0;
-}
diff --git a/src/knowledge/knowledge.c b/src/knowledge/knowledge.c
index 95683b9..463d40b 100644
--- a/src/knowledge/knowledge.c
+++ b/src/knowledge/knowledge.c
@@ -26,6 +26,7 @@ int ZoO_knowledge_lock_access
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
+   /* TODO */
    return 0;
 }
 
@@ -35,4 +36,5 @@ void ZoO_knowledge_unlock_access
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
+   /* TODO */
 }
diff --git a/src/knowledge/knowledge.h b/src/knowledge/knowledge.h
index 872bb94..c65ee2c 100644
--- a/src/knowledge/knowledge.h
+++ b/src/knowledge/knowledge.h
@@ -41,7 +41,7 @@ int ZoO_knowledge_learn_word
 (
    struct ZoO_knowledge k [const static 1],
    const ZoO_char word [const restrict static 1],
-   const ZoO_index word_length,
+   const size_t word_length,
    ZoO_index result [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 );
@@ -50,7 +50,7 @@ int ZoO_knowledge_learn_sequence
 (
    struct ZoO_knowledge k [const restrict static 1],
    const ZoO_index sequence [const restrict static 1],
-   const ZoO_index sequence_length,
+   const size_t sequence_length,
    const ZoO_index markov_order,
    const struct ZoO_pipe io [const restrict static 1]
 );
@@ -88,7 +88,7 @@ int ZoO_knowledge_get_word
    const struct ZoO_knowledge k [const static 1],
    const ZoO_index word_ref,
    const ZoO_char * word [const restrict static 1],
-   size_t word_size [const restrict static 1],
+   ZoO_index word_size [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 );
 
@@ -125,7 +125,7 @@ int ZoO_knowledge_find_following_words
 (
    const struct ZoO_knowledge k [const static 1],
    const ZoO_index sequence [const restrict],
-   const ZoO_index sequence_length,
+   const size_t sequence_length,
    const ZoO_index markov_order,
    const ZoO_index * restrict following_words [const restrict static 1],
    const ZoO_index * restrict following_words_weights [const restrict static 1],
diff --git a/src/knowledge/knowledge_finalize.c b/src/knowledge/knowledge_finalize.c
index 36a7406..9628672 100644
--- a/src/knowledge/knowledge_finalize.c
+++ b/src/knowledge/knowledge_finalize.c
@@ -1,8 +1,4 @@
 #include <stdlib.h>
-#include <string.h>
-#include <stdint.h> /* defines SIZE_MAX */
-
-#include "../cli/cli.h"
 
 #include "knowledge.h"
 
@@ -59,7 +55,7 @@ static void knowledge_word_finalize
    struct ZoO_knowledge_word w [const restrict static 1]
 )
 {
-   w->word_size = 0;
+   w->word_length = 0;
    w->occurrences = 0;
 
    if (w->word != (ZoO_char *) NULL)
diff --git a/src/knowledge/knowledge_learn_markov_sequence.c b/src/knowledge/knowledge_learn_markov_sequence.c
index ec71254..2bd0103 100644
--- a/src/knowledge/knowledge_learn_markov_sequence.c
+++ b/src/knowledge/knowledge_learn_markov_sequence.c
@@ -2,7 +2,7 @@
 #include <string.h>
 #include <stdint.h> /* defines SIZE_MAX */
 
-#include "../core/sequence.h"
+#include "../sequence/sequence.h"
 
 #include "../pipe/pipe.h"
 
@@ -18,15 +18,16 @@ static void set_nth_sequence
    const ZoO_index sequence_id
 )
 {
-   /* Safe: (> k->sequences_length 1) */
    if (sorted_sequence_id < (k->sequences_length - 1))
    {
       memmove
       (
-         /* Safe: (=< (+ sorted_sequence_id 1) k->sequences_length) */
          (void *) (k->sequences_sorted + (sorted_sequence_id + 1)),
          (const void *) (k->sequences_sorted + sorted_sequence_id),
-         ((k->sequences_length - 1) - sorted_sequence_id)
+         (
+            ((size_t) ((k->sequences_length - 1) - sorted_sequence_id))
+            * sizeof(ZoO_index)
+         )
       );
    }
 
diff --git a/src/knowledge/knowledge_learn_sequence.c b/src/knowledge/knowledge_learn_sequence.c
index 7696fbc..35b6d15 100644
--- a/src/knowledge/knowledge_learn_sequence.c
+++ b/src/knowledge/knowledge_learn_sequence.c
@@ -2,7 +2,7 @@
 #include <string.h>
 #include <stdint.h> /* defines SIZE_MAX */
 
-#include "../core/sequence.h"
+#include "../sequence/sequence.h"
 
 #include "../pipe/pipe.h"
 
@@ -15,11 +15,15 @@ static int add_following_sequence
 (
    struct ZoO_knowledge k [const restrict static 1],
    const ZoO_index sequence [const restrict static 1],
-   const ZoO_index index,
-   const ZoO_index sequence_length,
+   const size_t index,
+   const size_t sequence_length,
    const ZoO_index markov_order,
    const struct ZoO_pipe io [const restrict static 1]
-);
+)
+{
+   /* TODO */
+   return -1;
+}
 
 /******************************************************************************/
 /** LEARN PRECEDING SEQUENCE **************************************************/
@@ -28,33 +32,32 @@ static int add_preceding_sequence
 (
    struct ZoO_knowledge k [const restrict static 1],
    const ZoO_index sequence [const restrict static 1],
-   const ZoO_index index,
-   const ZoO_index sequence_length,
+   const size_t index,
+   const size_t sequence_length,
    const ZoO_index markov_order,
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
+   /* TODO */
+   return -1;
 }
 
 /******************************************************************************/
 /** EXPORTED ******************************************************************/
 /******************************************************************************/
-
 int ZoO_knowledge_learn_sequence
 (
    struct ZoO_knowledge k [const restrict static 1],
    const ZoO_index sequence [const restrict static 1],
-   const ZoO_index sequence_length,
+   const size_t sequence_length,
    const ZoO_index markov_order,
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
    ZoO_index * buffer;
-   ZoO_index i;
+   size_t i;
    const ZoO_index buffer_length = (markov_order - 1);
 
-   /* TODO */
-
    for (i = 0; i < sequence_length; ++i)
    {
       k->words[sequence[i]].occurrences += 1;
diff --git a/src/knowledge/knowledge_learn_word.c b/src/knowledge/knowledge_learn_word.c
index e6979dc..33a2bf1 100644
--- a/src/knowledge/knowledge_learn_word.c
+++ b/src/knowledge/knowledge_learn_word.c
@@ -30,7 +30,7 @@ static void initialize_word
 )
 {
    w->word = (const ZoO_char *) NULL;
-   w->word_size = 0;
+   w->word_length = 0;
    w->occurrences = 0;
 
    initialize_sequence_collection(&(w->followed));
@@ -53,7 +53,7 @@ static ZoO_char * copy_word
       (ZoO_char *)
       calloc
       (
-         (size_t) (original_length + 1),
+         original_length,
          sizeof(ZoO_char)
       );
 
@@ -71,8 +71,6 @@ static ZoO_char * copy_word
       (((size_t) original_length) * sizeof(ZoO_char))
    );
 
-   result[original_length] = '\0';
-
    return 0;
 }
 
@@ -86,7 +84,8 @@ static int reallocate_words_list
 
    if
    (
-      (SIZE_MAX / sizeof(struct ZoO_knowledge_word)) > (size_t) k->words_length
+      (SIZE_MAX / sizeof(struct ZoO_knowledge_word))
+      > (size_t) k->words_length
    )
    {
       ZoO_S_ERROR
@@ -135,7 +134,7 @@ static int reallocate_words_sorted_list
     * whose size is bigger than a ZoO_index.
     * */
    /*
-   if ((SIZE_MAX / sizeof(ZoO_index)) > (size_t) k->words_length)
+   if ((SIZE_MAX / sizeof(ZoO_index)) > k->words_length)
    {
       ZoO_S_ERROR
       (
@@ -185,7 +184,10 @@ static void set_nth_word
          /* Safe: (=< (+ sorted_word_id 1) k->words_length) */
          (void *) (k->words_sorted + (sorted_word_id + 1)),
          (const void *) (k->words_sorted + sorted_word_id),
-         ((k->words_length - 1) - sorted_word_id)
+         (
+            ((size_t) ((k->words_length - 1) - sorted_word_id))
+            * sizeof(ZoO_index)
+         )
       );
    }
 
@@ -235,7 +237,7 @@ static int add_word
    initialize_word(k->words + word_id);
 
    k->words[word_id].word = stored_word;
-   k->words[word_id].word_size = ((word_length + 1) * sizeof(ZoO_char));
+   k->words[word_id].word_length = word_length;
 
    if (reallocate_words_sorted_list(k, io) < 0)
    {
@@ -257,22 +259,28 @@ int ZoO_knowledge_learn_word
 (
    struct ZoO_knowledge k [const restrict static 1],
    const ZoO_char word [const restrict static 1],
-   const ZoO_index word_length,
+   const size_t word_length,
    ZoO_index word_id [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
    ZoO_index sorted_id;
 
+   if (word_length >= (size_t) ZoO_INDEX_MAX)
+   {
+      ZoO_S_ERROR(io, "Word is too long to be learned.");
+
+      return -1;
+   }
+
    if
    (
       ZoO_knowledge_find_word_id
       (
          k,
          word,
-         (word_length * sizeof(ZoO_char)),
-         word_id,
-         io
+         (((size_t) word_length) * sizeof(ZoO_char)),
+         word_id
       ) == 0
    )
    {
@@ -282,5 +290,5 @@ int ZoO_knowledge_learn_word
    sorted_id = *word_id;
    *word_id = k->words_length;
 
-   return add_word(k, word, word_length, *word_id, sorted_id, io);
+   return add_word(k, word, (ZoO_index) word_length, *word_id, sorted_id, io);
 }
diff --git a/src/knowledge/knowledge_search.c b/src/knowledge/knowledge_search.c
index 23aab71..4ea4572 100644
--- a/src/knowledge/knowledge_search.c
+++ b/src/knowledge/knowledge_search.c
@@ -2,7 +2,7 @@
 
 #include "../core/char.h"
 #include "../core/index.h"
-#include "../core/sequence.h"
+#include "../sequence/sequence.h"
 
 #include "../pipe/pipe.h"
 
@@ -13,7 +13,7 @@ int ZoO_knowledge_find_word_id
 (
    const struct ZoO_knowledge k [const restrict static 1],
    const ZoO_char word [const restrict static 1],
-   const size_t word_size,
+   const size_t word_length,
    ZoO_index result [const restrict static 1]
 )
 {
@@ -40,7 +40,7 @@ int ZoO_knowledge_find_word_id
    {
       i = (current_min + ((current_max - current_min) / 2));
 
-      cmp = ZoO_word_cmp(word, word_size, k->words[k->words_sorted[i]].word);
+      cmp = ZoO_word_cmp(word, word_length, k->words[k->words_sorted[i]].word);
 
       if (cmp > 0)
       {
@@ -211,7 +211,7 @@ int ZoO_knowledge_find_following_words
 (
    const struct ZoO_knowledge k [const static 1],
    const ZoO_index sequence [const restrict],
-   const ZoO_index sequence_length,
+   const size_t sequence_length,
    const ZoO_index markov_order,
    const ZoO_index * restrict following_words [const restrict static 1],
    const ZoO_index * restrict following_words_weights [const restrict static 1],
@@ -224,14 +224,15 @@ int ZoO_knowledge_find_following_words
    ZoO_index i, current_min, current_max, local_sequence;
    const ZoO_index * restrict candidate;
    const ZoO_index markov_sequence_length = (markov_order - 1);
-   const ZoO_index sequence_offset =
-      ((sequence_length - markov_sequence_length) - 1);
+   const size_t sequence_offset =
+      ((sequence_length - ((size_t) markov_sequence_length)) - 1);
    const ZoO_index word = sequence[sequence_offset];
 
    if (word >= k->words_length)
    {
       ZoO_S_ERROR
       (
+         io,
          "Attempting to find the following words of an unknown word."
       );
 
diff --git a/src/knowledge/knowledge_types.h b/src/knowledge/knowledge_types.h
index 7eafc8b..4962991 100644
--- a/src/knowledge/knowledge_types.h
+++ b/src/knowledge/knowledge_types.h
@@ -18,7 +18,7 @@ struct ZoO_knowledge_sequence_collection
 struct ZoO_knowledge_word
 {
    const ZoO_char * word;
-   size_t word_size;
+   ZoO_index word_length;
    ZoO_index occurrences;
    struct ZoO_knowledge_sequence_collection followed;
    struct ZoO_knowledge_sequence_collection preceded;
@@ -32,7 +32,6 @@ struct ZoO_knowledge
    ZoO_index ** sequences;
    ZoO_index sequences_length;
    ZoO_index * sequences_sorted;
-   ZoO_index sequences_length;
 };
 
 #endif
diff --git a/src/cli/CMakeLists.txt b/src/parameters/CMakeLists.txt
index 94e6337..94e6337 100644
--- a/src/cli/CMakeLists.txt
+++ b/src/parameters/CMakeLists.txt
diff --git a/src/cli/parameters.c b/src/parameters/parameters.c
index 82ac9d1..82ac9d1 100644
--- a/src/cli/parameters.c
+++ b/src/parameters/parameters.c
diff --git a/src/cli/parameters.h b/src/parameters/parameters.h
index 7927ef7..7927ef7 100644
--- a/src/cli/parameters.h
+++ b/src/parameters/parameters.h
diff --git a/src/cli/parameters_types.h b/src/parameters/parameters_types.h
index f9ca88b..f9ca88b 100644
--- a/src/cli/parameters_types.h
+++ b/src/parameters/parameters_types.h
diff --git a/src/pipe/pipe.c b/src/pipe/pipe.c
index e69de29..8f414f5 100644
--- a/src/pipe/pipe.c
+++ b/src/pipe/pipe.c
@@ -0,0 +1 @@
+/* TODO */
diff --git a/src/pipe/pipe.h b/src/pipe/pipe.h
index ea31b55..3c5fd44 100644
--- a/src/pipe/pipe.h
+++ b/src/pipe/pipe.h
@@ -143,4 +143,5 @@
       }\
    )
 
+/* TODO: add missing pipe functions */
 #endif
diff --git a/src/pipe/pipe_types.h b/src/pipe/pipe_types.h
index 15b4a54..cfeb514 100644
--- a/src/pipe/pipe_types.h
+++ b/src/pipe/pipe_types.h
@@ -1,5 +1,5 @@
 #ifndef _ZoO_PIPE_PIPE_TYPES_H_
-#define _ZoO_PIPE_PIPE_TYPESH_
+#define _ZoO_PIPE_PIPE_TYPES_H_
 
 #include <stdio.h>
 
@@ -8,6 +8,12 @@ struct ZoO_pipe
    FILE * out;
    FILE * in;
 };
-   const struct ZoO_pipe io [const restrict static 1]
+
+struct ZoO_pipe_names
+{
+   char request_pipe[255];
+   char reply_pipe[255];
+};
+//   const struct ZoO_pipe io [const restrict static 1]
 
 #endif
diff --git a/src/sequence/CMakeLists.txt b/src/sequence/CMakeLists.txt
new file mode 100644
index 0000000..1186557
--- /dev/null
+++ b/src/sequence/CMakeLists.txt
@@ -0,0 +1,11 @@
+set(
+   SRC_FILES ${SRC_FILES}
+   ${CMAKE_CURRENT_SOURCE_DIR}/sequence.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_append.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_creation.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_from_string.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/sequence_to_string.c
+)
+
+set(SRC_FILES ${SRC_FILES} PARENT_SCOPE)
+
diff --git a/src/sequence/sequence.c b/src/sequence/sequence.c
new file mode 100644
index 0000000..852b05c
--- /dev/null
+++ b/src/sequence/sequence.c
@@ -0,0 +1,170 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "../core/index.h"
+
+#include "sequence.h"
+
+/*
+ * Bypass rendundant ZoO_START_OF_SEQUENCE_ID at the start of a sequence.
+ */
+/*@
+   requires
+   (
+      \valid(sequence+ (0 .. sequence_length))
+      || (sequence_length == 0)
+   );
+   requires \separated(sequence, sequence_offset);
+
+   assigns (*sequence_offset);
+
+   ensures (*sequence_offset < sequence_length);
+
+   ensures
+   (
+      (*sequence_offset == 0)
+      || (sequence[0 .. *sequence_offset] == ZoO_START_OF_SEQUENCE_ID)
+   );
+
+   ensures
+   (
+      (*sequence_offset == sequence_length)
+      || (sequence[*sequence_offset + 1] != ZoO_START_OF_SEQUENCE_ID)
+   );
+
+@*/
+static void bypass_redundant_sos
+(
+   const ZoO_index sequence [const restrict],
+   const size_t sequence_length,
+   size_t sequence_offset [const restrict static 1]
+)
+{
+   ZoO_index i;
+
+   *sequence_offset = 0;
+
+   /*@
+      loop invariant 0 <= i <= sequence_length;
+      loop invariant (*sequence_offset <= i);
+      loop invariant
+      (
+         (*sequence_offset == 0)
+         || (sequence[*sequence_offset] == ZoO_START_OF_SEQUENCE_ID)
+      );
+      loop invariant
+         (
+            (i == 0) || (sequence[0 .. (i - 1)] == ZoO_START_OF_SEQUENCE_ID)
+         );
+      loop assigns i, *sequence_offset;
+      loop variant (sequence_length - i);
+   @*/
+   for (i = 0; i < sequence_length; ++i)
+   {
+      if (sequence[i] != ZoO_START_OF_SEQUENCE_ID)
+      {
+         return;
+      }
+      else if (sequence[i] == ZoO_START_OF_SEQUENCE_ID)
+      {
+         *sequence_offset = i;
+      }
+   }
+}
+
+
+/* See "sequence.h" */
+/*@
+   \requires
+   (
+      \valid(sequence_a+ (0 .. sequence_a_length))
+      || (sequence_a_length == 0)
+   );
+
+   \requires
+   (
+      \valid(sequence_b+ (0 .. sequence_b_length))
+      || (sequence_b_length == 0)
+   );
+
+   assigns \result;
+@*/
+int ZoO_sequence_cmp
+(
+   const ZoO_index sequence_a [const],
+   size_t sequence_a_length,
+   const ZoO_index sequence_b [const],
+   size_t sequence_b_length
+)
+{
+   size_t min_length, a, b;
+   size_t a_offset, b_offset;
+   size_t i;
+   /*@ ghost size_t actual_a_length, actual_b_length; @*/
+
+   bypass_redundant_sos(sequence_a, sequence_a_length, &a_offset);
+   bypass_redundant_sos(sequence_b, sequence_b_length, &b_offset);
+
+   /*@ ghost actual_a_length = sequence_a_length; @*/
+   /*@ ghost actual_b_length = sequence_b_length; @*/
+
+   /*@ assert (a_offset <= sequence_a_length); @*/
+   sequence_a_length -= a_offset;
+   /*@ assert (b_offset <= sequence_b_length); @*/
+   sequence_b_length -= b_offset;
+
+   if (sequence_a_length < sequence_b_length)
+   {
+      min_length = sequence_a_length;
+   }
+   else
+   {
+      min_length = sequence_b_length;
+   }
+
+   /*@ assert (min_length <= sequence_a_length); @*/
+   /*@ assert (min_length <= sequence_b_length); @*/
+
+   /*@ assert (min_length + a_offset <= actual_a_length); @*/
+   /*@ assert (min_length + b_offset <= actual_b_length); @*/
+
+   /*@
+      loop invariant 0 <= i <= min_length;
+      loop assigns i;
+      loop variant (min_length - i);
+   @*/
+   for (i = 0; i < min_length; ++i)
+   {
+      /*@ assert ((i + a_offset) < actual_a_length); @*/
+      a = sequence_a[i + a_offset];
+      /*@ assert ((i + b_offset) < actual_b_length); @*/
+      b = sequence_b[i + b_offset];
+
+      if (a < b)
+      {
+         return -1;
+      }
+      else if (b > a)
+      {
+         return 1;
+      }
+      else if ((a == ZoO_END_OF_SEQUENCE_ID) && (b == ZoO_END_OF_SEQUENCE_ID))
+      {
+         return 0;
+      }
+   }
+
+   if (sequence_a_length > sequence_b_length)
+   {
+      return 1;
+   }
+   else if (sequence_a_length < sequence_b_length)
+   {
+      return -1;
+   }
+   else
+   {
+      return 0;
+   }
+}
+
diff --git a/src/sequence/sequence.h b/src/sequence/sequence.h
new file mode 100644
index 0000000..d1ac16f
--- /dev/null
+++ b/src/sequence/sequence.h
@@ -0,0 +1,208 @@
+#ifndef _ZoO_CORE_SEQUENCE_H_
+#define _ZoO_CORE_SEQUENCE_H_
+
+/* Defines SIZE_MAX */
+#include <stdint.h>
+
+#include "../core/char_types.h"
+#include "../core/index_types.h"
+
+#include "../pipe/pipe.h"
+
+#include "../knowledge/knowledge_types.h"
+
+#include "sequence_types.h"
+
+/*@
+   requires \valid(sequence);
+   requires \valid(*sequence);
+   requires \valid(sequence_capacity);
+   requires \valid(io);
+   requires ((sequence_required_capacity * sizeof(ZoO_index)) <= SIZE_MAX);
+   requires (*sequence_capacity >= 0);
+   requires (*sequence_capacity <= SIZE_MAX);
+   requires (((*sequence_capacity) * sizeof(ZoO_index)) <= SIZE_MAX);
+   requires \separated(sequence, sequence_capacity, io);
+
+   ensures
+   (
+      (
+         (\result >= 0)
+         && (*sequence_capacity >= sequence_required_capacity)
+         && ((*sequence_capacity * sizeof(ZoO_index)) <= SIZE_MAX)
+      )
+      || (\result < 0)
+   );
+
+   behavior successful_reallocation:
+      assigns (*sequence);
+      assigns (*sequence_capacity);
+
+      ensures (\result > 0);
+      ensures ((*sequence_capacity) == sequence_required_capacity);
+      ensures \valid(sequence);
+
+   behavior already_done:
+      assigns \nothing;
+
+      ensures (\result == 0);
+      ensures ((*sequence_capacity) >= sequence_required_capacity);
+
+   behavior failure:
+      assigns \nothing;
+
+      ensures (\result < 0);
+
+   complete behaviors;
+   disjoint behaviors;
+@*/
+int ZoO_sequence_ensure_capacity
+(
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   const size_t sequence_required_capacity,
+   const struct ZoO_pipe io [const restrict static 1]
+);
+
+int ZoO_sequence_from_undercase_string
+(
+   const ZoO_char string [const restrict],
+   const size_t string_length,
+   struct ZoO_knowledge k [const restrict static 1],
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+);
+
+/*
+ * Creates a sequence containing {initial_word}. The remaining elements of
+ * sequence are added according to what is known to {k} as being possible.
+ * The resulting sequence starts by ZoO_START_OF_SEQUENCE_ID, and ends by
+ * ZoO_END_OF_SEQUENCE_ID. The sequence is allocated by the function. If an
+ * error occur, it is unallocated and set to NULL ({sequence_size} is set
+ * accordingly).
+ * Return:
+ *    0 on success.
+ *    -1 iff the allocating failed.
+ *    -2 iff the sequence initialization failed.
+ *    -3 iff an error occured when trying to add elements to the right of the
+ *       sequence.
+ *    -4 iff an error occured when trying to add elements to the left of the
+ *       sequence.
+ *    -5 iff the resulting sequence would have been empty.
+ * Pre:
+ *    (> {markov_order} 0)
+ *    (knows {k} {initial_word})
+ *    (initialized {k})
+ */
+int ZoO_sequence_create_from
+(
+   const ZoO_index initial_word,
+   size_t credits [const restrict],
+   struct ZoO_knowledge k [const restrict static 1],
+   const ZoO_index markov_order,
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+);
+
+/*@
+   requires \valid(sequence_length);
+   requires \valid(io);
+   requires (((*sequence_length) * sizeof(ZoO_index)) <= SIZE_MAX);
+   requires (((*sequence_capacity) * sizeof(ZoO_index)) <= SIZE_MAX);
+   requires \separated(sequence, sequence_capacity, sequence_length, io);
+
+   behavior success:
+      assigns (*sequence_length);
+      assigns (*sequence[0]);
+      assigns (*sequence_capacity);
+
+      ensures (\result >= 0);
+      ensures ((*sequence_length > \old(*sequence_length)));
+
+   behavior could_not_increase_length:
+      ensures (\result == -1);
+
+      assigns (*sequence_length);
+
+   behavior could_not_reallocate:
+      ensures (\result < -1);
+
+   complete behaviors;
+   disjoint behaviors;
+@*/
+int ZoO_sequence_append_left
+(
+   const ZoO_index word_id,
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+);
+
+/*@
+   requires \valid(*sequence);
+   requires \valid(sequence_capacity);
+   requires \valid(sequence_length);
+   requires \valid(io);
+   requires (((*sequence_length) * sizeof(ZoO_index)) <= SIZE_MAX);
+   requires (((*sequence_capacity) * sizeof(ZoO_index)) <= SIZE_MAX);
+   requires \separated(sequence, sequence_capacity, sequence_length, io);
+
+   behavior success:
+      assigns (*sequence_length);
+      assigns (*sequence);
+      assigns (*sequence_capacity);
+
+      ensures (\result >= 0);
+      ensures ((*sequence_length > \old(*sequence_length)));
+
+   behavior could_not_increase_length:
+      ensures (\result == -1);
+
+      assigns (*sequence_length);
+
+   behavior could_not_reallocate:
+      ensures (\result < -1);
+
+   complete behaviors;
+   disjoint behaviors;
+@*/
+int ZoO_sequence_append_right
+(
+   ZoO_index * sequence [const restrict static 1],
+   const ZoO_index word_id,
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+);
+
+/*
+ * Compares two sequences.
+ * ZoO_END_OF_SEQUENCE marks the ending of a sequence, regardless of indicated
+ * sequence length, meaning that [10][ZoO_END_OF_SEQUENCE][9] and
+ * [10][ZoO_END_OF_SEQUENCE][8] are considered equal. Sequences do not have to
+ * contain ZoO_END_OF_SEQUENCE. [10][ZoO_END_OF_SEQUENCE] and [10] are
+ * considered different, [10][ZoO_END_OF_SEQUENCE]
+ * and [10][ZoO_END_OF_SEQUENCE][ZoO_END_OF_SEQUENCE] are considered equal.
+ * Same logic is applyied for ZoO_START_OF_SEQUENCE:
+ * [START_OF_SEQUENCE][10] is not [10], but
+ * [START_OF_SEQUENCE][START_OF_SEQUENCE][10] and [START_OF_SEQUENCE][10] are
+ * the same.
+ * Return:
+ *    1 iff {sequence_a} should be considered being more than {sequence_b}
+ *    0 iff {sequence_a} should be considered being equal to {sequence_b}
+ *    -1 iff {sequence_a} should be considered being less than {sequence_b}
+ */
+int ZoO_sequence_cmp
+(
+   const ZoO_index sequence_a [const],
+   size_t sequence_a_length,
+   const ZoO_index sequence_b [const],
+   size_t sequence_b_length
+);
+
+#endif
diff --git a/src/sequence/sequence_append.c b/src/sequence/sequence_append.c
new file mode 100644
index 0000000..a119d8b
--- /dev/null
+++ b/src/sequence/sequence_append.c
@@ -0,0 +1,212 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h> /* defines SIZE_MAX */
+
+#include "../core/index.h"
+
+#include "../pipe/pipe.h"
+
+#include "sequence.h"
+
+/******************************************************************************/
+/** MEMORY (RE)ALLOCATION *****************************************************/
+/******************************************************************************/
+
+/*@
+   requires \valid(required_capacity);
+   requires \valid(io);
+   requires (*required_capacity >= 0);
+   requires (*required_capacity <= SIZE_MAX);
+   requires \separated(required_capacity, io);
+
+   assigns \result;
+
+   ensures (*required_capacity >= 0);
+
+   behavior success:
+      assigns (*required_capacity);
+
+      ensures (\result >= 0);
+      ensures ((*required_capacity) == (\old(*required_capacity) + 1));
+      ensures (((*required_capacity) * sizeof(ZoO_index)) <= SIZE_MAX);
+
+   behavior failure:
+      assigns \nothing;
+
+      ensures (\result < 0);
+
+   complete behaviors;
+   disjoint behaviors;
+@*/
+static int increment_required_capacity
+(
+   size_t required_capacity [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   if
+   (
+      (*required_capacity == SIZE_MAX)
+      || ((SIZE_MAX / sizeof(ZoO_index)) <= (*required_capacity + 1))
+   )
+   {
+      /*@ assert \valid(io); @*/
+      /*@ ghost return -1; @*/
+      ZoO_S_ERROR
+      (
+         io,
+         "Sequence capacity increment aborted, as the new size would not fit"
+         " in a size_t variable."
+      );
+
+      return -1;
+   }
+
+   /*@ assert ((*required_capacity) < SIZE_MAX); @*/
+   /*@ assert \valid(required_capacity); @*/
+   *required_capacity = (*required_capacity + 1);
+
+   /* assert (((*required_capacity) * sizeof(ZoO_index)) <= SIZE_MAX); @*/
+
+   return 0;
+}
+
+/******************************************************************************/
+/** EXPORTED ******************************************************************/
+/******************************************************************************/
+
+int ZoO_sequence_ensure_capacity
+(
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   const size_t sequence_required_capacity,
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   ZoO_index * new_sequence;
+
+   if (sequence_required_capacity <= *sequence_capacity)
+   {
+      return 0;
+   }
+
+   /*@
+      assert
+      (
+         sequence_required_capacity
+         <= (SIZE_MAX / sizeof(ZoO_index))
+      );
+   @*/
+   /*@ assert \valid(sequence); @*/
+   /*@ assert \valid(*sequence); @*/
+
+   new_sequence =
+      (ZoO_index *) realloc
+      (
+         (void *) *sequence,
+         (sequence_required_capacity * sizeof(ZoO_index))
+      );
+
+   if (new_sequence == (ZoO_index *) NULL)
+   {
+      /*@ assert \valid(io); @*/
+      /*@ ghost return -1; @*/
+
+      ZoO_S_ERROR
+      (
+         io,
+         "Unable to reallocate memory to match sequence's required size."
+      );
+
+      return -1;
+   }
+
+   *sequence_capacity = sequence_required_capacity;
+   *sequence = new_sequence;
+
+   return 1;
+}
+
+int ZoO_sequence_append_left
+(
+   const ZoO_index word_id,
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   if (increment_required_capacity(sequence_length, io) < 0)
+   {
+      return -1;
+   }
+
+   /*@ assert (((*sequence_length) * sizeof(ZoO_index)) <= SIZE_MAX); @*/
+   if
+   (
+      /* Appears to make Frama-C forget everything about *sequence_length. */
+      ZoO_sequence_ensure_capacity
+      (
+         sequence,
+         sequence_capacity,
+         *sequence_length,
+         io
+      ) < 0
+   )
+   {
+      return -2;
+   }
+   /*@ assert *sequence_length >= 0; @*/
+
+   if (*sequence_length > 1)
+   {
+      /*@ assert(((*sequence_length) * sizeof(ZoO_index)) <= SIZE_MAX); @*/
+
+      memmove
+      (
+         (void *) (*sequence + 1),
+         (const void *) sequence,
+         (((*sequence_length) - 1) * sizeof(ZoO_index))
+      );
+   }
+
+   (*sequence)[0] = word_id;
+
+   return 0;
+}
+
+int ZoO_sequence_append_right
+(
+   ZoO_index * sequence [const restrict static 1],
+   const ZoO_index word_id,
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   if (increment_required_capacity(sequence_length, io) < 0)
+   {
+      return -1;
+   }
+
+   /*@ assert ((*sequence_length * sizeof(ZoO_index)) < SIZE_MAX); @*/
+   if
+   (
+      ZoO_sequence_ensure_capacity
+      (
+         sequence,
+         sequence_capacity,
+         *sequence_length,
+         io
+      ) < 0
+   )
+   {
+      return -1;
+   }
+
+   /* assert (*sequence_length >= 1) */
+   (*sequence)[*sequence_length - 1] = word_id;
+
+   return 0;
+}
diff --git a/src/core/sequence_creation.c b/src/sequence/sequence_creation.c
index c5ca6af..e8ae2a1 100644
--- a/src/core/sequence_creation.c
+++ b/src/sequence/sequence_creation.c
@@ -52,72 +52,6 @@ static ZoO_index weighted_random_pick
 /******************************************************************************/
 
 /*
- * Adds an id to the left of the sequence.
- * This requires the reallocation of {sequence}. The freeing of the previous
- * memory space is handled. If an error happened, {*sequence} remains untouched.
- * Returns:
- *    0 on success.
- *    -1 iff adding the word would cause an overflow.
- *    -2 iff memory allocation was unsuccessful.
- * Post:
- *    (initialized {sequence})
- *    (initialized {*sequence})
- */
-static int left_append
-(
-   const ZoO_index word_id,
-   ZoO_index * sequence [const restrict],
-   const size_t sequence_size,
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index * new_sequence;
-
-   if ((SIZE_MAX - sizeof(ZoO_index)) > sequence_size)
-   {
-      ZoO_S_ERROR
-      (
-         io,
-         "Left side append aborted, as the new sequence's size would overflow."
-      );
-
-      return -1;
-   }
-
-   new_sequence = (ZoO_index *) malloc(sizeof(ZoO_index) + sequence_size);
-
-   if (new_sequence == (ZoO_index *) NULL)
-   {
-      ZoO_S_ERROR
-      (
-         io,
-         "Left side append aborted, as memory for the new sequence could not be"
-         " allocated."
-      );
-
-      return -2;
-   }
-
-   if (sequence_size > 0)
-   {
-      memcpy
-      (
-         (void *) (new_sequence + 1),
-         (const void *) sequence,
-         sequence_size
-      );
-
-      free((void *) sequence);
-   }
-
-   new_sequence[0] = word_id;
-
-   *sequence = new_sequence;
-
-   return 0;
-}
-
-/*
  * Adds an id to the left of the sequence, according to what is known as likely
  * to fit there.
  * This requires the reallocation of {sequence}. The freeing of the previous
@@ -137,9 +71,10 @@ static int left_append
 static int extend_left
 (
    ZoO_index * sequence [const restrict static 1],
-   const size_t sequence_size,
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
    const ZoO_index markov_order,
-   const struct ZoO_knowledge k [const restrict static 1],
+   struct ZoO_knowledge k [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
@@ -172,7 +107,7 @@ static int extend_left
 
    if
    (
-      left_append
+      ZoO_sequence_append_left
       (
          weighted_random_pick
          (
@@ -180,7 +115,8 @@ static int extend_left
             preceding_words_weights_sum
          ),
          sequence,
-         sequence_size,
+         sequence_capacity,
+         sequence_length,
          io
       ) < 0
    )
@@ -220,18 +156,30 @@ static int extend_left
 static int complete_left_part_of_sequence
 (
    ZoO_index * sequence [restrict static 1],
-   size_t sequence_size [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
    const ZoO_index markov_order,
-   ZoO_index credits [const restrict],
-   const struct ZoO_knowledge k [const restrict static 1],
+   size_t credits [const restrict],
+   struct ZoO_knowledge k [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
    for (;;)
    {
-      if ((credits == (ZoO_index *) NULL) || (*credits > 0))
+      if ((credits == (size_t *) NULL) || (*credits > 0))
       {
-         if (extend_left(sequence, *sequence_size, markov_order, k, io) < 0)
+         if
+         (
+            extend_left
+            (
+               sequence,
+               sequence_capacity,
+               sequence_length,
+               markov_order,
+               k,
+               io
+            ) < 0
+         )
          {
             /* We are sure *sequence[0] is defined. */
             if (*sequence[0] == ZoO_START_OF_SEQUENCE_ID)
@@ -256,13 +204,7 @@ static int complete_left_part_of_sequence
          return 0;
       }
 
-      /*
-       * Safe: if it was going to overflow, extend_left would have returned a
-       * negative value, making this statement unreachable.
-       */
-      *sequence_size = (*sequence_size + sizeof(ZoO_index));
-
-      if (credits != (ZoO_index *) NULL)
+      if (credits != (size_t *) NULL)
       {
          *credits -= 1;
       }
@@ -293,65 +235,6 @@ static int complete_left_part_of_sequence
 /** ADDING ELEMENTS TO THE RIGHT **********************************************/
 /******************************************************************************/
 
-/*
- * Adds an id to the right of the sequence.
- * This requires the reallocation of {sequence}. The freeing of the previous
- * memory space is handled. If an error happened, {sequence} remain untouched.
- * Returns:
- *    0 on success.
- *    -1 iff adding the word would cause an overflow.
- *    -2 iff memory allocation was unsuccessful.
- * Post:
- *    (initialized {sequence})
- *    (initialized {*sequence})
- */
-static int right_append
-(
-   ZoO_index * sequence [const restrict],
-   const ZoO_index word_id,
-   const size_t sequence_size,
-   const ZoO_index sequence_length,
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   ZoO_index * new_sequence;
-
-   if ((SIZE_MAX - sizeof(ZoO_index)) > sequence_size)
-   {
-      ZoO_S_ERROR
-      (
-         io,
-         "Right side append aborted, as the new sequence's size would overflow."
-      );
-
-      return -1;
-   }
-
-   new_sequence =
-      (ZoO_index *) realloc
-      (
-         sequence,
-         (sequence_size + sizeof(ZoO_index))
-      );
-
-   if (new_sequence == (ZoO_index *) NULL)
-   {
-      ZoO_S_ERROR
-      (
-         io,
-         "Right side append aborted, as memory for the new sequence could not "
-         "be allocated."
-      );
-
-      return -2;
-   }
-
-   new_sequence[sequence_length] = word_id;
-
-   *sequence = new_sequence;
-
-   return 0;
-}
 
 /*
  * Adds an id to the right of the sequence, according to what is known as likely
@@ -373,10 +256,10 @@ static int right_append
 static int extend_right
 (
    ZoO_index * sequence [const restrict static 1],
-   const size_t sequence_size,
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
    const ZoO_index markov_order,
-   const ZoO_index sequence_length,
-   const struct ZoO_knowledge k [const restrict static 1],
+   struct ZoO_knowledge k [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
@@ -393,11 +276,12 @@ static int extend_right
       (
          k,
          *sequence,
-         sequence_length,
+         *sequence_length,
          markov_order,
          &following_words,
          &following_words_weights,
-         &following_words_weights_sum
+         &following_words_weights_sum,
+         io
       ) < 0
    )
    {
@@ -410,7 +294,7 @@ static int extend_right
 
    if
    (
-      right_append
+      ZoO_sequence_append_right
       (
          sequence,
          weighted_random_pick
@@ -418,7 +302,7 @@ static int extend_right
             following_words_weights,
             following_words_weights_sum
          ),
-         sequence_size,
+         sequence_capacity,
          sequence_length,
          io
       ) < 0
@@ -459,36 +343,33 @@ static int extend_right
 static int complete_right_part_of_sequence
 (
    ZoO_index * sequence [const restrict static 1],
-   size_t sequence_size [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
    const ZoO_index markov_order,
-   ZoO_index credits [const restrict],
-   const struct ZoO_knowledge k [const restrict static 1],
+   size_t credits [const restrict],
+   struct ZoO_knowledge k [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
-   ZoO_index sequence_length;
-
-   sequence_length = (*sequence_size / sizeof(ZoO_index));
-
    for (;;)
    {
-      if ((credits == (ZoO_index *) NULL) || (*credits > 0))
+      if ((credits == (size_t *) NULL) || (*credits > 0))
       {
          if
          (
             extend_right
             (
                sequence,
-               *sequence_size,
-               markov_order,
+               sequence_capacity,
                sequence_length,
+               markov_order,
                k,
                io
             ) < 0
          )
          {
             /* Safe: (> sequence_length 1) */
-            if (*sequence[(sequence_length - 1)] == ZoO_END_OF_SEQUENCE_ID)
+            if (*sequence[(*sequence_length - 1)] == ZoO_END_OF_SEQUENCE_ID)
             {
                /*
                 * We failed to add a word, but it was because none should have
@@ -505,25 +386,18 @@ static int complete_right_part_of_sequence
       else
       {
          /* No more credits available, we end the sequence. */
-         *sequence[(sequence_length - 1)] = ZoO_END_OF_SEQUENCE_ID;
+         *sequence[(*sequence_length - 1)] = ZoO_END_OF_SEQUENCE_ID;
 
          return 0;
       }
 
-      /*
-       * Safe: if it was going to overflow, extend_left would have returned a
-       * negative value, making this statement unreachable.
-       */
-      *sequence_size = (*sequence_size + sizeof(ZoO_index));
-      sequence_length += 1;
-
-      if (credits != (ZoO_index *) NULL)
+      if (credits != (size_t *) NULL)
       {
          *credits -= 1;
       }
 
       /* Safe: (> sequence_length 1) */
-      switch (*sequence[(sequence_length - 1)])
+      switch (*sequence[(*sequence_length - 1)])
       {
          case ZoO_START_OF_SEQUENCE_ID:
             ZoO_S_WARNING
@@ -532,7 +406,7 @@ static int complete_right_part_of_sequence
                "END OF LINE was added at the right part of an sequence."
             );
 
-            *sequence[(sequence_length - 1)] = ZoO_END_OF_SEQUENCE_ID;
+            *sequence[(*sequence_length - 1)] = ZoO_END_OF_SEQUENCE_ID;
             return 0;
 
          case ZoO_END_OF_SEQUENCE_ID:
@@ -549,58 +423,6 @@ static int complete_right_part_of_sequence
 /******************************************************************************/
 
 /*
- * Allocates the memory required to store the initial sequence.
- * Returns:
- *    0 on success.
- *    -1 if this would require more memory than can indicate a size_t variable.
- *    -2 if the allocation failed.
- * Post:
- *    (initialized {*sequence})
- *    (initialized {*sequence_size})
- */
-static int allocate_initial_sequence
-(
-   ZoO_index * sequence [const restrict static 1],
-   size_t sequence_size [const restrict static 1],
-   const ZoO_index markov_order,
-   const struct ZoO_pipe io [const restrict static 1]
-)
-{
-   if ((SIZE_MAX / sizeof(ZoO_index)) > ((size_t) markov_order))
-   {
-      ZoO_S_ERROR
-      (
-         io,
-         "Unable to store size of the initial sequence in a size_t variable."
-         "Either reduce the size of a ZoO_index or the markovian order."
-      );
-
-      *sequence = (ZoO_index *) NULL;
-      *sequence_size = 0;
-
-      return -1;
-   }
-
-   *sequence_size = (((size_t) markov_order) * sizeof(ZoO_index));
-   *sequence = (ZoO_index *) malloc(*sequence_size);
-
-   if (*sequence == (void *) NULL)
-   {
-      *sequence_size = 0;
-
-      ZoO_S_ERROR
-      (
-         io,
-         "Unable to allocate the memory required for an new sequence."
-      );
-
-      return -2;
-   }
-
-   return 0;
-}
-
-/*
  * Initializes an pre-allocated sequence by filling it with {initial_word}
  * followed by a sequence of ({markov_order} - 1) words that is known to have
  * followed {initial_word} at least once. This sequence is chosen depending on
@@ -621,7 +443,7 @@ static int initialize_sequence
    ZoO_index sequence [const restrict static 1],
    const ZoO_index initial_word,
    const ZoO_index markov_order,
-   const struct ZoO_knowledge k [const static 1],
+   struct ZoO_knowledge k [const static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
@@ -637,7 +459,6 @@ static int initialize_sequence
       return 0;
    }
 
-   /* TODO */
    (void) ZoO_knowledge_lock_access(k, io);
 
    if
@@ -701,33 +522,57 @@ static int initialize_sequence
 int ZoO_sequence_create_from
 (
    const ZoO_index initial_word,
-   ZoO_index credits [const restrict],
-   const struct ZoO_knowledge k [const restrict static 1],
+   size_t credits [const restrict],
+   struct ZoO_knowledge k [const restrict static 1],
    const ZoO_index markov_order,
    ZoO_index * sequence [const restrict static 1],
-   size_t sequence_size [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
    const struct ZoO_pipe io [const restrict static 1]
 )
 {
-   if (allocate_initial_sequence(sequence, sequence_size, markov_order, io) < 0)
+   if
+   (
+      ZoO_sequence_ensure_capacity
+      (
+         sequence,
+         sequence_capacity,
+         markov_order,
+         io
+      ) < 0
+   )
    {
+      *sequence_length = 0;
+
       return -1;
    }
 
-   if (initialize_sequence(*sequence, initial_word, markov_order, k, io) < 0)
+   if
+   (
+      initialize_sequence
+      (
+         *sequence,
+         initial_word,
+         markov_order,
+         k,
+         io
+      ) < 0
+   )
    {
-      free((void *) *sequence);
-      *sequence_size = 0;
+      *sequence_length = 0;
 
       return -2;
    }
 
+   *sequence_length = markov_order;
+
    if
    (
       complete_right_part_of_sequence
       (
          sequence,
-         sequence_size,
+         sequence_capacity,
+         sequence_length,
          markov_order,
          credits,
          k,
@@ -735,8 +580,7 @@ int ZoO_sequence_create_from
       ) < 0
    )
    {
-      free((void *) *sequence);
-      *sequence_size = 0;
+      *sequence_length = 0;
 
       return -3;
    }
@@ -746,7 +590,8 @@ int ZoO_sequence_create_from
       complete_left_part_of_sequence
       (
          sequence,
-         sequence_size,
+         sequence_capacity,
+         sequence_length,
          markov_order,
          credits,
          k,
@@ -754,19 +599,17 @@ int ZoO_sequence_create_from
       ) < 0
    )
    {
-      free((void *) *sequence);
-      *sequence_size = 0;
+      *sequence_length = 0;
 
       return -4;
    }
 
-   if ((*sequence_size / sizeof(ZoO_index)) < 3)
+   if (*sequence_length < 3)
    {
       /* 2 elements, for start and stop. */
       ZoO_S_ERROR(io, "Created sequence was empty.");
 
-      free((void *) *sequence);
-      *sequence_size = 0;
+      *sequence_length = 0;
 
       return -5;
    }
diff --git a/src/sequence/sequence_from_string.c b/src/sequence/sequence_from_string.c
new file mode 100644
index 0000000..cd04d70
--- /dev/null
+++ b/src/sequence/sequence_from_string.c
@@ -0,0 +1,214 @@
+#define _POSIX_C_SOURCE 200809L
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h> /* defines SIZE_MAX */
+
+#include "../core/char.h"
+#include "../core/index.h"
+
+#include "../pipe/pipe.h"
+
+#include "../knowledge/knowledge.h"
+
+#include "sequence.h"
+
+/******************************************************************************/
+/** HANDLING WORDS ************************************************************/
+/******************************************************************************/
+
+/*
+ * Semaphore:
+ *    Takes then releases access for {k}.
+ */
+static int add_word_to_sequence
+(
+   const ZoO_char string [const restrict static 1],
+   const size_t word_start,
+   const size_t word_length,
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   struct ZoO_knowledge k [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   ZoO_index word_id;
+   ZoO_char * stored_word;
+
+   if (word_length == 0)
+   {
+      return 0;
+   }
+
+   (void) ZoO_knowledge_lock_access(k, io);
+
+   if
+   (
+      ZoO_knowledge_learn_word
+      (
+         k,
+         (string + word_start),
+         word_length,
+         &word_id,
+         io
+      ) < 0
+   )
+   {
+      (void) ZoO_knowledge_unlock_access(k, io);
+
+      return -1;
+   }
+
+   (void) ZoO_knowledge_unlock_access(k, io);
+
+   if
+   (
+      ZoO_sequence_append_right
+      (
+         sequence,
+         word_id,
+         sequence_capacity,
+         sequence_length,
+         io
+      ) < 0
+   )
+   {
+      return -1;
+   }
+
+   return 0;
+}
+
+static int find_word
+(
+   const ZoO_char string [const restrict static 1],
+   const size_t string_length,
+   const size_t offset,
+   size_t word_start [const restrict static 1],
+   size_t word_length [const restrict static 1]
+)
+{
+   size_t i;
+
+   i = offset;
+
+   while ((string[i] == ' ') && (i < string_length))
+   {
+      i += 1;
+   }
+
+   if (i >= string_length)
+   {
+      return -1;
+   }
+
+   *word_start = i;
+
+   while ((string[i] != ' ') && (i < string_length))
+   {
+      i += 1;
+   }
+
+   if (i >= string_length)
+   {
+      return -1;
+   }
+
+   *word_length = (i - *word_start);
+
+   return 0;
+}
+
+/******************************************************************************/
+/** EXPORTED ******************************************************************/
+/******************************************************************************/
+
+/* See: "sequence.h" */
+int ZoO_sequence_from_undercase_string
+(
+   const ZoO_char string [const restrict],
+   const size_t string_length,
+   struct ZoO_knowledge k [const restrict static 1],
+   ZoO_index * sequence [const restrict static 1],
+   size_t sequence_capacity [const restrict static 1],
+   size_t sequence_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   size_t word_start, word_length;
+   size_t i;
+
+   i = 0;
+
+   *sequence = (ZoO_index *) NULL;
+   *sequence_length = 0;
+
+   if
+   (
+      ZoO_sequence_append_right
+      (
+         sequence,
+         ZoO_START_OF_SEQUENCE_ID,
+         sequence_capacity,
+         sequence_length,
+         io
+      ) < 0
+   )
+   {
+      return -1;
+   }
+
+   while (i < string_length)
+   {
+      if (find_word(string, i, string_length, &word_start, &word_length) < 0)
+      {
+         break;
+      }
+
+      if
+      (
+         add_word_to_sequence
+         (
+            string,
+            word_start,
+            word_length,
+            sequence,
+            sequence_capacity,
+            sequence_length,
+            k,
+            io
+         ) < 0
+      )
+      {
+         free((void *) *sequence);
+         *sequence = (ZoO_index *) NULL;
+         *sequence_length = 0;
+
+         return -1;
+      }
+
+      i = (word_start + word_length);
+   }
+
+   if
+   (
+      ZoO_sequence_append_right
+      (
+         sequence,
+         ZoO_END_OF_SEQUENCE_ID,
+         sequence_capacity,
+         sequence_length,
+         io
+      ) < 0
+   )
+   {
+      free((void *) *sequence);
+
+      *sequence = (ZoO_index *) NULL;
+      *sequence_length = 0;
+
+      return -1;
+   }
+
+   return 0;
+}
diff --git a/src/sequence/sequence_to_string.c b/src/sequence/sequence_to_string.c
new file mode 100644
index 0000000..cec3af8
--- /dev/null
+++ b/src/sequence/sequence_to_string.c
@@ -0,0 +1,189 @@
+#define _POSIX_C_SOURCE 200809L
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h> /* defines SIZE_MAX */
+
+#include "../core/char.h"
+#include "../core/index.h"
+
+#include "../pipe/pipe.h"
+
+#include "../knowledge/knowledge.h"
+
+#include "sequence.h"
+
+/******************************************************************************/
+/** MEMORY ALLOCATION *********************************************************/
+/******************************************************************************/
+static int ensure_string_capacity
+(
+   ZoO_char * string [const restrict static 1],
+   size_t string_capacity [const restrict static 1],
+   const size_t string_required_capacity,
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   ZoO_char * new_string;
+
+   if (string_required_capacity <= *string_capacity)
+   {
+      return 0;
+   }
+
+   new_string =
+      (ZoO_char *) realloc
+      (
+         (void *) *string,
+         ((size_t) string_required_capacity) * sizeof(ZoO_char)
+      );
+
+   if (new_string== (ZoO_char *) NULL)
+   {
+      ZoO_S_ERROR
+      (
+         io,
+         "Unable to reallocate memory to match string's required size."
+      );
+
+      return -1;
+   }
+
+   *string_capacity = string_required_capacity;
+   *string = new_string;
+
+   return 1;
+}
+
+/******************************************************************************/
+/** ADD WORD ******************************************************************/
+/******************************************************************************/
+static int increment_required_capacity
+(
+   size_t current_capacity [const restrict static 1],
+   const size_t increase_factor,
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   if ((ZoO_INDEX_MAX - increase_factor) > *current_capacity)
+   {
+      ZoO_S_ERROR
+      (
+         io,
+         "String capacity increment aborted, as the new capacity would not"
+         " fit in a ZoO_index variable."
+      );
+
+      return -1;
+   }
+
+   *current_capacity += increase_factor;
+
+   if ((SIZE_MAX / sizeof(ZoO_char)) > *current_capacity)
+   {
+      *current_capacity -= increase_factor;
+
+      ZoO_S_ERROR
+      (
+         io,
+         "String capacity increment aborted, as the new size would not fit"
+         " in a size_t variable."
+      );
+
+      return -2;
+   }
+
+   return 0;
+}
+
+static int add_word
+(
+   const ZoO_index word_id,
+   struct ZoO_knowledge k [const restrict static 1],
+   ZoO_char * destination [const restrict static 1],
+   size_t destination_capacity [const restrict static 1],
+   size_t destination_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+	const ZoO_char * word;
+	ZoO_index word_size;
+   size_t insertion_point;
+
+	(void) ZoO_knowledge_lock_access(k, io);
+	ZoO_knowledge_get_word(k, word_id, &word, &word_size, io);
+	(void) ZoO_knowledge_unlock_access(k, io);
+
+   insertion_point = *destination_length;
+
+   /* word_size includes '\n', which will be replaced by a space. */
+   /* (word_size == ZoO_INDEX_MAX) ==> could not have learned word. */
+   if (increment_required_capacity(destination_length, (word_size + 1), io) < 0)
+   {
+      return -1;
+   }
+
+   if
+   (
+      ensure_string_capacity
+      (
+         destination,
+         destination_capacity,
+         *destination_length,
+         io
+      ) < 0
+   )
+   {
+      return -2;
+   }
+
+   memcpy
+   (
+      (*destination + insertion_point),
+      (const void *) word,
+      word_size
+   );
+
+   (*destination)[*destination_length - 1] = ' ';
+
+   return 0;
+}
+
+/******************************************************************************/
+/** EXPORTED ******************************************************************/
+/******************************************************************************/
+int ZoO_sequence_to_undercase_string
+(
+   const ZoO_index sequence [const restrict static 1],
+   const size_t sequence_length,
+   ZoO_char * destination [const restrict static 1],
+   struct ZoO_knowledge k [const restrict static 1],
+   size_t destination_capacity [const restrict static 1],
+   size_t destination_length [const restrict static 1],
+   const struct ZoO_pipe io [const restrict static 1]
+)
+{
+   size_t i;
+
+   for (i = 0; i < sequence_length; ++i)
+   {
+      if
+      (
+         add_word
+         (
+            sequence[i],
+            k,
+            destination,
+            destination_capacity,
+            destination_length,
+            io
+         ) < 0
+      )
+      {
+         *destination_length = 0;
+
+         return -1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/core/sequence_types.h b/src/sequence/sequence_types.h
index c260a8a..717d418 100644
--- a/src/core/sequence_types.h
+++ b/src/sequence/sequence_types.h
@@ -3,8 +3,7 @@
 
 #define ZoO_START_OF_SEQUENCE_ID 0
 #define ZoO_END_OF_SEQUENCE_ID   1
-#define ZoO_ACTION_SEQUENCE_ID   2
 
-#define ZoO_RESERVED_IDS_COUNT   3
+#define ZoO_RESERVED_IDS_COUNT   2
 
 #endif
diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt
new file mode 100644
index 0000000..2d1beaa
--- /dev/null
+++ b/src/server/CMakeLists.txt
@@ -0,0 +1,8 @@
+set(
+   SRC_FILES ${SRC_FILES}
+   ${CMAKE_CURRENT_SOURCE_DIR}/server.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_worker.c
+)
+
+set(SRC_FILES ${SRC_FILES} PARENT_SCOPE)
+
diff --git a/src/server/server.c b/src/server/server.c
index 3ded7cc..8a75615 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -1,6 +1,7 @@
 #include <signal.h>
+#include <stdio.h>
 
-#include "../cli/parameters.h"
+#include "../parameters/parameters.h"
 
 #include "server.h"
 
@@ -18,6 +19,7 @@ int ZoO_server_main (const struct ZoO_parameters params)
 {
    struct ZoO_server server;
    struct ZoO_server_message msg_buffer;
+   struct ZoO_server_worker_parameters worker_params;
 
    if
    (
@@ -31,6 +33,14 @@ int ZoO_server_main (const struct ZoO_parameters params)
       return -1;
    }
 
+   ZoO_server_worker_initialize_parameters
+   (
+      &worker_params,
+      &server,
+      &msg_buffer,
+      &params
+   );
+
    while ((ZoO_SERVER_IS_RUNNING == (char) 1) || (server.running_threads > 0))
    {
       if (ZoO_server_receive_message(&server, &msg_buffer) < 0)
@@ -42,13 +52,21 @@ int ZoO_server_main (const struct ZoO_parameters params)
 
       switch (msg_buffer.type)
       {
-         case 'C':
-            ZoO_server_new_client(&server, &msg_buffer);
+         case 'C': /* Client request */
+            ZoO_server_add_worker(&server, &worker_params);
+            break;
 
-         case 'J':
-            ZoO_server_join_thread(&server, &msg_buffer);
+         case 'J': /* Join request */
+            ZoO_server_finalize_worker(&server, &msg_buffer);
+            break;
 
          default:
+            fprintf
+            (
+               stderr,
+               "[W] Received message with unknown type '%c'.\n",
+               msg_buffer.type
+            );
             break;
       }
    }
diff --git a/src/server/server.h b/src/server/server.h
index a75c6e7..f6aa0de 100644
--- a/src/server/server.h
+++ b/src/server/server.h
@@ -1,7 +1,7 @@
 #ifndef _ZoO_SERVER_SERVER_H_
 #define _ZoO_SERVER_SERVER_H_
 
-#include "../cli/parameters_types.h"
+#include "../parameters/parameters_types.h"
 
 #include "server_types.h"
 
@@ -24,13 +24,14 @@ int ZoO_server_receive_message
    struct ZoO_server_message msg_buffer [const restrict static 1]
 );
 
-int ZoO_server_new_client
+int ZoO_server_add_worker
 (
-   struct ZoO_server [const restrict static 1],
-   struct ZoO_server_message msg_buffer [const restrict static 1]
+   struct ZoO_server s [const restrict static 1],
+   struct ZoO_server_message msg_buffer [const restrict static 1],
+   struct ZoO_worker_parameters worker_params [const restrict static 1]
 );
 
-int ZoO_server_join_thread
+int ZoO_server_finalize_worker
 (
    struct ZoO_server [const restrict static 1],
    struct ZoO_server_message msg_buffer [const restrict static 1]
diff --git a/src/server/server_add_server_worker.c b/src/server/server_add_server_worker.c
new file mode 100644
index 0000000..cae10fd
--- /dev/null
+++ b/src/server/server_add_server_worker.c
@@ -0,0 +1,13 @@
+#include <pthread.h>
+
+#include "server.h"
+
+int ZoO_server_add_worker
+(
+   struct ZoO_server s [const restrict static 1],
+   struct ZoO_server_message msg_buffer [const restrict static 1]
+)
+{
+   /* TODO */
+   return -1;
+}
diff --git a/src/server/server_types.h b/src/server/server_types.h
index 75016d4..aeb0ec8 100644
--- a/src/server/server_types.h
+++ b/src/server/server_types.h
@@ -5,24 +5,21 @@
 
 #include "../core/index.h"
 
-struct ZoO_server_pipes_data
-{
-   char request_pipe[255];
-   char reply_pipe[255];
-};
+#include "../pipe/pipe_types.h"
 
 struct ZoO_server_message
 {
    char type;
    union
    {
-      struct ZoO_server_pipes_data pipes_name;
+      struct ZoO_pipe_names pipe_names;
       ZoO_index pthread_id;
    } data;
 };
 
 struct ZoO_server
 {
+   /* TODO: insert 2 thread barrier. */
    mqd_t mailbox;
    ZoO_index running_threads;
 };
diff --git a/src/server/server_worker.c b/src/server/server_worker.c
new file mode 100644
index 0000000..04f71ca
--- /dev/null
+++ b/src/server/server_worker.c
@@ -0,0 +1,21 @@
+#include "worker.h"
+
+void ZoO_worker_initialize_parameters
+(
+   struct ZoO_worker_parameters worker_params;
+   const struct ZoO_server_message msg_buffer [const restrict static 1],
+   const struct ZoO_parameters params [const restrict static 1]
+)
+{
+   worker_params->thread_id = 0;
+   pthread_barrier_t * barrier;
+   mqd_t * server_mailbox;
+   const struct ZoO_pipe_names * pipe_names;
+
+   /* Program data */
+   ZoO_index markov_order;
+   struct ZoO_knowledge * k;
+   const char * storage_filename;
+
+   /* TODO */
+}
diff --git a/src/server/server_worker.h b/src/server/server_worker.h
new file mode 100644
index 0000000..825cc11
--- /dev/null
+++ b/src/server/server_worker.h
@@ -0,0 +1,8 @@
+#ifndef _ZoO_WORKER_WORKER_H_
+#define _ZoO_WORKER_WORKER_H_
+
+#include "../parameters/parameters_types.h"
+
+#include "worker_types.h"
+
+#endif
diff --git a/src/server/server_worker_types.h b/src/server/server_worker_types.h
new file mode 100644
index 0000000..07757bd
--- /dev/null
+++ b/src/server/server_worker_types.h
@@ -0,0 +1,27 @@
+#ifndef _ZoO_WORKER_WORKER_TYPES_H_
+#define _ZoO_WORKER_WORKER_TYPES_H_
+
+#include <mqueue.h>
+
+#include "../core/index_types.h"
+
+#include "../pipes/pipes_types.h"
+
+#include "../knowledge/knowledge_types.h"
+
+
+struct ZoO_worker_parameters
+{
+   /* Communication data */
+   ZoO_index thread_id;
+   pthread_barrier_t * barrier;
+   mqd_t * server_mailbox;
+   const struct ZoO_pipe_names * pipe_names;
+
+   /* Program data */
+   ZoO_index markov_order;
+   struct ZoO_knowledge * k;
+   const char * storage_filename;
+};
+
+#endif