X-Git-Url: https://git.cworth.org/git?p=mnemon;a=blobdiff_plain;f=mnemon.c;h=6600798c77d9f29429e6f1bc18633008e0d3452f;hp=101ace80edb9f29d49232261de5db331931a847a;hb=16ea9ef431682b5339ac94b29d235ea0af5d24a5;hpb=b3370d9eb4c77cfb39e6045af5f4cdb8c045452f

diff --git a/mnemon.c b/mnemon.c
index 101ace8..6600798 100644
--- a/mnemon.c
+++ b/mnemon.c
@@ -21,6 +21,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
+#include <stdint.h>
 
 #include <sys/types.h>
 #include <dirent.h>
@@ -28,6 +29,11 @@
 #include <string.h>
 #include <assert.h>
 
+#include <readline/readline.h>
+#include <readline/history.h>
+
+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)
 {
@@ -362,20 +380,13 @@ 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;
+    int i = bin - mnemon->bins;
 
-    item = category_add_item (category, count, challenge, response);
-
-    bin = mnemon_get_bin (mnemon, count);
-
-    bin_add_item (bin, item);
+    memmove (bin, bin + 1, (mnemon->num_bins - i) * sizeof (bin_t));
+    mnemon->num_bins--;
 }
 
 static void
@@ -399,6 +410,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 +460,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 +469,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
@@ -527,15 +553,139 @@ mnemon_save (mnemon_t *mnemon)
     }
 }
 
+/* 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)
+{
+    bin_t *bin;
+    int item_index;
+    item_t *item;
+    char *response;
+    bool_t correct;
+
+    while (1) {
+	mnemon_select_item (mnemon, &bin, &item_index);
+	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 (bin->num_items == 0)
+	    mnemon_remove_bin (mnemon, bin);
+
+	if (correct) {
+	    printf ("Correct! (Moving from %d to ", item->count);
+	    item->count++;
+	    /* We reserve an item count of 0 for an item that has
+	     * never been asked. */
+	    if (item->count == 0)
+		item->count = 1;
+	    printf ("%d)\n\n", item->count);
+	} else {
+	    printf ("  %s is the correct answer. (Moving from %d to ",
+		    item->response, item->count);
+	    item->count--;
+	    /* Penalize an incorrect response by forcing the count
+	     * negative. */
+	    if (item->count >= 0)
+		item->count = -1;
+	    printf ("%d)\n\n", item->count);
+	}
+
+	bin = mnemon_get_bin (mnemon, item->count);
+
+	bin_add_item (bin, item);
+    }
+}
+
 int
 main (int argc, char *argv[])
 {
     mnemon_t mnemon;
 
+    srand (1);
+
     mnemon_init (&mnemon);
 
     mnemon_load (&mnemon);
 
+    mnemon_do_challenges (&mnemon);
+
     mnemon_save (&mnemon);
 
     mnemon_fini (&mnemon);