Exemple #1
0
/**
 * compilerkit_character_class_new:
 * @fn compilerkit_character_class_new
 *
 * Constructs a character class object (internally the equivalent CompilerKitAlternation).
 * 
 * For example, `compilerkit_character_class_new('a','z')` produces the regex `[a-z]`.
 * `compilerkit_character_class_new('!','~')` produces the a regex to match all characters between ASCII '!' and '~' (this happens to include all Latin printable characters).
 * 
 * @pre None.
 * @param gunichar `lo` The low end of the character class. If this is `'\0'`, `lo` is the next higher character.
 * @param gunichar `hi` The high end of the character class. If this is `'\0'`, return the empty string.
 * @return GObject* a pointer to the new character class regex.
 */
GObject* compilerkit_character_class_new(gunichar lo, gunichar hi)
{
	GObject* newExpression;
    gunichar i;

    sort_chars (&lo, &hi);

    /* If they're the same, return the symbol instead. */
    if (lo == hi)
    {
        return compilerkit_symbol_new (lo);
    }

    /* Don't match NULL in the regex */
    if (lo == '\0')
    {
        lo++;
    }

    /* This must mean lo and hi are both NULL. Return EmptyString instead. */
    else if (hi == '\0')
    {
        return compilerkit_empty_string_get_instance();
    }
    
    newExpression = compilerkit_symbol_new(lo);
    for(i = lo+1; i <= hi; i++)
    {
        newExpression = compilerkit_alternation_new (newExpression, compilerkit_symbol_new(i));
    }
    return newExpression;
}
int main (int argc, char ** argv)
{
    CompilerKitEmptyString* empty_string;
    g_type_init();
    
    empty_string = compilerkit_empty_string_get_instance();
    
    g_object_unref (empty_string);
}
/**
 * test_concatenation_method:
 * @fn test_concatenation_method
 * Tests method compilerkit_concatenation_method in CompilerKitConcatenation struct.
 * @pre None
 * @param None
 * @return void
 */
void test_concatenation_constructor_empty_string (void)
{
	GObject* ckc;
	GObject* left;
	GObject* right;

    g_test_message ("Testing Concatenation constructor when either side is an empty string");
    g_test_timer_start ();

    /** @todo Test here  */

	// Right parameter is EmptyString
    {
        left = compilerkit_symbol_new('a');
        right = compilerkit_empty_string_get_instance ();
        ckc = compilerkit_concatenation_new(left,right);

        g_assert(COMPILERKIT_IS_SYMBOL(ckc));
        g_assert (left == ckc);

        g_object_unref (left);
        g_object_unref (right);
    }

	// Left parameter is EmptyString
    {
        left = compilerkit_empty_string_get_instance ();
        right = compilerkit_symbol_new('a');
        ckc = compilerkit_concatenation_new(left,right);

        g_assert(COMPILERKIT_IS_SYMBOL(ckc));
        g_assert (ckc == right);

        g_object_unref (left);
        g_object_unref (right);
    }

    // This test shouldn't take too long to run
    g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1);
}
/**
 * test_kleene_star_constructor:
 * @fn test_kleene_star_constructor
 * Tests compilerkit_kleene_star_new in CompilerKitKleeneStar struct.
 * @pre None
 * @param None
 * @return void
 */
void test_kleene_star_constructor (void)
{
	GObject* e_set;
	GObject* e_string;
	GObject* a;
	GObject* result;
	
	
    g_test_message ("Testing KleeneStar method");
    g_test_timer_start ();
	
	
	//empty set
	{
	
		e_set = compilerkit_empty_set_get_instance();
		result = compilerkit_kleene_star_new(e_set);
		g_assert(COMPILERKIT_IS_EMPTY_SET (result));
        g_object_unref (result);
	}
	
	//empty string
	{
		e_string = compilerkit_empty_string_get_instance();
		result = compilerkit_kleene_star_new(e_string);
		g_assert(COMPILERKIT_IS_EMPTY_STRING (result));
        g_object_unref (result);
	}
	
	//symbol
	{
		a = compilerkit_symbol_new('a');
		result = compilerkit_kleene_star_new(a);
		g_assert(COMPILERKIT_IS_KLEENE_STAR (result));
        g_object_unref (result);
	}
    
    
    g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1);
}
/**
 * test_derivative_visitor:
 * @fn test_derivative_visitor
 * Tests compilerkit_derivative_visitor.
 * @pre None
 * @param None
 * @return void
 */
void test_derivative_visitor (void)
{
    CompilerKitVisitor *derivative;
    GObject *regex, *new_regex;
	//GObject *symbol, *cat, *star;	/** @todo these are currently unused */
    
    g_test_message ("Testing Derivative visitor");
    g_test_timer_start ();
    
    derivative = compilerkit_derivative_visitor();
    regex = compilerkit_symbol_new ('h');
    
    // When we match a single character, h, against the single character 'h', we should get the empty string, because they match.
    new_regex = compilerkit_derivative_apply_char (derivative, regex, 'h');
    g_assert (new_regex == compilerkit_empty_string_get_instance());
    
    // When we match a single character, h, against the single character 'e', we should get the empty set, because they don't match.
    new_regex = compilerkit_derivative_apply_char (derivative, regex, 'e');
    g_assert (new_regex == compilerkit_empty_set_get_instance());
    
    // When we match a single character, h, against a string, we should get the empty set, because they don't match.
    new_regex = compilerkit_derivative_apply_string (derivative, regex, "hello");
    g_assert (new_regex == compilerkit_empty_set_get_instance());
    
    // When we match "hi!" against the string "hi", we should get the symbol "!", because that's what remains.
    regex = compilerkit_concatenation_new (regex, compilerkit_concatenation_new (compilerkit_symbol_new ('i'), compilerkit_symbol_new ('!')));
    new_regex = compilerkit_derivative_apply_string (derivative, regex, "hi");
//    g_warn_if_fail (g_type_name(G_OBJECT_TYPE(new_regex)));
//    g_assert (COMPILERKIT_IS_SYMBOL (new_regex));
//    g_assert (compilerkit_symbol_get_symbol(COMPILERKIT_SYMBOL(new_regex)) == '!');
    
    g_object_unref (derivative);
    g_object_unref (regex);

    // This test shouldn't take too long to run
    g_assert_cmpfloat(g_test_timer_elapsed (), <=, 1);
}
Exemple #6
0
/**
 * compilerkit_optional_new:
 * @fn compilerkit_optional_new
 *
 * Return a regex corresponding to the original regex|empty string
 * 
 * @pre regex is not NULL
 * @param GObject* regex to make optional
 * @return GObject* Alternation of the regex with the empty string
 */
GObject *compilerkit_optional_new (GObject *regex)
{
    return compilerkit_alternation_new (regex, compilerkit_empty_string_get_instance());
}