renaming symbols from libgnunetregextest to have the prefix REGEX_TEST

1 files changed, 33 insertions, 33 deletions

diff --git a/src/regex/regex_internal_dht.c b/src/regex/regex_internal_dht.c
index 0b5d99928..a11d59752 100644
--- a/src/regex/regex_internal_dht.c
+++ b/src/regex/regex_internal_dht.c
@@ -42,7 +42,7 @@
 #define DHT_OPT         GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
 #endif
 
-struct REGEX_ITERNAL_Announcement
+struct REGEX_INTERNAL_Announcement
 {
   /**
    * DHT handle to use, must be initialized externally.
@@ -57,7 +57,7 @@ struct REGEX_ITERNAL_Announcement
   /**
    * Automaton representation of the regex (expensive to build).
    */
-  struct REGEX_ITERNAL_Automaton* dfa;
+  struct REGEX_INTERNAL_Automaton* dfa;
 
   /**
    * Identity under which to announce the regex.
@@ -87,9 +87,9 @@ regex_iterator (void *cls,
                 const char *proof,
                 int accepting,
                 unsigned int num_edges,
-                const struct REGEX_ITERNAL_Edge *edges)
+                const struct REGEX_INTERNAL_Edge *edges)
 {
-  struct REGEX_ITERNAL_Announcement *h = cls;
+  struct REGEX_INTERNAL_Announcement *h = cls;
   struct RegexBlock *block;
   struct RegexEdge *block_edge;
   size_t size;
@@ -182,43 +182,43 @@ regex_iterator (void *cls,
 }
 
 
-struct REGEX_ITERNAL_Announcement *
-REGEX_ITERNAL_announce (struct GNUNET_DHT_Handle *dht,
+struct REGEX_INTERNAL_Announcement *
+REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
                        const struct GNUNET_PeerIdentity *id,
                        const char *regex,
                        uint16_t compression,
                        struct GNUNET_STATISTICS_Handle *stats)
 {
-  struct REGEX_ITERNAL_Announcement *h;
+  struct REGEX_INTERNAL_Announcement *h;
 
   GNUNET_assert (NULL != dht);
-  h = GNUNET_malloc (sizeof (struct REGEX_ITERNAL_Announcement));
+  h = GNUNET_malloc (sizeof (struct REGEX_INTERNAL_Announcement));
   h->regex = regex;
   h->dht = dht;
   h->stats = stats;
   h->id = *id;
-  h->dfa = REGEX_ITERNAL_construct_dfa (regex,
+  h->dfa = REGEX_INTERNAL_construct_dfa (regex,
                                        strlen (regex),
                                        compression);
-  REGEX_ITERNAL_reannounce (h);
+  REGEX_INTERNAL_reannounce (h);
   return h;
 }
 
 
 void
-REGEX_ITERNAL_reannounce (struct REGEX_ITERNAL_Announcement *h)
+REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
 {
   GNUNET_assert (NULL != h->dfa); /* make sure to call announce first */
-  LOG (GNUNET_ERROR_TYPE_INFO, "REGEX_ITERNAL_reannounce: %.60s\n", h->regex);
+  LOG (GNUNET_ERROR_TYPE_INFO, "REGEX_INTERNAL_reannounce: %.60s\n", h->regex);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "  full: %s\n", h->regex);
-  REGEX_ITERNAL_iterate_all_edges (h->dfa, &regex_iterator, h);
+  REGEX_INTERNAL_iterate_all_edges (h->dfa, &regex_iterator, h);
 }
 
 
 void
-REGEX_ITERNAL_announce_cancel (struct REGEX_ITERNAL_Announcement *h)
+REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h)
 {
-  REGEX_ITERNAL_automaton_destroy (h->dfa);
+  REGEX_INTERNAL_automaton_destroy (h->dfa);
   GNUNET_free (h);
 }
 
@@ -241,7 +241,7 @@ struct RegexSearchContext
     /**
      * Information about the search.
      */
-  struct REGEX_ITERNAL_Search *info;
+  struct REGEX_INTERNAL_Search *info;
 
     /**
      * We just want to look for one edge, the longer the better.
@@ -260,7 +260,7 @@ struct RegexSearchContext
  * Struct to keep information of searches of services described by a regex
  * using a user-provided string service description.
  */
