X-Git-Url: https://git.cworth.org/git?p=mnemon;a=blobdiff_plain;f=mnemon.c;h=25ba65fac17040f6b6600c6defa9d0bebcf1638f;hp=f35c0b7aabd8696520aef61f03239661b3ec65ba;hb=32442590b9ba9dcf60e15a5248cf2d15e66d458e;hpb=1165471b98eef572bc87e788e7c3c519b9ef73bf diff --git a/mnemon.c b/mnemon.c index f35c0b7..25ba65f 100644 --- a/mnemon.c +++ b/mnemon.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -28,6 +29,11 @@ #include #include +#include +#include + +typedef int bool_t; + typedef struct _item { int count; char *challenge; @@ -255,6 +261,18 @@ bin_add_item (bin_t *bin, bin->items[bin->num_items++] = item; } +static void +bin_remove_item (bin_t *bin, + int item_index) +{ + /* Replace the current item with the last item, (no need to shift + * any more than that since we don't care about the order of the + * items within a bin). */ + bin->num_items--; + if (bin->num_items) + bin->items[item_index] = bin->items[bin->num_items]; +} + static void mnemon_init (mnemon_t *mnemon) { @@ -348,12 +366,14 @@ mnemon_get_bin (mnemon_t *mnemon, else if (mnemon->bins[i].count > count) break; - mnemon_bins_grow (mnemon); + if (mnemon->num_bins == mnemon->bins_size) + mnemon_bins_grow (mnemon); bin = &mnemon->bins[i]; /* Make room to insert new bin at its sorted location. */ - memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t)); + if (i < mnemon->num_bins) + memmove (bin + 1, bin, (mnemon->num_bins - i) * sizeof (bin_t)); mnemon->num_bins++; bin_init (bin, count); @@ -362,20 +382,15 @@ mnemon_get_bin (mnemon_t *mnemon, } static void -mnemon_add_item (mnemon_t *mnemon, - category_t *category, - int count, - const char *challenge, - const char *response) +mnemon_remove_bin (mnemon_t *mnemon, + bin_t *bin) { - item_t *item; - bin_t *bin; - - item = category_add_item (category, count, challenge, response); + int i = bin - mnemon->bins; - bin = mnemon_get_bin (mnemon, count); + bin_fini (bin); - bin_add_item (bin, item); + memmove (bin, bin + 1, (mnemon->num_bins - i) * sizeof (bin_t)); + mnemon->num_bins--; } static void @@ -399,6 +414,7 @@ mnemon_load_category (mnemon_t *mnemon, int line_count = 0; char *path; category_t *category; + int i; path = xmalloc (strlen (mnemon->dir_name) + 1 + strlen (name) + 1); sprintf (path, "%s/%s", mnemon->dir_name, name); @@ -448,7 +464,7 @@ mnemon_load_category (mnemon_t *mnemon, chomp (line); response = line; - mnemon_add_item (mnemon, category, count, challenge, response); + category_add_item (category, count, challenge, response); free (challenge); } @@ -457,6 +473,20 @@ mnemon_load_category (mnemon_t *mnemon, free (line); fclose (file); free (path); + + /* Resize category items to fit exactly. */ + category->items_size = category->num_items; + category->items = xrealloc (category->items, category->items_size * sizeof (item_t)); + + /* Now that the category is completely loaded, with stable + * pointers to every item, we can add each item to its appropriate + * bin. */ + for (i = 0; i < category->num_items; i++) { + item_t *item = &category->items[i]; + bin_t *bin = mnemon_get_bin (mnemon, item->count); + + bin_add_item (bin, item); + } } static void @@ -503,6 +533,7 @@ mnemon_save (mnemon_t *mnemon) mnemon->dir_name, category->name); xasprintf (&lock_filename, "%s/.#%s", mnemon->dir_name, category->name); + file = fopen (lock_filename, "w"); if (file == NULL) { fprintf (stderr, "Error: Failed to open %s for writing: %s\n", @@ -512,24 +543,212 @@ mnemon_save (mnemon_t *mnemon) category_print (category, file); + fclose (file); + err = rename (lock_filename, filename); if (err < 0) { - fprintf (stderr, "Error: Failes to rename %s to %s: %s\n", + fprintf (stderr, "Error: Failed to rename %s to %s: %s\n", lock_filename, filename, strerror (errno)); continue; } + + free (filename); + free (lock_filename); } } +/* Return a uniformly-distributed pseudo-random integer within the + * range: + * + * 0 <= result < num_values + */ +static int +rand_within (int num_values) +{ + return (int) (num_values * (rand() / (RAND_MAX + 1.0))); +} + +/* Return an exponentially-distributed pseudo-random integer within + * the range: + * + * 0 <= result < num_values + * + * The distribution is such that each successively larger value will + * occur with a probability of half of the previous value. + */ +static int +rand_within_exponential (int num_values) +{ + static int r; + static uint32_t mask = 0; + int ones; + int bit; + + /* Optimize the constant case. */ + if (num_values == 1) + return 0; + + ones = 0; + + do { + if (mask == 0) { + r = rand (); + mask = 1 << 31; + while (mask > RAND_MAX) + mask >>= 1; + } + bit = r & mask; + mask >>= 1; + if (bit) { + ones++; + if (ones == num_values) + ones = 0; + } + } while (bit); + + return ones; +} + +static void +mnemon_select_item (mnemon_t *mnemon, + bin_t **bin_ret, + int *item_index_ret) +{ + int bin_index; + bin_t *bin; + + bin_index = rand_within_exponential (mnemon->num_bins); + + bin = &mnemon->bins[bin_index]; + + *bin_ret = bin; + *item_index_ret = rand_within (bin->num_items); +} + +static void +mnemon_do_challenges (mnemon_t *mnemon, + int to_introduce) +{ + bin_t *bin; + int item_index; + item_t *item; + char *response; + bool_t correct; + int unlearned; + int i; + + /* Count the number of items with negative counts. */ + unlearned = 0; + for (i = 0; i < mnemon->num_bins; i++) { + bin = &mnemon->bins[i]; + if (bin->count >= 0) + break; + unlearned += bin->num_items; + } + + to_introduce -= unlearned; + if (to_introduce < 0) + to_introduce = 0; + + if (unlearned) { + printf ("You've got %d items to learn already. ", unlearned); + if (to_introduce) + printf ("I'll introduce %d more as we go.", to_introduce); + printf ("\n"); + } else { + printf ("Introducing %d new items.\n", to_introduce); + } + printf ("\n"); + + do { + mnemon_select_item (mnemon, &bin, &item_index); + + if (bin->count == 0) + to_introduce--; + + item = bin->items[item_index]; + + printf ("%s\n", item->challenge); + + response = readline ("> "); + if (response == NULL) { + printf ("\n"); + break; + } + + correct = (strcmp (response, item->response) == 0); + + bin_remove_item (bin, item_index); + + /* If the bin is now empty, we must remove it. Also if we just + * picked the last word we'll ever pick from the bin with + * count 0, then we can remove that as well. */ + if (bin->num_items == 0 || + (bin->count == 0 && to_introduce == 0)) + { + mnemon_remove_bin (mnemon, bin); + } + + if (correct) { + item->count++; + /* We reserve an item count of 0 for an item that has + * never been asked. */ + if (item->count == 0) { + item->count = 1; + unlearned--; + printf ("You got it!"); + } else if (item->count < 0) { + printf ("Yes---just give me %d more.", + - item->count); + } else if (item->count == 1) { + printf ("On your first try, no less!"); + } else { + printf ("Masterful."); + } + } else { + printf (" %s is the correct answer.", + item->response); + if (item->count >= 0) + unlearned++; + item->count--; + /* Penalize an incorrect response by forcing the count + * negative. */ + if (item->count >= 0) { + item->count = -1; + printf ( " Oops, you knew that, right?\n "); + } + } + + printf (" ("); + if (to_introduce) + printf ("%d to come.", to_introduce); + if (to_introduce && unlearned) + printf (" "); + if (unlearned) + printf ("%d still unlearned.", unlearned); + if (to_introduce == 0 && unlearned == 0) + printf ("Great job!"); + printf (")\n\n"); + + bin = mnemon_get_bin (mnemon, item->count); + + bin_add_item (bin, item); + } while (unlearned || to_introduce); +} + int main (int argc, char *argv[]) { mnemon_t mnemon; + srand (time (NULL)); + mnemon_init (&mnemon); mnemon_load (&mnemon); + mnemon_do_challenges (&mnemon, 10); + mnemon_save (&mnemon); mnemon_fini (&mnemon);