/***************************************************Project Mutator****************************************************/
//-*-c++-*-
/*first line intentionally left blank.*/
/*the source code for bruiser's auto-completion and suggestions.*/
/*Copyright (C) 2017 Farzad Sadeghi
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 3
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.*/
/**********************************************************************************************************************/
/*included modules*/
/*project headers*/
#include "./lua-5.3.4/src/lua.h"
#include "./lua-5.3.4/src/lauxlib.h"
#include "./lua-5.3.4/src/lualib.h"
/*standard headers*/
#include "inttypes.h"
#include "stdbool.h"
#include "stddef.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "unistd.h"
/*other*/
#include "CompletionHints.h"
#include "completions.h"
#include "linenoise/linenoise.h"
/**********************************************************************************************************************/
size_t get_str_len(const char* str) {
int size_counter = 0;
while (true) {
if (str[size_counter] != '\0') {
size_counter++;
} else {
return size_counter;
}
}
}
int devi_find_last_word(char const * const str, char* delimiters, int delimiter_size) {
size_t str_len = get_str_len(str);
for (int i = 0; i < delimiter_size; ++i) {
if (delimiters[i] == str[str_len-1]) return -1;
}
for (int i = str_len -1; i >=0; --i) {
for (int j = 0; j < delimiter_size;++j) {
if (delimiters[j] == str[i]) {
return i + 1;
} else {
/*intentionally left blank*/
}
}
}
return 0;
}
word_pos_t devi_find_middle_word(char const * const str, char* delimiters, int delimiter_size, size_t pos) {
size_t str_len = get_str_len(str);
word_pos_t result;
result.begin = -1;
result.end = -1;
if (NULL == str) return result;
bool begin_matched = false;
bool end_matched = false;
for (int i = 0; i < delimiter_size; ++i) {
if (str[pos] == delimiters[i]) {
return result;
}
}
for (int i = pos; i >=0; --i) {
for (int j = 0; j < delimiter_size;++j) {
if (delimiters[j] == str[i]) {
result.begin = i + 1;
begin_matched = true;
} else {
/*intentionally left blank*/
}
}
}
for (int i = pos; i <= str_len - 1; ++i) {
for (int j = 0; j < delimiter_size;++j) {
if (delimiters[j] == str[i]) {
result.end = i - 1;
end_matched = true;
} else {
/*intentionally left blank*/
}
}
}
if (!begin_matched) {
result.begin = 0;
}
if (!end_matched) {
result.end = strlen(str) - 1;
}
return result;
}
size_t devi_rfind(char const * const str, char const * const substr) {
size_t str_len = get_str_len(str);
size_t substr_len = get_str_len(substr);
for (size_t i = str_len-1; i >=0 ; --i) {
if (substr[substr_len-1] != str[i]) {
continue;
} else {
bool matched = true;
for (int j = substr_len-1; j >= 0; --j) {
if (substr[j] == str[i - (substr_len - j -1)]) {
continue;
} else {
matched = false;
}
}
if (matched) return (i - substr_len + 1);
}
}
return -1;
}
size_t devi_lfind(char const * const str, char const * const substr) {
size_t str_len = get_str_len(str);
size_t substr_len = get_str_len(substr);
for (size_t i = 0; i < str_len; ++i) {
if (substr[0] != str[i]) {
continue;
} else {
bool matched = true;
for (size_t j = 0; j < substr_len; ++j) {
if (i + j >= str_len) return -1;
if (substr[j] == str[i+j]) {
continue;
} else {
matched = false;
}
}
if (matched) return (i);
}
}
return -1;
}
void shell_completion(const char* buf, linenoiseCompletions* lc, size_t pos) {
if (0 != pos) {
word_pos_t word_pos = devi_find_middle_word(buf, ID_BREAKERS, NELEMS(ID_BREAKERS), pos - 1);
if (word_pos.begin == -1 || word_pos.end == -1) {
return;
}
char* last_word = malloc(word_pos.end - word_pos.begin + 2);
last_word[word_pos.end - word_pos.begin + 1] = '\0';
memcpy(last_word, &buf[word_pos.begin], word_pos.end - word_pos.begin + 1);
char* ln_matched;
// custom list completion candidates
for(int i=0; i < NELEMS(LUA_FUNCS); ++i) {
if ( 0 == devi_lfind(LUA_FUNCS[i], last_word)) {
ln_matched = malloc(strlen(buf) + strlen(LUA_FUNCS[i]) - strlen(last_word) + 1);
ln_matched[strlen(buf) + strlen(LUA_FUNCS[i]) - strlen(last_word)] = '\0';
memcpy(ln_matched, buf, word_pos.begin);
memcpy(&ln_matched[word_pos.begin], LUA_FUNCS[i], strlen(LUA_FUNCS[i]));
if (0 == (strlen(buf) - word_pos.end - 1)) {
/* No Op */
} else {
memcpy(&ln_matched[word_pos.begin + strlen(LUA_FUNCS[i])], &buf[pos], strlen(buf) - pos + 1);
}
linenoiseAddCompletion(lc, ln_matched, pos + strlen(LUA_FUNCS[i]) - strlen(last_word));
free(ln_matched);
}
}
#if 0
// Lua global table completions
lua_pushglobaltable(ls);
lua_pushnil(ls);
while(0 != lua_next(ls, -2)) {
if ( 0 == devi_lfind(lua_tostring(ls, -2), last_word)) {
char* ss = lua_tostring(ls, -2);
ln_matched = malloc(strlen(buf) + strlen(ss) - strlen(last_word) + 1);
ln_matched[strlen(buf) + strlen(ss) - strlen(last_word)] = '\0';
memcpy(ln_matched, buf, word_pos.begin);
memcpy(&ln_matched[word_pos.begin], ss, strlen(ss));
if (0 == (strlen(buf) - word_pos.end - 1)) {
/* No Op */
} else {
memcpy(&ln_matched[word_pos.begin + strlen(ss)], &buf[pos], strlen(buf) - pos + 1);
}
linenoiseAddCompletion(lc, ln_matched, pos + strlen(ss) - strlen(last_word));
free(ln_matched);
}
lua_pop(ls, 1);
}
lua_pop(ls, 1);
#endif
free(last_word);
}
}
char* shell_hint(const char* buf, int* color, int* bold) {
if (NULL != buf) {
*color = 35;
*bold = 0;
} else {
return "";
}
int last_word_index = devi_find_last_word(buf, ID_BREAKERS, NELEMS(ID_BREAKERS));
char* last_word = malloc(strlen(buf) - last_word_index+1);
last_word[strlen(buf) - last_word_index] = '\0';
memcpy(last_word, &buf[last_word_index], strlen(buf) - last_word_index);
char* ln_matched;
for(int i=0; i < NELEMS(LUA_FUNCS); ++i) {
size_t match_index = devi_lfind(LUA_FUNCS[i], last_word);
if (0 == match_index) {
ln_matched = malloc(strlen(LUA_FUNCS[i])-strlen(last_word)+1);
ln_matched[strlen(LUA_FUNCS[i]) - strlen(last_word)] = '\0';
memcpy(ln_matched, &LUA_FUNCS[i][match_index+strlen(last_word)], strlen(LUA_FUNCS[i]) - strlen(last_word));
free(last_word);
return ln_matched;
}
}
#if 0
lua_pushglobaltable(ls);
lua_pushnil(ls);
while(0 != lua_next(ls, -2)) {
size_t match_index = devi_lfind(lua_tostring(ls, -2), last_word);
if (0 == match_index) {
ln_matched = malloc(strlen(lua_tostring(ls, -2))-strlen(last_word)+1);
ln_matched[strlen(lua_tostring(ls, -2)) - strlen(last_word)] = '\0';
memcpy(ln_matched, &lua_tostring(ls, -2)[match_index+strlen(last_word)], strlen(lua_tostring(ls, -2)) - strlen(last_word));
free(last_word);
return ln_matched;
}
lua_pop(ls, 1);
}
lua_pop(ls, 1);
#endif
free(last_word);
return NULL;
}
/**********************************************************************************************************************/
/*last line intentionally left blank*/
