X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fregex%2Fregex.c;h=c8b8ad3faedb680268ff3256c91ea8b868a9a449;hb=adbde8be4b6ee0a854177237391936faa8ca61c2;hp=721fe35596b91f906a7258e454ce10552ac973f9;hpb=fc28f65347c3d353c3b60468367f5765b0048c5c;p=oweals%2Fgnunet.git

diff --git a/src/regex/regex.c b/src/regex/regex.c
index 721fe3559..c8b8ad3fa 100644
--- a/src/regex/regex.c
+++ b/src/regex/regex.c
@@ -28,10 +28,12 @@
 #include "gnunet_regex_lib.h"
 #include "regex_internal.h"
 
+
 /**
  * Constant for how many bits the initial string regex should have.
  */
-#define INITIAL_BITS 10
+#define INITIAL_BITS 8
+
 
 /**
  * Context that contains an id counter for states and transitions as well as a
@@ -60,211 +62,6 @@ struct GNUNET_REGEX_Context
   struct GNUNET_REGEX_Automaton *stack_tail;
 };
 
-/**
- * Type of an automaton.
- */
-enum GNUNET_REGEX_AutomatonType
-{
-  NFA,
-  DFA
-};
-
-/**
- * Automaton representation.
- */
-struct GNUNET_REGEX_Automaton
-{
-  /**
-   * Linked list of NFAs used for partial NFA creation.
-   */
-  struct GNUNET_REGEX_Automaton *prev;
-
-  /**
-   * Linked list of NFAs used for partial NFA creation.
-   */
-  struct GNUNET_REGEX_Automaton *next;
-
-  /**
-   * First state of the automaton. This is mainly used for constructing an NFA,
-   * where each NFA itself consists of one or more NFAs linked together.
-   */
-  struct GNUNET_REGEX_State *start;
-
-  /**
-   * End state of the partial NFA. This is undefined for DFAs
-   */
-  struct GNUNET_REGEX_State *end;
-
-  /**
-   * Number of states in the automaton.
-   */
-  unsigned int state_count;
-
-  /**
-   * DLL of states.
-   */
-  struct GNUNET_REGEX_State *states_head;
-
-  /**
-   * DLL of states
-   */
-  struct GNUNET_REGEX_State *states_tail;
-
-  /**
-   * Type of the automaton.
-   */
-  enum GNUNET_REGEX_AutomatonType type;
-
-  /**
-   * Regex
-   */
-  char *regex;
-
-  /**
-   * Canonical regex (result of RX->NFA->DFA->RX)
-   */
-  char *canonical_regex;
-};
-
-/**
- * A state. Can be used in DFA and NFA automatons.
- */
-struct GNUNET_REGEX_State
-{
-  /**
-   * This is a linked list.
-   */
-  struct GNUNET_REGEX_State *prev;
-
-  /**
-   * This is a linked list.
-   */
-  struct GNUNET_REGEX_State *next;
-
-  /**
-   * Unique state id.
-   */
-  unsigned int id;
-
-  /**
-   * If this is an accepting state or not.
-   */
-  int accepting;
-
-  /**
-   * Marking of the state. This is used for marking all visited states when
-   * traversing all states of an automaton and for cases where the state id
-   * cannot be used (dfa minimization).
-   */
-  int marked;
-
-  /**
-   * Marking the state as contained. This is used for checking, if the state is
-   * contained in a set in constant time
-   */
-  int contained;
-
-  /**
-   * Marking the state as part of an SCC (Strongly Connected Component).  All
-   * states with the same scc_id are part of the same SCC. scc_id is 0, if state
-   * is not a part of any SCC.
-   */
-  unsigned int scc_id;
-
-  /**
-   * Used for SCC detection.
-   */
-  int index;
-
-  /**
-   * Used for SCC detection.
-   */
-  int lowlink;
-
-  /**
-   * Human readable name of the automaton. Used for debugging and graph
-   * creation.
-   */
-  char *name;
-
-  /**
-   * Hash of the state.
-   */
-  struct GNUNET_HashCode hash;
-
-  /**
-   * State ID for proof creation.
-   */
-  unsigned int proof_id;
-
-  /**
-   * Proof for this state.
-   */
-  char *proof;
-
-  /**
-   * Number of transitions from this state to other states.
-   */
-  unsigned int transition_count;
-
-  /**
-   * DLL of transitions.
-   */
-  struct Transition *transitions_head;
-
-  /**
-   * DLL of transitions.
-   */
-  struct Transition *transitions_tail;
-
-  /**
-   * Set of states on which this state is based on. Used when creating a DFA out
-   * of several NFA states.
-   */
-  struct GNUNET_REGEX_StateSet *nfa_set;
-};
-
-/**
- * Transition between two states. Each state can have 0-n transitions.  If label
- * is 0, this is considered to be an epsilon transition.
- */
-struct Transition
-{
-  /**
-   * This is a linked list.
-   */
-  struct Transition *prev;
-
-  /**
-   * This is a linked list.
-   */
-  struct Transition *next;
-
-  /**
-   * Unique id of this transition.
-   */
-  unsigned int id;
-
-  /**
-   * Label for this transition. This is basically the edge label for the graph.
-   */
-  char label;
-
-  /**
-   * State to which this transition leads.
-   */
-  struct GNUNET_REGEX_State *to_state;
-
-  /**
-   * State from which this transition origins.
-   */
-  struct GNUNET_REGEX_State *from_state;
-
-  /**
-   * Mark this transition. For example when reversing the automaton.
-   */
-  int mark;
-};
 
 /**
  * Set of states.
@@ -282,6 +79,7 @@ struct GNUNET_REGEX_StateSet
   unsigned int len;
 };
 
+
 /*
  * Debug helper functions
  */
@@ -294,6 +92,7 @@ struct GNUNET_REGEX_StateSet
 void
 debug_print_transitions (struct GNUNET_REGEX_State *s);
 
+
 /**
  * Print information of the given state 's'.
  *
@@ -318,6 +117,7 @@ debug_print_state (struct GNUNET_REGEX_State *s)
   debug_print_transitions (s);
 }
 
+
 /**
  * Print debug information for all states contained in the automaton 'a'.
  *
@@ -332,13 +132,14 @@ debug_print_states (struct GNUNET_REGEX_Automaton *a)
     debug_print_state (s);
 }
 
+
 /**
  * Print debug information for given transition 't'.
  *
  * @param t transition for which to print debug info.
  */
 void
