/** * 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); }
/** * 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()); }