regex_test_lib.h File Reference

#include "regex_internal_lib.h"

Include dependency graph for regex_test_lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	REGEX_TEST_GraphSavingOptions { REGEX_TEST_GRAPH_DEFAULT = 0 , REGEX_TEST_GRAPH_VERBOSE = 1 , REGEX_TEST_GRAPH_COLORING = 2 }
	Options for graph creation function REGEX_TEST_automaton_save_graph. More...

Functions
char *	REGEX_TEST_combine (char *const regexes[], unsigned int alphabet_size)
	Combine an array of regexes into a single prefix-shared regex. More...
char **	REGEX_TEST_read_from_file (const char *filename)
	Read a set of regexes from a file, one per line and return them in an array suitable for REGEX_TEST_combine. More...
void	REGEX_TEST_free_from_file (char **regexes)
	Free all memory reserved for a set of regexes created by read_from_file. More...
char *	REGEX_TEST_generate_random_regex (size_t rx_length, char *matching_str)
	Generate a (pseudo) random regular expression of length 'rx_length', as well as a (optional) string that will be matched by the generated regex. More...
char *	REGEX_TEST_generate_random_string (size_t max_len)
	Generate a random string of maximum length 'max_len' that only contains literals allowed in a regular expression. More...
void	REGEX_TEST_automaton_save_graph (struct REGEX_INTERNAL_Automaton *a, const char *filename, enum REGEX_TEST_GraphSavingOptions options)
	Save the given automaton as a GraphViz dot file. More...

Enumeration Type Documentation

REGEX_TEST_GraphSavingOptions

enum REGEX_TEST_GraphSavingOptions

Options for graph creation function REGEX_TEST_automaton_save_graph.

Enumerator
REGEX_TEST_GRAPH_DEFAULT	Default. Do nothing special.
REGEX_TEST_GRAPH_VERBOSE	The generated graph will include extra information such as the NFA states that were used to generate the DFA state.
REGEX_TEST_GRAPH_COLORING	Enable graph coloring. Will color each SCC in a different color.

Definition at line 116 of file regex_test_lib.h.

{
  REGEX_TEST_GRAPH_DEFAULT = 0,
 
  REGEX_TEST_GRAPH_VERBOSE = 1,
 
  REGEX_TEST_GRAPH_COLORING = 2
};

Function Documentation

REGEX_TEST_combine()

char * REGEX_TEST_combine	(	char *const	regexes[],
		unsigned int	alphabet_size
	)

Combine an array of regexes into a single prefix-shared regex.

Returns a prefix-combine regex that matches the same strings as any of the original regexes.

WARNING: only useful for reading specific regexes for specific applications, namely the gnunet-regex-profiler / gnunet-regex-daemon. This function DOES NOT support arbitrary regex combining.

Parameters

regexes	A NULL-terminated array of regexes.
alphabet_size	Size of the alphabet the regex uses.

Returns

A string with a single regex that matches any of the original regexes

Definition at line 545 of file regex_test_lib.c.

{
  unsigned int i;
  char *combined;
  const char *current;
  struct RegexCombineCtx *ctx;
 
  ctx = new_regex_ctx (alphabet_size);
  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);
    debugctx (ctx, 0);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "\nCombining...\n");
  debugctx (ctx, 0);
 
  combined = regex_combine (ctx);
 
  regex_ctx_destroy (ctx);
 
  return combined;
}