-debug_print_transition (struct Transition *t)
+debug_print_transition (struct GNUNET_REGEX_Transition *t)
 {
   char *to_state;
   char *from_state;
@@ -366,107 +167,17 @@ debug_print_transition (struct Transition *t)
               t->id, from_state, label, to_state);
 }
 
+
 void
 debug_print_transitions (struct GNUNET_REGEX_State *s)
 {
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
 
   for (t = s->transitions_head; NULL != t; t = t->next)
     debug_print_transition (t);
 }
 
 
-/**
- * Recursive function doing DFS with 'v' as a start, detecting all SCCs inside
- * the subgraph reachable from 'v'. Used with scc_tarjan function to detect all
- * SCCs inside an automaton.
- *
- * @param scc_counter counter for numbering the sccs
- * @param v start vertex
- * @param index current index
- * @param stack stack for saving all SCCs
- * @param stack_size current size of the stack
- */
-static void
-scc_tarjan_strongconnect (unsigned int *scc_counter,
-                          struct GNUNET_REGEX_State *v, unsigned int *index,
-                          struct GNUNET_REGEX_State **stack,
-                          unsigned int *stack_size)
-{
-  struct GNUNET_REGEX_State *w;
-  struct Transition *t;
-
-  v->index = *index;
-  v->lowlink = *index;
-  (*index)++;
-  stack[(*stack_size)++] = v;
-  v->contained = 1;
-
-  for (t = v->transitions_head; NULL != t; t = t->next)
-  {
-    w = t->to_state;
-    if (NULL != w && w->index < 0)
-    {
-      scc_tarjan_strongconnect (scc_counter, w, index, stack, stack_size);
-      v->lowlink = (v->lowlink > w->lowlink) ? w->lowlink : v->lowlink;
-    }
-    else if (0 != w->contained)
-      v->lowlink = (v->lowlink > w->index) ? w->index : v->lowlink;
-  }
-
-  if (v->lowlink == v->index)
-  {
-    w = stack[--(*stack_size)];
-    w->contained = 0;
-
-    if (v != w)
-    {
-      (*scc_counter)++;
-      while (v != w)
-      {
-        w->scc_id = *scc_counter;
-        w = stack[--(*stack_size)];
-        w->contained = 0;
-      }
-      w->scc_id = *scc_counter;
-    }
-  }
-}
-
-
-/**
- * Detect all SCCs (Strongly Connected Components) inside the given automaton.
- * SCCs will be marked using the scc_id on each state.
- *
- * @param a the automaton for which SCCs should be computed and assigned.
- */
-static void
-scc_tarjan (struct GNUNET_REGEX_Automaton *a)
-{
-  unsigned int index;
-  unsigned int scc_counter;
-  struct GNUNET_REGEX_State *v;
-  struct GNUNET_REGEX_State *stack[a->state_count];
-  unsigned int stack_size;
-
-  for (v = a->states_head; NULL != v; v = v->next)
-  {
-    v->contained = 0;
-    v->index = -1;
-    v->lowlink = -1;
-  }
-
-  stack_size = 0;
-  index = 0;
-  scc_counter = 0;
-
-  for (v = a->states_head; NULL != v; v = v->next)
-  {
-    if (v->index < 0)
-      scc_tarjan_strongconnect (&scc_counter, v, &index, stack, &stack_size);
-  }
-}
-
 /**
  * Adds a transition from one state to another on 'label'. Does not add
  * duplicate states.
@@ -482,8 +193,8 @@ state_add_transition (struct GNUNET_REGEX_Context *ctx,
                       struct GNUNET_REGEX_State *to_state)
 {
   int is_dup;
-  struct Transition *t;
-  struct Transition *oth;
+  struct GNUNET_REGEX_Transition *t;
+  struct GNUNET_REGEX_Transition *oth;
 
   if (NULL == from_state)
   {
@@ -513,7 +224,7 @@ state_add_transition (struct GNUNET_REGEX_Context *ctx,
       break;
   }
 
-  t = GNUNET_malloc (sizeof (struct Transition));
+  t = GNUNET_malloc (sizeof (struct GNUNET_REGEX_Transition));
   t->id = ctx->transition_id++;
   t->label = label;
   t->to_state = to_state;
@@ -525,6 +236,30 @@ state_add_transition (struct GNUNET_REGEX_Context *ctx,
                                       from_state->transitions_tail, oth, t);
 }
 
+
+/**
+ * Remove a 'transition' from 'state'.
+ *
+ * @param state state from which the to-be-removed transition originates.
+ * @param transition transition that should be removed from state 'state'.
+ */
+static void
+state_remove_transition (struct GNUNET_REGEX_State *state,
+                         struct GNUNET_REGEX_Transition *transition)
+{
+  if (NULL == state || NULL == transition)
+    return;
+
+  if (transition->from_state != state)
+    return;
+
+  state->transition_count--;
+  GNUNET_CONTAINER_DLL_remove (state->transitions_head, state->transitions_tail,
+                               transition);
+  GNUNET_free (transition);
+}
+
+
 /**
  * Compare two states. Used for sorting.
  *
@@ -547,18 +282,20 @@ state_compare (const void *a, const void *b)
   return (*s1)->id - (*s2)->id;
 }
 
+
 /**
  * Get all edges leaving state 's'.
  *
  * @param s state.
- * @param edges all edges leaving 's'.
+ * @param edges all edges leaving 's', expected to be allocated and have enough
+ *        space for s->transitions_count elements.
  *
  * @return number of edges.
  */
 static unsigned int
 state_get_edges (struct GNUNET_REGEX_State *s, struct GNUNET_REGEX_Edge *edges)
 {
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
   unsigned int count;
 
   if (NULL == s)
@@ -578,6 +315,7 @@ state_get_edges (struct GNUNET_REGEX_State *s, struct GNUNET_REGEX_Edge *edges)
   return count;
 }
 
