Cosmetics.

[selector.git] / selector.c

diff --git a/selector.c b/selector.c
index b0f30ce..eb8e22f 100644 (file)
--- a/selector.c
+++ b/selector.c
@@ -25,7 +25,7 @@
 /*
 
   To use it as a super-history-search for bash:
-  selector --bash -l ${HISTSIZE} <(history)
+  selector --bash <(history)
 
 */
 
@@ -45,7 +45,7 @@
 #include <getopt.h>
 #include <limits.h>
 
-#define VERSION "1.1.1"
+#define VERSION "1.1.2"
 
 #define BUFFER_SIZE 4096
 
@@ -191,7 +191,7 @@ void usage(FILE *out) {
   fprintf(out, " -q, --no-beep\n");
   fprintf(out, "         make a flash instead of a beep on an edition error\n");
   fprintf(out, " --bash\n");
-  fprintf(out, "         setting for bash history search, same as -b -i -d -v -w\n");
+  fprintf(out, "         setting for bash history search, same as -b -i -d -v -w -l ${HISTSIZE}\n");
   fprintf(out, " --, --rest-are-files\n");
   fprintf(out, "         all following arguments are filenames\n");
   fprintf(out, " -t <title>, --title <title>\n");
@@ -214,6 +214,8 @@ void usage(FILE *out) {
 
 /* A quick and dirty hash table */
 
+#define MAGIC_HASH_MULTIPLIER 387433
+
 /* The table itself stores indexes of the strings taken in a char**
    table. When a string is added, if it was already in the table, the
    new index replaces the previous one.  */
@@ -252,18 +254,19 @@ int add_and_get_previous_index(struct hash_table_t *hash_table,
                                const char *new_string, int new_index,
                                char **strings) {
 
-  unsigned int code = 0;
+  unsigned int code = 0, start;
   int k;
 
   /* This is my recipe. I checked, it seems to work (as long as
-     hash_table->size is not a multiple of 387433 that should be
-     okay) */
+     hash_table->size is not a multiple of MAGIC_HASH_MULTIPLIER that
+     should be okay) */
 
   for(k = 0; new_string[k]; k++) {
-    code = code * 387433 + (unsigned int) (new_string[k]);
+    code = code * MAGIC_HASH_MULTIPLIER + (unsigned int) (new_string[k]);
   }
 
   code = code % hash_table->size;
+  start = code;
 
   while(hash_table->entries[code] >= 0) {
     /* There is a string with that code */
@@ -278,6 +281,12 @@ int add_and_get_previous_index(struct hash_table_t *hash_table,
     /* This collision was not the same string, let's move to the next
        in the table */
     code = (code + 1) % hash_table->size;
+    /* We came back to our original code, which means that the table
+       is full */
+    if(code == start) {
+      printf("Full hash table (that should not happen)\n");
+      exit(EXIT_FAILURE);
+   }
   }
 
   /* This string was not already in there, store the index in the
@@ -299,7 +308,7 @@ typedef struct {
   char *splitted_patterns, **patterns;
 } matcher_t;
 
-int match(char *string, matcher_t *matcher) {
+int match(matcher_t *matcher, char *string) {
   int n;
   if(matcher->nb_patterns >= 0) {
     if(matcher->case_sensitive) {
@@ -326,8 +335,9 @@ void free_matcher(matcher_t *matcher) {
   }
 }
 
-void initialize_matcher(int use_regexp, int case_sensitive,
-                        matcher_t *matcher, const char *pattern) {
+void initialize_matcher(matcher_t *matcher,
+                        int use_regexp, int case_sensitive,
+                        const char *pattern) {
   const char *s;
   char *t, *last_pattern_start;
   int n;
@@ -430,14 +440,14 @@ void kill_after_cursor(char *buffer, int *position) {
 
 int previous_visible(int current_line, char **lines, matcher_t *matcher) {
   int line = current_line - 1;
-  while(line >= 0 && !match(lines[line], matcher)) line--;
+  while(line >= 0 && !match(matcher, lines[line])) line--;
   return line;
 }
 
 int next_visible(int current_line, int nb_lines, char **lines,
                  matcher_t *matcher) {
   int line = current_line + 1;
-  while(line < nb_lines && !match(lines[line], matcher)) line++;
+  while(line < nb_lines && !match(matcher, lines[line])) line++;
 
   if(line < nb_lines)
     return line;
@@ -472,7 +482,7 @@ void update_screen(int *current_focus_line, int *displayed_focus_line,
   int nb_printed_lines = 0;
   int cursor_x;
 
-  initialize_matcher(use_regexp, case_sensitive, &matcher, pattern);
+  initialize_matcher(&matcher, use_regexp, case_sensitive, pattern);
 
   console_width = getmaxx(stdscr);
   console_height = getmaxy(stdscr);
@@ -495,7 +505,7 @@ void update_screen(int *current_focus_line, int *displayed_focus_line,
 
   else if(nb_lines > 0) {
     int new_focus_line;
-    if(match(lines[*current_focus_line], &matcher)) {
+    if(match(&matcher, lines[*current_focus_line])) {
       new_focus_line = *current_focus_line;
     } else {
       new_focus_line = next_visible(*current_focus_line, nb_lines, lines,
@@ -545,21 +555,21 @@ void update_screen(int *current_focus_line, int *displayed_focus_line,
 
         if(first_line > 0) {
           first_line--;
-          while(first_line > 0 && !match(lines[first_line], &matcher)) {
+          while(first_line > 0 && !match(&matcher, lines[first_line])) {
             first_line--;
           }
-          if(match(lines[first_line], &matcher)) {
+          if(match(&matcher, lines[first_line])) {
             nb_match++;
           }
         }
 
         if(nb_match < console_height - 1 && last_line < nb_lines - 1) {
           last_line++;
-          while(last_line < nb_lines - 1 && !match(lines[last_line], &matcher)) {
+          while(last_line < nb_lines - 1 && !match(&matcher, lines[last_line])) {
             last_line++;
           }
 
-          if(match(lines[last_line], &matcher)) {
+          if(match(&matcher, lines[last_line])) {
             nb_match++;
           }
         }
@@ -568,7 +578,7 @@ void update_screen(int *current_focus_line, int *displayed_focus_line,
       /* Now we display them */
 
       for(l = first_line; l <= last_line; l++) {
-        if(match(lines[l], &matcher)) {
+        if(match(&matcher, lines[l])) {
           int k = 0;
 
           while(lines[l][k] && k < BUFFER_SIZE - 2 && k < console_width - 2) {
@@ -855,6 +865,7 @@ int main(int argc, char **argv) {
   char **lines, **labels;
   int nb_lines;
   struct hash_table_t *hash_table;
+  char *bash_histsize;
 
   if(!isatty(STDIN_FILENO)) {
     fprintf(stderr, "selector: The standard input is not a tty.\n");
@@ -967,6 +978,10 @@ int main(int argc, char **argv) {
       remove_duplicates = 1;
       output_to_vt_buffer = 1;
       add_control_qs = 1;
+      bash_histsize = getenv("HISTSIZE");
+      if(bash_histsize) {
+        str_to_positive_integers(bash_histsize, &nb_lines_max, 1);
+      }
       break;
 
     default:
@@ -975,14 +990,14 @@ int main(int argc, char **argv) {
     }
   }
 
-  if(show_help || error) {
-    if(error) {
-      usage(stderr);
-      exit(EXIT_FAILURE);
-    } else {
-      usage(stdout);
-      exit(EXIT_SUCCESS);
-    }
+  if(error) {
+    usage(stderr);
+    exit(EXIT_FAILURE);
+  }
+
+  if(show_help) {
+    usage(stdout);
+    exit(EXIT_SUCCESS);
   }
 
   lines = safe_malloc(nb_lines_max * sizeof(char *));