1 /*
2 * Very simple multibyte buffer editor. Allows to maintaine the current
3 * position in the string, add and remove chars on the current position.
4 *
5 * This file may be distributed under the terms of the
6 * GNU Lesser General Public License.
7 *
8 * Copyright (C) 2017 Karel Zak <kzak@redhat.com>
9 */
10 #include <stdlib.h>
11 #include <string.h>
12 #include <errno.h>
13 #include <stdio.h>
14
15 #include "mbsalign.h"
16 #include "mbsedit.h"
17
18 struct mbs_editor *mbs_new_edit(char *buf, size_t bufsz, size_t ncells)
19 {
20 struct mbs_editor *edit = calloc(1, sizeof(*edit));
21
22 if (edit) {
23 edit->buf = buf;
24 edit->max_bytes = bufsz;
25 edit->max_cells = ncells;
26 edit->cur_cells = mbs_safe_width(buf);
27 edit->cur_bytes = strlen(buf);
28 }
29 return edit;
30 }
31
32 char *mbs_free_edit(struct mbs_editor *edit)
33 {
34 char *ret = edit ? edit->buf : NULL;
35
36 free(edit);
37 return ret;
38 }
39
40 static size_t mbs_next(const char *str, size_t *ncells)
41 {
42 #ifdef HAVE_WIDECHAR
43 wchar_t wc;
44 size_t n = 0;
45
46 if (!str || !*str)
47 return 0;
48
49 n = mbrtowc(&wc, str, MB_CUR_MAX, NULL);
50 *ncells = wcwidth(wc);
51 return n;
52 #else
53 if (!str || !*str)
54 return 0;
55 *ncells = 1;
56 return 1;
57 #endif
58 }
59
60 static size_t mbs_prev(const char *start, const char *end, size_t *ncells)
61 {
62 #ifdef HAVE_WIDECHAR
63 wchar_t wc = 0;
64 const char *p, *prev;
65 size_t n = 0;
66
67 if (!start || !end || start == end || !*start)
68 return 0;
69
70 prev = p = start;
71 while (p < end) {
72 n = mbrtowc(&wc, p, MB_CUR_MAX, NULL);
73 prev = p;
74
75 if (n == (size_t) -1 || n == (size_t) -2)
76 p++;
77 else
78 p += n;
79 }
80
81 if (prev == end)
82 return 0;
83 *ncells = wcwidth(wc);
84 return n;
85 #else
86 if (!start || !end || start == end || !*start)
87 return 0;
88 *ncells = 1;
89 return 1;
90 #endif
91 }
92
93 int mbs_edit_goto(struct mbs_editor *edit, int where)
94 {
95 switch (where) {
96 case MBS_EDIT_LEFT:
97 if (edit->cursor == 0)
98 return 1;
99 else {
100 size_t n, cells;
101 n = mbs_prev(edit->buf, edit->buf + edit->cursor, &cells);
102 if (n) {
103 edit->cursor -= n;
104 edit->cursor_cells -= cells;
105 }
106 }
107 break;
108 case MBS_EDIT_RIGHT:
109 if (edit->cursor_cells >= edit->cur_cells)
110 return 1;
111 else {
112 size_t n, cells;
113 n = mbs_next(edit->buf + edit->cursor, &cells);
114 if (n) {
115 edit->cursor += n;
116 edit->cursor_cells += cells;
117 }
118 }
119 break;
120 case MBS_EDIT_HOME:
121 edit->cursor = 0;
122 edit->cursor_cells = 0;
123 break;
124 case MBS_EDIT_END:
125 edit->cursor = edit->cur_bytes;
126 edit->cursor_cells = edit->cur_cells;
127 break;
128 default:
129 return -EINVAL;
130 }
131
132 return 0;
133 }
134
135 /* Remove next MB from @str, returns number of removed bytes */
136 static size_t remove_next(char *str, size_t *ncells)
137 {
138 /* all in bytes! */
139 size_t bytes, move_bytes, n;
140
141 n = mbs_next(str, ncells);
142 bytes = strlen(str);
143 move_bytes = bytes - n;
144
145 memmove(str, str + n, move_bytes);
146 str[bytes - n] = '\0';
147 return n;
148 }
149
150 static size_t mbs_insert(char *str, wint_t c, size_t *ncells)
151 {
152 /* all in bytes! */
153 size_t n = 1, bytes;
154 char *in;
155
156 #ifdef HAVE_WIDECHAR
157 wchar_t wc = (wchar_t) c;
158 char in_buf[MB_CUR_MAX];
159
160 n = wctomb(in_buf, wc);
161 if (n == (size_t) -1)
162 return n;
163 *ncells = wcwidth(wc);
164 in = in_buf;
165 #else
166 *ncells = 1;
167 in = (char *) &c;
168 #endif
169 bytes = strlen(str);
170
171 memmove(str + n, str, bytes);
172 memcpy(str, in, n);
173 str[bytes + n] = '\0';
174 return n;
175 }
176
177 static int mbs_edit_remove(struct mbs_editor *edit)
178 {
179 size_t n, ncells;
180
181 if (edit->cur_cells == 0 || edit->cursor >= edit->cur_bytes)
182 return 1;
183
184 n = remove_next(edit->buf + edit->cursor, &ncells);
185 if (n == (size_t)-1)
186 return 1;
187
188 edit->cur_bytes -= n;
189 edit->cur_cells = mbs_safe_width(edit->buf);
190 return 0;
191 }
192
193 int mbs_edit_delete(struct mbs_editor *edit)
194 {
195 if (edit->cursor >= edit->cur_bytes
196 && mbs_edit_goto(edit, MBS_EDIT_LEFT) == 1)
197 return 1;
198
199 return mbs_edit_remove(edit);
200 }
201
202 int mbs_edit_backspace(struct mbs_editor *edit)
203 {
204 if (mbs_edit_goto(edit, MBS_EDIT_LEFT) == 0)
205 return mbs_edit_remove(edit);
206 return 1;
207 }
208
209 int mbs_edit_insert(struct mbs_editor *edit, wint_t c)
210 {
211 size_t n, ncells;
212
213 if (edit->cur_bytes + MB_CUR_MAX > edit->max_bytes)
214 return 1;
215
216 n = mbs_insert(edit->buf + edit->cursor, c, &ncells);
217 if (n == (size_t)-1)
218 return 1;
219
220 edit->cursor += n;
221 edit->cursor_cells += ncells;
222 edit->cur_bytes += n;
223 edit->cur_cells = mbs_safe_width(edit->buf);
224 return 0;
225 }