+
 /**
  * Compare to state sets by comparing the id's of the states that are contained
  * in each set. Both sets are expected to be sorted by id!
@@ -611,6 +349,7 @@ state_set_compare (struct GNUNET_REGEX_StateSet *sset1,
   return result;
 }
 
+
 /**
  * Clears the given StateSet 'set'
  *
@@ -626,6 +365,7 @@ state_set_clear (struct GNUNET_REGEX_StateSet *set)
   }
 }
 
+
 /**
  * Clears an automaton fragment. Does not destroy the states inside the
  * automaton.
@@ -646,6 +386,7 @@ automaton_fragment_clear (struct GNUNET_REGEX_Automaton *a)
   GNUNET_free (a);
 }
 
+
 /**
  * Frees the memory used by State 's'
  *
@@ -654,8 +395,8 @@ automaton_fragment_clear (struct GNUNET_REGEX_Automaton *a)
 static void
 automaton_destroy_state (struct GNUNET_REGEX_State *s)
 {
-  struct Transition *t;
-  struct Transition *next_t;
+  struct GNUNET_REGEX_Transition *t;
+  struct GNUNET_REGEX_Transition *next_t;
 
   if (NULL == s)
     return;
@@ -675,6 +416,7 @@ automaton_destroy_state (struct GNUNET_REGEX_State *s)
   GNUNET_free (s);
 }
 
+
 /**
  * Remove a state from the given automaton 'a'. Always use this function when
  * altering the states of an automaton. Will also remove all transitions leading
@@ -689,7 +431,7 @@ automaton_remove_state (struct GNUNET_REGEX_Automaton *a,
 {
   struct GNUNET_REGEX_State *ss;
   struct GNUNET_REGEX_State *s_check;
-  struct Transition *t_check;
+  struct GNUNET_REGEX_Transition *t_check;
 
   if (NULL == a || NULL == s)
     return;
@@ -717,6 +459,7 @@ automaton_remove_state (struct GNUNET_REGEX_Automaton *a,
   automaton_destroy_state (ss);
 }
 
+
 /**
  * Merge two states into one. Will merge 's1' and 's2' into 's1' and destroy
  * 's2'.
@@ -733,9 +476,9 @@ automaton_merge_states (struct GNUNET_REGEX_Context *ctx,
                         struct GNUNET_REGEX_State *s2)
 {
   struct GNUNET_REGEX_State *s_check;
-  struct Transition *t_check;
-  struct Transition *t;
-  struct Transition *t_next;
+  struct GNUNET_REGEX_Transition *t_check;
+  struct GNUNET_REGEX_Transition *t;
+  struct GNUNET_REGEX_Transition *t_next;
   char *new_name;
   int is_dup;
 
@@ -763,11 +506,7 @@ automaton_merge_states (struct GNUNET_REGEX_Context *ctx,
         if (GNUNET_NO == is_dup)
           t_check->to_state = s1;
         else
-        {
-          GNUNET_CONTAINER_DLL_remove (t_check->from_state->transitions_head,
-                                       t_check->from_state->transitions_tail,
-                                       t_check);
-        }
+          state_remove_transition (t_check->from_state, t_check);
       }
     }
   }
@@ -790,6 +529,7 @@ automaton_merge_states (struct GNUNET_REGEX_Context *ctx,
   automaton_destroy_state (s2);
 }
 
+
 /**
  * Add a state to the automaton 'a', always use this function to alter the
  * states DLL of the automaton.
@@ -805,15 +545,6 @@ automaton_add_state (struct GNUNET_REGEX_Automaton *a,
   a->state_count++;
 }
 
-/**
- * Function that is called with each state, when traversing an automaton.
- *
- * @param cls closure.
- * @param count current count of the state, from 0 to a->state_count -1.
- * @param s state.
- */
-typedef void (*GNUNET_REGEX_traverse_action) (void *cls, unsigned int count,
-                                              struct GNUNET_REGEX_State * s);
 
 /**
  * Depth-first traversal of all states that are reachable from state 's'. Expects the states to
@@ -829,7 +560,7 @@ static void
 automaton_state_traverse (struct GNUNET_REGEX_State *s, unsigned int *count,
                           GNUNET_REGEX_traverse_action action, void *action_cls)
 {
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
 
   if (GNUNET_NO != s->marked)
     return;
@@ -850,9 +581,10 @@ automaton_state_traverse (struct GNUNET_REGEX_State *s, unsigned int *count,
  * @param action action to be performed on each state.
  * @param action_cls closure for action
  */
