catboy/edit.c

216 lines
4.9 KiB
C
Raw Normal View History

/* Copyright (C) 2020 C. McEnroe <june@causal.agency>
*
* 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, see <https://www.gnu.org/licenses/>.
*/
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
2020-02-09 12:32:35 +00:00
#include <wctype.h>
#include "chat.h"
enum { Cap = 512 };
static wchar_t buf[Cap];
static size_t len;
static size_t pos;
char *editBuffer(size_t *mbsPos) {
static char mbs[MB_LEN_MAX * Cap];
const wchar_t *ptr = buf;
size_t mbsLen = wcsnrtombs(mbs, &ptr, pos, sizeof(mbs) - 1, NULL);
assert(mbsLen != (size_t)-1);
if (mbsPos) *mbsPos = mbsLen;
ptr = &buf[pos];
size_t n = wcsnrtombs(
&mbs[mbsLen], &ptr, len - pos, sizeof(mbs) - mbsLen - 1, NULL
);
assert(n != (size_t)-1);
mbsLen += n;
mbs[mbsLen] = '\0';
return mbs;
}
static struct {
wchar_t buf[Cap];
size_t len;
} cut;
static bool reserve(size_t index, size_t count) {
if (len + count > Cap) return false;
2020-02-07 06:55:26 +00:00
memmove(&buf[index + count], &buf[index], sizeof(*buf) * (len - index));
len += count;
return true;
2020-02-07 06:55:26 +00:00
}
static void delete(bool copy, size_t index, size_t count) {
2020-02-07 06:55:26 +00:00
if (index + count > len) return;
if (copy) {
memcpy(cut.buf, &buf[index], sizeof(*buf) * count);
cut.len = count;
}
2020-02-07 06:55:26 +00:00
memmove(
&buf[index], &buf[index + count], sizeof(*buf) * (len - index - count)
);
len -= count;
}
2020-02-09 07:33:53 +00:00
static struct {
size_t pos;
size_t pre;
size_t len;
} tab;
static void tabComplete(uint id) {
2020-02-09 07:33:53 +00:00
if (!tab.len) {
tab.pos = pos;
while (tab.pos && buf[tab.pos - 1] != L' ') tab.pos--;
if (tab.pos == pos) return;
tab.pre = pos - tab.pos;
tab.len = tab.pre;
}
2020-02-09 19:17:04 +00:00
char mbs[MB_LEN_MAX * Cap];
2020-02-09 07:33:53 +00:00
const wchar_t *ptr = &buf[tab.pos];
size_t n = wcsnrtombs(mbs, &ptr, tab.pre, sizeof(mbs) - 1, NULL);
assert(n != (size_t)-1);
mbs[n] = '\0';
const char *comp = complete(id, mbs);
if (!comp) comp = complete(id, mbs);
if (!comp) {
tab.len = 0;
return;
}
2020-02-09 19:17:04 +00:00
wchar_t wcs[Cap];
2020-02-09 07:33:53 +00:00
n = mbstowcs(wcs, comp, sizeof(wcs));
assert(n != (size_t)-1);
if (tab.pos + n + 2 > Cap) {
completeReject();
tab.len = 0;
return;
}
delete(false, tab.pos, tab.len);
2020-02-09 07:33:53 +00:00
if (wcs[0] != L'/' && !tab.pos) {
tab.len = n + 2;
reserve(tab.pos, tab.len);
buf[tab.pos + n + 0] = L':';
buf[tab.pos + n + 1] = L' ';
} else if (
tab.pos >= 2 && (buf[tab.pos - 2] == L':' || buf[tab.pos - 2] == L',')
) {
tab.len = n + 2;
reserve(tab.pos, tab.len);
buf[tab.pos - 2] = L',';
buf[tab.pos + n + 0] = L':';
buf[tab.pos + n + 1] = L' ';
} else {
tab.len = n + 1;
reserve(tab.pos, tab.len);
buf[tab.pos + n] = L' ';
}
memcpy(&buf[tab.pos], wcs, sizeof(*wcs) * n);
pos = tab.pos + tab.len;
}
static void tabAccept(void) {
completeAccept();
tab.len = 0;
}
static void tabReject(void) {
completeReject();
tab.len = 0;
}
void edit(uint id, enum Edit op, wchar_t ch) {
2020-02-09 07:33:53 +00:00
size_t init = pos;
switch (op) {
break; case EditHead: pos = 0;
break; case EditTail: pos = len;
break; case EditPrev: if (pos) pos--;
break; case EditNext: if (pos < len) pos++;
2020-02-09 09:20:07 +00:00
break; case EditPrevWord: {
if (pos) pos--;
2020-02-09 12:32:35 +00:00
while (pos && !iswspace(buf[pos - 1])) pos--;
2020-02-09 09:20:07 +00:00
}
break; case EditNextWord: {
if (pos < len) pos++;
2020-02-09 12:32:35 +00:00
while (pos < len && !iswspace(buf[pos])) pos++;
2020-02-09 09:20:07 +00:00
}
break; case EditDeleteHead: delete(true, 0, pos); pos = 0;
break; case EditDeleteTail: delete(true, pos, len - pos);
break; case EditDeletePrev: if (pos) delete(false, --pos, 1);
break; case EditDeleteNext: delete(false, pos, 1);
2020-02-09 09:32:32 +00:00
break; case EditDeletePrevWord: {
if (!pos) break;
size_t word = pos - 1;
2020-02-09 12:32:35 +00:00
while (word && !iswspace(buf[word - 1])) word--;
delete(true, word, pos - word);
2020-02-09 09:32:32 +00:00
pos = word;
}
break; case EditDeleteNextWord: {
if (pos == len) break;
size_t word = pos + 1;
2020-02-09 12:32:35 +00:00
while (word < len && !iswspace(buf[word])) word++;
delete(true, pos, word - pos);
2020-02-09 09:32:32 +00:00
}
break; case EditPaste: {
if (reserve(pos, cut.len)) {
memcpy(&buf[pos], cut.buf, sizeof(*buf) * cut.len);
pos += cut.len;
}
}
2020-02-07 06:55:26 +00:00
break; case EditTranspose: {
if (!pos || len < 2) break;
if (pos == len) pos--;
2020-02-12 06:19:07 +00:00
wchar_t t = buf[pos - 1];
buf[pos - 1] = buf[pos];
buf[pos++] = t;
}
break; case EditInsert: {
if (reserve(pos, 1)) {
buf[pos++] = ch;
}
}
2020-02-08 02:30:25 +00:00
break; case EditComplete: {
2020-02-09 07:33:53 +00:00
tabComplete(id);
return;
2020-02-08 02:30:25 +00:00
}
break; case EditEnter: {
2020-02-09 07:33:53 +00:00
tabAccept();
command(id, editBuffer(NULL));
2020-02-09 07:33:53 +00:00
len = pos = 0;
return;
}
}
2020-02-09 07:33:53 +00:00
if (pos < init) {
tabReject();
} else {
tabAccept();
}
}