DBL_WORD ST_FindSubstring(
/* The suffix array */
SUFFIX_TREE* tree,
/* The substring to find */
char* W,
/* The length of W */
DBL_WORD P)
{
/* Starts with the root's son that has the first character of W as its
incoming edge first character */
NODE* node = find_son(tree, tree->root, W[0]);
DBL_WORD k,j = 0, node_label_end;
/* Scan nodes down from the root untill a leaf is reached or the substring is
found */
while(node!=0)
{
k=node->edge_label_start;
node_label_end = get_node_label_end(tree,node);
/* Scan a single edge - compare each character with the searched string */
while(j<P && k<=node_label_end && tree->tree_string[k] == W[j])
{
j++;
k++;
#ifdef STATISTICS
counter++;
#endif
}
/* Checking which of the stopping conditions are true */
if(j == P)
{
/* W was found - it is a substring. Return its path starting index */
return node->path_position;
}
else if(k > node_label_end)
/* Current edge is found to match, continue to next edge */
node = find_son(tree, node, W[j]);
else
{
/* One non-matching symbols is found - W is not a substring */
return ST_ERROR;
}
}
return ST_ERROR;
}
SuffixTreeIndex_T SuffixTree_find_substring(const SuffixTree_T tree,
char* query,
SuffixTreeIndex_T query_length)
{
/* Starts with the root's son that has the first character of W as its
incoming edge first character */
Node_T node = find_son(tree, tree->root, query[0]);
SuffixTreeIndex_T k,j = 0, node_label_end;
/* Scan nodes down from the root untill a leaf is reached or the substring is
found */
while(node != NULL)
{
k=node->edge_label_start;
node_label_end = get_node_label_end(tree,node);
/* Scan a single edge - compare each character with the searched string */
while(j<query_length && k<=node_label_end && tree->tree_string[k] == query[j])
{
j++;
k++;
}
/* Checking which of the stopping conditions are true */
if(j == query_length)
{
/* W was found - it is a substring. Return its path starting index */
return node->path_position;
}
else if(k > node_label_end)
/* Current edge is found to match, continue to next edge */
node = find_son(tree, node, query[j]);
else
{
/* One non-matching symbols is found - W is not a substring */
return (SuffixTreeIndex_T)-1;
}
}
return (SuffixTreeIndex_T)-1;
}
void SEA(
SUFFIX_TREE* tree,
POS* pos,
PATH str,
DBL_WORD* rule_applied,
char after_rule_3)
{
DBL_WORD chars_found = 0 , path_pos = str.begin;
NODE* tmp;
#ifdef DEBUG
ST_PrintTree(tree);
printf("extension: %lu phase+1: %lu",str.begin, str.end);
if(after_rule_3 == 0)
printf(" followed from (%lu,%lu | %lu) ", pos->node->edge_label_start, get_node_label_end(tree,pos->node), pos->edge_pos);
else
printf(" starting at (%lu,%lu | %lu) ", pos->node->edge_label_start, get_node_label_end(tree,pos->node), pos->edge_pos);
#endif
#ifdef STATISTICS
counter++;
#endif
/* Follow suffix link only if it's not the first extension after rule 3 was applied */
if(after_rule_3 == 0)
follow_suffix_link(tree, pos);
#ifdef DEBUG
#ifdef STATISTICS
if(after_rule_3 == 0)
printf("to (%lu,%lu | %lu). counter: %lu\n", pos->node->edge_label_start, get_node_label_end(tree,pos->node),pos->edge_pos,counter);
else
printf(". counter: %lu\n", counter);
#endif
#endif
/* If node is root - trace whole string starting from the root, else - trace last character only */
if(pos->node == tree->root)
{
pos->node = trace_string(tree, tree->root, str, &(pos->edge_pos), &chars_found, no_skip);
}
else
{
str.begin = str.end;
chars_found = 0;
/* Consider 2 cases:
1. last character matched is the last of its edge */
if(is_last_char_in_edge(tree,pos->node,pos->edge_pos))
{
/* Trace only last symbol of str, search in the NEXT edge (node) */
tmp = find_son(tree, pos->node, tree->tree_string[str.end]);
if(tmp != 0)
{
pos->node = tmp;
pos->edge_pos = 0;
chars_found = 1;
}
}
/* 2. last character matched is NOT the last of its edge */
else
{
/* Trace only last symbol of str, search in the CURRENT edge (node) */
if(tree->tree_string[pos->node->edge_label_start+pos->edge_pos+1] == tree->tree_string[str.end])
{
pos->edge_pos++;
chars_found = 1;
}
}
}
/* If whole string was found - rule 3 applies */
if(chars_found == str.end - str.begin + 1)
{
*rule_applied = 3;
/* If there is an internal node that has no suffix link yet (only one may
exist) - create a suffix link from it to the father-node of the
current position in the tree (pos) */
if(suffixless != 0)
{
create_suffix_link(suffixless, pos->node->father);
/* Marks that no internal node with no suffix link exists */
suffixless = 0;
}
#ifdef DEBUG
printf("rule 3 (%lu,%lu)\n",str.begin,str.end);
#endif
return;
}
/* If last char found is the last char of an edge - add a character at the
next edge */
if(is_last_char_in_edge(tree,pos->node,pos->edge_pos) || pos->node == tree->root)
{
/* Decide whether to apply rule 2 (new_son) or rule 1 */
if(pos->node->sons != 0)
{
/* Apply extension rule 2 new son - a new leaf is created and returned
by apply_extension_rule_2 */
apply_extension_rule_2(pos->node, str.begin+chars_found, str.end, path_pos, 0, new_son);
*rule_applied = 2;
/* If there is an internal node that has no suffix link yet (only one
may exist) - create a suffix link from it to the father-node of the
current position in the tree (pos) */
if(suffixless != 0)
{
create_suffix_link(suffixless, pos->node);
/* Marks that no internal node with no suffix link exists */
suffixless = 0;
}
}
}
else
{
/* Apply extension rule 2 split - a new node is created and returned by
apply_extension_rule_2 */
tmp = apply_extension_rule_2(pos->node, str.begin+chars_found, str.end, path_pos, pos->edge_pos, split);
if(suffixless != 0)
create_suffix_link(suffixless, tmp);
/* Link root's sons with a single character to the root */
if(get_node_label_length(tree,tmp) == 1 && tmp->father == tree->root)
{
tmp->suffix_link = tree->root;
/* Marks that no internal node with no suffix link exists */
suffixless = 0;
}
else
/* Mark tmp as waiting for a link */
suffixless = tmp;
/* Prepare pos for the next extension */
pos->node = tmp;
*rule_applied = 2;
}
}
NODE* trace_single_edge(
SUFFIX_TREE* tree,
/* Node to start from */
NODE* node,
/* String to trace */
PATH str,
/* Last matching position in edge */
DBL_WORD* edge_pos,
/* Last matching position in tree source string */
DBL_WORD* chars_found,
/* Skip or no_skip*/
SKIP_TYPE type,
/* 1 if search is done, 0 if not */
int* search_done)
{
NODE* cont_node;
DBL_WORD length,str_len;
/* Set default return values */
*search_done = 1;
*edge_pos = 0;
/* Search for the first character of the string in the outcoming edge of
node */
cont_node = find_son(tree, node, tree->tree_string[str.begin]);
if(cont_node == 0)
{
/* Search is done, string not found */
*edge_pos = get_node_label_length(tree,node)-1;
*chars_found = 0;
return node;
}
/* Found first character - prepare for continuing the search */
node = cont_node;
length = get_node_label_length(tree,node);
str_len = str.end - str.begin + 1;
/* Compare edge length and string length. */
/* If edge is shorter then the string being searched and skipping is
enabled - skip edge */
if(type == skip)
{
if(length <= str_len)
{
(*chars_found) = length;
(*edge_pos) = length-1;
if(length < str_len)
*search_done = 0;
}
else
{
(*chars_found) = str_len;
(*edge_pos) = str_len-1;
}
#ifdef STATISTICS
counter++;
#endif
return node;
}
else
{
/* Find minimum out of edge length and string length, and scan it */
if(str_len < length)
length = str_len;
for(*edge_pos=1, *chars_found=1; *edge_pos<length; (*chars_found)++,(*edge_pos)++)
{
#ifdef STATISTICS
counter++;
#endif
/* Compare current characters of the string and the edge. If equal -
continue */
if(tree->tree_string[node->edge_label_start+*edge_pos] != tree->tree_string[str.begin+*edge_pos])
{
(*edge_pos)--;
return node;
}
}
}
/* The loop has advanced *edge_pos one too much */
(*edge_pos)--;
if((*chars_found) < str_len)
/* Search is not done yet */
*search_done = 0;
return node;
}
int SEA(SuffixTree_T tree, struct SuffixTreePos* pos,
struct SuffixTreePath str, SuffixTreeIndex_T* rule_applied,
char after_rule_3)
{
SuffixTreeIndex_T chars_found = 0 , path_pos = str.begin;
Node_T tmp = NULL;
/* Follow suffix link only if it's not the first extension after rule 3 was applied */
if(after_rule_3 == 0)
follow_suffix_link(tree, pos);
/* If node is root - trace whole string starting from the root, else - trace last character only */
if(pos->node == tree->root)
{
pos->node = trace_string(tree, tree->root, str, &(pos->edge_pos), &chars_found, no_skip);
}
else
{
str.begin = str.end;
chars_found = 0;
/* Consider 2 cases:
1. last character matched is the last of its edge */
if(is_last_char_in_edge(tree,pos->node,pos->edge_pos))
{
/* Trace only last symbol of str, search in the NEXT edge (node) */
tmp = find_son(tree, pos->node, tree->tree_string[str.end]);
if(tmp != NULL)
{
pos->node = tmp;
pos->edge_pos = 0;
chars_found = 1;
}
}
/* 2. last character matched is NOT the last of its edge */
else
{
/* Trace only last symbol of str, search in the CURRENT edge (node) */
if(tree->tree_string[pos->node->edge_label_start+pos->edge_pos+1] == tree->tree_string[str.end])
{
pos->edge_pos++;
chars_found = 1;
}
}
}
/* If whole string was found - rule 3 applies */
if(chars_found == str.end - str.begin + 1)
{
*rule_applied = 3;
/* If there is an internal node that has no suffix link yet (only one may
exist) - create a suffix link from it to the father-node of the
current position in the tree (pos) */
if(suffixless != NULL)
{
create_suffix_link(suffixless, pos->node->father);
/* Marks that no internal node with no suffix link exists */
suffixless = NULL;
}
#ifdef DEBUG
printf("rule 3 (%zu,%zu)\n",str.begin,str.end);
#endif
return 0;
}
/* If last char found is the last char of an edge - add a character at the
next edge */
if(is_last_char_in_edge(tree,pos->node,pos->edge_pos) || pos->node == tree->root)
{
/* Decide whether to apply rule 2 (new_son) or rule 1 */
if(pos->node->left_son != NULL)
{
/* Apply extension rule 2 new son - a new leaf is created and returned
by apply_extension_rule_2 */
tmp = apply_extension_rule_2(pos->node, str.begin+chars_found, str.end, path_pos, 0, new_son);
check(tmp, "Could not apply extension rule 2.");
*rule_applied = 2;
/* If there is an internal node that has no suffix link yet (only one
may exist) - create a suffix link from it to the father-node of the
current position in the tree (pos) */
if(suffixless != NULL)
{
create_suffix_link(suffixless, pos->node);
/* Marks that no internal node with no suffix link exists */
suffixless = NULL;
}
}
}
else
{
/* Apply extension rule 2 split - a new node is created and returned by
apply_extension_rule_2 */
tmp = apply_extension_rule_2(pos->node, str.begin+chars_found, str.end, path_pos, pos->edge_pos, split);
check(tmp, "Could not apply extension rule 2.");
if(suffixless != NULL)
create_suffix_link(suffixless, tmp);
/* Link root's sons with a single character to the root */
if(get_node_label_length(tree,tmp) == 1 && tmp->father == tree->root)
{
tmp->suffix_link = tree->root;
/* Marks that no internal node with no suffix link exists */
suffixless = NULL;
}
else
/* Mark tmp as waiting for a link */
suffixless = tmp;
/* Prepare pos for the next extension */
pos->node = tmp;
*rule_applied = 2;
}
return 0;
error:
return 1;
}
Node_T trace_single_edge(SuffixTree_T tree, Node_T node, struct SuffixTreePath str,
SuffixTreeIndex_T* edge_pos, SuffixTreeIndex_T* chars_found,
Skip_T type, int* search_done)
{
Node_T cont_node;
SuffixTreeIndex_T length, str_len;
/* Set default return values */
*search_done = 1;
*edge_pos = 0;
/* Search for the first character of the string in the outcoming edge of
node */
cont_node = find_son(tree, node, tree->tree_string[str.begin]);
if(cont_node == NULL)
{
/* Search is done, string not found */
*edge_pos = get_node_label_length(tree,node)-1;
*chars_found = 0;
return node;
}
/* Found first character - prepare for continuing the search */
node = cont_node;
length = get_node_label_length(tree,node);
str_len = str.end - str.begin + 1;
/* Compare edge length and string length. */
/* If edge is shorter then the string being searched and skipping is
enabled - skip edge */
if(type == skip)
{
if(length <= str_len)
{
(*chars_found) = length;
(*edge_pos) = length-1;
if(length < str_len)
*search_done = 0;
}
else
{
(*chars_found) = str_len;
(*edge_pos) = str_len-1;
}
return node;
}
else
{
/* Find minimum out of edge length and string length, and scan it */
if(str_len < length)
length = str_len;
for(*edge_pos=1, *chars_found=1; *edge_pos<length; (*chars_found)++,(*edge_pos)++)
{
/* Compare current characters of the string and the edge. If equal -
continue */
if(tree->tree_string[node->edge_label_start+*edge_pos] != tree->tree_string[str.begin+*edge_pos])
{
(*edge_pos)--;
return node;
}
}
}
/* The loop has advanced *edge_pos one too much */
(*edge_pos)--;
if((*chars_found) < str_len)
/* Search is not done yet */
*search_done = 0;
return node;
}