-static void
-automaton_traverse (struct GNUNET_REGEX_Automaton *a,
-                    GNUNET_REGEX_traverse_action action, void *action_cls)
+void
+GNUNET_REGEX_automaton_traverse (struct GNUNET_REGEX_Automaton *a,
+                                 GNUNET_REGEX_traverse_action action,
+                                 void *action_cls)
 {
   unsigned int count;
   struct GNUNET_REGEX_State *s;
@@ -868,9 +600,6 @@ automaton_traverse (struct GNUNET_REGEX_Automaton *a,
  * Check if the given string 'str' needs parentheses around it when
  * using it to generate a regex.
  *
- * Currently only tests for first and last characters being '()' respectively.
- * FIXME: What about "(ab)|(cd)"?
- *
  * @param str string
  *
  * @return GNUNET_YES if parentheses are needed, GNUNET_NO otherwise
@@ -916,12 +645,9 @@ needs_parentheses (const char *str)
 
 /**
  * Remove parentheses surrounding string 'str'.
- * Example: "(a)" becomes "a".
+ * Example: "(a)" becomes "a", "(a|b)|(a|c)" stays the same.
  * You need to GNUNET_free the returned string.
  *
- * Currently only tests for first and last characters being '()' respectively.
- * FIXME: What about "(ab)|(cd)"?
- *
  * @param str string, free'd or re-used by this function, can be NULL
  *
  * @return string without surrounding parentheses, string 'str' if no preceding
@@ -931,12 +657,18 @@ static char *
 remove_parentheses (char *str)
 {
   size_t slen;
+  const char *pos;
 
   if ((NULL == str) || ('(' != str[0]) ||
       (str[(slen = strlen (str)) - 1] != ')'))
     return str;
-  memmove (str, &str[1], slen - 2);
-  str[slen - 2] = '\0';
+
+  pos = strchr (&str[1], ')');
+  if (pos == &str[slen - 1])
+  {
+    memmove (str, &str[1], slen - 2);
+    str[slen - 2] = '\0';
+  }
   return str;
 }
 
@@ -983,6 +715,7 @@ remove_epsilon (const char *str)
   return GNUNET_strdup (str);
 }
 
+
 /**
  * Compare 'str1', starting from position 'k',  with whole 'str2'
  *
@@ -1018,8 +751,9 @@ nullstrcmp (const char *str1, const char *str2)
   return strcmp (str1, str2);
 }
 
+
 /**
- * Helper function used as 'action' in 'automaton_traverse' function to create
+ * Helper function used as 'action' in 'GNUNET_REGEX_automaton_traverse' function to create
  * the depth-first numbering of the states.
  *
  * @param cls states array.
@@ -1032,14 +766,16 @@ number_states (void *cls, unsigned int count, struct GNUNET_REGEX_State *s)
   struct GNUNET_REGEX_State **states = cls;
 
   s->proof_id = count;
-  states[count] = s;
+  if (NULL != states)
+    states[count] = s;
 }
 
-/** 
+
+/**
  * Construct the regular expression given the inductive step,
  * $R^{(k)}_{ij} = R^{(k-1)}_{ij} | R^{(k-1)}_{ik} ( R^{(k-1)}_{kk} )^*
  * R^{(k-1)}_{kj}, and simplify the resulting expression saved in R_cur_ij.
- * 
+ *
  * @param R_last_ij value of  $R^{(k-1)_{ij}.
  * @param R_last_ik value of  $R^{(k-1)_{ik}.
  * @param R_last_kk value of  $R^{(k-1)_{kk}.
@@ -1065,7 +801,6 @@ automaton_create_proofs_simplify (char *R_last_ij, char *R_last_ik,
   int ij_ik_cmp;
   int ij_kj_cmp;
 
-  //int ik_kj_cmp;
   int ik_kk_cmp;
   int kk_kj_cmp;
   int clean_ik_kk_cmp;
@@ -1110,7 +845,6 @@ automaton_create_proofs_simplify (char *R_last_ij, char *R_last_ik,
   ij_kj_cmp = nullstrcmp (R_last_ij, R_last_kj);
   ij_ik_cmp = nullstrcmp (R_last_ij, R_last_ik);
   ik_kk_cmp = nullstrcmp (R_last_ik, R_last_kk);
-  //ik_kj_cmp = nullstrcmp (R_last_ik, R_last_kj);
   kk_kj_cmp = nullstrcmp (R_last_kk, R_last_kj);
 
   // Assign R_temp_(ik|kk|kj) to R_last[][] and remove epsilon as well
@@ -1373,6 +1107,10 @@ automaton_create_proofs_simplify (char *R_last_ij, char *R_last_ik,
     }
   }
 
+  GNUNET_free_non_null (R_temp_ik);
+  GNUNET_free_non_null (R_temp_kk);
+  GNUNET_free_non_null (R_temp_kj);
+
   if (NULL == R_cur_l && NULL == R_cur_r)
   {
     *R_cur_ij = NULL;
@@ -1381,33 +1119,30 @@ automaton_create_proofs_simplify (char *R_last_ij, char *R_last_ik,
 
   if (NULL != R_cur_l && NULL == R_cur_r)
   {
-    *R_cur_ij = GNUNET_strdup (R_cur_l);
+    *R_cur_ij = R_cur_l;
     return;
   }
 
   if (NULL == R_cur_l && NULL != R_cur_r)
   {
-    *R_cur_ij = GNUNET_strdup (R_cur_r);
+    *R_cur_ij = R_cur_r;
     return;
   }
 
   if (0 == nullstrcmp (R_cur_l, R_cur_r))
   {
-    *R_cur_ij = GNUNET_strdup (R_cur_l);
+    *R_cur_ij = R_cur_l;
+    GNUNET_free (R_cur_r);
     return;
   }
 
   GNUNET_asprintf (R_cur_ij, "(%s|%s)", R_cur_l, R_cur_r);
 
-  GNUNET_free_non_null (R_cur_l);
-  GNUNET_free_non_null (R_cur_r);
-
-  GNUNET_free_non_null (R_temp_ik);
-  GNUNET_free_non_null (R_temp_kk);
-  GNUNET_free_non_null (R_temp_kj);
-
+  GNUNET_free (R_cur_l);
+  GNUNET_free (R_cur_r);
 }
 
+
 /**
  * create proofs for all states in the given automaton. Implementation of the
  * algorithm descriped in chapter 3.2.1 of "Automata Theory, Languages, and
@@ -1423,7 +1158,7 @@ automaton_create_proofs (struct GNUNET_REGEX_Automaton *a)
   char *R_last[n][n];
   char *R_cur[n][n];
   char *temp;
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
   char *complete_regex;
   unsigned int i;
   unsigned int j;
@@ -1431,7 +1166,7 @@ automaton_create_proofs (struct GNUNET_REGEX_Automaton *a)
 
 
   /* create depth-first numbering of the states, initializes 'state' */
-  automaton_traverse (a, &number_states, states);
+  GNUNET_REGEX_automaton_traverse (a, &number_states, states);
 
   /* Compute regular expressions of length "1" between each pair of states */
   for (i = 0; i < n; i++)
@@ -1534,13 +1269,6 @@ automaton_create_proofs (struct GNUNET_REGEX_Automaton *a)
   }
   a->canonical_regex = complete_regex;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "---------------------------------------------\n");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Regex: %s\n", a->regex);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Complete Regex: %s\n", complete_regex);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "---------------------------------------------\n");
-
   // cleanup
   for (i = 0; i < n; i++)
   {
@@ -1549,6 +1277,7 @@ automaton_create_proofs (struct GNUNET_REGEX_Automaton *a)
   }
 }
 
