* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA."
*/
-/* Portably, schmortability. I want ease of programming. */
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
+#include "dict.h"
+
#include <string.h>
#include <errno.h>
#include <ctype.h>
-#include "dict.h"
-
typedef struct _string {
size_t size;
char *s;
size_t len;
} string_t;
-#define TRIE_FLAGS_IS_WORD (1<<0)
-
typedef bool_t
(*trie_predicate_t) (trie_t *trie);
#define TRIE_CHAR_TO_INDEX(c) (tolower (c) - 'a')
#define TRIE_INDEX_TO_CHAR(i) (i + 'a')
-void *
+static void *
xmalloc (size_t size)
{
void *res;
return res;
}
-void *
+static void *
xrealloc (void *ptr, size_t size)
{
void *res;
return res;
}
-void
+static void
chomp (char *s)
{
int len = strlen (s);
s[len - 1] = '\0';
}
-void
+static void
string_init (string_t *string)
{
string->size = 0;
string->len = 0;
}
-void
+static void
string_fini (string_t *string)
{
string->size = 0;
string->len = 0;
}
-void
+static void
string_append_char (string_t *string, char c)
{
if (string->size == 0) {
string->s[string->len] = '\0';
}
-void
+static void
string_chop (string_t *string)
{
if (string->len == 0)
trie_destroy (trie->next[i]);
}
-trie_t *
+static trie_t *
trie_create (void)
{
trie_t *trie;
free (trie);
}
-void
+static trie_t *
trie_add (trie_t *trie,
const char *word_chunk)
{
char c = word_chunk[0];
int i;
- if (c == '\0') {
- trie->flags |= TRIE_FLAGS_IS_WORD;
- return;
- }
+ if (c == '\0')
+ return trie;
i = TRIE_CHAR_TO_INDEX (c);
if (trie->next[i] == NULL)
trie->next[i] = trie_create ();
- trie_add (trie->next[i], word_chunk + 1);
+ return trie_add (trie->next[i], word_chunk + 1);
}
-trie_t *
+static trie_t *
trie_find (trie_t *trie,
const char *word_chunk)
{
return trie;
}
-int
+static int
trie_count (trie_t *trie,
trie_predicate_t predicate)
{
return count;
}
-int
-trie_print (trie_t *trie,
- string_t *string,
- trie_predicate_t predicate,
- int length,
- int min_length,
- int max_length)
+static int
+trie_for_each (trie_t *trie,
+ string_t *string,
+ trie_predicate_t predicate,
+ int length,
+ int min_length,
+ int max_length,
+ dict_action_t action,
+ void *closure)
{
char c;
int i;
if (length >= min_length && (predicate) (trie))
{
count = 1;
- printf ("%s ", string->s);
+
+ action (closure, string->s, &trie->flags);
}
if (length == max_length)
c = TRIE_INDEX_TO_CHAR (i);
string_append_char (string, c);
- count += trie_print (trie->next[i], string, predicate,
- length + 1, min_length, max_length);
+ count += trie_for_each (trie->next[i], string, predicate,
+ length + 1, min_length, max_length,
+ action, closure);
string_chop (string);
}
dict_add_word (dict_t *dict,
const char *word)
{
- trie_add (dict, word);
+ trie_t *trie;
+
+ trie = trie_add (dict, word);
+ trie->flags |= DICT_ENTRY_FLAG_IS_WORD;
}
void
}
int
-dict_print (dict_t *dict)
+dict_for_each_if (dict_t *dict,
+ dict_action_t action,
+ void *closure,
+ dict_entry_predicate_t predicate)
+
{
int count;
string_t string;
string_init (&string);
- dict_entry_predicate = NULL;
- count = trie_print (dict, &string, dict_predicate,
- 0, 0, -1);
+ dict_entry_predicate = predicate;
+ count = trie_for_each (dict, &string, dict_predicate,
+ 0, 0, -1, action, closure);
string_fini (&string);
}
int
-dict_print_if (dict_t *dict,
- dict_entry_predicate_t predicate)
+dict_for_each (dict_t *dict,
+ dict_action_t action,
+ void *closure)
{
- int count;
- string_t string;
-
- string_init (&string);
-
- dict_entry_predicate = predicate;
- count = trie_print (dict, &string, dict_predicate,
- 0, 0, -1);
-
- string_fini (&string);
-
- return count;
+ return dict_for_each_if (dict, action, closure, NULL);
}
int
-dict_print_by_length_if (dict_t *dict,
- dict_entry_predicate_t predicate)
+dict_for_each_by_length_if (dict_t *dict,
+ dict_action_t action,
+ void *closure,
+ dict_entry_predicate_t predicate)
{
int length, total, words, count = 0;
string_t string;
length = 1;
do {
- words = trie_print (dict, &string, dict_predicate,
- 0, length, length);
- if (words) {
- printf ("\n");
+ words = trie_for_each (dict, &string, dict_predicate,
+ 0, length, length,
+ action, closure);
+ if (words)
count += words;
- }
length++;
} while (count < total);
return count;
}
+
+int
+dict_for_each_by_length (dict_t *dict,
+ dict_action_t action,
+ void *closure)
+{
+ return dict_for_each_by_length_if (dict, action, closure, NULL);
+}
+
+static void
+dict_action_print (void *closure, char *word, dict_entry_t *entry)
+{
+ int *length_of_last = closure;
+ int length = strlen (word);
+
+ if (length == *length_of_last)
+ printf(" ");
+ else if (*length_of_last)
+ printf("\n");
+
+ printf ("%s", word);
+
+ *length_of_last = length;
+}
+
+int
+dict_print (dict_t *dict)
+{
+ int length_of_last = 0;
+
+ return dict_for_each (dict,
+ dict_action_print, &length_of_last);
+}
+
+int
+dict_print_by_length (dict_t *dict)
+{
+ int length_of_last = 0;
+
+ return dict_for_each_by_length (dict,
+ dict_action_print, &length_of_last);
+}
+
+int
+dict_print_if (dict_t *dict,
+ dict_entry_predicate_t predicate)
+{
+ int length_of_last = 0;
+
+ return dict_for_each_if (dict,
+ dict_action_print, &length_of_last,
+ predicate);
+}
+
+int
+dict_print_by_length_if (dict_t *dict,
+ dict_entry_predicate_t predicate)
+{
+ int length_of_last = 0;
+
+ return dict_for_each_by_length_if (dict,
+ dict_action_print, &length_of_last,
+ predicate);
+}
projects / wordgame / blobdiff