#include "platform.h"
#include "gnunet_util_lib.h"
+
+/**
+ * Struct to hold the tree formed by prefix-combining the regexes.
+ */
struct RegexCombineCtx {
+
+ /**
+ * Next node with same prefix but different token.
+ */
struct RegexCombineCtx *next;
+
+ /**
+ * Prev node with same prefix but different token.
+ */
struct RegexCombineCtx *prev;
+ /**
+ * First child node with same prefix and token.
+ */
struct RegexCombineCtx *head;
+
+ /**
+ * Last child node.
+ */
struct RegexCombineCtx *tail;
+ /**
+ * Token.
+ */
char *s;
};
+// static void
+// space (int n)
+// {
+// int i;
+// for (i = 0; i < n; i++)
+// printf (" ");
+// }
+//
+// static void
+// debugctx (struct RegexCombineCtx *ctx, int level)
+// {
+// struct RegexCombineCtx *p;
+// space (level);
+// if (NULL != ctx->s)
+// printf ("'%s'\n", ctx->s);
+// else
+// printf ("NULL\n");
+// for (p = ctx->head; NULL != p; p = p->next)
+// {
+// debugctx (p, level + 1);
+// }
+// }
+
+/**
+ * Extract a string from all prefix-combined regexes.
+ *
+ * @param ctx Context with 0 or more regexes.
+ *
+ * @return Regex that matches any of the added regexes.
+ */
static char *
regex_combine (struct RegexCombineCtx *ctx)
{
char *regex;
char *tmp;
char *s;
+ int opt;
- if (NULL != ctx->s)
- GNUNET_asprintf (®ex, "%s(", ctx->s);
- else
- regex = GNUNET_strdup ("(");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "prefix: %s\n", regex);
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new combine %s\n", ctx->s);
+ regex = GNUNET_strdup ("");
+ opt = GNUNET_NO;
for (p = ctx->head; NULL != p; p = p->next)
{
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "adding '%s' to innner %s\n", p->s, ctx->s);
s = regex_combine (p);
- GNUNET_asprintf (&tmp, "%s%s|", regex, s);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " total '%s'\n", s);
+ if (strlen(s) == 0)
+ opt = GNUNET_YES;
+ else
+ {
+ GNUNET_asprintf (&tmp, "%s%s|", regex, s);
+ GNUNET_free_non_null (regex);
+ regex = tmp;
+ }
GNUNET_free_non_null (s);
- GNUNET_free_non_null (regex);
- regex = tmp;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " so far '%s' for inner %s\n", regex, ctx->s);
}
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "opt: %d, innner: '%s'\n", opt, regex);
len = strlen (regex);
- if (1 == len)
- return GNUNET_strdup ("");
+ if (0 == len)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "empty, returning ''\n");
+ GNUNET_free (regex);
+ return GNUNET_strdup (ctx->s);
+ }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pre-partial: %s\n", regex);
if ('|' == regex[len - 1])
- regex[len - 1] = ')';
- if ('(' == regex[len - 1])
regex[len - 1] = '\0';
+ if (NULL != ctx->s)
+ {
+ if (opt)
+ GNUNET_asprintf (&s, "%s[%s]", ctx->s, regex);
+ else
+ GNUNET_asprintf (&s, "%s(%s)", ctx->s, regex);
+ GNUNET_free (regex);
+ regex = s;
+ }
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "partial: %s\n", regex);
return regex;
}
+
+/**
+ * Add a single regex to a context, combining with exisiting regex by-prefix.
+ *
+ * @param ctx Context with 0 or more regexes.
+ * @param regex Regex to add.
+ */
static void
regex_add (struct RegexCombineCtx *ctx, const char *regex)
{
}
else
{
- struct RegexCombineCtx *new;
- new = GNUNET_malloc (sizeof (struct RegexCombineCtx));
- new->s = GNUNET_strdup (&p->s[1]);
+ struct RegexCombineCtx *newctx;
+ newctx = GNUNET_malloc (sizeof (struct RegexCombineCtx));
+ newctx->s = GNUNET_strdup (&p->s[1]);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " p has now %s\n", p->s);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " p will have %.1s\n", p->s);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " regex is %s\n", regex);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " new has now %s\n", new->s);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " new has now %s\n", newctx->s);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " rest is now %s\n", rest);
p->s[1] = '\0'; /* dont realloc */
- GNUNET_CONTAINER_DLL_insert (p->head, p->tail, new);
+ GNUNET_CONTAINER_DLL_insert (p->head, p->tail, newctx);
regex_add (p, rest);
}
return;
}
+/**
+ * Free all resources used by the context node and all its children.
+ *
+ * @param ctx Context to free.
+ */
+static void
+regex_ctx_destroy (struct RegexCombineCtx *ctx)
+{
+ struct RegexCombineCtx *p;
+ struct RegexCombineCtx *next;
+
+ for (p = ctx->head; NULL != p; p = next)
+ {
+ next = p->next;
+ regex_ctx_destroy (p);
+ }
+ GNUNET_free_non_null (ctx->s); /* 's' on root node is null */
+ GNUNET_free (ctx);
+}
+
+
/**
* Return a prefix-combine regex that matches the same strings as
* any of the original regexes.
unsigned int i;
char *combined;
const char *current;
- struct RegexCombineCtx ctx;
+ struct RegexCombineCtx *ctx;
- memset (&ctx, 0, sizeof (struct RegexCombineCtx));
+ ctx = GNUNET_malloc (sizeof (struct RegexCombineCtx));
for (i = 0; regexes[i]; i++)
{
current = regexes[i];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Regex %u: %s\n", i, current);
- regex_add (&ctx, current);
+ regex_add (ctx, current);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\nCombining...\n");
+ //debugctx (ctx, 0);
+
+ combined = regex_combine (ctx);
- combined = regex_combine (&ctx);
+ regex_ctx_destroy (ctx);
return combined;
}
struct GNUNET_DISK_FileHandle *f;
unsigned int nr;
unsigned int offset;
- off_t size;
+ uint64_t size;
size_t len;
char *buffer;
char *regex;
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Can't get size of file %s\n", filename);
+ GNUNET_DISK_file_close (f);
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
else
{
len -= 6;
- buffer[len] = '\0';
+ regex[len] = '\0';
}
regex = GNUNET_realloc (regex, len + 1);
GNUNET_array_grow (regexes, nr, nr + 1);
+ GNUNET_assert (NULL == regexes[nr - 2]);
regexes[nr - 2] = regex;
regexes[nr - 1] = NULL;
+ regex = NULL;
} while (offset < size);
+ GNUNET_free_non_null (regex);
GNUNET_free (buffer);
return regexes;
projects / oweals / gnunet.git / blobdiff