+
 /**
  * Creates a new DFA state based on a set of NFA states. Needs to be freed using
  * automaton_destroy_state.
@@ -1566,7 +1295,7 @@ dfa_state_create (struct GNUNET_REGEX_Context *ctx,
   char *name;
   int len = 0;
   struct GNUNET_REGEX_State *cstate;
-  struct Transition *ctran;
+  struct GNUNET_REGEX_Transition *ctran;
   unsigned int i;
 
   s = GNUNET_malloc (sizeof (struct GNUNET_REGEX_State));
@@ -1628,6 +1357,7 @@ dfa_state_create (struct GNUNET_REGEX_Context *ctx,
   return s;
 }
 
+
 /**
  * Move from the given state 's' to the next state on transition 'label'
  *
@@ -1639,7 +1369,7 @@ dfa_state_create (struct GNUNET_REGEX_Context *ctx,
 static struct GNUNET_REGEX_State *
 dfa_move (struct GNUNET_REGEX_State *s, const char label)
 {
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
   struct GNUNET_REGEX_State *new_s;
 
   if (NULL == s)
@@ -1659,6 +1389,7 @@ dfa_move (struct GNUNET_REGEX_State *s, const char label)
   return new_s;
 }
 
+
 /**
  * Remove all unreachable states from DFA 'a'. Unreachable states are those
  * states that are not reachable from the starting state.
@@ -1676,7 +1407,7 @@ dfa_remove_unreachable_states (struct GNUNET_REGEX_Automaton *a)
     s->marked = GNUNET_NO;
 
   // 2. traverse dfa from start state and mark all visited states
-  automaton_traverse (a, NULL, NULL);
+  GNUNET_REGEX_automaton_traverse (a, NULL, NULL);
 
   // 3. delete all states that were not visited
   for (s = a->states_head; NULL != s; s = s_next)
@@ -1687,9 +1418,10 @@ dfa_remove_unreachable_states (struct GNUNET_REGEX_Automaton *a)
   }
 }
 
+
 /**
  * Remove all dead states from the DFA 'a'. Dead states are those states that do
- * not transition to any other state but themselfes.
+ * not transition to any other state but themselves.
  *
  * @param a DFA automaton
  */
@@ -1697,7 +1429,7 @@ static void
 dfa_remove_dead_states (struct GNUNET_REGEX_Automaton *a)
 {
   struct GNUNET_REGEX_State *s;
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
   int dead;
 
   GNUNET_assert (DFA == a->type);
@@ -1725,6 +1457,7 @@ dfa_remove_dead_states (struct GNUNET_REGEX_Automaton *a)
   }
 }
 
