diff options
Diffstat (limited to 'src/regex/regex_test_lib.c')
-rw-r--r-- | src/regex/regex_test_lib.c | 336 |
1 files changed, 277 insertions, 59 deletions
diff --git a/src/regex/regex_test_lib.c b/src/regex/regex_test_lib.c index c42dbcef6..f4025f652 100644 --- a/src/regex/regex_test_lib.c +++ b/src/regex/regex_test_lib.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | * This file is part of GNUnet | 2 | * This file is part of GNUnet |
3 | * Copyright (C) 2012 GNUnet e.V. | 3 | * Copyright (C) 2012-2017 GNUnet e.V. |
4 | * | 4 | * |
5 | * GNUnet is free software; you can redistribute it and/or modify | 5 | * GNUnet is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License as published | 6 | * it under the terms of the GNU General Public License as published |
@@ -32,27 +32,17 @@ | |||
32 | /** | 32 | /** |
33 | * Struct to hold the tree formed by prefix-combining the regexes. | 33 | * Struct to hold the tree formed by prefix-combining the regexes. |
34 | */ | 34 | */ |
35 | struct RegexCombineCtx { | 35 | struct RegexCombineCtx |
36 | 36 | { | |
37 | /** | ||
38 | * Next node with same prefix but different token. | ||
39 | */ | ||
40 | struct RegexCombineCtx *next; | ||
41 | |||
42 | /** | ||
43 | * Prev node with same prefix but different token. | ||
44 | */ | ||
45 | struct RegexCombineCtx *prev; | ||
46 | |||
47 | /** | 37 | /** |
48 | * First child node with same prefix and token. | 38 | * Child nodes with same prefix and token. |
49 | */ | 39 | */ |
50 | struct RegexCombineCtx *head; | 40 | struct RegexCombineCtx **children; |
51 | 41 | ||
52 | /** | 42 | /** |
53 | * Last child node. | 43 | * Alphabet size (how many @a children there are) |
54 | */ | 44 | */ |
55 | struct RegexCombineCtx *tail; | 45 | unsigned int size; |
56 | 46 | ||
57 | /** | 47 | /** |
58 | * Token. | 48 | * Token. |
@@ -60,30 +50,133 @@ struct RegexCombineCtx { | |||
60 | char *s; | 50 | char *s; |
61 | }; | 51 | }; |
62 | 52 | ||
63 | /* | 53 | |
54 | /** | ||
55 | * Char 2 int | ||
56 | * | ||
57 | * Convert a character into its int value depending on the base used | ||
58 | * | ||
59 | * @param c Char | ||
60 | * @param size base (2, 8 or 16(hex)) | ||
61 | * | ||
62 | * @return Int in range [0, (base-1)] | ||
63 | */ | ||
64 | static int | ||
65 | c2i (char c, int size) | ||
66 | { | ||
67 | switch (size) | ||
68 | { | ||
69 | case 2: | ||
70 | case 8: | ||
71 | return c - '0'; | ||
72 | break; | ||
73 | case 16: | ||
74 | if (c >= '0' && c <= '9') | ||
75 | return c - '0'; | ||
76 | else if (c >= 'A' && c <= 'F') | ||
77 | return c - 'A' + 10; | ||
78 | else if (c >= 'a' && c <= 'f') | ||
79 | return c - 'a' + 10; | ||
80 | else | ||
81 | { | ||
82 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
83 | "Cannot convert char %c in base %u\n", | ||
84 | c, size); | ||
85 | GNUNET_assert (0); | ||
86 | } | ||
87 | break; | ||
88 | default: | ||
89 | GNUNET_assert (0); | ||
90 | } | ||
91 | } | ||
92 | |||
93 | |||
94 | /** | ||
95 | * Printf spaces to indent the regex tree | ||
96 | * | ||
97 | * @param n Indentation level | ||
98 | */ | ||
64 | static void | 99 | static void |
65 | space (int n) | 100 | space (int n) |
66 | { | 101 | { |
67 | int i; | 102 | int i; |
68 | for (i = 0; i < n; i++) | 103 | for (i = 0; i < n; i++) |
69 | printf (" "); | 104 | fprintf (stderr, "| "); |
70 | } | 105 | } |
71 | 106 | ||
107 | |||
108 | /** | ||
109 | * Printf the combined regex ctx. | ||
110 | * | ||
111 | * @param ctx The ctx to printf | ||
112 | * @param level Indentation level to start with | ||
113 | */ | ||
72 | static void | 114 | static void |
73 | debugctx (struct RegexCombineCtx *ctx, int level) | 115 | debugctx (struct RegexCombineCtx *ctx, int level) |
74 | { | 116 | { |
75 | struct RegexCombineCtx *p; | 117 | return; |
76 | space (level); | 118 | unsigned int i; |
77 | if (NULL != ctx->s) | 119 | if (NULL != ctx->s) |
78 | printf ("'%s'\n", ctx->s); | 120 | { |
121 | space (level - 1); | ||
122 | fprintf (stderr, "%u:'%s'\n", c2i(ctx->s[0], ctx->size), ctx->s); | ||
123 | } | ||
79 | else | 124 | else |
80 | printf ("NULL\n"); | 125 | fprintf (stderr, "ROOT (base %u)\n", ctx->size); |
81 | for (p = ctx->head; NULL != p; p = p->next) | 126 | for (i = 0; i < ctx->size; i++) |
127 | { | ||
128 | if (NULL != ctx->children[i]) | ||
129 | { | ||
130 | space (level); | ||
131 | debugctx (ctx->children[i], level + 1); | ||
132 | } | ||
133 | } | ||
134 | fflush(stderr); | ||
135 | } | ||
136 | |||
137 | |||
138 | /** | ||
139 | * Add a single regex to a context, combining with exisiting regex by-prefix. | ||
140 | * | ||
141 | * @param ctx Context with 0 or more regexes. | ||
142 | * @param regex Regex to add. | ||
143 | */ | ||
144 | static void | ||
145 | regex_add (struct RegexCombineCtx *ctx, const char *regex); | ||
146 | |||
147 | |||
148 | /** | ||
149 | * Create and initialize a new RegexCombineCtx. | ||
150 | * | ||
151 | * @param alphabet_size Size of the alphabet (and the Trie array) | ||
152 | */ | ||
153 | static struct RegexCombineCtx * | ||
154 | new_regex_ctx (unsigned int alphabet_size) | ||
155 | { | ||
156 | struct RegexCombineCtx *ctx; | ||
157 | size_t array_size; | ||
158 | |||
159 | array_size = sizeof(struct RegexCombineCtx *) * alphabet_size; | ||
160 | ctx = GNUNET_new (struct RegexCombineCtx); | ||
161 | ctx->children = GNUNET_malloc (array_size); | ||
162 | ctx->size = alphabet_size; | ||
163 | |||
164 | return ctx; | ||
165 | } | ||
166 | |||
167 | static void | ||
168 | move_children (struct RegexCombineCtx *dst, const struct RegexCombineCtx *src) | ||
169 | { | ||
170 | size_t array_size; | ||
171 | |||
172 | array_size = sizeof(struct RegexCombineCtx *) * src->size; | ||
173 | memcpy (dst->children, src->children, array_size); | ||
174 | for (int i = 0; i < src->size; i++) | ||
82 | { | 175 | { |
83 | debugctx (p, level + 1); | 176 | src->children[i] = NULL; |
84 | } | 177 | } |
85 | } | 178 | } |
86 | */ | 179 | |
87 | 180 | ||
88 | /** | 181 | /** |
89 | * Extract a string from all prefix-combined regexes. | 182 | * Extract a string from all prefix-combined regexes. |
@@ -96,6 +189,7 @@ static char * | |||
96 | regex_combine (struct RegexCombineCtx *ctx) | 189 | regex_combine (struct RegexCombineCtx *ctx) |
97 | { | 190 | { |
98 | struct RegexCombineCtx *p; | 191 | struct RegexCombineCtx *p; |
192 | unsigned int i; | ||
99 | size_t len; | 193 | size_t len; |
100 | char *regex; | 194 | char *regex; |
101 | char *tmp; | 195 | char *tmp; |
@@ -105,9 +199,14 @@ regex_combine (struct RegexCombineCtx *ctx) | |||
105 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new combine %s\n", ctx->s); | 199 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new combine %s\n", ctx->s); |
106 | regex = GNUNET_strdup (""); | 200 | regex = GNUNET_strdup (""); |
107 | opt = GNUNET_NO; | 201 | opt = GNUNET_NO; |
108 | for (p = ctx->head; NULL != p; p = p->next) | 202 | for (i = 0; i < ctx->size; i++) |
109 | { | 203 | { |
110 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "adding '%s' to innner %s\n", p->s, ctx->s); | 204 | p = ctx->children[i]; |
205 | if (NULL == p) | ||
206 | continue; | ||
207 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
208 | "adding '%s' to innner %s\n", | ||
209 | p->s, ctx->s); | ||
111 | s = regex_combine (p); | 210 | s = regex_combine (p); |
112 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " total '%s'\n", s); | 211 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " total '%s'\n", s); |
113 | if (strlen(s) == 0) | 212 | if (strlen(s) == 0) |
@@ -171,10 +270,10 @@ get_prefix_length (const char *s1, const char *s2) | |||
171 | l2 = strlen (s2); | 270 | l2 = strlen (s2); |
172 | limit = l1 > l2 ? l2 : l1; | 271 | limit = l1 > l2 ? l2 : l1; |
173 | 272 | ||
174 | for (i = 1; i <= limit; i++) | 273 | for (i = 0; i < limit; i++) |
175 | { | 274 | { |
176 | if (0 != strncmp (s1, s2, i)) | 275 | if (s1[i] != s2[i]) |
177 | return i - 1; | 276 | return i; |
178 | } | 277 | } |
179 | return limit; | 278 | return limit; |
180 | } | 279 | } |
@@ -194,13 +293,19 @@ get_longest_prefix (struct RegexCombineCtx *ctx, const char *regex) | |||
194 | { | 293 | { |
195 | struct RegexCombineCtx *p; | 294 | struct RegexCombineCtx *p; |
196 | struct RegexCombineCtx *best; | 295 | struct RegexCombineCtx *best; |
296 | unsigned int i; | ||
197 | unsigned int l; | 297 | unsigned int l; |
198 | unsigned int best_l; | 298 | unsigned int best_l; |
199 | 299 | ||
200 | best_l = 0; | 300 | best_l = 0; |
201 | best = NULL; | 301 | best = NULL; |
202 | for (p = ctx->head; NULL != p; p = p->next) | 302 | |
303 | for (i = 0; i < ctx->size; i++) | ||
203 | { | 304 | { |
305 | p = ctx->children[i]; | ||
306 | if (NULL == p) | ||
307 | continue; | ||
308 | |||
204 | l = get_prefix_length (p->s, regex); | 309 | l = get_prefix_length (p->s, regex); |
205 | if (l > best_l) | 310 | if (l > best_l) |
206 | { | 311 | { |
@@ -212,6 +317,103 @@ get_longest_prefix (struct RegexCombineCtx *ctx, const char *regex) | |||
212 | return best; | 317 | return best; |
213 | } | 318 | } |
214 | 319 | ||
320 | static void | ||
321 | regex_add_multiple (struct RegexCombineCtx *ctx, | ||
322 | const char *regex, | ||
323 | struct RegexCombineCtx **children) | ||
324 | { | ||
325 | char tmp[2]; | ||
326 | long unsigned int i; | ||
327 | size_t l; | ||
328 | struct RegexCombineCtx *newctx; | ||
329 | unsigned int count; | ||
330 | |||
331 | if ('(' != regex[0]) | ||
332 | { | ||
333 | GNUNET_assert (0); | ||
334 | } | ||
335 | |||
336 | /* Does the regex cover *all* possible children? Then don't add any, | ||
337 | * as it will be covered by the post-regex "(a-z)*" | ||
338 | */ | ||
339 | l = strlen (regex); | ||
340 | count = 0; | ||
341 | for (i = 1UL; i < l; i++) | ||
342 | { | ||
343 | if (regex[i] != '|' && regex[i] != ')') | ||
344 | { | ||
345 | count++; | ||
346 | } | ||
347 | } | ||
348 | if (count == ctx->size) | ||
349 | { | ||
350 | return; | ||
351 | } | ||
352 | |||
353 | /* Add every component as a child node */ | ||
354 | tmp[1] = '\0'; | ||
355 | for (i = 1UL; i < l; i++) | ||
356 | { | ||
357 | if (regex[i] != '|' && regex[i] != ')') | ||
358 | { | ||
359 | tmp[0] = regex[i]; | ||
360 | newctx = new_regex_ctx(ctx->size); | ||
361 | newctx->s = GNUNET_strdup (tmp); | ||
362 | if (children != NULL) | ||
363 | memcpy (newctx->children, children, sizeof (*children) * ctx->size); | ||
364 | ctx->children[c2i(tmp[0], ctx->size)] = newctx; | ||
365 | } | ||
366 | } | ||
367 | } | ||
368 | |||
369 | /** | ||
370 | * Add a single regex to a context, splitting the exisiting state. | ||
371 | * | ||
372 | * We only had a partial match, split existing state, truncate the current node | ||
373 | * so it only contains the prefix, add suffix(es) as children. | ||
374 | * | ||
375 | * @param ctx Context to split. | ||
376 | * @param len Lenght of ctx->s | ||
377 | * @param prefix_l Lenght of common prefix of the new regex and @a ctx->s | ||
378 | */ | ||
379 | static void | ||
380 | regex_split (struct RegexCombineCtx *ctx, | ||
381 | unsigned int len, | ||
382 | unsigned int prefix_l) | ||
383 | { | ||
384 | struct RegexCombineCtx *newctx; | ||
385 | unsigned int idx; | ||
386 | char *suffix; | ||
387 | |||
388 | suffix = GNUNET_malloc (len - prefix_l + 1); | ||
389 | strncpy (suffix, &ctx->s[prefix_l], len - prefix_l + 1); | ||
390 | |||
391 | /* Suffix saved, truncate current node so it only contains the prefix, | ||
392 | * copy any children nodes to put as grandchildren and initialize new empty | ||
393 | * children array. | ||
394 | */ | ||
395 | ctx->s[prefix_l] = '\0'; | ||
396 | |||
397 | /* If the suffix is an OR expression, add multiple children */ | ||
398 | if ('(' == suffix[0]) | ||
399 | { | ||
400 | struct RegexCombineCtx **tmp; | ||
401 | |||
402 | tmp = ctx->children; | ||
403 | ctx->children = GNUNET_malloc (sizeof(*tmp) * ctx->size); | ||
404 | regex_add_multiple (ctx, suffix, tmp); | ||
405 | GNUNET_free (tmp); | ||
406 | return; | ||
407 | } | ||
408 | |||
409 | /* The suffix is a normal string, add as one node */ | ||
410 | newctx = new_regex_ctx (ctx->size); | ||
411 | newctx->s = suffix; | ||
412 | move_children (newctx, ctx); | ||
413 | idx = c2i(suffix[0], ctx->size); | ||
414 | ctx->children[idx] = newctx; | ||
415 | } | ||
416 | |||
215 | 417 | ||
216 | /** | 418 | /** |
217 | * Add a single regex to a context, combining with exisiting regex by-prefix. | 419 | * Add a single regex to a context, combining with exisiting regex by-prefix. |
@@ -224,17 +426,31 @@ regex_add (struct RegexCombineCtx *ctx, const char *regex) | |||
224 | { | 426 | { |
225 | struct RegexCombineCtx *p; | 427 | struct RegexCombineCtx *p; |
226 | struct RegexCombineCtx *newctx; | 428 | struct RegexCombineCtx *newctx; |
429 | long unsigned int l; | ||
227 | unsigned int prefix_l; | 430 | unsigned int prefix_l; |
228 | const char *rest_r; | 431 | const char *rest_r; |
229 | const char *rest_s; | 432 | const char *rest_s; |
230 | size_t len; | 433 | size_t len; |
434 | int idx; | ||
435 | |||
436 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
437 | "regex_add '%s' into '%s'\n", | ||
438 | regex, ctx->s); | ||
439 | l = strlen (regex); | ||
440 | if (0UL == l) | ||
441 | return; | ||
231 | 442 | ||
232 | if (0 == strlen (regex)) | 443 | /* If the regex is in the form of (a|b|c), add every character separately */ |
444 | if ('(' == regex[0]) | ||
445 | { | ||
446 | regex_add_multiple (ctx, regex, NULL); | ||
233 | return; | 447 | return; |
448 | } | ||
234 | 449 | ||
235 | p = get_longest_prefix (ctx, regex); | 450 | p = get_longest_prefix (ctx, regex); |
236 | if (NULL != p) /* There is some prefix match, reduce regex and try again */ | 451 | if (NULL != p) |
237 | { | 452 | { |
453 | /* There is some prefix match, reduce regex and try again */ | ||
238 | prefix_l = get_prefix_length (p->s, regex); | 454 | prefix_l = get_prefix_length (p->s, regex); |
239 | rest_s = &p->s[prefix_l]; | 455 | rest_s = &p->s[prefix_l]; |
240 | rest_r = ®ex[prefix_l]; | 456 | rest_r = ®ex[prefix_l]; |
@@ -243,35 +459,29 @@ regex_add (struct RegexCombineCtx *ctx, const char *regex) | |||
243 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "rest r '%s'\n", rest_r); | 459 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "rest r '%s'\n", rest_r); |
244 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "rest s '%s'\n", rest_s); | 460 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "rest s '%s'\n", rest_s); |
245 | len = strlen (p->s); | 461 | len = strlen (p->s); |
246 | if (prefix_l < len) /* only partial match, split existing state */ | 462 | if (prefix_l < len) |
247 | { | 463 | { |
248 | newctx = GNUNET_new (struct RegexCombineCtx); | 464 | regex_split (p, len, prefix_l); |
249 | newctx->head = p->head; | ||
250 | newctx->tail = p->tail; | ||
251 | newctx->s = GNUNET_malloc(len - prefix_l + 1); | ||
252 | strncpy (newctx->s, rest_s, len - prefix_l + 1); | ||
253 | |||
254 | p->head = newctx; | ||
255 | p->tail = newctx; | ||
256 | p->s[prefix_l] = '\0'; | ||
257 | } | 465 | } |
258 | regex_add (p, rest_r); | 466 | regex_add (p, rest_r); |
259 | return; | 467 | return; |
260 | } | 468 | } |
469 | |||
261 | /* There is no prefix match, add new */ | 470 | /* There is no prefix match, add new */ |
262 | if (NULL == ctx->head && NULL != ctx->s) | 471 | idx = c2i(regex[0], ctx->size); |
472 | if (NULL == ctx->children[idx] && NULL != ctx->s) | ||
263 | { | 473 | { |
264 | /* this was the end before, add empty string */ | 474 | /* this was the end before, add empty string */ |
265 | newctx = GNUNET_new (struct RegexCombineCtx); | 475 | newctx = new_regex_ctx (ctx->size); |
266 | newctx->s = GNUNET_strdup (""); | 476 | newctx->s = GNUNET_strdup (""); |
267 | GNUNET_CONTAINER_DLL_insert (ctx->head, ctx->tail, newctx); | 477 | ctx->children[idx] = newctx; |
268 | } | 478 | } |
269 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " no match\n"); | 479 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " no match\n"); |
270 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " new state %s\n", regex); | 480 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " new state %s\n", regex); |
271 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " under %s\n", ctx->s); | 481 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " under %s\n", ctx->s); |
272 | newctx = GNUNET_new (struct RegexCombineCtx); | 482 | newctx = new_regex_ctx(ctx->size); |
273 | newctx->s = GNUNET_strdup (regex); | 483 | newctx->s = GNUNET_strdup (regex); |
274 | GNUNET_CONTAINER_DLL_insert (ctx->head, ctx->tail, newctx); | 484 | ctx->children[idx] = newctx; |
275 | } | 485 | } |
276 | 486 | ||
277 | 487 | ||
@@ -283,45 +493,53 @@ regex_add (struct RegexCombineCtx *ctx, const char *regex) | |||
283 | static void | 493 | static void |
284 | regex_ctx_destroy (struct RegexCombineCtx *ctx) | 494 | regex_ctx_destroy (struct RegexCombineCtx *ctx) |
285 | { | 495 | { |
286 | struct RegexCombineCtx *p; | 496 | unsigned int i; |
287 | struct RegexCombineCtx *next; | 497 | |
498 | if (NULL == ctx) | ||
499 | return; | ||
288 | 500 | ||
289 | for (p = ctx->head; NULL != p; p = next) | 501 | for (i = 0; i < ctx->size; i++) |
290 | { | 502 | { |
291 | next = p->next; | 503 | regex_ctx_destroy (ctx->children[i]); |
292 | regex_ctx_destroy (p); | ||
293 | } | 504 | } |
294 | GNUNET_free_non_null (ctx->s); /* 's' on root node is null */ | 505 | GNUNET_free_non_null (ctx->s); /* 's' on root node is null */ |
506 | GNUNET_free (ctx->children); | ||
295 | GNUNET_free (ctx); | 507 | GNUNET_free (ctx); |
296 | } | 508 | } |
297 | 509 | ||
298 | 510 | ||
299 | /** | 511 | /** |
300 | * Return a prefix-combine regex that matches the same strings as | 512 | * Combine an array of regexes into a single prefix-shared regex. |
513 | * Returns a prefix-combine regex that matches the same strings as | ||
301 | * any of the original regexes. | 514 | * any of the original regexes. |
302 | * | 515 | * |
303 | * WARNING: only useful for reading specific regexes for specific applications, | 516 | * WARNING: only useful for reading specific regexes for specific applications, |
304 | * namely the gnunet-regex-profiler / gnunet-regex-daemon. | 517 | * namely the gnunet-regex-profiler / gnunet-regex-daemon. |
305 | * This function DOES NOT support arbitrary regex combining. | 518 | * This function DOES NOT support arbitrary regex combining. |
519 | * | ||
520 | * @param regexes A NULL-terminated array of regexes. | ||
521 | * @param alphabet_size Size of the alphabet the regex uses. | ||
522 | * | ||
523 | * @return A string with a single regex that matches any of the original regexes | ||
306 | */ | 524 | */ |
307 | char * | 525 | char * |
308 | REGEX_TEST_combine (char * const regexes[]) | 526 | REGEX_TEST_combine (char * const regexes[], unsigned int alphabet_size) |
309 | { | 527 | { |
310 | unsigned int i; | 528 | unsigned int i; |
311 | char *combined; | 529 | char *combined; |
312 | const char *current; | 530 | const char *current; |
313 | struct RegexCombineCtx *ctx; | 531 | struct RegexCombineCtx *ctx; |
314 | 532 | ||
315 | ctx = GNUNET_new (struct RegexCombineCtx); | 533 | ctx = new_regex_ctx (alphabet_size); |
316 | for (i = 0; regexes[i]; i++) | 534 | for (i = 0; regexes[i]; i++) |
317 | { | 535 | { |
318 | current = regexes[i]; | 536 | current = regexes[i]; |
319 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Regex %u: %s\n", i, current); | 537 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Regex %u: %s\n", i, current); |
320 | regex_add (ctx, current); | 538 | regex_add (ctx, current); |
321 | /* debugctx (ctx, 0); */ | 539 | debugctx (ctx, 0); |
322 | } | 540 | } |
323 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\nCombining...\n"); | 541 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\nCombining...\n"); |
324 | /* debugctx (ctx, 0); */ | 542 | debugctx (ctx, 0); |
325 | 543 | ||
326 | combined = regex_combine (ctx); | 544 | combined = regex_combine (ctx); |
327 | 545 | ||