I notice that using a windows terminal program (CRT) in its default VT100 or any of its ANSI modes has display issues. I also notice issues when running telnet from a WIN7 command prompt.

Looking at the Wikipedia page for ANSI Escape Codes, I note that the CHA (ESC [ n G) sequence is not part of ANSI.SYS and I believe was not part of the VT100 command set (I think it was added in the VT220).

Looking at the code, it appears that cu

rrently it is used only to set the cursor to the first column. I replaced all of thos occurances with an CUB sequence to send the cursor back 999 coulums. This seems to work fine with all of the terminals that I tried. It may also be possible to replace the CHA 0 with a \r instead. Here is a patch:

diff --git a/linenoise.c b/linenoise.c
index aef5cdd..b5404b2 100644
--- a/linenoise.c
+++ b/linenoise.c
@@ -56,10 +56,6 @@
  * flickering effect with some slow terminal, but the lesser sequences
  * the more compatible.
  *
- * CHA (Cursor Horizontal Absolute)
- *    Sequence: ESC [ n G
- *    Effect: moves cursor to column n
- *
  * EL (Erase Line)
  *    Sequence: ESC [ n K
  *    Effect: if n is 0 or missing, clear from cursor to end of line
@@ -68,7 +64,19 @@
  *
  * CUF (CUrsor Forward)
  *    Sequence: ESC [ n C
- *    Effect: moves cursor forward of n chars
+ *    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 cusor 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.
@@ -471,7 +479,7 @@ static void refreshSingleLine(struct linenoiseState *l) {

     abInit(&ab);
     /* Cursor to left edge */
-    snprintf(seq,64,"\x1b[0G");
+    snprintf(seq,64,"\x1b[999D");
     abAppend(&ab,seq,strlen(seq));
     /* Write the prompt and the current buffer content */
     abAppend(&ab,l->prompt,strlen(l->prompt));
@@ -480,7 +488,7 @@ static void refreshSingleLine(struct linenoiseState *l) {
     snprintf(seq,64,"\x1b[0K");
     abAppend(&ab,seq,strlen(seq));
     /* Move cursor to original position. */
-    snprintf(seq,64,"\x1b[0G\x1b[%dC", (int)(pos+plen));
+    snprintf(seq,64,"\x1b[999D\x1b[%dC", (int)(pos+plen));
     abAppend(&ab,seq,strlen(seq));
     if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */
     abFree(&ab);
@@ -515,13 +523,13 @@ static void refreshMultiLine(struct linenoiseState *l) {
     /* Now for every row clear it, go up. */
     for (j = 0; j < old_rows-1; j++) {
         lndebug("clear+up");
-        snprintf(seq,64,"\x1b[0G\x1b[0K\x1b[1A");
+        snprintf(seq,64,"\x1b[999D\x1b[0K\x1b[1A");
         abAppend(&ab,seq,strlen(seq));
     }

     /* Clean the top line. */
     lndebug("clear");
-    snprintf(seq,64,"\x1b[0G\x1b[0K");
+    snprintf(seq,64,"\x1b[999D\x1b[0K");
     abAppend(&ab,seq,strlen(seq));

     /* Write the prompt and the current buffer content */
@@ -536,7 +544,7 @@ static void refreshMultiLine(struct linenoiseState *l) {
     {
         lndebug("<newline>");
         abAppend(&ab,"\n",1);
-        snprintf(seq,64,"\x1b[0G");
+        snprintf(seq,64,"\x1b[999D");
         abAppend(&ab,seq,strlen(seq));
         rows++;
         if (rows > (int)l->maxrows) l->maxrows = rows;
@@ -555,7 +563,7 @@ static void refreshMultiLine(struct linenoiseState *l) {

     /* Set column. */
     lndebug("set col %d", 1+((plen+(int)l->pos) % (int)l->cols));
-    snprintf(seq,64,"\x1b[%dG", 1+((plen+(int)l->pos) % (int)l->cols));
+    snprintf(seq,64,"\x1b[999D\x1b[%dC", 1+((plen+(int)l->pos) % (int)l->cols));
     abAppend(&ab,seq,strlen(seq));

     lndebug("\n");
@@ -904,7 +912,7 @@ void linenoisePrintKeyCodes(void) {

         printf("'%c' %02x (%d) (type quit to exit)\n",
             isprint(c) ? c : '?', (int)c, (int)c);
-        printf("\x1b[0G"); /* Go left edge manually, we are in raw mode. */
+        printf("\x1b[999D"); /* Go left edge manually, we are in raw mode. */
         fflush(stdout);
     }
     disableRawMode(STDIN_FILENO);

Free Software is not incompatible at all with commercial use. Indeed, quite the opposite; were I running a company based on open code, it would be significantly to my advantage to choose a copyleft license. But that's beside the point.

Free Software, then, is not disjunct from Commercial, and it would be more appropriate to say that the BSD permits use in Free Software or Proprietary use-cases, because that's the real difference between, say, the GPL and BSD.

I feel like I must be doing something wrong as I can't really imagine being the first to notice this behavior. So I apologize in advance if I'm just being silly here.

I'm using linenoise in a multi-threaded application that accepts user-input on terminal but can also output text on its own (for example, in case of errors it prints an error message). We used to use libreadline, but it's no longer possible because of its license.

The error messages are just printed as:

std::cout << "Line one\n";
std::cout << "Line two\n";

With linenoise, the output is as follows:

Line one
        Line two

So 'Line two' is on a new line, but it starts right after 'Line one', rather than at the beginning of the line. It is as if the implicit \r is missing. It's solved by using "\r\n" instead of \n as newline but it's kind of awkward to change this all over the place.

Note: clearly, whenever something is printed as a result of user-input, everything is fine. e.g.

> help
No problem
with newlines
here

Is this a known issue? Can I work around it without having to sed all of my \n into \r\n?

Thank you for your time.

I'm using https://github.com/hoelzro/lua-linenoise and noticed that the prompt string cannot contain non-printed characters without messing up tab completion, which must be due to incorrect string length calculation. My use case is ANSI coloring (256 spectrum).

https://github.com/hoelzro/lua-linenoise/issues/15

When building projects using linenoise with strict warnings, gcc complains about the lndebug macro being called with no parameter.

Adding an explicit NULL satisfies the compiler and removes the warning.

(See discussion here: http://unixpapa.com/incnote/variadic.html and here: http://stackoverflow.com/q/3576396/26702.)

I've made a few changes to linenoise.h so it can be included in a C++ application.

Also I ran into a bug with the escape sequence processing on a "real" serial connection where the first byte of the sequence could be lost if the read call returns 1 rather than 2 bytes.

Using redis on an ARM embedded-system; however, when opening redis-cli on the serial console, I cannot see any characters, and also input doesn't seem to work, as typing commands blind doesn't do anything either. Also, all control signals are consumed as well so I have to kill off the process to get control of the serial port back.

Using redis-cli over SSH to the same device works fine. After logging in I see there is a .rediscli-history file that has the commands that I was typing over SSH, but nothing for the serial port.

As mentioned in https://github.com/antirez/redis/pull/6834 I try to add mask input mode to linenoise. Add two functions: linenoiseMaskModeEnable linenoiseMaskModeDisable

And in ./linenoise_example You can use /mask to enable input masking, and use /unmask to disable it.

Signed-off-by: lifubang [email protected]

This fixes an accidental drift towards C99/C11 dependencies.

Noticed this when Redis builds started to fail on older Debian systems (gcc 4.9.2). Apparently deps/Makefile also happens to not propagate CFLAGS so -std=c11 is omitted, resulting with build failures:

[...]
MAKE linenoise
cd linenoise && make
make[3]: Entering directory '/work/redis-unstable/deps/linenoise'
cc  -Wall -Os -g  -c linenoise.c
linenoise.c: In function 'refreshMultiLine':
linenoise.c:601:9: error: 'for' loop initial declarations are only allowed in C99 or C11 mode
         for (uint i = 0; i < l->len; i++) abAppend(&ab,"*",1);
[...]

I created a cmake file to enable integration of this with a larger cmake project using ExternalProject. This maintains compatibility. This also allows linenoise to be installed a system library and dynamically linked. I am willing to add conditional compilation for the static target.

We've been using linenoise in a larger multi-threaded project. When another thread uses printf to display some message and a linenoise prompt is on the screen, the message prints at the end of our current prompt, and no new prompt is displayed resulting in ugly output.

Our new function allows other processes to remotely refresh the linenoise line. Thereby they can print their string on its own line, then reshesh the prompt so everything looks nice.

This is accomplished by replacing read in several places with a function that uses select to wait on two file descriptors, stdin and a control pipe that we create. linenoiseRemoteRefreshLine() pushes a new control character (ctrl-r) into our control pipe; when that is received, a flag is set that calls for refresh line to be called.

Highlight and copy the 10 lines below:

This is line 1. This is line 2. This is line 3. This is line 4. This is line 5. This is line 6. This is line 7. This is line 8. This is line 9. This is line 10.

Now run the example program and paste these10 lines into it. This is what you get:

$ ./linenoise_example hello> This is line 1. echo: 'This is line 1.' hello>

Only the first line is received. Lines 2 - 9 are ignored. Each line should be printed with a prompt and a response. Pasting short code snippets into a REPL is a very common thing to do.

When a NULL prompt is passed the linenoise() function it will assume that a prompt has already been written. It computes the length of the prompt from cursor position at the time it is called and avoids writing over the prompt when editing. This allows using linenoise to add line editing capability to a program (e.g. tclsh) which provides a REPL, so prints its own prompts, but does not provide any command line editing.

Hi,

When switching my application from libreadline to linenoise, I noticed that I can no longer debug my application from the IntelliJ console (terminal works alright). The line input just doesn't end, and newline just goes to the next line and I can just keep typing.

I would have opened this issue at IntelliJ, but all others I have tried (libedit, tecla, replxx majorly) works fine with IntelliJ debug console. What could be the problem?? Can this be fixes??

It would be nice to be able to debug my application from my IDE.

Before this commit the linenoiseHistorySave performed fopen(filename, ...) and chmod(filename, ...) and this creates a time of use vs time of check vulnerability.

I have not checked whether this can be exploited, but the fix is trivial here: we can just use fchmod with the opened file descriptor and this is what this commit changes :).

Btw this was found with https://codeql.github.com/ and its https://codeql.github.com/codeql-query-help/cpp/cpp-toctou-race-condition/ rule when scanning a bigger project that used linenoise as a dependency.

As of now, linenoise uses atexit() to call free a bunch of times. It seems completely unnecessary do so, because the OS will already reclaim that memory at exit (and far more efficiently, too). Also, using atexit() for this purpose means that if some user of the library decides to use atexit() to save linenoise history to a file, it won't work because linenoise's atexit() will practically always be called later (because it's only called once the first line is processed), and therefore its atexit() set function would be called first once the program exits, making the history written to file complete garbage.

I would suggest simply removing the freeHistory() call from linenoiseAtExit(), or removing the function altogether.