+
 /**
  * Merge all non distinguishable states in the DFA 'a'
  *
@@ -1739,8 +1472,8 @@ dfa_merge_nondistinguishable_states (struct GNUNET_REGEX_Context *ctx,
   int table[a->state_count][a->state_count];
   struct GNUNET_REGEX_State *s1;
   struct GNUNET_REGEX_State *s2;
-  struct Transition *t1;
-  struct Transition *t2;
+  struct GNUNET_REGEX_Transition *t1;
+  struct GNUNET_REGEX_Transition *t2;
   struct GNUNET_REGEX_State *s1_next;
   struct GNUNET_REGEX_State *s2_next;
   int change;
@@ -1819,6 +1552,7 @@ dfa_merge_nondistinguishable_states (struct GNUNET_REGEX_Context *ctx,
   }
 }
 
+
 /**
  * Minimize the given DFA 'a' by removing all unreachable states, removing all
  * dead states and merging all non distinguishable states
@@ -1845,6 +1579,7 @@ dfa_minimize (struct GNUNET_REGEX_Context *ctx,
   dfa_merge_nondistinguishable_states (ctx, a);
 }
 
+
 /**
  * Creates a new NFA fragment. Needs to be cleared using
  * automaton_fragment_clear.
@@ -1866,7 +1601,7 @@ nfa_fragment_create (struct GNUNET_REGEX_State *start,
   n->start = NULL;
   n->end = NULL;
 
-  if (NULL == start && NULL == end)
+  if (NULL == start || NULL == end)
     return n;
 
   automaton_add_state (n, end);
@@ -1878,6 +1613,7 @@ nfa_fragment_create (struct GNUNET_REGEX_State *start,
   return n;
 }
 
+
 /**
  * Adds a list of states to the given automaton 'n'.
  *
@@ -1915,6 +1651,7 @@ nfa_add_states (struct GNUNET_REGEX_Automaton *n,
     n->state_count++;
 }
 
+
 /**
  * Creates a new NFA state. Needs to be freed using automaton_destroy_state.
  *
@@ -1942,6 +1679,7 @@ nfa_state_create (struct GNUNET_REGEX_Context *ctx, int accepting)
   return s;
 }
 
+
 /**
  * Calculates the NFA closure set for the given state.
  *
@@ -1960,7 +1698,7 @@ nfa_closure_create (struct GNUNET_REGEX_Automaton *nfa,
   struct GNUNET_REGEX_StateSet *cls_check;
   struct GNUNET_REGEX_State *clsstate;
   struct GNUNET_REGEX_State *currentstate;
-  struct Transition *ctran;
+  struct GNUNET_REGEX_Transition *ctran;
 
   if (NULL == s)
     return NULL;
@@ -2008,6 +1746,7 @@ nfa_closure_create (struct GNUNET_REGEX_Automaton *nfa,
   return cls;
 }
 
+
 /**
  * Calculates the closure set for the given set of states.
  *
@@ -2064,6 +1803,7 @@ nfa_closure_set_create (struct GNUNET_REGEX_Automaton *nfa,
   return cls;
 }
 
+
 /**
  * Pops two NFA fragments (a, b) from the stack and concatenates them (ab)
  *
@@ -2074,28 +1814,31 @@ nfa_add_concatenation (struct GNUNET_REGEX_Context *ctx)
 {
   struct GNUNET_REGEX_Automaton *a;
   struct GNUNET_REGEX_Automaton *b;
-  struct GNUNET_REGEX_Automaton *new;
+  struct GNUNET_REGEX_Automaton *new_nfa;
 
   b = ctx->stack_tail;
+  GNUNET_assert (NULL != b);
   GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, b);
   a = ctx->stack_tail;
+  GNUNET_assert (NULL != a);
   GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, a);
 
   state_add_transition (ctx, a->end, 0, b->start);
   a->end->accepting = 0;
   b->end->accepting = 1;
 
-  new = nfa_fragment_create (NULL, NULL);
-  nfa_add_states (new, a->states_head, a->states_tail);
-  nfa_add_states (new, b->states_head, b->states_tail);
-  new->start = a->start;
-  new->end = b->end;
+  new_nfa = nfa_fragment_create (NULL, NULL);
+  nfa_add_states (new_nfa, a->states_head, a->states_tail);
+  nfa_add_states (new_nfa, b->states_head, b->states_tail);
+  new_nfa->start = a->start;
+  new_nfa->end = b->end;
   automaton_fragment_clear (a);
   automaton_fragment_clear (b);
 
-  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new);
+  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new_nfa);
 }
 
+
 /**
  * Pops a NFA fragment from the stack (a) and adds a new fragment (a*)
  *
@@ -2105,12 +1848,11 @@ static void
 nfa_add_star_op (struct GNUNET_REGEX_Context *ctx)
 {
   struct GNUNET_REGEX_Automaton *a;
-  struct GNUNET_REGEX_Automaton *new;
+  struct GNUNET_REGEX_Automaton *new_nfa;
   struct GNUNET_REGEX_State *start;
   struct GNUNET_REGEX_State *end;
 
   a = ctx->stack_tail;
-  GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, a);
 
   if (NULL == a)
   {
@@ -2119,6 +1861,8 @@ nfa_add_star_op (struct GNUNET_REGEX_Context *ctx)
     return;
   }
 
+  GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, a);
+
   start = nfa_state_create (ctx, 0);
   end = nfa_state_create (ctx, 1);
 
@@ -2130,13 +1874,14 @@ nfa_add_star_op (struct GNUNET_REGEX_Context *ctx)
   a->end->accepting = 0;
   end->accepting = 1;
 
-  new = nfa_fragment_create (start, end);
-  nfa_add_states (new, a->states_head, a->states_tail);
+  new_nfa = nfa_fragment_create (start, end);
+  nfa_add_states (new_nfa, a->states_head, a->states_tail);
   automaton_fragment_clear (a);
 
-  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new);
+  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new_nfa);
 }
 
+
 /**
  * Pops an NFA fragment (a) from the stack and adds a new fragment (a+)
  *
@@ -2155,6 +1900,7 @@ nfa_add_plus_op (struct GNUNET_REGEX_Context *ctx)
   GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, a);
 }
 
+
 /**
  * Pops an NFA fragment (a) from the stack and adds a new fragment (a?)
  *
@@ -2164,12 +1910,11 @@ static void
 nfa_add_question_op (struct GNUNET_REGEX_Context *ctx)
 {
   struct GNUNET_REGEX_Automaton *a;
-  struct GNUNET_REGEX_Automaton *new;
+  struct GNUNET_REGEX_Automaton *new_nfa;
   struct GNUNET_REGEX_State *start;
   struct GNUNET_REGEX_State *end;
 
   a = ctx->stack_tail;
-  GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, a);
 
   if (NULL == a)
   {
@@ -2178,6 +1923,8 @@ nfa_add_question_op (struct GNUNET_REGEX_Context *ctx)
     return;
   }
 
+  GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, a);
+
   start = nfa_state_create (ctx, 0);
   end = nfa_state_create (ctx, 1);
 
@@ -2187,13 +1934,14 @@ nfa_add_question_op (struct GNUNET_REGEX_Context *ctx)
 
   a->end->accepting = 0;
 
-  new = nfa_fragment_create (start, end);
-  nfa_add_states (new, a->states_head, a->states_tail);
+  new_nfa = nfa_fragment_create (start, end);
+  nfa_add_states (new_nfa, a->states_head, a->states_tail);
   automaton_fragment_clear (a);
 
-  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new);
+  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new_nfa);
 }
 
+
 /**
  * Pops two NFA fragments (a, b) from the stack and adds a new NFA fragment that
  * alternates between a and b (a|b)
@@ -2205,13 +1953,15 @@ nfa_add_alternation (struct GNUNET_REGEX_Context *ctx)
 {
   struct GNUNET_REGEX_Automaton *a;
   struct GNUNET_REGEX_Automaton *b;
-  struct GNUNET_REGEX_Automaton *new;
+  struct GNUNET_REGEX_Automaton *new_nfa;
   struct GNUNET_REGEX_State *start;
   struct GNUNET_REGEX_State *end;
 
   b = ctx->stack_tail;
+  GNUNET_assert (NULL != b);
   GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, b);
   a = ctx->stack_tail;
+  GNUNET_assert (NULL != a);
   GNUNET_CONTAINER_DLL_remove (ctx->stack_head, ctx->stack_tail, a);
 
   start = nfa_state_create (ctx, 0);
@@ -2226,15 +1976,16 @@ nfa_add_alternation (struct GNUNET_REGEX_Context *ctx)
   b->end->accepting = 0;
   end->accepting = 1;
 
-  new = nfa_fragment_create (start, end);
-  nfa_add_states (new, a->states_head, a->states_tail);
-  nfa_add_states (new, b->states_head, b->states_tail);
+  new_nfa = nfa_fragment_create (start, end);
+  nfa_add_states (new_nfa, a->states_head, a->states_tail);
+  nfa_add_states (new_nfa, b->states_head, b->states_tail);
   automaton_fragment_clear (a);
   automaton_fragment_clear (b);
 
-  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new);
+  GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, new_nfa);
 }
 
+
 /**
  * Adds a new nfa fragment to the stack
  *
@@ -2258,6 +2009,7 @@ nfa_add_label (struct GNUNET_REGEX_Context *ctx, const char lit)
   GNUNET_CONTAINER_DLL_insert_tail (ctx->stack_head, ctx->stack_tail, n);
 }
 
+
 /**
  * Initialize a new context
  *
@@ -2277,6 +2029,7 @@ GNUNET_REGEX_context_init (struct GNUNET_REGEX_Context *ctx)
   ctx->stack_tail = NULL;
 }
 
+
 /**
  * Construct an NFA by parsing the regex string of length 'len'.
  *
@@ -2387,6 +2140,7 @@ GNUNET_REGEX_construct_nfa (const char *regex, const size_t len)
     case 92:                   /* escape: \ */
       regexp++;
       count++;
+      /* fall through! */
     default:
       if (atomcount > 1)
       {
@@ -2421,6 +2175,9 @@ GNUNET_REGEX_construct_nfa (const char *regex, const size_t len)
 
   nfa->regex = GNUNET_strdup (regex);
 
+  /* create depth-first numbering of the states for pretty printing */
+  GNUNET_REGEX_automaton_traverse (nfa, &number_states, NULL);
+
   return nfa;
 
 error:
@@ -2439,6 +2196,7 @@ error:
   return NULL;
 }
 
