Repository navigation
Expand file tree
/
Copy pathlinenoise.c
More file actions
2801 lines (2536 loc) · 97.2 KB
/
Copy pathlinenoise.c
File metadata and controls
2801 lines (2536 loc) · 97.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* linenoise.c -- guerrilla line editing library against the idea that a
* line editing lib needs to be 20,000 lines of C code.
*
* You can find the latest source code at:
*
* http://github.com/antirez/linenoise
*
* Does a number of crazy assumptions that happen to be true in 99.9999% of
* the 2010 UNIX computers around.
*
* ------------------------------------------------------------------------
*
* Copyright (c) 2010-2023, Salvatore Sanfilippo <antirez at gmail dot com>
* Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ------------------------------------------------------------------------
*
* References:
* - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
* - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
*
* Todo list:
* - Filter bogus Ctrl+<char> combinations.
* - Win32 support
*
* Bloat:
* - History search like Ctrl+r in readline?
*
* List of escape sequences used by this program, we do everything just
* with three sequences. In order to be so cheap we may have some
* flickering effect with some slow terminal, but the lesser sequences
* the more compatible.
*
* EL (Erase Line)
* Sequence: ESC [ n K
* Effect: if n is 0 or missing, clear from cursor to end of line
* Effect: if n is 1, clear from beginning of line to cursor
* Effect: if n is 2, clear entire line
*
* CUF (CUrsor Forward)
* Sequence: ESC [ n C
* Effect: moves cursor forward n chars
*
* CUB (CUrsor Backward)
* Sequence: ESC [ n D
* Effect: moves cursor backward n chars
*
* The following is used to get the terminal width if getting
* the width with the TIOCGWINSZ ioctl fails
*
* DSR (Device Status Report)
* Sequence: ESC [ 6 n
* Effect: reports the current cursor position as ESC [ n ; m R
* where n is the row and m is the column
*
* When multi line mode is enabled, we also use an additional escape
* sequence. However multi line editing is disabled by default.
*
* CUU (Cursor Up)
* Sequence: ESC [ n A
* Effect: moves cursor up of n chars.
*
* CUD (Cursor Down)
* Sequence: ESC [ n B
* Effect: moves cursor down of n chars.
*
* When linenoiseClearScreen() is called, two additional escape sequences
* are used in order to clear the screen and position the cursor at home
* position.
*
* CUP (Cursor position)
* Sequence: ESC [ H
* Effect: moves the cursor to upper left corner
*
* ED (Erase display)
* Sequence: ESC [ 2 J
* Effect: clear the whole screen
*
*/
#include <termios.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdint.h>
#include "linenoise.h"
static struct {
char *text;
size_t len, cap;
int fd, depth;
} terminal_update;
static int terminalWrite(int fd, const char *text, size_t len) {
while (len) {
ssize_t n = write(fd, text, len);
if (n < 0 && errno == EINTR) continue;
if (n <= 0) { if (!n) errno = EIO; return -1; }
text += n;
len -= (size_t)n;
}
return 0;
}
int linenoiseWrite(int fd, const char *text, size_t len) {
if (!terminal_update.depth || terminal_update.fd != fd)
return terminalWrite(fd, text, len);
if (len > SIZE_MAX - terminal_update.len) { errno = ENOMEM; return -1; }
size_t need = terminal_update.len + len;
if (need > terminal_update.cap) {
size_t cap = need <= SIZE_MAX / 2 ? need * 2 : need;
char *p = realloc(terminal_update.text, cap);
if (!p) return -1;
terminal_update.text = p;
terminal_update.cap = cap;
}
if (len) memcpy(terminal_update.text + terminal_update.len, text, len);
terminal_update.len = need;
return 0;
}
void linenoiseBeginUpdate(int fd) {
if (terminal_update.depth++) return;
terminal_update.fd = fd;
terminal_update.len = 0;
linenoiseWrite(fd, "\x1b[?2026h", 8);
}
void linenoiseEndUpdate(void) {
if (!terminal_update.depth || terminal_update.depth > 1) {
if (terminal_update.depth) terminal_update.depth--;
return;
}
linenoiseWrite(terminal_update.fd, "\x1b[?2026l", 8);
terminal_update.depth = 0;
terminalWrite(terminal_update.fd, terminal_update.text, terminal_update.len);
free(terminal_update.text);
terminal_update.text = NULL;
terminal_update.len = terminal_update.cap = 0;
}
#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
#define LINENOISE_MAX_LINE (1024*1024) // That will get dynamically allocated
#define LINENOISE_INITIAL_BUFLEN 4096
#define PASTE_FOLD_THRESHOLD 200 // Min bytes to fold a single-line paste.
#define PASTE_FOLD_CONTEXT 8 // Context chars kept around generic folds.
#define HISTORY_FOLD_THRESHOLD 4096 // Min bytes to fold single-line history.
#define HISTORY_FOLD_MULTILINE_LINES 16 // Min lines to fold shorter history.
#define HISTORY_FOLD_CONTEXT 96 // Context chars kept around history folds.
#define PASTE_MAX_BYTES LINENOISE_MAX_LINE
static char *unsupported_term[] = {"dumb","cons25","emacs",NULL};
static linenoiseCompletionCallback *completionCallback = NULL;
static linenoiseHintsCallback *hintsCallback = NULL;
static linenoiseFreeHintsCallback *freeHintsCallback = NULL;
static char *linenoiseReadLine(FILE *fp, int *err);
static char *linenoiseNoTTY(void);
static void refreshLineWithCompletion(struct linenoiseState *ls, linenoiseCompletions *lc, int flags);
static void refreshLineWithFlags(struct linenoiseState *l, int flags);
static void linenoiseFoldClear(struct linenoiseState *l);
static struct termios orig_termios; /* In order to restore at exit.*/
static int maskmode = 0; /* Show "***" instead of input. For passwords. */
static int rawmode = 0; /* For atexit() function to check if restore is needed*/
static int rawmode_output = STDOUT_FILENO; /* fd used for terminal escapes. */
static int mlmode = 0; /* Multi line mode. Default is single line. */
static int atexit_registered = 0; /* Register atexit just 1 time. */
static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
static int history_len = 0;
static char **history = NULL;
/* =========================== UTF-8 support ================================ */
/* Return the number of bytes that compose the UTF-8 character starting at
* 'c'. This function assumes a valid UTF-8 encoding and handles the four
* standard byte patterns:
* 0xxxxxxx -> 1 byte (ASCII)
* 110xxxxx -> 2 bytes
* 1110xxxx -> 3 bytes
* 11110xxx -> 4 bytes */
static int utf8ByteLen(char c) {
unsigned char uc = (unsigned char)c;
if ((uc & 0x80) == 0) return 1; /* 0xxxxxxx: ASCII */
if ((uc & 0xE0) == 0xC0) return 2; /* 110xxxxx: 2-byte seq */
if ((uc & 0xF0) == 0xE0) return 3; /* 1110xxxx: 3-byte seq */
if ((uc & 0xF8) == 0xF0) return 4; /* 11110xxx: 4-byte seq */
return 1; /* Fallback for invalid encoding, treat as single byte. */
}
/* Decode a UTF-8 sequence starting at 's' into a Unicode codepoint.
* Returns the codepoint value. Assumes valid UTF-8 encoding. */
static uint32_t utf8DecodeChar(const char *s, size_t *len) {
unsigned char *p = (unsigned char *)s;
uint32_t cp;
if ((*p & 0x80) == 0) {
*len = 1;
return *p;
} else if ((*p & 0xE0) == 0xC0) {
*len = 2;
cp = (*p & 0x1F) << 6;
cp |= (p[1] & 0x3F);
return cp;
} else if ((*p & 0xF0) == 0xE0) {
*len = 3;
cp = (*p & 0x0F) << 12;
cp |= (p[1] & 0x3F) << 6;
cp |= (p[2] & 0x3F);
return cp;
} else if ((*p & 0xF8) == 0xF0) {
*len = 4;
cp = (*p & 0x07) << 18;
cp |= (p[1] & 0x3F) << 12;
cp |= (p[2] & 0x3F) << 6;
cp |= (p[3] & 0x3F);
return cp;
}
*len = 1;
return *p; /* Fallback for invalid sequences. */
}
/* Zero means more bytes are needed. Invalid sequences consume one byte. */
size_t linenoiseUtf8Decode(const char *s, size_t len, uint32_t *cp) {
if (!len) return 0;
unsigned char lead = (unsigned char)s[0];
size_t n = (size_t)utf8ByteLen(s[0]);
*cp = 0xfffd;
if (lead < 0x80) { *cp = lead; return 1; }
if (lead < 0xc2 || lead > 0xf4) return 1;
for (size_t i = 1; i < n && i < len; i++)
if (((unsigned char)s[i] & 0xc0) != 0x80) return 1;
if (len < n) return 0;
size_t decoded;
uint32_t value = utf8DecodeChar(s, &decoded);
if (value > 0x10ffff || (value >= 0xd800 && value <= 0xdfff) ||
(n == 3 && value < 0x800) || (n == 4 && value < 0x10000)) return 1;
*cp = value;
return n;
}
/* Check if codepoint is a variation selector (emoji style modifiers). */
static int isVariationSelector(uint32_t cp) {
return cp == 0xFE0E || cp == 0xFE0F; /* Text/emoji style */
}
/* Check if codepoint is a skin tone modifier. */
static int isSkinToneModifier(uint32_t cp) {
return cp >= 0x1F3FB && cp <= 0x1F3FF;
}
/* Check if codepoint is Zero Width Joiner. */
static int isZWJ(uint32_t cp) {
return cp == 0x200D;
}
/* Check if codepoint is a Regional Indicator (for flag emoji). */
static int isRegionalIndicator(uint32_t cp) {
return cp >= 0x1F1E6 && cp <= 0x1F1FF;
}
/* Check if codepoint is a combining mark or other zero-width character. */
static int isCombiningMark(uint32_t cp) {
return (cp >= 0x0300 && cp <= 0x036F) || /* Combining Diacriticals */
(cp >= 0x1AB0 && cp <= 0x1AFF) || /* Combining Diacriticals Extended */
(cp >= 0x1DC0 && cp <= 0x1DFF) || /* Combining Diacriticals Supplement */
(cp >= 0x20D0 && cp <= 0x20FF) || /* Combining Diacriticals for Symbols */
(cp >= 0xFE20 && cp <= 0xFE2F); /* Combining Half Marks */
}
/* Check if codepoint extends the previous character (doesn't start a new grapheme). */
static int isGraphemeExtend(uint32_t cp) {
return isVariationSelector(cp) || isSkinToneModifier(cp) ||
isZWJ(cp) || isCombiningMark(cp);
}
/* Decode the UTF-8 codepoint ending at position 'pos' (exclusive) and
* return its value. Also sets *cplen to the byte length of the codepoint. */
static uint32_t utf8DecodePrev(const char *buf, size_t pos, size_t *cplen) {
if (pos == 0) {
*cplen = 0;
return 0;
}
/* Scan backwards to find the start byte. */
size_t i = pos;
do {
i--;
} while (i > 0 && (pos - i) < 4 && ((unsigned char)buf[i] & 0xC0) == 0x80);
*cplen = pos - i;
size_t dummy;
return utf8DecodeChar(buf + i, &dummy);
}
/* Given a buffer and a position, return the byte length of the grapheme
* cluster before that position. A grapheme cluster includes:
* - The base character
* - Any following variation selectors, skin tone modifiers
* - ZWJ sequences (emoji joined by Zero Width Joiner)
* - Regional indicator pairs (flag emoji) */
static size_t utf8PrevCharLen(const char *buf, size_t pos) {
if (pos == 0) return 0;
size_t total = 0;
size_t curpos = pos;
/* First, get the last codepoint. */
size_t cplen;
uint32_t cp = utf8DecodePrev(buf, curpos, &cplen);
if (cplen == 0) return 0;
total += cplen;
curpos -= cplen;
/* If we're at an extending character, we need to find what it extends.
* Keep going back through the grapheme cluster. */
while (curpos > 0) {
size_t prevlen;
uint32_t prevcp = utf8DecodePrev(buf, curpos, &prevlen);
if (prevlen == 0) break;
if (isZWJ(prevcp)) {
/* ZWJ joins two emoji. Include the ZWJ and continue to get
* the preceding character. */
total += prevlen;
curpos -= prevlen;
/* Now get the character before ZWJ. */
prevcp = utf8DecodePrev(buf, curpos, &prevlen);
if (prevlen == 0) break;
total += prevlen;
curpos -= prevlen;
cp = prevcp;
continue; /* Check if there's more extending before this. */
} else if (isGraphemeExtend(cp)) {
/* Current cp is an extending character; include previous. */
total += prevlen;
curpos -= prevlen;
cp = prevcp;
continue;
} else if (isRegionalIndicator(cp) && isRegionalIndicator(prevcp)) {
/* Two regional indicators form a flag. But we need to be careful:
* flags are always pairs, so only join if we're at an even boundary.
* For simplicity, just join one pair. */
total += prevlen;
curpos -= prevlen;
break;
} else {
/* No more extending; we've found the start of the cluster. */
break;
}
}
return total;
}
/* Given a buffer, position and total length, return the byte length of the
* grapheme cluster at the current position. */
static size_t utf8NextCharLen(const char *buf, size_t pos, size_t len) {
if (pos >= len) return 0;
size_t n = linenoiseNextGrapheme(buf + pos, len - pos, NULL);
return n ? n : 1;
}
/* Return the display width of a Unicode codepoint. This is a heuristic
* that works for most common cases:
* - Control chars and zero-width: 0 columns
* - Grapheme-extending chars (VS, skin tone, ZWJ): 0 columns
* - ASCII printable: 1 column
* - Wide chars (CJK, emoji, fullwidth): 2 columns
* - Everything else: 1 column
*
* This is not a full wcwidth() implementation, but a minimal heuristic
* that handles emoji and CJK characters reasonably well. */
static int utf8CharWidth(uint32_t cp) {
/* Control characters and combining marks: zero width. */
if (cp < 32 || (cp >= 0x7F && cp < 0xA0)) return 0;
if (isCombiningMark(cp)) return 0;
/* Grapheme-extending characters: zero width.
* These modify the preceding character rather than taking space. */
if (isVariationSelector(cp)) return 0;
if (isSkinToneModifier(cp)) return 0;
if (isZWJ(cp)) return 0;
/* Wide character ranges - these display as 2 columns:
* - CJK Unified Ideographs and Extensions
* - Fullwidth forms
* - Various emoji ranges */
if (cp >= 0x1100 &&
(cp <= 0x115F || /* Hangul Jamo */
cp == 0x2329 || cp == 0x232A || /* Angle brackets */
(cp >= 0x231A && cp <= 0x231B) || /* Watch, Hourglass */
(cp >= 0x23E9 && cp <= 0x23F3) || /* Various symbols */
(cp >= 0x23F8 && cp <= 0x23FA) || /* Various symbols */
(cp >= 0x25AA && cp <= 0x25AB) || /* Small squares */
(cp >= 0x25FB && cp <= 0x25FE) || /* Squares */
(cp >= 0x2600 && cp <= 0x26FF) || /* Misc Symbols (sun, cloud, etc) */
(cp >= 0x2700 && cp <= 0x27BF) || /* Dingbats (❤, ✂, etc) */
(cp >= 0x2934 && cp <= 0x2935) || /* Arrows */
(cp >= 0x2B05 && cp <= 0x2B07) || /* Arrows */
(cp >= 0x2B1B && cp <= 0x2B1C) || /* Squares */
cp == 0x2B50 || cp == 0x2B55 || /* Star, circle */
(cp >= 0x2E80 && cp <= 0xA4CF &&
cp != 0x303F) || /* CJK ... Yi */
(cp >= 0xAC00 && cp <= 0xD7A3) || /* Hangul Syllables */
(cp >= 0xF900 && cp <= 0xFAFF) || /* CJK Compatibility Ideographs */
(cp >= 0xFE10 && cp <= 0xFE1F) || /* Vertical forms */
(cp >= 0xFE30 && cp <= 0xFE6F) || /* CJK Compatibility Forms */
(cp >= 0xFF00 && cp <= 0xFF60) || /* Fullwidth Forms */
(cp >= 0xFFE0 && cp <= 0xFFE6) || /* Fullwidth Signs */
(cp >= 0x1F1E6 && cp <= 0x1F1FF) || /* Regional Indicators (flags) */
(cp >= 0x1F300 && cp <= 0x1F64F) || /* Misc Symbols and Emoticons */
(cp >= 0x1F680 && cp <= 0x1F6FF) || /* Transport and Map Symbols */
(cp >= 0x1F900 && cp <= 0x1F9FF) || /* Supplemental Symbols */
(cp >= 0x1FA00 && cp <= 0x1FAFF) || /* Chess, Extended-A */
(cp >= 0x20000 && cp <= 0x2FFFF))) /* CJK Extension B and beyond */
return 2;
return 1; /* Default: single width */
}
int linenoiseCharacterWidth(uint32_t cp) {
return utf8CharWidth(cp);
}
size_t linenoiseNextGrapheme(const char *s, size_t len, int *width) {
uint32_t cp;
size_t used = linenoiseUtf8Decode(s, len, &cp);
if (!used) { if (width) *width = 0; return 0; }
int w = utf8CharWidth(cp), regional = isRegionalIndicator(cp), joined = 0;
while (used < len) {
size_t n = linenoiseUtf8Decode(s + used, len - used, &cp);
if (!n) break;
if (joined) {
if (utf8CharWidth(cp) > w) w = utf8CharWidth(cp);
joined = 0;
} else if (isZWJ(cp)) {
joined = 1;
} else if (isGraphemeExtend(cp)) {
if (cp == 0xfe0f && w) w = 2;
} else if (regional && isRegionalIndicator(cp)) {
regional = 0;
} else break;
used += n;
}
if (width) *width = w;
return used;
}
/* If s[] points at an ANSI CSI escape sequence (e.g. a color change like
* ESC [ 1 ; 32 m), return its length in bytes. Otherwise return 0.
*
* The caller must have already verified that s[0] == ESC (0x1b). The
* sequence layout follows ECMA-48: ESC '[' , parameter bytes (0x30-0x3f),
* intermediate bytes (0x20-0x2f), and a final byte (0x40-0x7e). */
static size_t ansiEscapeLen(const char *s, size_t len) {
size_t i;
if (len < 2 || s[1] != '[') return 0;
i = 2;
while (i < len && (unsigned char)s[i] >= 0x30 && (unsigned char)s[i] <= 0x3f) i++;
while (i < len && (unsigned char)s[i] >= 0x20 && (unsigned char)s[i] <= 0x2f) i++;
if (i >= len || (unsigned char)s[i] < 0x40 || (unsigned char)s[i] > 0x7e) return 0;
return i + 1;
}
/* Calculate the display width of a UTF-8 string of 'len' bytes.
* This is used for cursor positioning in the terminal.
* Handles grapheme clusters: characters joined by ZWJ contribute 0 width
* after the first character in the sequence.
* ANSI CSI escape sequences (e.g. color codes in the prompt) are treated
* as zero-width. */
static size_t utf8StrWidth(const char *s, size_t len) {
size_t width = 0;
for (size_t i = 0; i < len;) {
if (s[i] == 0x1b) {
size_t skip = ansiEscapeLen(s + i, len - i);
if (skip) { i += skip; continue; }
}
int w = 0;
size_t n = linenoiseNextGrapheme(s + i, len - i, &w);
if (!n) break;
width += (size_t)w;
i += n;
}
return width;
}
/* Return the display width of a single UTF-8 character at position 's'. */
static int utf8SingleCharWidth(const char *s, size_t len) {
int width = 0;
linenoiseNextGrapheme(s, len, &width);
return width;
}
enum KEY_ACTION{
KEY_NULL = 0, /* NULL */
CTRL_A = 1, /* Ctrl+a */
CTRL_B = 2, /* Ctrl-b */
CTRL_C = 3, /* Ctrl-c */
CTRL_D = 4, /* Ctrl-d */
CTRL_E = 5, /* Ctrl-e */
CTRL_F = 6, /* Ctrl-f */
CTRL_H = 8, /* Ctrl-h */
TAB = 9, /* Tab */
CTRL_K = 11, /* Ctrl+k */
CTRL_L = 12, /* Ctrl+l */
ENTER = 13, /* Enter */
CTRL_N = 14, /* Ctrl-n */
CTRL_P = 16, /* Ctrl-p */
CTRL_T = 20, /* Ctrl-t */
CTRL_U = 21, /* Ctrl+u */
CTRL_W = 23, /* Ctrl+w */
ESC = 27, /* Escape */
BACKSPACE = 127 /* Backspace */
};
static void linenoiseAtExit(void);
int linenoiseHistoryAdd(const char *line);
#define REFRESH_CLEAN (1<<0) // Clean the old prompt from the screen
#define REFRESH_WRITE (1<<1) // Rewrite the prompt on the screen.
#define REFRESH_ALL (REFRESH_CLEAN|REFRESH_WRITE) // Do both.
static void refreshLine(struct linenoiseState *l);
/* Debugging macro. */
#if 0
FILE *lndebug_fp = NULL;
#define lndebug(...) \
do { \
if (lndebug_fp == NULL) { \
lndebug_fp = fopen("/tmp/lndebug.txt","a"); \
fprintf(lndebug_fp, \
"[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\n", \
(int)l->len,(int)l->pos,(int)l->oldpos,plen,rows,rpos, \
(int)l->oldrows,old_rows); \
} \
fprintf(lndebug_fp, ", " __VA_ARGS__); \
fflush(lndebug_fp); \
} while (0)
#else
#define lndebug(fmt, ...)
#endif
/* ======================= Low level terminal handling ====================== */
/* Enable "mask mode". When it is enabled, instead of the input that
* the user is typing, the terminal will just display a corresponding
* number of asterisks, like "****". This is useful for passwords and other
* secrets that should not be displayed. */
void linenoiseMaskModeEnable(void) {
maskmode = 1;
}
/* Disable mask mode. */
void linenoiseMaskModeDisable(void) {
maskmode = 0;
}
/* Set if to use or not the multi line mode. */
void linenoiseSetMultiLine(int ml) {
mlmode = ml;
}
/* Return true if the terminal name is in the list of terminals we know are
* not able to understand basic escape sequences. */
static int isUnsupportedTerm(void) {
char *term = getenv("TERM");
int j;
if (term == NULL) return 0;
for (j = 0; unsupported_term[j]; j++)
if (!strcasecmp(term,unsupported_term[j])) return 1;
return 0;
}
static void linenoiseMakeRawMode(struct termios *raw) {
raw->c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
raw->c_oflag &= ~(OPOST);
raw->c_cflag |= (CS8);
raw->c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
raw->c_cc[VMIN] = 1;
raw->c_cc[VTIME] = 0;
}
static int linenoiseTermiosRawFieldsEqual(const struct termios *a,
const struct termios *b) {
return a->c_iflag == b->c_iflag &&
a->c_oflag == b->c_oflag &&
a->c_cflag == b->c_cflag &&
a->c_lflag == b->c_lflag &&
a->c_cc[VMIN] == b->c_cc[VMIN] &&
a->c_cc[VTIME] == b->c_cc[VTIME];
}
/* Raw mode: 1960 magic shit. */
static int enableRawMode(int fd) {
struct termios raw;
/* Test mode: when LINENOISE_ASSUME_TTY is set, skip terminal setup.
* This allows testing via pipes without a real terminal. */
if (getenv("LINENOISE_ASSUME_TTY")) {
rawmode = 1;
return 0;
}
if (!isatty(STDIN_FILENO)) goto fatal;
if (!atexit_registered) {
atexit(linenoiseAtExit);
atexit_registered = 1;
}
if (tcgetattr(fd,&orig_termios) == -1) goto fatal;
raw = orig_termios; /* modify the original mode */
linenoiseMakeRawMode(&raw);
/* put terminal in raw mode after flushing */
if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal;
rawmode = 1;
/* Ask the terminal to wrap paste input between ESC[200~ and ESC[201~. */
if (write(rawmode_output, "\x1b[?2004h", 8) == -1) {}
return 0;
fatal:
errno = ENOTTY;
return -1;
}
static void disableRawMode(int fd) {
/* Test mode: nothing to restore. */
if (getenv("LINENOISE_ASSUME_TTY")) {
rawmode = 0;
return;
}
/* Don't even check the return value as it's too late. */
if (rawmode && tcsetattr(fd,TCSAFLUSH,&orig_termios) != -1) {
/* Leave bracketed paste mode when leaving raw mode. */
if (write(rawmode_output, "\x1b[?2004l", 8) == -1) {}
rawmode = 0;
}
}
/* Re-enable raw mode if a child process changed the terminal state. This is
* useful when the application spawns external processes that may reset the
* terminal to cooked mode. This is deliberately conservative: while an editor
* is active, orig_termios must remain the cooked-mode state used by
* disableRawMode(), so never replace it with the current terminal attributes.
* TCSANOW avoids discarding bytes the user typed while the child was running. */
void linenoiseRestoreRawMode(void) {
if (getenv("LINENOISE_ASSUME_TTY")) return;
if (!rawmode) return;
if (!isatty(STDIN_FILENO)) return;
struct termios current, raw = orig_termios;
linenoiseMakeRawMode(&raw);
if (tcgetattr(STDIN_FILENO, ¤t) == -1) return;
if (!linenoiseTermiosRawFieldsEqual(¤t, &raw))
tcsetattr(STDIN_FILENO, TCSANOW, &raw);
/* Re-enable bracketed paste mode in case the child disabled it. */
if (write(rawmode_output, "\x1b[?2004h", 8) == -1) {}
}
/* Use the ESC [6n escape sequence to query the horizontal cursor position
* and return it. On error -1 is returned, on success the position of the
* cursor. */
static int getCursorPosition(int ifd, int ofd) {
char buf[32];
int cols, rows;
unsigned int i = 0;
/* Report cursor location */
if (write(ofd, "\x1b[6n", 4) != 4) return -1;
/* Read the response: ESC [ rows ; cols R */
while (i < sizeof(buf)-1) {
if (read(ifd,buf+i,1) != 1) break;
if (buf[i] == 'R') break;
i++;
}
buf[i] = '\0';
/* Parse it. */
if (buf[0] != ESC || buf[1] != '[') return -1;
if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
return cols;
}
/* Try to get the number of columns in the current terminal, or assume 80
* if it fails. */
static int getColumns(int ifd, int ofd) {
struct winsize ws;
/* Test mode: use LINENOISE_COLS env var for fixed width. */
char *cols_env = getenv("LINENOISE_COLS");
if (cols_env) return atoi(cols_env);
if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
/* ioctl() failed. Try to query the terminal itself. */
int start, cols;
/* Get the initial position so we can restore it later. */
start = getCursorPosition(ifd,ofd);
if (start == -1) goto failed;
/* Go to right margin and get position. */
if (write(ofd,"\x1b[999C",6) != 6) goto failed;
cols = getCursorPosition(ifd,ofd);
if (cols == -1) goto failed;
/* Restore position. */
if (cols > start) {
char seq[32];
snprintf(seq,32,"\x1b[%dD",cols-start);
if (write(ofd,seq,strlen(seq)) == -1) {
/* Can't recover... */
}
}
return cols;
} else {
return ws.ws_col;
}
failed:
return 80;
}
/* Clear the screen. Used to handle ctrl+l */
void linenoiseClearScreen(void) {
if (write(STDOUT_FILENO,"\x1b[H\x1b[2J",7) <= 0) {
/* nothing to do, just to avoid warning. */
}
}
/* Beep, used for completion when there is nothing to complete or when all
* the choices were already shown. */
static void linenoiseBeep(void) {
fprintf(stderr, "\x7");
fflush(stderr);
}
/* ============================== Completion ================================ */
/* Free a list of completion option populated by linenoiseAddCompletion(). */
static void freeCompletions(linenoiseCompletions *lc) {
size_t i;
for (i = 0; i < lc->len; i++)
free(lc->cvec[i]);
if (lc->cvec != NULL)
free(lc->cvec);
}
/* Called by completeLine() and linenoiseShow() to render the current
* edited line with the proposed completion. If the current completion table
* is already available, it is passed as second argument, otherwise the
* function will use the callback to obtain it.
*
* Flags are the same as refreshLine*(), that is REFRESH_* macros. */
static void refreshLineWithCompletion(struct linenoiseState *ls, linenoiseCompletions *lc, int flags) {
/* Obtain the table of completions if the caller didn't provide one. */
linenoiseCompletions ctable = { 0, NULL };
if (lc == NULL) {
completionCallback(ls->buf,&ctable);
lc = &ctable;
}
/* Show the edited line with completion if possible, or just refresh. */
if (ls->completion_idx < lc->len) {
struct linenoiseState saved = *ls;
ls->len = ls->pos = strlen(lc->cvec[ls->completion_idx]);
ls->buf = lc->cvec[ls->completion_idx];
ls->fold_count = 0;
refreshLineWithFlags(ls,flags);
ls->len = saved.len;
ls->pos = saved.pos;
ls->buf = saved.buf;
ls->fold_count = saved.fold_count;
} else {
refreshLineWithFlags(ls,flags);
}
/* Free the completions table if needed. */
if (lc != &ctable) freeCompletions(&ctable);
}
/* This is an helper function for linenoiseEdit*() and is called when the
* user types the <tab> key in order to complete the string currently in the
* input.
*
* The state of the editing is encapsulated into the pointed linenoiseState
* structure as described in the structure definition.
*
* If the function returns non-zero, the caller should handle the
* returned value as a byte read from the standard input, and process
* it as usually: this basically means that the function may return a byte
* read from the terminal but not processed. Otherwise, if zero is returned,
* the input was consumed by the completeLine() function to navigate the
* possible completions, and the caller should read for the next characters
* from stdin. */
static int linenoiseEditGrow(struct linenoiseState *l, size_t needed);
static int completeLine(struct linenoiseState *ls, int keypressed) {
linenoiseCompletions lc = { 0, NULL };
char c = keypressed;
completionCallback(ls->buf,&lc);
if (lc.len == 0) {
linenoiseBeep();
ls->in_completion = 0;
c = 0;
} else {
switch(c) {
case 9: /* tab */
if (ls->in_completion == 0) {
ls->in_completion = 1;
ls->completion_idx = 0;
} else {
ls->completion_idx = (ls->completion_idx+1) % (lc.len+1);
if (ls->completion_idx == lc.len) linenoiseBeep();
}
c = 0;
break;
case 27: /* escape */
/* Re-show original buffer */
if (ls->completion_idx < lc.len) refreshLine(ls);
ls->in_completion = 0;
c = 0;
break;
default:
/* Update buffer and return */
if (ls->completion_idx < lc.len) {
size_t len = strlen(lc.cvec[ls->completion_idx]);
if (linenoiseEditGrow(ls, len) == -1) {
linenoiseBeep();
ls->in_completion = 0;
c = 0;
break;
}
memcpy(ls->buf, lc.cvec[ls->completion_idx], len + 1);
ls->len = ls->pos = len;
linenoiseFoldClear(ls);
}
ls->in_completion = 0;
break;
}
/* Show completion or original buffer */
if (ls->in_completion && ls->completion_idx < lc.len) {
refreshLineWithCompletion(ls,&lc,REFRESH_ALL);
} else {
refreshLine(ls);
}
}
freeCompletions(&lc);
return c; /* Return last read character */
}
/* Register a callback function to be called for tab-completion. */
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
completionCallback = fn;
}
/* Register a hits function to be called to show hits to the user at the
* right of the prompt. */
void linenoiseSetHintsCallback(linenoiseHintsCallback *fn) {
hintsCallback = fn;
}
/* Register a function to free the hints returned by the hints callback
* registered with linenoiseSetHintsCallback(). */
void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) {
freeHintsCallback = fn;
}
/* This function is used by the callback function registered by the user
* in order to add completion options given the input string when the
* user typed <tab>. See the example.c source code for a very easy to
* understand example. */
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
size_t len = strlen(str);
char *copy, **cvec;
copy = malloc(len+1);
if (copy == NULL) return;
memcpy(copy,str,len+1);
cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
if (cvec == NULL) {
free(copy);
return;
}
lc->cvec = cvec;
lc->cvec[lc->len++] = copy;
}
/* =========================== Line editing ================================= */
/* We define a very simple "append buffer" structure, that is an heap
* allocated string where we can append to. This is useful in order to
* write all the escape sequences in a buffer and flush them to the standard
* output in a single call, to avoid flickering effects. */
struct abuf {
char *b;
int len;
};
static void abInit(struct abuf *ab) {
ab->b = NULL;
ab->len = 0;
}
static void abAppend(struct abuf *ab, const char *s, int len) {
char *new = realloc(ab->b,ab->len+len);
if (new == NULL) return;
memcpy(new+ab->len,s,len);
ab->b = new;
ab->len += len;
}
static void abFree(struct abuf *ab) {
free(ab->b);
}
static int linenoiseStatusActive(struct linenoiseState *l) {
return l->status && l->status[0];
}
static int linenoiseStatusRows(struct linenoiseState *l) {
if (!linenoiseStatusActive(l)) return 0;
int rows = 1;
for (char *p = l->status; *p; p++) {
if (*p == '\n') rows++;
}
return rows;
}
/* Append at most maxcols terminal cells of UTF-8 text. Status text is
* expected to be plain text, with styling supplied separately by the caller,
* but we still treat ANSI CSI escapes as zero-width so a caller can pass a
* pre-colored status without corrupting cursor accounting. */
static size_t abAppendUtf8Clipped(struct abuf *ab, const char *s, size_t len,
size_t maxcols) {
size_t i = 0, width = 0;
while (i < len) {
if (s[i] == 0x1b) {
size_t skip = ansiEscapeLen(s + i, len - i);
if (skip > 0) {
abAppend(ab, s + i, (int)skip);
i += skip;
continue;
}
}
int cwidth;
size_t clen = linenoiseNextGrapheme(s + i, len - i, &cwidth);
if (!clen) break;
if (width + (size_t)cwidth > maxcols) break;
abAppend(ab, s + i, (int)clen);
width += cwidth;
i += clen;
}
return width;
}
static void refreshStatusLinePart(struct abuf *ab, struct linenoiseState *l,
const char *s, size_t len, int row) {
size_t width = 0;
size_t cols = l->cols ? l->cols : 80;
if (row > 0) {
char seq[64];
int n = snprintf(seq, sizeof(seq), "\x1b[%d;1H", row);
abAppend(ab, seq, n);
} else abAppend(ab, "\r\n", 2);
/* Fill the complete status row explicitly. Some terminals do not paint