/*****************************************************************
Function Name: main
Description: This is a main function
Parameter:
@argc: argument count
@argv: argument vector
Author: SA12226114(Xin Zhu), SA12226139(Dan Shu)
Date: 2012-11-27
******************************************************************/
int main(int argc, char *argv[])
{
void *db = NULL;
char cmdline[CMDLINE_LEN], cmd[CMD_LEN], key[KEY_LEN], value[VALUE_LEN];
/* display menu */
util_menu();
while(1)
{
/* format command line */
util_format(cmdline, cmd, key, value);
if(strncmp(cmd, "open", sizeof("open")) == 0) /* create database */
{
db_create(&db, key);
}
else if(strncmp(cmd, "set", sizeof("set")) == 0) /* store records */
{
db_write(db, key, value);
}
else if(strncmp(cmd, "get", sizeof("get")) == 0) /* retrieve records */
{
db_read(db, key);
}
else if(strncmp(cmd, "remove", sizeof("remove")) == 0) /* remove a record */
{
db_remove(db, key);
}
else if(strncmp(cmd, "ls", sizeof("ls")) == 0) /* dump all records in database */
{
db_queryallrecords(db);
}
else if(strncmp(cmd, "close", sizeof("close")) == 0) /* close the database */
{
db_close(&db);
}
else if(strncmp(cmd, "delete", sizeof("delete")) == 0) /* delete the object */
{
db_delete(&db);
}
else if(strncmp(cmd, "help", sizeof("help")) == 0) /* display menu info */
{
util_menu();
}
else if(strncmp(cmd, "quit", sizeof("quit")) == 0) /* quit system */
{
return;
}
}
return 0;
}
/**********************************************************************
* Function main()
*
* Parameter:
*
* This is the main function. It allocates space for the initial data
* structures and displays the main menu. You can choose an algorithm
* sub-menu, or the String Utilities Menu.
*
**********************************************************************/
int main(void)
{
/*
* Initialize the array of sequences.
*/
create_seq_array();
/*
* The main loop.
*/
while (1) {
printf("\n** Main Menu **\n");
printf("\n");
printf("1) Basic Search Algorithms\n");
printf("2) Z-value Algorithms\n");
printf("3) Suffix Tree Algorithms\n");
printf("4) Suffix Array Algorithms\n");
printf("5) Repeat Algorithms\n");
printf("*) String Utilities\n");
printf("0) Exit Program\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return 0;
case '1':
basic_alg_menu();
break;
case '2':
z_alg_menu();
break;
case '3':
suf_tree_menu();
break;
case '4':
suf_ary_menu();
break;
case '5':
repeats_menu();
break;
case '*':
util_menu();
break;
default:
printf("\nThat is not a choice.\n");
break;
}
}
} /* main() */
/**********************************************************************
* Function repeats_menu()
*
* Parameter:
*
*
* This function prompts user to choose an algorithm to compute
* repeats and similar things.
* The utilities menu is also available from this menu.
*
**********************************************************************/
void repeats_menu()
{
static int smax_percent = 0;
static int smax_minlen = 0;
int status, num_lines;
char ch;
STRING *text;
while (1) {
num_lines = 20;
printf("\n** Repeats Menu **\n\n");
printf("1) Find primitive tandem repeats (Crochemore's algorithm)\n");
printf("2) Find supermaximals and near supermaximals of a string\n");
printf("3) Find nonoverlapping maximals of a string"
" (Crochemore variant)\n");
printf("4) Find nonoverlapping maximals of a string"
" (big path algorithm)\n");
printf("5) Find tandem repeats/tandem arrays using the suffix tree\n");
printf("6) Find vocabulary of tandem repeats (and more) using\n");
printf(" a) Ziv-Lempel decomposition\n");
printf(" b) nonoverlapping blocks decomposition (as in the book)\n");
printf("7) Find occurrences in linear time (without suffix tree) using\n");
printf(" a) Ziv-Lempel decomposition\n");
printf(" b) nonoverlapping blocks decomposition (as in the book)\n");
printf("*) String Utilites\n");
printf("0) Exit\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return;
case '1':
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
strmat_repeats_primitives(text, stats_flag);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '2':
if (!(text = get_string("text")))
continue;
smax_percent = get_bounded("Percent Supermaximal", 0, 100, smax_percent);
printf("\n");
if (smax_percent == -1)
continue;
smax_minlen = get_bounded("Supermax. Minimum Length", 0, text->length,
smax_minlen);
printf("\n");
if (smax_minlen == -1)
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
mprintf("Finding the supermaximals...\n\n");
strmat_repeats_supermax(text, smax_percent, smax_minlen);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '3':
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
strmat_repeats_nonoverlapping(text, stats_flag);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '4':
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
strmat_repeats_bigpath(text, stree_build_policy, stree_build_threshold,
stats_flag);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '5':
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
strmat_repeats_tandem(text, stree_build_policy, stree_build_threshold,
stats_flag);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '6':
ch = toupper(choice[1]);
if (ch!='A' && ch!='B') {
printf("\nYou must specify which type of decomposition to use"
"(as in '6a' or '6b').\n");
continue;
}
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
strmat_repeats_vocabulary(text, stree_build_policy,
stree_build_threshold, stats_flag,ch);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '7':
ch = toupper(choice[1]);
if (ch!='A' && ch!='B') {
printf("\nYou must specify which type of decomposition to use"
"(as in '7a' or '7b').\n");
continue;
}
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
strmat_repeats_linear_occs(text, stree_build_policy,
stree_build_threshold, stats_flag,ch);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '*':
util_menu();
break;
default:
printf("\nThat is not a choice.\n");
}
}
}
/**********************************************************************
* Function suf_ary_menu()
*
* Parameter:
*
*
* This function prompts user to choose an algorithm to create
* a suffix array and use it.
* The utilities menu is also available from this menu.
*
**********************************************************************/
void suf_ary_menu()
{
int status, num_lines;
STRING *spt, *pattern, *text;
while (1) {
num_lines = 13;
printf("\n** Suffix Array Menu **\n\n");
printf("1) Build suffix array using quick sort\n");
printf("2) Build suffix array (Zerkle's version)\n");
printf("3) Build suffix array from a suffix tree\n");
printf("4) Exact matching using suffix array and naive algorithm\n");
printf("5) Exact matching using suffix array and mlr accelerant\n");
printf("6) Exact matching using suffix array and lcp super-accelerant\n");
printf("*) String Utilites\n");
printf("0) Exit\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return;
case '1':
if (!(spt = get_string("sequence")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe sequence:\n");
terse_print_string(spt);
mputc('\n');
status = map_sequences(spt, NULL, NULL, 0);
if (status != -1) {
mprintf("Building suffix array using qsort...\n\n");
strmat_sary_qsort(spt, stats_flag);
unmap_sequences(spt, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '2':
if (!(spt = get_string("sequence")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe sequence:\n");
terse_print_string(spt);
mputc('\n');
status = map_sequences(spt, NULL, NULL, 0);
if (status != -1) {
mprintf("Executing Zerkle's algorithm...\n\n");
strmat_sary_zerkle(spt, stats_flag);
unmap_sequences(spt, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '3':
if (!(spt = get_string("sequence")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe sequence:\n");
terse_print_string(spt);
mputc('\n');
status = map_sequences(spt, NULL, NULL, 0);
if (status != -1) {
mprintf("Building suffix array from suffix tree...\n\n");
strmat_sary_stree(spt, stats_flag);
unmap_sequences(spt, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '4':
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
mprintf("Executing exact matching using suffix array...\n\n");
strmat_sary_match_naive(pattern, text, stats_flag);
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '5':
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
mprintf("Executing exact matching using suffix array...\n\n");
strmat_sary_match_mlr(pattern, text, stats_flag);
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '6':
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
mprintf("Executing exact matching using suffix array...\n\n");
strmat_sary_match_lcp(pattern, text, stats_flag);
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '*':
util_menu();
break;
default:
printf("\nThat is not a choice.\n");
}
}
}
/**********************************************************************
* Function suf_tree_menu()
*
* Parameter:
*
*
* This function prompts user to choose an algorithm to create
* a suffix tree and use it.
* The utilities menu is also available from this menu.
*
**********************************************************************/
void suf_tree_menu()
{
int i, status, num_lines, num_strings;
char ch;
STRING *pattern, **strings, *text;
while (1) {
num_lines = 18;
printf("\n** Suffix Tree Menu **\n\n");
printf("1) Build a suffix tree using Ukkonen's algorithm\n");
printf("2) Build a suffix tree using Weiner's algorithm\n");
printf("3) Exact matching using a suffix tree for the text\n");
printf("4) Walk around a suffix tree\n");
printf("5) Compute the LCA values for a suffix tree\n");
printf(" a) using the naive LCA algorithm\n");
printf(" b) using the constant time LCA algorithm\n");
printf("6) Compute Lempel-Ziv decomposition\n");
printf(" a) original version (f-factorization)\n");
printf(" b) nonoverlapping blocks (as in the book)\n");
printf("8) Set suffix tree build policy (current: ");
switch(stree_build_policy) {
case LINKED_LIST: printf("linked list)\n"); break;
case SORTED_LIST: printf("sorted list)\n"); break;
case LIST_THEN_ARRAY: printf("list then array, threshold %d)\n",
stree_build_threshold); break;
case COMPLETE_ARRAY: printf("complete array)\n"); break;
}
printf("9) Suffix tree print toggle (current: %s)\n",
(stree_print_flag == ON ? "on" : "off"));
printf("*) String Utilites\n");
printf("0) Exit\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return;
case '1':
strings = get_string_ary("list of sequences", &num_strings);
if (strings == NULL)
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe sequences:\n");
for (i=0; i < num_strings; i++) {
mprintf("%2d)", i + 1);
terse_print_string(strings[i]);
}
mputc('\n');
status = map_sequences(NULL, NULL, strings, num_strings);
if (status != -1) {
mprintf("Executing Ukkonen's Algorithm...\n\n");
strmat_ukkonen_build(strings, num_strings, stree_build_policy,
stree_build_threshold, stats_flag,
stree_print_flag);
unmap_sequences(NULL, NULL, strings, num_strings);
}
mend(num_lines);
putchar('\n');
free(strings);
break;
case '2':
strings = get_string_ary("list of sequences", &num_strings);
if (strings == NULL)
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe sequences:\n");
for (i=0; i < num_strings; i++) {
mprintf("%2d)", i + 1);
terse_print_string(strings[i]);
}
mputc('\n');
status = map_sequences(NULL, NULL, strings, num_strings);
if (status != -1) {
mprintf("Executing Weiner's Algorithm...\n\n");
strmat_weiner_build(strings, num_strings, stree_build_policy,
stree_build_threshold, stats_flag,
stree_print_flag);
unmap_sequences(NULL, NULL, strings, num_strings);
}
mend(num_lines);
putchar('\n');
free(strings);
break;
case '3':
if (!(pattern = get_string("pattern")) ||
!(strings = get_string_ary("list of sequences", &num_strings)))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe texts:\n");
for (i=0; i < num_strings; i++) {
mprintf("%2d)", i + 1);
terse_print_string(strings[i]);
}
mputc('\n');
status = map_sequences(NULL, pattern, strings, num_strings);
if (status != -1) {
mprintf("Executing exact matching with a suffix tree...\n\n");
strmat_stree_match(pattern, strings, num_strings, stree_build_policy,
stree_build_threshold, stats_flag);
unmap_sequences(NULL, pattern, strings, num_strings);
}
mend(num_lines);
putchar('\n');
free(strings);
break;
case '4':
strings = get_string_ary("list of sequences", &num_strings);
if (strings == NULL)
continue;
status = map_sequences(NULL, NULL, strings, num_strings);
if (status != -1) {
strmat_stree_walkaround(strings, num_strings, stree_build_policy,
stree_build_threshold);
unmap_sequences(NULL, NULL, strings, num_strings);
}
putchar('\n');
free(strings);
break;
case '5':
ch = toupper(choice[1]);
if (ch != 'A' && ch != 'B') {
printf("\nYou must specify which type of LCA algorithm to use "
"(as in '3a' or '3b').\n");
continue;
}
strings = get_string_ary("list of sequences", &num_strings);
if (strings == NULL)
continue;
status = map_sequences(NULL, NULL, strings, num_strings);
if (status != -1) {
if (ch == 'A')
strmat_stree_naive_lca(strings, num_strings, stree_build_policy,
stree_build_threshold, stats_flag);
else
strmat_stree_lca(strings, num_strings, stree_build_policy,
stree_build_threshold, stats_flag);
unmap_sequences(NULL, NULL, strings, num_strings);
}
putchar('\n');
free(strings);
break;
case '6':
ch = toupper(choice[1]);
if (ch!='A' && ch!='B') {
printf("\nYou must specify which type of decomposition to compute "
"(as in '6a' or '6b').\n");
continue;
}
if (!(text = get_string("string")))
continue;
mstart(stdin, fpout, OK, OK, 0, NULL);
mprintf("\nThe string:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, NULL, 0);
if(status != -1) {
strmat_stree_lempel_ziv(text, stree_build_policy,
stree_build_threshold, stats_flag,ch);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '8':
choice = "0";
while (choice[0] != '1' && choice[0] != '2' &&
choice[0] != '3' && choice[0] != '4') {
printf("\n** Suffix Tree Build Policies **\n");
printf("\n(1 - linked list, 2 - sorted list, 3 - linked list/array,"
" 4 - complete array)\n");
printf("Enter Build Policy [%d]: ",
(stree_build_policy == LINKED_LIST ? 1
: (stree_build_policy == SORTED_LIST ? 2
: (stree_build_policy == LIST_THEN_ARRAY ? 3 : 4))));
if ((choice = my_getline(stdin, &ch_len)) == NULL || choice[0] == '\0')
break;
switch (choice[0]) {
case '1':
stree_build_policy = LINKED_LIST;
break;
case '2':
stree_build_policy = SORTED_LIST;
break;
case '3':
stree_build_policy = LIST_THEN_ARRAY;
break;
case '4':
stree_build_policy = COMPLETE_ARRAY;
break;
default:
printf("\nThat is not a choice.\n");
}
}
if (stree_build_policy == LIST_THEN_ARRAY) {
printf("\nEnter Build Threshold [%d]: ", stree_build_threshold);
if ((choice = my_getline(stdin, &ch_len)) != NULL)
sscanf(choice, "%d", &stree_build_threshold);
}
putchar('\n');
break;
case '9':
if (stree_print_flag == ON)
stree_print_flag = OFF;
else
stree_print_flag = ON;
break;
case '*':
util_menu();
break;
default:
printf("\nThat is not a choice.\n");
}
}
}
/**********************************************************************
* Function z_alg_menu();
*
* Parameter:
*
*
* This function prompts user to create and utilize the Z values
* for a string. The utilities menu is also available from this menu.
*
**********************************************************************/
void z_alg_menu()
{
int status, num_lines;
char ch;
STRING *text, *pattern;
while (1) {
num_lines = 12;
printf("\n** Z-value Algorithm Menu **\n\n");
printf("1) Build Z values for a sequence\n");
printf("2) Exact matching using Z values\n");
printf("3) Knuth-Morris-Pratt (Z-values preprocessing)\n");
printf(" a) using sp values\n");
printf(" b) using sp' values\n");
printf("*) String Utilites\n");
printf("0) Exit\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return;
case '1':
if (!(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mputs("The string:\n");
terse_print_string(text);
status = map_sequences(text, NULL, NULL, 0);
if (status != -1) {
mputs("Building Z values...\n\n");
strmat_z_build(text, stats_flag);
unmap_sequences(text, NULL, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '2':
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mputs("\nThe pattern:\n");
terse_print_string(pattern);
mputs("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
mputs("Executing exact matching with Z values algorithm...\n\n");
strmat_z_match(pattern, text, stats_flag);
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '3':
ch = choice[1];
if (toupper(ch) != 'A' && toupper(ch) != 'B') {
printf("\nYou must specify the KMP variation (as in '3a' or '3b').\n");
continue;
}
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
if (toupper(ch) == 'A') {
mprintf ("Executing KMP with sp values...\n\n");
strmat_kmp_sp_z_match(pattern, text, stats_flag);
}
else {
mprintf ("Executing KMP with sp' values...\n\n");
strmat_kmp_spprime_z_match(pattern, text, stats_flag);
}
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '*':
util_menu();
break;
default:
printf("\nThat is not a choice.\n");
}
}
}
/**********************************************************************
* Function basic_alg_menu();
*
* Parameter:
*
*
* This function prompts user to choose a basic algorithm to execute
* such as Boyer-Moore. The utilities menu is also available from
* this menu.
*
**********************************************************************/
void basic_alg_menu()
{
int i, status, num_lines, alpha_size, num_patterns;
char ch;
STRING *text, *pattern, **patterns;
alpha_size = 0;
while (1) {
num_lines = 22;
printf("\n** Basic Search Algorithm Menu **\n\n");
printf("1) Naive Algorithm\n");
printf("2) Boyer-Moore Variations\n");
printf(" a) Bad character rule\n");
printf(" b) Extended bad character rule\n");
printf(" c) Good suffix & bad character rules\n");
printf(" d) Good suffix & extended bad character rules\n");
printf("3) Knuth-Morris-Pratt (original preprocessing)\n");
printf(" a) using sp values\n");
printf(" b) using sp' values\n");
printf("4) Aho-Corasick Set Matching\n");
printf("5) Boyer-Moore Set Matching\n");
printf(" a) Bad character rule only\n");
printf(" b) Good suffix rule using keyword and suffix trees\n");
printf(" c) Good suffix rule using suffix tree only\n");
printf(" d) using original Boyer-Moore (1c) on each pattern\n");
printf("*) String Utilites\n");
printf("0) Exit\n");
printf("\nEnter Selection: ");
while ((choice = my_getline(stdin, &ch_len)) == NULL) ;
switch (choice[0]) {
case '0':
return;
case '1':
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
mprintf ("Executing naive search algorithm...\n\n");
strmat_naive_match(pattern, text, stats_flag);
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '2':
ch = choice[1];
if (toupper(ch) != 'A' && toupper(ch) != 'B' &&
toupper(ch) != 'C' && toupper(ch) != 'D') {
printf("\nYou must specify the Boyer-Moore variation"
" (as in '2a' or '2c').\n");
continue;
}
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
mprintf("Executing Boyer-Moore algorithm...\n\n");
switch (toupper(ch)) {
case 'A': strmat_bmbad_match(pattern, text, stats_flag); break;
case 'B': strmat_bmext_match(pattern, text, stats_flag); break;
case 'C': strmat_bmgood_match(pattern, text, stats_flag); break;
case 'D': strmat_bmextgood_match(pattern, text, stats_flag); break;
}
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '3':
ch = choice[1];
if (toupper(ch) != 'A' && toupper(ch) != 'B') {
printf("\nYou must specify the KMP variation (as in '3a' or '3b').\n");
continue;
}
if (!(pattern = get_string("pattern")) || !(text = get_string("text")))
continue;
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe pattern:\n");
terse_print_string(pattern);
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, pattern, NULL, 0);
if (status != -1) {
if (toupper(ch) == 'A') {
mprintf ("Executing KMP with sp values...\n\n");
strmat_kmp_sp_orig_match(pattern, text, stats_flag);
}
else {
mprintf ("Executing KMP with sp' values...\n\n");
strmat_kmp_spprime_orig_match(pattern, text, stats_flag);
}
unmap_sequences(text, pattern, NULL, 0);
}
mend(num_lines);
putchar('\n');
break;
case '4':
if (!(patterns = get_string_ary("list of patterns", &num_patterns)))
continue;
if (!(text = get_string("text"))) {
free(patterns);
continue;
}
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe patterns:\n");
for (i=0; i < num_patterns; i++) {
mprintf("%2d)", i + 1);
terse_print_string(patterns[i]);
}
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, patterns, num_patterns);
if (status != -1) {
mprintf("Executing Aho-Corasick algorithm...\n\n");
strmat_ac_match(patterns, num_patterns, text, stats_flag);
unmap_sequences(text, NULL, patterns, num_patterns);
}
mend(num_lines);
putchar('\n');
free(patterns);
break;
case '5':
ch = toupper(choice[1]);
if (ch != 'A' && ch != 'B' && ch != 'C' && ch != 'D') {
printf("\nYou must specify the set Boyer-Moore variation"
" (as in '5a' or '5c').\n");
continue;
}
if (!(patterns = get_string_ary("list of patterns", &num_patterns)))
continue;
if (!(text = get_string("text"))) {
free(patterns);
continue;
}
mstart(stdin, fpout, OK, OK, 5, NULL);
mprintf("\nThe patterns:\n");
for (i=0; i < num_patterns; i++) {
mprintf("%2d)", i + 1);
terse_print_string(patterns[i]);
}
mprintf("\nThe text:\n");
terse_print_string(text);
mputc('\n');
status = map_sequences(text, NULL, patterns, num_patterns);
if (status != -1) {
mprintf("Executing Boyer-Moore set matching algorithm...\n\n");
switch (toupper(ch)) {
case 'A': strmat_bmset_badonly_match(patterns, num_patterns,
text, stats_flag); break;
case 'B': strmat_bmset_2trees_match(patterns, num_patterns,
text, stats_flag); break;
case 'C': strmat_bmset_1tree_match(patterns, num_patterns,
text, stats_flag); break;
case 'D': strmat_bmset_naive_match(patterns, num_patterns,
text, stats_flag); break;
}
unmap_sequences(text, NULL, patterns, num_patterns);
}
mend(num_lines);
putchar('\n');
free(patterns);
break;
case '*':
util_menu();
break;
default:
printf("\nThat is not a choice.\n");
}
}
}