+
 /**
  * Create DFA states based on given 'nfa' and starting with 'dfa_state'.
  *
@@ -2454,7 +2212,7 @@ construct_dfa_states (struct GNUNET_REGEX_Context *ctx,
                       struct GNUNET_REGEX_Automaton *dfa,
                       struct GNUNET_REGEX_State *dfa_state)
 {
-  struct Transition *ctran;
+  struct GNUNET_REGEX_Transition *ctran;
   struct GNUNET_REGEX_State *state_iter;
   struct GNUNET_REGEX_State *new_dfa_state;
   struct GNUNET_REGEX_State *state_contains;
@@ -2492,6 +2250,7 @@ construct_dfa_states (struct GNUNET_REGEX_Context *ctx,
   }
 }
 
+
 /**
  * Construct DFA for the given 'regex' of length 'len'
  *
@@ -2542,6 +2301,7 @@ GNUNET_REGEX_construct_dfa (const char *regex, const size_t len)
   return dfa;
 }
 
+
 /**
  * Free the memory allocated by constructing the GNUNET_REGEX_Automaton data
  * structure.
@@ -2570,132 +2330,6 @@ GNUNET_REGEX_automaton_destroy (struct GNUNET_REGEX_Automaton *a)
   GNUNET_free (a);
 }
 
-/**
- * Save a state to an open file pointer. cls is expected to be a file pointer to
- * an open file. Used only in conjunction with
- * GNUNET_REGEX_automaton_save_graph.
- *
- * @param cls file pointer.
- * @param count current count of the state, not used.
- * @param s state.
- */
-void
-GNUNET_REGEX_automaton_save_graph_step (void *cls, unsigned int count,
-                                        struct GNUNET_REGEX_State *s)
-{
-  FILE *p;
-  struct Transition *ctran;
-  char *s_acc = NULL;
-  char *s_tran = NULL;
-
-  p = cls;
-
-  if (s->accepting)
-  {
-    GNUNET_asprintf (&s_acc,
-                     "\"%s(%i)\" [shape=doublecircle, color=\"0.%i 0.8 0.95\"];\n",
-                     s->name, s->proof_id, s->scc_id);
-  }
-  else
-  {
-    GNUNET_asprintf (&s_acc, "\"%s(%i)\" [color=\"0.%i 0.8 0.95\"];\n", s->name,
-                     s->proof_id, s->scc_id);
-  }
-
-  if (NULL == s_acc)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not print state %s\n", s->name);
-    return;
-  }
-  fwrite (s_acc, strlen (s_acc), 1, p);
-  GNUNET_free (s_acc);
-  s_acc = NULL;
-
-  for (ctran = s->transitions_head; NULL != ctran; ctran = ctran->next)
-  {
-    if (NULL == ctran->to_state)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Transition from State %i has no state for transitioning\n",
-                  s->id);
-      continue;
-    }
-
-    if (ctran->label == 0)
-    {
-      GNUNET_asprintf (&s_tran,
-                       "\"%s(%i)\" -> \"%s(%i)\" [label = \"epsilon\", color=\"0.%i 0.8 0.95\"];\n",
-                       s->name, s->proof_id, ctran->to_state->name,
-                       ctran->to_state->proof_id, s->scc_id);
-    }
-    else
-    {
-      GNUNET_asprintf (&s_tran,
-                       "\"%s(%i)\" -> \"%s(%i)\" [label = \"%c\", color=\"0.%i 0.8 0.95\"];\n",
-                       s->name, s->proof_id, ctran->to_state->name,
-                       ctran->to_state->proof_id, ctran->label, s->scc_id);
-    }
-
-    if (NULL == s_tran)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not print state %s\n",
-                  s->name);
-      return;
-    }
-
-    fwrite (s_tran, strlen (s_tran), 1, p);
-    GNUNET_free (s_tran);
-    s_tran = NULL;
-  }
-}
-
-/**
- * Save the given automaton as a GraphViz dot file
- *
- * @param a the automaton to be saved
- * @param filename where to save the file
- */
-void
-GNUNET_REGEX_automaton_save_graph (struct GNUNET_REGEX_Automaton *a,
-                                   const char *filename)
-{
-  char *start;
-  char *end;
-  FILE *p;
-
-  if (NULL == a)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not print NFA, was NULL!");
-    return;
-  }
-
-  if (NULL == filename || strlen (filename) < 1)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No Filename given!");
-    return;
-  }
-
-  p = fopen (filename, "w");
-
-  if (NULL == p)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not open file for writing: %s",
-                filename);
-    return;
-  }
-
-  /* First add the SCCs to the automaton, so we can color them nicely */
-  scc_tarjan (a);
-
-  start = "digraph G {\nrankdir=LR\n";
-  fwrite (start, strlen (start), 1, p);
-
-  automaton_traverse (a, &GNUNET_REGEX_automaton_save_graph_step, p);
-
-  end = "\n}\n";
-  fwrite (end, strlen (end), 1, p);
-  fclose (p);
-}
 
 /**
  * Evaluates the given string using the given DFA automaton
@@ -2737,6 +2371,7 @@ evaluate_dfa (struct GNUNET_REGEX_Automaton *a, const char *string)
   return 1;
 }
 
+
 /**
  * Evaluates the given string using the given NFA automaton
  *
@@ -2767,7 +2402,6 @@ evaluate_nfa (struct GNUNET_REGEX_Automaton *a, const char *string)
     return 0;
 
   result = 1;
-  strp = string;
   sset = nfa_closure_create (a, a->start, 0);
 
   for (strp = string; NULL != strp && *strp; strp++)
@@ -2792,6 +2426,7 @@ evaluate_nfa (struct GNUNET_REGEX_Automaton *a, const char *string)
   return result;
 }
 
+
 /**
  * Evaluates the given 'string' against the given compiled regex
  *
@@ -2844,9 +2479,10 @@ GNUNET_REGEX_get_canonical_regex (struct GNUNET_REGEX_Automaton *a)
   return a->canonical_regex;
 }
 
+
 /**
  * Get the first key for the given 'input_string'. This hashes the first x bits
- * of the 'input_strings'.
+ * of the 'input_string'.
  *
  * @param input_string string.
  * @param string_len length of the 'input_string'.
@@ -2855,9 +2491,9 @@ GNUNET_REGEX_get_canonical_regex (struct GNUNET_REGEX_Automaton *a)
  * @return number of bits of 'input_string' that have been consumed
  *         to construct the key
  */