-struct REGEX_ITERNAL_Search
+struct REGEX_INTERNAL_Search
 {
     /**
      * DHT handle to use, must be initialized externally.
@@ -300,7 +300,7 @@ struct REGEX_ITERNAL_Search
   /**
    * @param callback Callback for found peers.
    */
-  REGEX_ITERNAL_Found callback;
+  REGEX_INTERNAL_Found callback;
 
   /**
    * @param callback_cls Closure for @c callback.
@@ -352,7 +352,7 @@ dht_get_string_accept_handler (void *cls, struct GNUNET_TIME_Absolute exp,
 {
   const struct RegexAccept *block = data;
   struct RegexSearchContext *ctx = cls;
-  struct REGEX_ITERNAL_Search *info = ctx->info;
+  struct REGEX_INTERNAL_Search *info = ctx->info;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Got regex results from DHT!\n");
   LOG (GNUNET_ERROR_TYPE_INFO, "   accept for %s (key %s)\n",
@@ -430,7 +430,7 @@ dht_get_string_handler (void *cls, struct GNUNET_TIME_Absolute exp,
 {
   const struct RegexBlock *block = data;
   struct RegexSearchContext *ctx = cls;
-  struct REGEX_ITERNAL_Search *info = ctx->info;
+  struct REGEX_INTERNAL_Search *info = ctx->info;
   void *copy;
   size_t len;
   char *datastore;
@@ -466,7 +466,7 @@ dht_get_string_handler (void *cls, struct GNUNET_TIME_Absolute exp,
 
     memcpy (proof, &block[1], len);
     proof[len] = '\0';
-    if (GNUNET_OK != REGEX_ITERNAL_check_proof (proof, key))
+    if (GNUNET_OK != REGEX_INTERNAL_check_proof (proof, key))
     {
       GNUNET_break_op (0);
       return;
@@ -543,7 +543,7 @@ regex_edge_iterator (void *cls,
                      const struct GNUNET_HashCode *key)
 {
   struct RegexSearchContext *ctx = cls;
-  struct REGEX_ITERNAL_Search *info = ctx->info;
+  struct REGEX_INTERNAL_Search *info = ctx->info;
   const char *current;
   size_t current_len;
 
@@ -602,7 +602,7 @@ regex_next_edge (const struct RegexBlock *block,
                  struct RegexSearchContext *ctx)
 {
   struct RegexSearchContext *new_ctx;
-  struct REGEX_ITERNAL_Search *info = ctx->info;
+  struct REGEX_INTERNAL_Search *info = ctx->info;
   struct GNUNET_DHT_GetHandle *get_h;
   struct GNUNET_HashCode *hash;
   const char *rest;
@@ -611,7 +611,7 @@ regex_next_edge (const struct RegexBlock *block,
   /* Find the longest match for the current string position, 
    * among tokens in the given block */
   ctx->longest_match = 0;
-  result = REGEX_ITERNAL_block_iterate (block, size,
+  result = REGEX_INTERNAL_block_iterate (block, size,
                                        &regex_edge_iterator, ctx);
   GNUNET_break (GNUNET_OK == result);
 
@@ -670,14 +670,14 @@ regex_next_edge (const struct RegexBlock *block,
 }
 
 
-struct REGEX_ITERNAL_Search *
-REGEX_ITERNAL_search (struct GNUNET_DHT_Handle *dht,
+struct REGEX_INTERNAL_Search *
+REGEX_INTERNAL_search (struct GNUNET_DHT_Handle *dht,
                      const char *string,
-                     REGEX_ITERNAL_Found callback,
+                     REGEX_INTERNAL_Found callback,
                      void *callback_cls,
                      struct GNUNET_STATISTICS_Handle *stats)
 {
-  struct REGEX_ITERNAL_Search *h;
+  struct REGEX_INTERNAL_Search *h;
   struct GNUNET_DHT_GetHandle *get_h;
   struct RegexSearchContext *ctx;
   struct GNUNET_HashCode key;
@@ -685,10 +685,10 @@ REGEX_ITERNAL_search (struct GNUNET_DHT_Handle *dht,
   size_t len;
 
   /* Initialize handle */
-  LOG (GNUNET_ERROR_TYPE_INFO, "REGEX_ITERNAL_search: %s\n", string);
+  LOG (GNUNET_ERROR_TYPE_INFO, "REGEX_INTERNAL_search: %s\n", string);
   GNUNET_assert (NULL != dht);
   GNUNET_assert (NULL != callback);
-  h = GNUNET_malloc (sizeof (struct REGEX_ITERNAL_Search));
+  h = GNUNET_malloc (sizeof (struct REGEX_INTERNAL_Search));
   h->dht = dht;
   h->description = GNUNET_strdup (string);
   h->callback = callback;
@@ -699,7 +699,7 @@ REGEX_ITERNAL_search (struct GNUNET_DHT_Handle *dht,
 
   /* Initialize context */
   len = strlen (string);
-  size = REGEX_ITERNAL_get_first_key (string, len, &key);
+  size = REGEX_INTERNAL_get_first_key (string, len, &key);
   ctx = GNUNET_malloc (sizeof (struct RegexSearchContext));
   ctx->position = size;
   ctx->info = h;
@@ -779,7 +779,7 @@ regex_free_result (void *cls,
  * @param ctx The search context.
  */
 static void
-regex_cancel_search (struct REGEX_ITERNAL_Search *ctx)
+regex_cancel_search (struct REGEX_INTERNAL_Search *ctx)
 {
   GNUNET_free (ctx->description);
   GNUNET_CONTAINER_multihashmap_iterate (ctx->dht_get_handles,
@@ -801,7 +801,7 @@ regex_cancel_search (struct REGEX_ITERNAL_Search *ctx)
 }
 
 void
-REGEX_ITERNAL_search_cancel (struct REGEX_ITERNAL_Search *h)
+REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h)
 {
   regex_cancel_search (h);
   GNUNET_free (h);