327 lines
11 KiB
C
327 lines
11 KiB
C
/* ----------------------------------------------------------------------------
|
|
Copyright (c) 2021, Daan Leijen
|
|
This is free software; you can redistribute it and/or modify it
|
|
under the terms of the MIT License. A copy of the license can be
|
|
found in the "LICENSE" file at the root of this distribution.
|
|
-----------------------------------------------------------------------------*/
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "../include/isocline.h"
|
|
#include "common.h"
|
|
#include "env.h"
|
|
#include "stringbuf.h"
|
|
#include "completions.h"
|
|
|
|
|
|
//-------------------------------------------------------------
|
|
// Completions
|
|
//-------------------------------------------------------------
|
|
|
|
typedef struct completion_s {
|
|
const char* replacement;
|
|
const char* display;
|
|
const char* help;
|
|
ssize_t delete_before;
|
|
ssize_t delete_after;
|
|
} completion_t;
|
|
|
|
struct completions_s {
|
|
ic_completer_fun_t* completer;
|
|
void* completer_arg;
|
|
ssize_t completer_max;
|
|
ssize_t count;
|
|
ssize_t len;
|
|
completion_t* elems;
|
|
alloc_t* mem;
|
|
};
|
|
|
|
static void default_filename_completer( ic_completion_env_t* cenv, const char* prefix );
|
|
|
|
ic_private completions_t* completions_new(alloc_t* mem) {
|
|
completions_t* cms = mem_zalloc_tp(mem, completions_t);
|
|
if (cms == NULL) return NULL;
|
|
cms->mem = mem;
|
|
cms->completer = &default_filename_completer;
|
|
return cms;
|
|
}
|
|
|
|
ic_private void completions_free(completions_t* cms) {
|
|
if (cms == NULL) return;
|
|
completions_clear(cms);
|
|
if (cms->elems != NULL) {
|
|
mem_free(cms->mem, cms->elems);
|
|
cms->elems = NULL;
|
|
cms->count = 0;
|
|
cms->len = 0;
|
|
}
|
|
mem_free(cms->mem, cms); // free ourselves
|
|
}
|
|
|
|
|
|
ic_private void completions_clear(completions_t* cms) {
|
|
while (cms->count > 0) {
|
|
completion_t* cm = cms->elems + cms->count - 1;
|
|
mem_free( cms->mem, cm->display);
|
|
mem_free( cms->mem, cm->replacement);
|
|
mem_free( cms->mem, cm->help);
|
|
memset(cm,0,sizeof(*cm));
|
|
cms->count--;
|
|
}
|
|
}
|
|
|
|
static void completions_push(completions_t* cms, const char* replacement, const char* display, const char* help, ssize_t delete_before, ssize_t delete_after)
|
|
{
|
|
if (cms->count >= cms->len) {
|
|
ssize_t newlen = (cms->len <= 0 ? 32 : cms->len*2);
|
|
completion_t* newelems = mem_realloc_tp(cms->mem, completion_t, cms->elems, newlen );
|
|
if (newelems == NULL) return;
|
|
cms->elems = newelems;
|
|
cms->len = newlen;
|
|
}
|
|
assert(cms->count < cms->len);
|
|
completion_t* cm = cms->elems + cms->count;
|
|
cm->replacement = mem_strdup(cms->mem,replacement);
|
|
cm->display = mem_strdup(cms->mem,display);
|
|
cm->help = mem_strdup(cms->mem,help);
|
|
cm->delete_before = delete_before;
|
|
cm->delete_after = delete_after;
|
|
cms->count++;
|
|
}
|
|
|
|
ic_private ssize_t completions_count(completions_t* cms) {
|
|
return cms->count;
|
|
}
|
|
|
|
static bool completions_contains(completions_t* cms, const char* replacement) {
|
|
for( ssize_t i = 0; i < cms->count; i++ ) {
|
|
const completion_t* c = cms->elems + i;
|
|
if (strcmp(replacement,c->replacement) == 0) { return true; }
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ic_private bool completions_add(completions_t* cms, const char* replacement, const char* display, const char* help, ssize_t delete_before, ssize_t delete_after) {
|
|
if (cms->completer_max <= 0) return false;
|
|
cms->completer_max--;
|
|
//debug_msg("completion: add: %d,%d, %s\n", delete_before, delete_after, replacement);
|
|
if (!completions_contains(cms,replacement)) {
|
|
completions_push(cms, replacement, display, help, delete_before, delete_after);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static completion_t* completions_get(completions_t* cms, ssize_t index) {
|
|
if (index < 0 || cms->count <= 0 || index >= cms->count) return NULL;
|
|
return &cms->elems[index];
|
|
}
|
|
|
|
ic_private const char* completions_get_display( completions_t* cms, ssize_t index, const char** help ) {
|
|
if (help != NULL) { *help = NULL; }
|
|
completion_t* cm = completions_get(cms, index);
|
|
if (cm == NULL) return NULL;
|
|
if (help != NULL) { *help = cm->help; }
|
|
return (cm->display != NULL ? cm->display : cm->replacement);
|
|
}
|
|
|
|
ic_private const char* completions_get_help( completions_t* cms, ssize_t index ) {
|
|
completion_t* cm = completions_get(cms, index);
|
|
if (cm == NULL) return NULL;
|
|
return cm->help;
|
|
}
|
|
|
|
ic_private const char* completions_get_hint(completions_t* cms, ssize_t index, const char** help) {
|
|
if (help != NULL) { *help = NULL; }
|
|
completion_t* cm = completions_get(cms, index);
|
|
if (cm == NULL) return NULL;
|
|
ssize_t len = ic_strlen(cm->replacement);
|
|
if (len < cm->delete_before) return NULL;
|
|
const char* hint = (cm->replacement + cm->delete_before);
|
|
if (*hint == 0 || utf8_is_cont((uint8_t)(*hint))) return NULL; // utf8 boundary?
|
|
if (help != NULL) { *help = cm->help; }
|
|
return hint;
|
|
}
|
|
|
|
ic_private void completions_set_completer(completions_t* cms, ic_completer_fun_t* completer, void* arg) {
|
|
cms->completer = completer;
|
|
cms->completer_arg = arg;
|
|
}
|
|
|
|
ic_private void completions_get_completer(completions_t* cms, ic_completer_fun_t** completer, void** arg) {
|
|
*completer = cms->completer;
|
|
*arg = cms->completer_arg;
|
|
}
|
|
|
|
|
|
ic_public void* ic_completion_arg( const ic_completion_env_t* cenv ) {
|
|
return (cenv == NULL ? NULL : cenv->env->completions->completer_arg);
|
|
}
|
|
|
|
ic_public bool ic_has_completions( const ic_completion_env_t* cenv ) {
|
|
return (cenv == NULL ? false : cenv->env->completions->count > 0);
|
|
}
|
|
|
|
ic_public bool ic_stop_completing( const ic_completion_env_t* cenv) {
|
|
return (cenv == NULL ? true : cenv->env->completions->completer_max <= 0);
|
|
}
|
|
|
|
|
|
static ssize_t completion_apply( completion_t* cm, stringbuf_t* sbuf, ssize_t pos ) {
|
|
if (cm == NULL) return -1;
|
|
debug_msg( "completion: apply: %s at %zd\n", cm->replacement, pos);
|
|
ssize_t start = pos - cm->delete_before;
|
|
if (start < 0) start = 0;
|
|
ssize_t n = cm->delete_before + cm->delete_after;
|
|
if (ic_strlen(cm->replacement) == n && strncmp(sbuf_string_at(sbuf,start), cm->replacement, to_size_t(n)) == 0) {
|
|
// no changes
|
|
return -1;
|
|
}
|
|
else {
|
|
sbuf_delete_from_to( sbuf, start, pos + cm->delete_after );
|
|
return sbuf_insert_at(sbuf, cm->replacement, start);
|
|
}
|
|
}
|
|
|
|
ic_private ssize_t completions_apply( completions_t* cms, ssize_t index, stringbuf_t* sbuf, ssize_t pos ) {
|
|
completion_t* cm = completions_get(cms, index);
|
|
return completion_apply( cm, sbuf, pos );
|
|
}
|
|
|
|
|
|
static int completion_compare(const void* p1, const void* p2) {
|
|
if (p1 == NULL || p2 == NULL) return 0;
|
|
const completion_t* cm1 = (const completion_t*)p1;
|
|
const completion_t* cm2 = (const completion_t*)p2;
|
|
return ic_stricmp(cm1->replacement, cm2->replacement);
|
|
}
|
|
|
|
ic_private void completions_sort(completions_t* cms) {
|
|
if (cms->count <= 0) return;
|
|
qsort(cms->elems, to_size_t(cms->count), sizeof(cms->elems[0]), &completion_compare);
|
|
}
|
|
|
|
#define IC_MAX_PREFIX (256)
|
|
|
|
// find longest common prefix and complete with that.
|
|
ic_private ssize_t completions_apply_longest_prefix(completions_t* cms, stringbuf_t* sbuf, ssize_t pos) {
|
|
if (cms->count <= 1) {
|
|
return completions_apply(cms,0,sbuf,pos);
|
|
}
|
|
|
|
// set initial prefix to the first entry
|
|
completion_t* cm = completions_get(cms, 0);
|
|
if (cm == NULL) return -1;
|
|
|
|
char prefix[IC_MAX_PREFIX+1];
|
|
ssize_t delete_before = cm->delete_before;
|
|
ic_strncpy( prefix, IC_MAX_PREFIX+1, cm->replacement, IC_MAX_PREFIX );
|
|
prefix[IC_MAX_PREFIX] = 0;
|
|
|
|
// and visit all others to find the longest common prefix
|
|
for(ssize_t i = 1; i < cms->count; i++) {
|
|
cm = completions_get(cms,i);
|
|
if (cm->delete_before != delete_before) { // deletions must match delete_before
|
|
prefix[0] = 0;
|
|
break;
|
|
}
|
|
// check if it is still a prefix
|
|
const char* r = cm->replacement;
|
|
ssize_t j;
|
|
for(j = 0; prefix[j] != 0 && r[j] != 0; j++) {
|
|
if (prefix[j] != r[j]) break;
|
|
}
|
|
prefix[j] = 0;
|
|
if (j <= 0) break;
|
|
}
|
|
|
|
// check the length
|
|
ssize_t len = ic_strlen(prefix);
|
|
if (len <= 0 || len < delete_before) return -1;
|
|
|
|
// we found a prefix :-)
|
|
completion_t cprefix;
|
|
memset(&cprefix,0,sizeof(cprefix));
|
|
cprefix.delete_before = delete_before;
|
|
cprefix.replacement = prefix;
|
|
ssize_t newpos = completion_apply( &cprefix, sbuf, pos);
|
|
if (newpos < 0) return newpos;
|
|
|
|
// adjust all delete_before for the new replacement
|
|
for( ssize_t i = 0; i < cms->count; i++) {
|
|
cm = completions_get(cms,i);
|
|
cm->delete_before = len;
|
|
}
|
|
|
|
return newpos;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------
|
|
// Completer functions
|
|
//-------------------------------------------------------------
|
|
|
|
ic_public bool ic_add_completions(ic_completion_env_t* cenv, const char* prefix, const char** completions) {
|
|
for (const char** pc = completions; *pc != NULL; pc++) {
|
|
if (ic_istarts_with(*pc, prefix)) {
|
|
if (!ic_add_completion_ex(cenv, *pc, NULL, NULL)) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
ic_public bool ic_add_completion(ic_completion_env_t* cenv, const char* replacement) {
|
|
return ic_add_completion_ex(cenv, replacement, NULL, NULL);
|
|
}
|
|
|
|
ic_public bool ic_add_completion_ex( ic_completion_env_t* cenv, const char* replacement, const char* display, const char* help ) {
|
|
return ic_add_completion_prim(cenv,replacement,display,help,0,0);
|
|
}
|
|
|
|
ic_public bool ic_add_completion_prim(ic_completion_env_t* cenv, const char* replacement, const char* display, const char* help, long delete_before, long delete_after) {
|
|
return (*cenv->complete)(cenv->env, cenv->closure, replacement, display, help, delete_before, delete_after );
|
|
}
|
|
|
|
static bool prim_add_completion(ic_env_t* env, void* funenv, const char* replacement, const char* display, const char* help, long delete_before, long delete_after) {
|
|
ic_unused(funenv);
|
|
return completions_add(env->completions, replacement, display, help, delete_before, delete_after);
|
|
}
|
|
|
|
ic_public void ic_set_default_completer(ic_completer_fun_t* completer, void* arg) {
|
|
ic_env_t* env = ic_get_env(); if (env == NULL) return;
|
|
completions_set_completer(env->completions, completer, arg);
|
|
}
|
|
|
|
ic_private ssize_t completions_generate(struct ic_env_s* env, completions_t* cms, const char* input, ssize_t pos, ssize_t max) {
|
|
completions_clear(cms);
|
|
if (cms->completer == NULL || input == NULL || ic_strlen(input) < pos) return 0;
|
|
|
|
// set up env
|
|
ic_completion_env_t cenv;
|
|
cenv.env = env;
|
|
cenv.input = input,
|
|
cenv.cursor = (long)pos;
|
|
cenv.arg = cms->completer_arg;
|
|
cenv.complete = &prim_add_completion;
|
|
cenv.closure = NULL;
|
|
const char* prefix = mem_strndup(cms->mem, input, pos);
|
|
cms->completer_max = max;
|
|
|
|
// and complete
|
|
cms->completer(&cenv,prefix);
|
|
|
|
// restore
|
|
mem_free(cms->mem,prefix);
|
|
return completions_count(cms);
|
|
}
|
|
|
|
// The default completer is no completion is set
|
|
static void default_filename_completer( ic_completion_env_t* cenv, const char* prefix ) {
|
|
#ifdef _WIN32
|
|
const char sep = '\\';
|
|
#else
|
|
const char sep = '/';
|
|
#endif
|
|
ic_complete_filename( cenv, prefix, sep, ".", NULL);
|
|
}
|