int request_document(void) {
int i = -1;
req_list rl;
buffer *b = (buffer *)buffers.head;
if (b->b_node.next && req_list_init(&rl, NULL, true, true, '*')==OK) {
i = 0;
int cur_entry = 0;
while(b->b_node.next) {
if (b == cur_buffer) cur_entry = i;
req_list_add(&rl, b->filename ? b->filename : UNNAMED_NAME, b->is_modified);
b = (buffer *)b->b_node.next;
i++;
}
rl.ignore_tab = true;
req_list_finalize(&rl);
print_message(info_msg[SELECT_DOC]);
i = request_strings(&rl, cur_entry);
reset_window();
draw_status_bar();
if (i >= 0 && rl.reordered) {
/* We're going to cheat big time here. We have an array of pointers
at rl.entries that's big enough to hold all the buffer pointers,
and that's exactly what we're going to use it for now. */
b = (buffer *)buffers.head;
for (int j = 0; b->b_node.next; j++ ) {
rl.entries[j] = (char *)b;
b = (buffer *)b->b_node.next;
rem(b->b_node.prev);
}
/* Ack! We're removed all our buffers! */
for (int j = 0; j < rl.cur_entries; j++) {
add_tail(&buffers, (node *)rl.entries[rl.orig_order[j]]);
}
}
req_list_free(&rl);
}
return i;
}
char *request_syntax() {
char syn_dir_name[512];
char *p;
req_list rl;
DIR *d;
if (req_list_init(&rl, filenamecmp, false, false, '*') != OK) return NULL;
if ((p = exists_prefs_dir()) && strlen(p) + 2 + strlen(SYNTAX_DIR) < sizeof syn_dir_name) {
strcat(strcpy(syn_dir_name, p), SYNTAX_DIR);
if (d = opendir(syn_dir_name)) {
load_syntax_names(&rl,d,true);
closedir(d);
}
}
if ((p = exists_gprefs_dir()) && strlen(p) + 2 + strlen(SYNTAX_DIR) < sizeof syn_dir_name) {
strcat(strcpy(syn_dir_name, p), SYNTAX_DIR);
if (d = opendir(syn_dir_name)) {
load_syntax_names(&rl,d,false);
closedir(d);
}
}
req_list_finalize(&rl);
p = NULL;
int result;
if (rl.cur_entries && (result = request_strings(&rl, 0)) != ERROR) {
char * const q = rl.entries[result >= 0 ? result : -result - 2];
if (p = malloc(strlen(q)+3)) {
strcpy(p,q);
if (p[strlen(p)-1] == rl.suffix) p[strlen(p)-1] = '\0';
if (result < 0) {
memmove(p + 1, p, strlen(p) + 1);
p[0] = '\0';
}
}
}
req_list_free(&rl);
return p;
}
char *request_files(const char * const filename, bool use_prefix) {
char * const cur_dir_name = ne_getcwd(CUR_DIR_MAX_SIZE);
if (!cur_dir_name) return NULL;
char * const dir_name = str_dup(filename);
if (dir_name) {
int result = 0;
char * const p = (char *)file_part(dir_name);
if (p != dir_name) {
*p = 0;
result = chdir(tilde_expand(dir_name));
}
free(dir_name);
if (result == -1) return NULL;
}
req_list rl;
bool next_dir;
char *result = NULL;
do {
next_dir = false;
if (req_list_init(&rl, filenamecmp, true, false, '/') != OK) break;
DIR * const d = opendir(CURDIR);
if (d) {
stop = false;
for(struct dirent * de; !stop && (de = readdir(d)); ) {
const bool is_dir = is_directory(de->d_name);
if (use_prefix && !is_prefix(file_part(filename), de->d_name)) continue;
if (!req_list_add(&rl, de->d_name, is_dir)) break;
}
req_list_finalize(&rl);
if (rl.cur_entries) {
/* qsort(rl.entries, rl.cur_entries, sizeof(char *), filenamecmpp); */
const int t = request_strings(&rl, 0);
if (t != ERROR) {
char * const p = rl.entries[t >= 0 ? t : -t - 2];
if (p[strlen(p) - 1] == '/' && t >= 0) {
p[strlen(p) - 1] = 0;
if (chdir(p)) alert();
else use_prefix = false;
next_dir = true;
}
else {
result = ne_getcwd(CUR_DIR_MAX_SIZE + strlen(p) + 2);
if (strcmp(result, "/")) strcat(result, "/");
strcat(result, p);
if (t < 0) {
memmove(result + 1, result, strlen(result) + 1);
result[0] = 0;
}
}
}
}
closedir(d);
}
else alert();
req_list_free(&rl);
} while(next_dir);
chdir(cur_dir_name);
free(cur_dir_name);
return result;
}
char *autocomplete(char *p, char *req_msg, const int ext, int * const error) {
int max_len = 0, min_len = INT_MAX, prefix_len = strlen(p);
assert(p);
req_list_init(&rl, (cur_buffer->opt.case_search ? strcmp : strdictcmp), false, false, EXTERNAL_FLAG_CHAR);
count_scanned = 0;
search_buff(cur_buffer, p, cur_buffer->encoding, cur_buffer->opt.case_search, false);
if (stop) {
req_list_free(&rl);
free(p);
return NULL;
}
if (ext) {
buffer *b = (buffer *)buffers.head;
while (b->b_node.next) {
if (b != cur_buffer) {
search_buff(b, p, cur_buffer->encoding, cur_buffer->opt.case_search, true);
if (stop) {
req_list_free(&rl);
free(p);
return NULL;
}
}
b = (buffer *)b->b_node.next;
}
}
for(int i = 0; i < rl.cur_entries; i++) {
const int l = strlen(rl.entries[i]);
if (max_len < l) max_len = l;
if (min_len > l) min_len = l;
}
/* We compact the table into a vector of char pointers. */
req_list_finalize(&rl);
free(p);
p = NULL;
#ifdef NE_TEST
/* During tests, we always output the middle entry. */
if (rl.cur_entries) {
if (rl.entries[rl.cur_entries/2][strlen(rl.entries[rl.cur_entries/2]) - 1] == EXTERNAL_FLAG_CHAR) rl.entries[rl.cur_entries/2][strlen(rl.entries[rl.cur_entries/2]) - 1] = 0;
p = str_dup(rl.entries[rl.cur_entries/2]);
}
*error = AUTOCOMPLETE_COMPLETED;
req_list_free(&rl);
return p;
#endif
if (rl.cur_entries > 0) {
qsort(rl.entries, rl.cur_entries, sizeof(char *), strdictcmpp);
/* Find maximum common prefix. */
int m = strlen(rl.entries[0]);
if (rl.entries[0][m-1] == EXTERNAL_FLAG_CHAR) m--;
for(int i = 1; i < rl.cur_entries; i++) {
int j;
for(j = 0; j < m; j++)
if (rl.entries[i][j] != rl.entries[0][j]) break;
m = j;
}
/* If we can output more characters than the prefix len, we do so without
starting the requester. */
if (m > prefix_len) {
p = malloc(m + 1);
strncpy(p, rl.entries[0], m);
p[m] = 0;
*error = min_len == m ? AUTOCOMPLETE_COMPLETED : AUTOCOMPLETE_PARTIAL;
}
else {
if (req_msg) print_message(req_msg);
int result = request_strings(&rl, 0);
if (result != ERROR) {
result = result >= 0 ? result : -result - 2;
/* Delete EXTERNAL_FLAG_CHAR at the end of the strings if necessary. */
if (rl.entries[result][strlen(rl.entries[result]) - 1] == EXTERNAL_FLAG_CHAR) rl.entries[result][strlen(rl.entries[result]) - 1] = 0;
p = str_dup(rl.entries[result]);
*error = AUTOCOMPLETE_COMPLETED;
}
else *error = AUTOCOMPLETE_CANCELLED;
reset_window();
}
}
else *error = AUTOCOMPLETE_NO_MATCH;
req_list_free(&rl);
D(fprintf(stderr, "autocomp returning '%s', entries: %d\n", p, rl.cur_entries);)
return p;
