IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

vim-patch:8.2.3184: cannot add a digraph with a leading space

Browse Source 
Problem:    Cannot add a digraph with a leading space.  It is not easy to list
            existing digraphs.
Solution:   Add setdigraph(), setdigraphlist(), getdigraph() and
            getdigraphlist(). (closes vim/vim#8580)
6106504e9e

Use GA_APPEND_VIA_PTR in registerdigraph().
Use tv_list_append_*() in getdigraphlist_appendpair().
Put the error messages in digraph.c.
E196 is N/A.
Remove mentions about 'encoding' being non-Unicode.
Nvim doesn't support setting encoding=japan, so skip a test.
This commit is contained in:
zeertzjq 2022-02-17 15:23:17 +08:00
parent 7e1e906738
commit cbc54cf484
8 changed files with 407 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
runtime/doc/builtin.txt
View File

@ -185,6 +185,8 @@ getcompletion({pat}, {type} [, {filtered}])
getcurpos([{winnr}]) List position of the cursor
getcursorcharpos([{winnr}]) List character position of the cursor
getcwd([{winnr} [, {tabnr}]]) String get the current working directory
getdigraph({chars}) String get the digraph of {chars}
getdigraphlist([{listall}]) List get all |digraph|s
getenv({name}) String return environment variable
getfontname([{name}]) String name of font being used
getfperm({fname}) String file permissions of file {fname}
@ -402,6 +404,8 @@ setcharpos({expr}, {list}) Number set the {expr} position to {list}
setcharsearch({dict}) Dict set character search from {dict}
setcmdpos({pos}) Number set cursor position in command-line
setcursorcharpos({list}) Number move cursor to position in {list}
setdigraph({chars}, {digraph}) Boolean register |digraph|
setdigraphlist({digraphlist}) Boolean register multiple |digraph|s
setenv({name}, {val}) none set environment variable
setfperm({fname}, {mode} Number set {fname} file permissions to {mode}
setline({lnum}, {line}) Number set line {lnum} to {line}
@ -2891,6 +2895,45 @@ getcwd([{winnr} [, {tabnr}]]) *getcwd()*
Can also be used as a |method|: >
GetWinnr()->getcwd()
<
getdigraph({chars}) *getdigraph()* *E1214*
Return the digraph of {chars}. This should be a string with
exactly two characters. If {chars} are not just two
characters, or the digraph of {chars} does not exist, an error
is given and an empty string is returned.
Also see |getdigraphlist()|.
Examples: >
" Get a built-in digraph
:echo getdigraph('00') " Returns '∞'
" Get a user-defined digraph
:call setdigraph('aa', 'あ')
:echo getdigraph('aa') " Returns 'あ'
<
Can also be used as a |method|: >
GetChars()->getdigraph()
<
getdigraphlist([{listall}]) *getdigraphlist()*
Return a list of digraphs. If the {listall} argument is given
and it is TRUE, return all digraphs, including the default
digraphs. Otherwise, return only user-defined digraphs.
Also see |getdigraph()|.
Examples: >
" Get user-defined digraphs
:echo getdigraphlist()
" Get all the digraphs, including default digraphs
:echo digraphlist(1)
<
Can also be used as a |method|: >
GetNumber()->getdigraphlist()
<
getenv({name}) *getenv()*
Return the value of environment variable {name}. The {name}
@ -6734,6 +6777,46 @@ setcursorcharpos({list})
Can also be used as a |method|: >
GetCursorPos()->setcursorcharpos()
setdigraph({chars}, {digraph}) *setdigraph()* *E1205*
Add digraph {chars} to the list. {chars} must be a string
with two characters. {digraph} is a string with one utf-8
encoded character. Be careful, composing characters are NOT
ignored. This function is similar to |:digraphs| command, but
useful to add digraphs start with a white space.
The function result is v:true if |digraph| is registered. If
this fails an error message is given and v:false is returned.
If you want to define multiple digraphs at once, you can use
|setdigraphlist()|.
Example: >
call setdigraph(' ', 'あ')
<
Can be used as a |method|: >
GetString()->setdigraph('あ')
<
setdigraphlist({digraphlist}) *setdigraphlist()*
Similar to |setdigraph()| but this function can add multiple
digraphs at once. {digraphlist} is a list composed of lists,
where each list contains two strings with {chars} and
{digraph} as in |setdigraph()|.
Example: >
call setdigraphlist([['aa', 'あ'], ['ii', 'い']])
<
It is similar to the following: >
for [chars, digraph] in [['aa', 'あ'], ['ii', 'い']]
call setdigraph(chars, digraph)
endfor
< Except that the function returns after the first error,
following digraphs will not be added.
Can be used as a |method|: >
GetList()->setdigraphlist()
<
setenv({name}, {val}) *setenv()*
Set environment variable {name} to {val}. Example: >
call setenv('HOME', '/home/myhome')

3
runtime/doc/digraph.txt
View File

@ -35,6 +35,9 @@ An alternative is using the 'keymap' option.
< Avoid defining a digraph with '_' (underscore) as the
first character, it has a special meaning in the
future.
NOTE: This command cannot add a digraph that starts
with a white space. If you want to add such digraph,
you can use |setdigraph()| instead.
Example of the output of ":digraphs": >
TH Þ 222 ss ß 223 a! à 224 a' á 225 a> â 226 a? ã 227 a: ä 228

4
runtime/doc/usr_41.txt
View File

@ -964,6 +964,10 @@ Mappings: *mapping-functions*
mapcheck() check if a matching mapping exists
maparg() get rhs of a mapping
wildmenumode() check if the wildmode is active
getdigraph() get |digraph|
getdigraphlist() get all |digraph|s
setdigraph() register |digraph|
setdigraphlist() register multiple |digraph|s
Signs: *sign-functions*
sign_define() define or update a sign

257
src/nvim/digraph.c
View File

@ -12,6 +12,7 @@
#include "nvim/ascii.h"
#include "nvim/charset.h"
#include "nvim/digraph.h"
#include "nvim/eval/typval.h"
#include "nvim/ex_cmds2.h"
#include "nvim/ex_docmd.h"
#include "nvim/ex_getln.h"
@ -34,6 +35,12 @@ typedef struct digraph {
result_T result;
} digr_T;
static char e_digraph_must_be_just_two_characters_str[]
= N_("E1214: Digraph must be just two characters: %s");
static char e_digraph_argument_must_be_one_character_str[]
= N_("E1215: Digraph must be one character: %s");
static char e_setdigraphlist_argument_must_be_list_of_lists_with_two_items[]
= N_("E1216: setdigraphlist() argument must be a list of lists with two items");
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "digraph.c.generated.h"
@ -1607,6 +1614,44 @@ int getdigraph(int char1, int char2, bool meta_char)
return retval;
}
/// Add a digraph to the digraph table.
static void registerdigraph(int char1, int char2, int n)
{
// If the digraph already exists, replace "result".
digr_T *dp = (digr_T *)user_digraphs.ga_data;
for (int i = 0; i < user_digraphs.ga_len; i++) {
if ((int)dp->char1 == char1 && (int)dp->char2 == char2) {
dp->result = n;
return;
}
dp++;
}
// Add a new digraph to the table.
dp = GA_APPEND_VIA_PTR(digr_T, &user_digraphs);
dp->char1 = (char_u)char1;
dp->char2 = (char_u)char2;
dp->result = n;
}
/// Check the characters are valid for a digraph.
/// If they are valid, returns true; otherwise, give an error message and
/// returns false.
bool check_digraph_chars_valid(int char1, int char2)
{
if (char2 == 0) {
char_u msg[MB_MAXBYTES + 1];
msg[utf_char2bytes(char1, msg)] = NUL;
semsg(_(e_digraph_must_be_just_two_characters_str), msg);
return false;
}
if (char1 == ESC || char2 == ESC) {
emsg(_("E104: Escape not allowed in digraph"));
return false;
}
return true;
}
/// Add the digraphs in the argument to the digraph table.
/// format: {c1}{c2} char {c1}{c2} char ...
///
@ -1622,15 +1667,10 @@ void putdigraph(char_u *str)
char_u char1 = *str++;
char_u char2 = *str++;
if (char2 == 0) {
emsg(_(e_invarg));
if (!check_digraph_chars_valid(char1, char2)) {
return;
}
if ((char1 == ESC) || (char2 == ESC)) {
emsg(_("E104: Escape not allowed in digraph"));
return;
}
str = skipwhite(str);
if (!ascii_isdigit(*str)) {
@ -1639,25 +1679,7 @@ void putdigraph(char_u *str)
}
int n = getdigits_int(&str, true, 0);
// If the digraph already exists, replace the result.
digr_T *dp = (digr_T *)user_digraphs.ga_data;
int i;
for (i = 0; i < user_digraphs.ga_len; i++) {
if (((int)dp->char1 == char1) && ((int)dp->char2 == char2)) {
dp->result = n;
break;
}
dp++;
}
// Add a new digraph to the table.
if (i == user_digraphs.ga_len) {
dp = GA_APPEND_VIA_PTR(digr_T, &user_digraphs);
dp->char1 = char1;
dp->char2 = char2;
dp->result = n;
}
registerdigraph(char1, char2, n);
}
}
@ -1707,6 +1729,50 @@ void listdigraphs(bool use_headers)
}
}
static void getdigraphlist_appendpair(digr_T *dp, list_T *l)
{
list_T *l2 = tv_list_alloc(2);
tv_list_append_list(l, l2);
char_u buf[30];
buf[0] = dp->char1;
buf[1] = dp->char2;
buf[2] = NUL;
tv_list_append_string(l2, (char *)buf, -1);
char_u *p = buf;
p += utf_char2bytes(dp->result, p);
*p = NUL;
tv_list_append_string(l2, (char *)buf, -1);
}
void getdigraphlist_common(bool list_all, typval_T *rettv)
{
tv_list_alloc_ret(rettv, (int)sizeof(digraphdefault) + user_digraphs.ga_len);
digr_T *dp;
if (list_all) {
dp = digraphdefault;
for (int i = 0; dp->char1 != NUL && !got_int; i++) {
digr_T tmp;
tmp.char1 = dp->char1;
tmp.char2 = dp->char2;
tmp.result = getexactdigraph(tmp.char1, tmp.char2, false);
if (tmp.result != 0 && tmp.result != tmp.char2) {
getdigraphlist_appendpair(&tmp, rettv->vval.v_list);
}
dp++;
}
}
dp = (digr_T *)user_digraphs.ga_data;
for (int i = 0; i < user_digraphs.ga_len && !got_int; i++) {
getdigraphlist_appendpair(dp, rettv->vval.v_list);
dp++;
}
}
struct dg_header_entry {
int dg_start;
const char *dg_header;
@ -1797,6 +1863,147 @@ static void printdigraph(const digr_T *dp, result_T *previous)
}
}
/// Get the two digraph characters from a typval.
/// @return OK or FAIL.
static int get_digraph_chars(typval_T *arg, int *char1, int *char2)
{
char buf_chars[NUMBUFLEN];
const char *chars = tv_get_string_buf_chk(arg, buf_chars);
const char_u *p = (const char_u *)chars;
if (p != NULL) {
if (*p != NUL) {
*char1 = mb_cptr2char_adv(&p);
if (*p != NUL) {
*char2 = mb_cptr2char_adv(&p);
if (*p == NUL) {
if (check_digraph_chars_valid(*char1, *char2)) {
return OK;
}
return FAIL;
}
}
}
}
semsg(_(e_digraph_must_be_just_two_characters_str), chars);
return FAIL;
}
static bool setdigraph_common(typval_T *argchars, typval_T *argdigraph)
{
int char1, char2;
if (get_digraph_chars(argchars, &char1, &char2) == FAIL) {
return false;
}
char buf_digraph[NUMBUFLEN];
const char *digraph = tv_get_string_buf_chk(argdigraph, buf_digraph);
if (digraph == NULL) {
return false;
}
const char_u *p = (const char_u *)digraph;
int n = mb_cptr2char_adv(&p);
if (*p != NUL) {
semsg(_(e_digraph_argument_must_be_one_character_str), digraph);
return false;
}
registerdigraph(char1, char2, n);
return true;
}
/// "getdigraph()" function
void f_getdigraph(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
rettv->v_type = VAR_STRING;
rettv->vval.v_string = NULL; // Return empty string for failure
const char *digraphs = tv_get_string_chk(&argvars[0]);
if (digraphs == NULL) {
return;
}
if (STRLEN(digraphs) != 2) {
semsg(_(e_digraph_must_be_just_two_characters_str), digraphs);
return;
}
int code = getdigraph(digraphs[0], digraphs[1], false);
char_u buf[NUMBUFLEN];
buf[utf_char2bytes(code, buf)] = NUL;
rettv->vval.v_string = vim_strsave(buf);
}
/// "getdigraphlist()" function
void f_getdigraphlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
bool flag_list_all;
if (argvars[0].v_type == VAR_UNKNOWN) {
flag_list_all = false;
} else {
bool error = false;
varnumber_T flag = tv_get_number_chk(&argvars[0], &error);
if (error) {
return;
}
flag_list_all = flag != 0;
}
getdigraphlist_common(flag_list_all, rettv);
}
/// "setdigraph()" function
void f_setdigraph(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
rettv->v_type = VAR_BOOL;
rettv->vval.v_bool = kBoolVarFalse;
if (!setdigraph_common(&argvars[0], &argvars[1])) {
return;
}
rettv->vval.v_bool = kBoolVarTrue;
}
/// "setdigraphlist()" function
void f_setdigraphlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
{
rettv->v_type = VAR_BOOL;
rettv->vval.v_bool = kBoolVarFalse;
if (argvars[0].v_type != VAR_LIST) {
emsg(_(e_setdigraphlist_argument_must_be_list_of_lists_with_two_items));
return;
}
list_T *pl = argvars[0].vval.v_list;
if (pl == NULL) {
// Empty list always results in success.
rettv->vval.v_bool = kBoolVarTrue;
return;
}
TV_LIST_ITER_CONST(pl, pli, {
if (TV_LIST_ITEM_TV(pli)->v_type != VAR_LIST) {
emsg(_(e_setdigraphlist_argument_must_be_list_of_lists_with_two_items));
return;
}
list_T *l = TV_LIST_ITEM_TV(pli)->vval.v_list;
if (l == NULL || tv_list_len(l) != 2) {
emsg(_(e_setdigraphlist_argument_must_be_list_of_lists_with_two_items));
return;
}
if (!setdigraph_common(TV_LIST_ITEM_TV(tv_list_first(l)),
TV_LIST_ITEM_TV(TV_LIST_ITEM_NEXT(l, tv_list_first(l))))) {
return;
}
});
rettv->vval.v_bool = kBoolVarTrue;
}
/// structure used for b_kmap_ga.ga_data
typedef struct {
char_u *from;

1
src/nvim/digraph.h
View File

@ -2,6 +2,7 @@
#define NVIM_DIGRAPH_H
#include "nvim/ex_cmds_defs.h"
#include "nvim/eval/funcs.h"
#include "nvim/types.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS

4
src/nvim/eval.lua
View File

@ -156,6 +156,8 @@ return {
getcurpos={args={0, 1}, base=1},
getcursorcharpos={args={0, 1}, base=1},
getcwd={args={0, 2}, base=1},
getdigraph={args=1, base=1},
getdigraphlist={args={0, 1}, base=1},
getenv={args=1, base=1},
getfontname={args={0, 1}},
getfperm={args=1, base=1},
@ -322,6 +324,8 @@ return {
setcharsearch={args=1, base=1},
setcmdpos={args=1, base=1},
setcursorcharpos={args={1, 3}, base=1},
setdigraph={args=2, base=1},
setdigraphlist={args=1, base=1},
setenv={args=2, base=2},
setfperm={args=2, base=1},
setline={args=2, base=2},

1
src/nvim/eval/funcs.c
View File

@ -15,6 +15,7 @@
#include "nvim/charset.h"
#include "nvim/context.h"
#include "nvim/cursor.h"
#include "nvim/digraph.h"
#include "nvim/diff.h"
#include "nvim/edit.h"
#include "nvim/eval.h"

80
src/nvim/testdir/test_digraph.vim
View File

@ -212,7 +212,7 @@ func Test_digraphs()
call Put_Dig("el")
call assert_equal(['␀', 'ü', '∞', 'l'], getline(line('.')-3,line('.')))
call assert_fails('digraph xy z', 'E39:')
call assert_fails('digraph x', 'E474:')
call assert_fails('digraph x', 'E1214:')
bw!
endfunc
@ -505,4 +505,82 @@ func Test_entering_digraph()
call StopVimInTerminal(buf)
endfunc
func Test_setdigraph_function()
new
call setdigraph('aa', 'あ')
call Put_Dig('aa')
call assert_equal('あ', getline('$'))
call setdigraph(' i', 'い')
call Put_Dig(' i')
call assert_equal('い', getline('$'))
call setdigraph(' ', 'う')
call Put_Dig(' ')
call assert_equal('う', getline('$'))
eval 'aa'->setdigraph('え')
call Put_Dig('aa')
call assert_equal('え', getline('$'))
call assert_fails('call setdigraph("aaa", "あ")', 'E1214: Digraph must be just two characters: aaa')
call assert_fails('call setdigraph("b", "あ")', 'E1214: Digraph must be just two characters: b')
call assert_fails('call setdigraph("あ", "あ")', 'E1214: Digraph must be just two characters: あ')
call assert_fails('call setdigraph("aa", "ああ")', 'E1215: Digraph must be one character: ああ')
call assert_fails('call setdigraph("aa", "か" .. nr2char(0x3099))', 'E1215: Digraph must be one character: か' .. nr2char(0x3099))
bwipe!
endfunc
func Test_getdigraph_function()
" Built-in digraphs
call assert_equal('∞', getdigraph('00'))
" User-defined digraphs
call setdigraph('aa', 'あ')
call setdigraph(' i', 'い')
call setdigraph(' ', 'う')
call assert_equal('あ', getdigraph('aa'))
call assert_equal('あ', 'aa'->getdigraph())
call assert_equal('い', getdigraph(' i'))
call assert_equal('う', getdigraph(' '))
call assert_fails('call getdigraph("aaa")', 'E1214: Digraph must be just two characters: aaa')
call assert_fails('call getdigraph("b")', 'E1214: Digraph must be just two characters: b')
endfunc
func Test_getdigraph_function_encode()
throw 'Skipped: Nvim does not support setting encoding=japan'
CheckFeature iconv
let testcases = {
\'00': '∞',
\'aa': 'あ',
\}
for [key, ch] in items(testcases)
call setdigraph(key, ch)
set encoding=japan
call assert_equal(iconv(ch, 'utf-8', 'japan'), getdigraph(key))
set encoding&
endfor
endfunc
func Test_setdigraphlist_function()
call setdigraphlist([['aa', 'き'], ['bb', 'く']])
call assert_equal('き', getdigraph('aa'))
call assert_equal('く', getdigraph('bb'))
call assert_fails('call setdigraphlist([[]])', 'E1216:')
call assert_fails('call setdigraphlist([["aa", "b", "cc"]])', '1216:')
call assert_fails('call setdigraphlist([["あ", "あ"]])', 'E1214: Digraph must be just two characters: あ')
endfunc
func Test_getdigraphlist_function()
" Make sure user-defined digraphs are defined
call setdigraphlist([['aa', 'き'], ['bb', 'く']])
for pair in getdigraphlist(1)
call assert_equal(getdigraph(pair[0]), pair[1])
endfor
" We don't know how many digraphs are registered before, so check the number
" of digraphs returned.
call assert_equal(getdigraphlist()->len(), getdigraphlist(0)->len())
call assert_notequal((getdigraphlist()->len()), getdigraphlist(1)->len())
endfunc
" vim: shiftwidth=2 sts=2 expandtab