References ctx, debugctx(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, new_regex_ctx(), regex_add(), regex_combine(), and regex_ctx_destroy().

Referenced by main(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEX_TEST_read_from_file()

char ** REGEX_TEST_read_from_file

(

const char *

filename

)

Read a set of regexes from a file, one per line and return them in an array suitable for REGEX_TEST_combine.

The array must be free'd using REGEX_TEST_free_from_file.

Parameters

filename

Name of the file containing the regexes.

Returns

A newly allocated, NULL terminated array of regexes.

Definition at line 581 of file regex_test_lib.c.

{
  struct GNUNET_DISK_FileHandle *f;
  unsigned int nr;
  unsigned int offset;
  off_t size;
  size_t len;
  char *buffer;
  char *regex;
  char **regexes;
 
  f = GNUNET_DISK_file_open (filename,
                             GNUNET_DISK_OPEN_READ,
                             GNUNET_DISK_PERM_NONE);
  if (NULL == f)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Can't open file %s for reading\n", filename);
    return NULL;
  }
  if (GNUNET_OK != GNUNET_DISK_file_handle_size (f, &size))
  {
    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,
              "using file %s, size %llu\n",
              filename, (unsigned long long) size);
 
  buffer = GNUNET_malloc (size + 1);
  GNUNET_DISK_file_read (f, buffer, size);
  GNUNET_DISK_file_close (f);
  regexes = GNUNET_malloc (sizeof(char *));
  nr = 1;
  offset = 0;
  regex = NULL;
  do
  {
    if (NULL == regex)
      regex = GNUNET_malloc (size + 1);
    len = (size_t) sscanf (&buffer[offset], "%s", regex);
    if (0 == len)
      break;
    len = strlen (regex);
    offset += len + 1;
    if (len < 1)
      continue;
    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 (regex);
  GNUNET_free (buffer);
 
  return regexes;
}

References removetrailingwhitespace::f, filename, GNUNET_array_grow, GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_realloc, and size.

Referenced by main(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEX_TEST_free_from_file()

void REGEX_TEST_free_from_file

(

char **

regexes

)

Free all memory reserved for a set of regexes created by read_from_file.

Parameters

regexes

NULL-terminated array of regexes.

Definition at line 652 of file regex_test_lib.c.

{
  unsigned int i;
 
  for (i = 0; regexes[i]; i++)
    GNUNET_free (regexes[i]);
  GNUNET_free (regexes);
}

References GNUNET_free.

Referenced by main(), and run().

Here is the caller graph for this function:

REGEX_TEST_generate_random_regex()

char * REGEX_TEST_generate_random_regex	(	size_t	rx_length,
		char *	matching_str
	)

Generate a (pseudo) random regular expression of length 'rx_length', as well as a (optional) string that will be matched by the generated regex.

The returned regex needs to be freed.

Parameters

rx_length	length of the random regex.
matching_str	(optional) pointer to a string that will contain a string that will be matched by the generated regex, if 'matching_str' pointer was not NULL.

Returns

NULL if 'rx_length' is 0, a random regex of length 'rx_length', which needs to be freed, otherwise.

The returned regex needs to be freed.

Parameters

rx_length	length of the random regex.
matching_str	(optional) pointer to a string that will contain a string that will be matched by the generated regex, if 'matching_str' pointer was not NULL. Make sure you allocated at least rx_length+1 bytes for this string.

Returns

NULL if 'rx_length' is 0, a random regex of length 'rx_length', which needs to be freed, otherwise.

Definition at line 64 of file regex_test_random.c.

{
  char *rx;
  char *rx_p;
  char *matching_strp;
  unsigned int i;
  unsigned int char_op_switch;
  unsigned int last_was_op;
  int rx_op;
  char current_char;
 
  if (0 == rx_length)
    return NULL;
 
  if (NULL != matching_str)
    matching_strp = matching_str;
  else
    matching_strp = NULL;
 
  rx = GNUNET_malloc (rx_length + 1);
  rx_p = rx;
  current_char = 0;
  last_was_op = 1;
 
  for (i = 0; i < rx_length; i++)
  {
    char_op_switch = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2);
 
    if ((0 == char_op_switch) && ! last_was_op)
    {
      last_was_op = 1;
      rx_op = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 4);
 
      switch (rx_op)
      {
      case 0:
        current_char = '+';
        break;
 
      case 1:
        current_char = '*';
        break;
 
      case 2:
        current_char = '?';
        break;
 
      case 3:
        if (i < rx_length - 1)       /* '|' cannot be at the end */
          current_char = '|';
        else
          current_char = get_random_literal ();
        break;
      }
    }
    else
    {
      current_char = get_random_literal ();
      last_was_op = 0;
    }
 
    if ((NULL != matching_strp) &&
        ((current_char != '+') && (current_char != '*') && (current_char !=
                                                            '?') &&
         (current_char != '|') ))
    {
      *matching_strp = current_char;
      matching_strp++;
    }
 
    *rx_p = current_char;
    rx_p++;
  }
  *rx_p = '\0';
  if (NULL != matching_strp)
    *matching_strp = '\0';
 
  return rx;
}

References get_random_literal(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), and GNUNET_malloc.

Here is the call graph for this function:

REGEX_TEST_generate_random_string()

char * REGEX_TEST_generate_random_string

(

size_t

max_len

)

Generate a random string of maximum length 'max_len' that only contains literals allowed in a regular expression.

The string might be 0 chars long but is garantueed to be shorter or equal to 'max_len'.

Parameters

max_len

maximum length of the string that should be generated.

Returns

random string that needs to be freed.

Definition at line 155 of file regex_test_random.c.

{
  unsigned int i;
  char *str;
  size_t len;
 
  if (1 > max_len)
    return GNUNET_strdup ("");
 
  len = (size_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max_len);
  str = GNUNET_malloc (len + 1);
 
  for (i = 0; i < len; i++)
  {
    str[i] = get_random_literal ();
  }
 
  str[i] = '\0';
 
  return str;
}

References get_random_literal(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_malloc, and GNUNET_strdup.

Here is the call graph for this function:

REGEX_TEST_automaton_save_graph()

void REGEX_TEST_automaton_save_graph	(	struct REGEX_INTERNAL_Automaton *	a,
		const char *	filename,
		enum REGEX_TEST_GraphSavingOptions	options
	)

Save the given automaton as a GraphViz dot file.

Parameters

a	the automaton to be saved.
filename	where to save the file.
options	options for graph generation that include coloring or verbose mode

Definition at line 270 of file regex_test_graph.c.

{
  char *start;
  char *end;
  struct REGEX_TEST_Graph_Context ctx;
 
  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;
  }
 
  ctx.filep = fopen (filename, "w");
  ctx.verbose =
    (0 == (options & REGEX_TEST_GRAPH_VERBOSE)) ? GNUNET_NO : GNUNET_YES;
  ctx.coloring =
    (0 == (options & REGEX_TEST_GRAPH_COLORING)) ? GNUNET_NO : GNUNET_YES;
 
  if (NULL == ctx.filep)
  {
    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 */
  if (GNUNET_YES == ctx.coloring)
    scc_tarjan (a);
 
  start = (char*) "digraph G {\nrankdir=LR\n";
  fwrite (start, strlen (start), 1, ctx.filep);
 
  REGEX_INTERNAL_automaton_traverse (a, a->start, NULL, NULL,
                                     &automaton_save_graph_step,
                                     &ctx);
 
  end = (char*) "\n}\n";
  fwrite (end, strlen (end), 1, ctx.filep);
  fclose (ctx.filep);
}

References automaton_save_graph_step(), ctx, end, filename, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_YES, options, REGEX_INTERNAL_automaton_traverse(), REGEX_TEST_GRAPH_COLORING, REGEX_TEST_GRAPH_VERBOSE, scc_tarjan(), start, and REGEX_INTERNAL_Automaton::start.

Here is the call graph for this function: