Efficient way tokenize strings - C

Question

I am trying tokenize a string. I have a table of available tokens ordered in form three. Each token knows that it has children. A simple token table will look like this:

pattern value has_children -------- ------ -------- s s-val 1 stack stack-val 0 over over-val 1 overflow overflow-val 0 

In this table, stack is a child of s and overflow is a child of over . In practice, this table will have 5,000+ records sorted this way.

Now, given the stackover line, it should output stack-valover-val . The algorithm is greedy, and he will try to find the longest match ever.

To do this, I will start reading each character from the input, look for a match, if a match is found, and the token has children, find the match again by including the next character. Do this until we find the longest match. If no match is found, try matching by including the next character until we reach the end of the line or a successful match.

If we reach the end of the line without matching, print the character ? and remove the first character from the input. Repeat the whole process with the remaining characters.

This algorithm works, but rolling back and repeating all possible input combinations makes it slow and complicated.

I am wondering if there is a better way to solve this? Any help would be greatly appreciated.

Answer 1

Instead of backtracking, you can keep all possible results in memory until one result appears at a certain point in the input stream. Example

Tokens: S STACK STACKOVERFLOW STAG OVERFLOW

String: SSTACKOVERFUN

1 - Found S in place 0, have tokens starting with S, try them all, only S is valid, therefore allow S
2 - S on 1, have such tokens, try them, valid are S and STACK. Don't decide, just keep that in mind.
3 - T by 2, do not have such tokens, so S can be resolved now, but we also have a longer token (STACK), so S is not good. Ditch S, and STACK only remains, but he has children. Try the line for children. There are no possible children, therefore allow STACK
4 - O to 6, have such tokens, try them, have only OVER, so allow OVER
5 - F by 10, there are no such tokens, and nothing is decided because of this, so it is non-tokenizable
6 and 7 - the same as in step 5

End result: S STACK OVER fun

Answer 2

Could you use the Aho-Corasick algorithm ? It creates a machine for searching the tree of keywords (trie).

Answer 3

I think you want to take all your keywords and sort them alphabetically so that your list becomes (plus a few extra)

 0 stack 1 1 s 0 2 overflow 3 3 over 5 4 ovum 5 5 o 0 6 exchange 7 7 ex 0 

The third column of this list is a pointer to the parent token, which is always lower in the list. Then you can take the target string and binary search where it fits in this list. If it lands above a marker that matches, then you remove this part and repeat the process for the remainder. If it does not match, you use the parent pointer to find the next longest potential matching token.

If you want to really introduce yourself, you can also break lines into 64-bit words and compare 8 characters at once in binary search.

Answer 4

I suggest you try Ragel , it can generate efficient scanners that can perform the longest match / return. See Chapter 6.3 in Ragel for more information .

I created a tiny test that, I think, matches your specification, this is just a description of the state machine, without entering any code to enter:

 %%{ machine test; main := |* 's' => { puts("s-val");}; 'stack' => { puts("stack-val");}; 'over' => { puts("over-val");}; 'overflow' => { puts("overflow-val");}; # Anything else matches to any, outputs a '?' and continues any => {putc('?');}; *|; }%% 

Answer 5

The following token_tree code is based on the prefix_tree class from ZeroMQ

The prefix_tree class only returns true when one of the tree prefixes matches the start of text input. He will not even tell you what prefix or how long this prefix.

This token_tree will look for the longest token that matches the beginning of text input. Search The token_tree_longest_token () function should only return the length of the longest marker against the start of text input.

The basic algorithm is similar to that described in the question, but its implementation can be faster.

There are also several ways to improve memory usage, which can speed it up.

 #include <stdint.h> #include <stdlib.h> /* #define TEST_TOKEN_TREE */ /* * TODO: possible improvements, use multiple types of nodes: string/branch/leaf. * The string node would replace a chain of normal token_nodes and save memory. * This would require spliting a node to add branch points. * Use these structs: * struct token_node { * uint32_t ref_count; * uint8_t node_type; -- node is token_node_str/token_node_branch/token_node_leaf * }; * struct token_node_str { * token_node base; * uint8_t reserved; * uint16_t len; -- string length * token_node *child; -- string nodes can only have one child. * uint8_t str[0]; -- embedded string (not null-terminated) * }; * struct token_node_branch { * token_node base; * uint8_t min; -- smallest char in child list. * uint16_t count; -- child count. * token_node *children[0]; * }; * struct token_node_leaf { -- leaf nodes have no children. * token_node base; * }; * This will save memory, but will make code much more complex. */ typedef struct token_tree token_tree; typedef struct token_node token_node; struct token_tree { token_node *root; /**< root node of token tree. */ }; struct token_node { uint32_t ref_count; /**< how many token references end at this node. */ uint8_t min; /**< smallest 'char' in children list. */ uint8_t reserved; /**< padding. */ uint16_t count; /**< number of children. (max count = 256, so count must be 16bits) */ token_node *children[0]; /**< list of children nodes. index by (c - min) */ }; #define NODE_SIZE(count) (sizeof(token_node) + (sizeof(token_node *) * count)) static token_node *token_node_new(uint16_t count) { token_node *node = calloc(1, NODE_SIZE(count)); node->count = count; return node; } static void token_node_build_chain(token_node **pnode, const uint8_t *token, size_t len) { token_node *node; do { /* the last node in the chain will have no children. */ node = token_node_new((len == 0) ? 0 : 1); *pnode = node; /* add node to slot in parent children list. */ if(len == 0) break; /* new node will have one child. */ node->min = *token; node->count = 1; /* slot where next node will be saved. */ pnode = &(node->children[0]); /* consume char. */ token++; len--; } while(1); /* mark last node as end of a valid token. */ node->ref_count++; } static void token_node_free(token_node *node) { uint32_t i; uint32_t count = node->count; /* free children nodes. */ for(i=0; i < count; i++) { if(node->children[i]) token_node_free(node->children[i]); } free(node); } static void token_node_grow(token_node **pnode, uint8_t c) { token_node *node = *pnode; token_node **children; uint8_t old_min = node->min; uint16_t old_count = node->count; uint32_t i; uint8_t min; uint16_t count; if(c < old_min) { min = c; count = old_count + (old_min - min); } else { if(old_count == 0) { /* the list was empty, so this is the first char. */ old_min = c; } min = old_min; c -= old_min; if(c < old_count) { /* don't need to grow. */ return; } count = c + 1; } node = realloc(node, NODE_SIZE(count)); *pnode = node; children = node->children; /* if the 'min' value changed, then we need to move all the old slots up. */ if(old_min != min) { uint32_t diff = old_min - min; for(i=count-1; i >= diff; i--) { children[i] = children[i - diff]; } /* null new slots at start of children list. */ for(i=0; i < diff; i++) { children[i] = NULL; } } else { /* null new slots at end of children list. */ for(i=old_count; i < count; i++) { children[i] = NULL; } } node->min = min; node->count = count; } static token_node **token_node_find_last_node(token_node **pnode, const uint8_t **ptoken, size_t *plen) { const uint8_t *token = *ptoken; size_t len = *plen; uint32_t c; token_node *node = *pnode; while(node && len) { /* next char. */ c = (*token); /* if c < node->min, then it will underflow and be > node->count. */ c -= node->min; /* make sure c is in range. */ if(c >= node->count) { /* * NOTE: we don't consume this char and "*pnode" will not be null. * When adding tokens, this node will be grown to hold more children. */ break; } /* consume char. */ token++; len--; /* get pointer to next node slot. */ pnode = &(node->children[c]); node = *pnode; } *ptoken = token; *plen = len; /* return pointer to last node slot. */ return pnode; } static void token_node_add(token_node **pnode, const uint8_t *token, size_t len) { token_node *node; /* find last node in chain for this token. */ pnode = token_node_find_last_node(pnode, &token, &len); /* if full token was consumed then we found the last node for this token. */ if(!len) { node = *pnode; node->ref_count++; return; } /* check if the children list of the last node needs to be grown. */ node = *pnode; if(node) { uint32_t c = *token; /* consume char. */ token++; len--; /* grow node to make room for new char. */ token_node_grow(pnode, c); node = *pnode; /* token_node_grow() may change the node pointer. */ /* get slot for new child. */ pnode = &(node->children[c - node->min]); } /* build node chain for un-consumed part of token. */ token_node_build_chain(pnode, token, len); } static size_t token_node_longest_token(token_node *node, const uint8_t *text, size_t len) { size_t last_token_len = 0; size_t off = 0; uint32_t c; /* loop until we get a NULL node or run out of text. */ do { if(node->ref_count > 0) { /* found a token, keep track of it length. */ last_token_len = off; } /* end of input text. */ if(off >= len) break; /* next char. */ c = text[off]; /* if c < node->min, then it will underflow and be > node->count. */ c -= node->min; /* make sure c is in range. */ if(c >= node->count) { /* End of search, no more child nodes. */ break; } /* consume char. */ off++; /* get pointer to next node slot. */ node = node->children[c]; } while(node); /* return length of largest token found. */ return last_token_len; } extern token_tree *token_tree_new() { token_tree *tree = malloc(sizeof(token_tree)); tree->root = token_node_new(0); return tree; } extern void token_tree_free(token_tree *tree) { token_node_free(tree->root); free(tree); } extern void token_tree_add(token_tree *tree, const char *token, size_t len) { token_node_add(&(tree->root), token, len); } extern size_t token_tree_longest_token(token_tree *tree, const char *text, size_t len) { return token_node_longest_token(tree->root, text, len); } #ifdef TEST_TOKEN_TREE #include <stdio.h> #include <string.h> static const char *test_tokens[] = { "s", "stack", "stackoverflow", "over", "overflow", NULL, }; static const char *test_input[] = { "aastackoverasdfasdf", "stack7777", "777stack777", "overstackflow", NULL, }; static void add_tokens(token_tree *tree, const char **tokens) { int i; for(i = 0; tokens[i] != NULL; i++) { token_tree_add(tree, tokens[i], strlen(tokens[i])); } } static void print_tokens(token_tree *tree, const char *text) { size_t len = strlen(text); size_t token_len; printf("input: \"%s\"\n", text); printf("tokens: ["); while(len) { token_len = token_tree_longest_token(tree, text, len); if(token_len > 0) { printf("<%.*s>", (int)token_len, text); } else { printf("?"); token_len = 1; } text += token_len; len -= token_len; } printf("]\n"); } static void run_test(token_tree *tree, const char **texts) { int i; for(i = 0; texts[i] != NULL; i++) { print_tokens(tree, texts[i]); } } int main(int argc, char *argv[]) { token_tree *tree = token_tree_new(); add_tokens(tree, test_tokens); run_test(tree, test_input); run_test(tree, test_tokens); token_tree_free(tree); } #endif