-unsigned int
-GNUNET_REGEX_get_first_key (const char *input_string, unsigned int string_len,
-                            struct GNUNET_HashCode *key)
+size_t
+GNUNET_REGEX_get_first_key (const char *input_string, size_t string_len,
+                            struct GNUNET_HashCode * key)
 {
   unsigned int size;
 
@@ -2874,20 +2510,142 @@ GNUNET_REGEX_get_first_key (const char *input_string, unsigned int string_len,
   return size;
 }
 
+
 /**
  * Check if the given 'proof' matches the given 'key'.
  *
- * @param proof partial regex
- * @param key hash
+ * @param proof partial regex of a state.
+ * @param key hash of a state.
  *
- * @return GNUNET_OK if the proof is valid for the given key
+ * @return GNUNET_OK if the proof is valid for the given key.
  */
 int
 GNUNET_REGEX_check_proof (const char *proof, const struct GNUNET_HashCode *key)
 {
-  return GNUNET_OK;
+  struct GNUNET_HashCode key_check;
+
+  GNUNET_CRYPTO_hash (proof, strlen (proof), &key_check);
+  return (0 ==
+          GNUNET_CRYPTO_hash_cmp (key, &key_check)) ? GNUNET_OK : GNUNET_NO;
+}
+
+
+/**
+ * Recursive helper function for iterate_initial_edges. Will call iterator
+ * function for each initial state.
+ *
+ * @param min_len minimum length of the path in the graph.
+ * @param max_len maximum length of the path in the graph.
+ * @param cur_len current length of the path already traversed.
+ * @param consumed_string string consumed by traversing the graph till this state.
+ * @param state current state of the automaton.
+ * @param iterator iterator function called for each edge.
+ * @param iterator_cls closure for the iterator function.
+ */
+static void
+iterate_initial_edge (const unsigned int min_len, const unsigned int max_len,
+                      unsigned int cur_len, char *consumed_string,
+                      struct GNUNET_REGEX_State *state,
+                      GNUNET_REGEX_KeyIterator iterator, void *iterator_cls)
+{
+  unsigned int i;
+  char label[state->transition_count][2];
+  char *temp;
+  struct GNUNET_REGEX_Transition *t;
+  unsigned int num_edges = state->transition_count;
+  struct GNUNET_REGEX_Edge edges[num_edges];
+  struct GNUNET_HashCode hash;
+
+  if (cur_len > min_len && NULL != consumed_string && cur_len <= max_len)
+  {
+    for (i = 0, t = state->transitions_head; NULL != t; t = t->next, i++)
+    {
+      label[i][0] = t->label;
+      label[i][1] = '\0';
+      edges[i].label = label[i];
+      edges[i].destination = t->to_state->hash;
+    }
+
+    GNUNET_CRYPTO_hash (consumed_string, strlen (consumed_string), &hash);
+    iterator (iterator_cls, &hash, consumed_string, state->accepting, num_edges,
+              edges);
+  }
+
+  if (cur_len < max_len)
+  {
+    cur_len++;
+    for (t = state->transitions_head; NULL != t; t = t->next)
+    {
+      if (NULL != consumed_string)
+        GNUNET_asprintf (&temp, "%s%c", consumed_string, t->label);
+      else
+        GNUNET_asprintf (&temp, "%c", t->label);
+
+      iterate_initial_edge (min_len, max_len, cur_len, temp, t->to_state,
+                            iterator, iterator_cls);
+      GNUNET_free (temp);
+    }
+  }
+}
+
+
+/**
+ * Iterate over all initial edges that aren't actually part of the automaton.
+ * This is needed to find the initial states returned by
+ * GNUNET_REGEX_get_first_key. Iteration will start at the first branch state (a
+ * state that has more than one outgoing edge, can be the first state), because
+ * all previous states will have the same proof and be iterated over in
+ * iterate_all_edges.
+ *
+ * @param a the automaton for which the initial states should be computed.
+ * @param initial_len length of the initial state string.
+ * @param iterator iterator function called for each edge.
+ * @param iterator_cls closure for the iterator function.
+ */
+void
+iterate_initial_edges (struct GNUNET_REGEX_Automaton *a,
+                       const unsigned int initial_len,
+                       GNUNET_REGEX_KeyIterator iterator, void *iterator_cls)
+{
+  char *consumed_string;
+  char *temp;
+  struct GNUNET_REGEX_State *s;
+  unsigned int cur_len;
+
+  if (1 > initial_len)
+    return;
+
+  consumed_string = NULL;
+  s = a->start;
+  cur_len = 0;
+
+  if (1 == s->transition_count)
+  {
+    do
+    {
+      if (NULL != consumed_string)
+      {
+        temp = consumed_string;
+        GNUNET_asprintf (&consumed_string, "%s%c", consumed_string,
+                         s->transitions_head->label);
+        GNUNET_free (temp);
+      }
+      else
+        GNUNET_asprintf (&consumed_string, "%c", s->transitions_head->label);
+
+      s = s->transitions_head->to_state;
+      cur_len++;
+    }
+    while (cur_len < initial_len && 1 == s->transition_count);
+  }
+
+  iterate_initial_edge (cur_len, initial_len, cur_len, consumed_string, s,
+                        iterator, iterator_cls);
+
+  GNUNET_free_non_null (consumed_string);
 }
 
+
 /**
  * Iterate over all edges helper function starting from state 's', calling
  * iterator on for each edge.
@@ -2900,7 +2658,7 @@ static void
 iterate_edge (struct GNUNET_REGEX_State *s, GNUNET_REGEX_KeyIterator iterator,
               void *iterator_cls)
 {
-  struct Transition *t;
+  struct GNUNET_REGEX_Transition *t;
   struct GNUNET_REGEX_Edge edges[s->transition_count];
   unsigned int num_edges;
 
@@ -2910,13 +2668,16 @@ iterate_edge (struct GNUNET_REGEX_State *s, GNUNET_REGEX_KeyIterator iterator,
 
     num_edges = state_get_edges (s, edges);
 
-    iterator (iterator_cls, &s->hash, s->proof, s->accepting, num_edges, edges);
+    if (0 < strlen (s->proof) || s->accepting)
+      iterator (iterator_cls, &s->hash, s->proof, s->accepting, num_edges,
+                edges);
 
     for (t = s->transitions_head; NULL != t; t = t->next)
       iterate_edge (t->to_state, iterator, iterator_cls);
   }
 }
 
+
 /**
  * Iterate over all edges starting from start state of automaton 'a'. Calling
  * iterator for each edge.
@@ -2935,5 +2696,6 @@ GNUNET_REGEX_iterate_all_edges (struct GNUNET_REGEX_Automaton *a,
   for (s = a->states_head; NULL != s; s = s->next)
     s->marked = GNUNET_NO;
 
+  iterate_initial_edges (a, INITIAL_BITS, iterator, iterator_cls);
   iterate_edge (a->start, iterator, iterator_cls);
 }