1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "choices.h"
#include "match.h"
/* Initial size of buffer for storing input in memory */
#define INITIAL_BUFFER_SIZE 4096
/* Initial size of choices array */
#define INITIAL_CHOICE_CAPACITY 128
static int cmpchoice(const void *_idx1, const void *_idx2) {
const struct scored_result *a = _idx1;
const struct scored_result *b = _idx2;
if (a->score == b->score)
return 0;
else if (a->score < b->score)
return 1;
else
return -1;
}
static void *safe_realloc(void *buffer, size_t size) {
buffer = realloc(buffer, size);
if (!buffer) {
fprintf(stderr, "Error: Can't allocate memory (%zu bytes)\n", size);
abort();
}
return buffer;
}
void choices_fread(choices_t *c, FILE *file) {
size_t bufsize = INITIAL_BUFFER_SIZE, pos = 0;
char *buf = safe_realloc(NULL, bufsize);
/* Continue reading until we get a "short" read, indicating EOF */
while ((pos += fread(buf + pos, 1, bufsize - pos, file)) == bufsize) {
bufsize *= 2;
buf = safe_realloc(buf, bufsize);
}
buf[pos] = 0;
/* Truncate buffer to used size, (maybe) freeing some memory for
* future allocations.
*/
buf = safe_realloc(buf, pos + 1);
/* Tokenize input and add to choices */
char *line = buf;
do {
char *nl = strchr(line, '\n');
if (nl)
*nl++ = '\0';
/* Skip empty lines */
if (*line)
choices_add(c, line);
line = nl;
} while (line);
}
static void choices_resize(choices_t *c, size_t new_capacity) {
c->strings = safe_realloc(c->strings, new_capacity * sizeof(const char *));
c->capacity = new_capacity;
}
static void choices_reset_search(choices_t *c) {
free(c->results);
c->selection = c->available = 0;
c->results = NULL;
}
void choices_init(choices_t *c) {
c->strings = NULL;
c->results = NULL;
c->capacity = c->size = 0;
choices_reset_search(c);
choices_resize(c, INITIAL_CHOICE_CAPACITY);
}
void choices_free(choices_t *c) {
free(c->strings);
free(c->results);
}
void choices_add(choices_t *c, const char *choice) {
/* Previous search is now invalid */
choices_reset_search(c);
if (c->size == c->capacity) {
choices_resize(c, c->capacity * 2);
}
c->strings[c->size++] = choice;
}
size_t choices_available(choices_t *c) {
return c->available;
}
void choices_search(choices_t *c, const char *search) {
choices_reset_search(c);
c->results = malloc(c->size * sizeof(struct scored_result));
if (!c->results) {
fprintf(stderr, "Error: Can't allocate memory\n");
abort();
}
for (size_t i = 0; i < c->size; i++) {
if (has_match(search, c->strings[i])) {
c->results[c->available].str = c->strings[i];
c->results[c->available].score = match(search, c->strings[i]);
c->available++;
}
}
qsort(c->results, c->available, sizeof(struct scored_result), cmpchoice);
}
const char *choices_get(choices_t *c, size_t n) {
if (n < c->available) {
return c->results[n].str;
} else {
return NULL;
}
}
double choices_getscore(choices_t *c, size_t n) {
return c->results[n].score;
}
void choices_prev(choices_t *c) {
if (c->available)
c->selection = (c->selection + c->available - 1) % c->available;
}
void choices_next(choices_t *c) {
if (c->available)
c->selection = (c->selection + 1) % c->available;
}
|
