Remove conditional compilation for WCHAR support in libedit

[nealsid]

Summary

This change moves to using narrow character types and libedit APIs in Editline, because those are the same types that the rest of LLVM/LLDB uses, and it's generally considered better practice to use UTF-8 encoded in char than it is to use wider characters. However, for character input, the change leaves in using a wchar to enable input of multi-byte characters.

[teemperor]

I actually expected after the RFC that we would remove all the non-wchar code, but this seems also fine. I think this LGTM in general, but I feel a bit nervous about touching stuff that depends so much on OS/environment. What OS/environment did you test this patch on? Would be nice to have this tested on a few setups before landing.

Also I'm kinda curious if you found any docs/examples that explain whether mixing the wchar/char functions like we do now is actually supported in libedit? IIUC we call now el_wset and el_set on the same libedit instance. It feels like the wchar support in the FreeBSD port was some kind of parallel implementation to the normal char support, so I'm surprised that we can just mix those functions and everything still works fine (at least on my Linux machine this seems to work).

lldb/source/Host/common/Editline.cpp

554

The original code was actually LLVM-code style (no {} around single line ifs)

[nealsid]

In D106035#2879939, @teemperor wrote:

I actually expected after the RFC that we would remove all the non-wchar code, but this seems also fine. I think this LGTM in general, but I feel a bit nervous about touching stuff that depends so much on OS/environment. What OS/environment did you test this patch on? Would be nice to have this tested on a few setups before landing.

This was my mistake, sorry. I originally went the route in this patch and ran into some errors testing, so I switched to what I detailed in the RFC. But then I found the problem (I was using narrow chars for the GetCharacter callback when that actually isn't supported). Overall I think it is best to use narrow char and string rather than wide-char and wstring because that's more consistent with the rest of LLVM.

Regarding platforms, I tested on OS X Big Sur and Monterey, and Debian Linux inside a VM. Jan was able to build on Fedora. I'm happy to test on more platforms - FreeBSD, NetBSD perhaps?

Also I'm kinda curious if you found any docs/examples that explain whether mixing the wchar/char functions like we do now is actually supported in libedit? IIUC we call now el_wset and el_set on the same libedit instance. It feels like the wchar support in the FreeBSD port was some kind of parallel implementation to the normal char support, so I'm surprised that we can just mix those functions and everything still works fine (at least on my Linux machine this seems to work).

Yeah, the original source converts the parameters and calls el_w* functions when the narrow-char functions are called. This is also true on FreeBSD: https://github.com/freebsd/freebsd-src/blob/373ffc62c158e52cde86a5b934ab4a51307f9f2e/contrib/libedit/eln.c#L359

[nealsid]

Reran clang-format and removed extra braces.

[teemperor]

In D106035#2885174, @nealsid wrote:

In D106035#2879939, @teemperor wrote:

I actually expected after the RFC that we would remove all the non-wchar code, but this seems also fine. I think this LGTM in general, but I feel a bit nervous about touching stuff that depends so much on OS/environment. What OS/environment did you test this patch on? Would be nice to have this tested on a few setups before landing.

This was my mistake, sorry. I originally went the route in this patch and ran into some errors testing, so I switched to what I detailed in the RFC. But then I found the problem (I was using narrow chars for the GetCharacter callback when that actually isn't supported). Overall I think it is best to use narrow char and string rather than wide-char and wstring because that's more consistent with the rest of LLVM.

I actually like this approach even better, so I'm glad this turned out the way it did!

Regarding platforms, I tested on OS X Big Sur and Monterey, and Debian Linux inside a VM. Jan was able to build on Fedora. I'm happy to test on more platforms - FreeBSD, NetBSD perhaps?

I think this is more than enough to test on before landing so this LGTM. FWIW, we do have a release branching in about 10 days or so, so you might want to wait with landing this just directly after that branch was made so that this spends a bit more time on ToT where we can find issues before going into a release. (I assume you don't care whether this makes it into the current release or not, but please correct me if i'm wrong).

Also I'm kinda curious if you found any docs/examples that explain whether mixing the wchar/char functions like we do now is actually supported in libedit? IIUC we call now el_wset and el_set on the same libedit instance. It feels like the wchar support in the FreeBSD port was some kind of parallel implementation to the normal char support, so I'm surprised that we can just mix those functions and everything still works fine (at least on my Linux machine this seems to work).

Yeah, the original source converts the parameters and calls el_w* functions when the narrow-char functions are called. This is also true on FreeBSD: https://github.com/freebsd/freebsd-src/blob/373ffc62c158e52cde86a5b934ab4a51307f9f2e/contrib/libedit/eln.c#L359

Cool, thanks for finding that out!

Anyway, I think this LGTM. Thanks for doing it! Also I can't recall if you have commit access, so please let me know if I should land this.

[nealsid]

In D106035#2885292, @teemperor wrote:

In D106035#2885174, @nealsid wrote:

In D106035#2879939, @teemperor wrote:

I actually expected after the RFC that we would remove all the non-wchar code, but this seems also fine. I think this LGTM in general, but I feel a bit nervous about touching stuff that depends so much on OS/environment. What OS/environment did you test this patch on? Would be nice to have this tested on a few setups before landing.

This was my mistake, sorry. I originally went the route in this patch and ran into some errors testing, so I switched to what I detailed in the RFC. But then I found the problem (I was using narrow chars for the GetCharacter callback when that actually isn't supported). Overall I think it is best to use narrow char and string rather than wide-char and wstring because that's more consistent with the rest of LLVM.

I actually like this approach even better, so I'm glad this turned out the way it did!

Regarding platforms, I tested on OS X Big Sur and Monterey, and Debian Linux inside a VM. Jan was able to build on Fedora. I'm happy to test on more platforms - FreeBSD, NetBSD perhaps?

I think this is more than enough to test on before landing so this LGTM. FWIW, we do have a release branching in about 10 days or so, so you might want to wait with landing this just directly after that branch was made so that this spends a bit more time on ToT where we can find issues before going into a release. (I assume you don't care whether this makes it into the current release or not, but please correct me if i'm wrong).

Definitely +1 on baking it at HEAD for a bit - SGTM.

Also I'm kinda curious if you found any docs/examples that explain whether mixing the wchar/char functions like we do now is actually supported in libedit? IIUC we call now el_wset and el_set on the same libedit instance. It feels like the wchar support in the FreeBSD port was some kind of parallel implementation to the normal char support, so I'm surprised that we can just mix those functions and everything still works fine (at least on my Linux machine this seems to work).

Yeah, the original source converts the parameters and calls el_w* functions when the narrow-char functions are called. This is also true on FreeBSD: https://github.com/freebsd/freebsd-src/blob/373ffc62c158e52cde86a5b934ab4a51307f9f2e/contrib/libedit/eln.c#L359

Cool, thanks for finding that out!

Anyway, I think this LGTM. Thanks for doing it! Also I can't recall if you have commit access, so please let me know if I should land this.

I don't, but maybe I can start that conversation around commit access. For this patch, I'll watch for the next release branch cut and ask you about landing it then. Thanks!

Neal

[nealsid]

Update against HEAD (I still need to do a bit more testing but wanted to get the buildbot results in the meantime)

[nealsid]

Update against HEAD; tested on Debian Buster and Monterey

[teemperor]

The release branch was recently made, so we can land this right now. Just give me a ping when I should merge this :)

[nealsid]

In D106035#2927660, @teemperor wrote:

The release branch was recently made, so we can land this right now. Just give me a ping when I should merge this :)

Thanks - I recently got commit access so I figured I'd try it out with this one, and I *think* it worked.

[teemperor]

In D106035#2927714, @nealsid wrote:

In D106035#2927660, @teemperor wrote:

The release branch was recently made, so we can land this right now. Just give me a ping when I should merge this :)

Thanks - I recently got commit access so I figured I'd try it out with this one, and I *think* it worked.

Jepp, worked and congrats!

[teemperor]

I fear I might also have to congratulate you on your first revert (sorry, couldn't resist that joke). TestUnicode is failing for me with this patch on Arch Linux:

Command Output (stdout):
--
lldb version 14.0.0 ([e-mail]:Teemperor/llvm-project revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5)
  clang revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
  llvm revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
Skipping the following test categories: ['libc++', 'dsym', 'gmodules', 'debugserver', 'objc']

--
Command Output (stderr):
--
FAIL: LLDB (/home/teemperor/work/ci/build/bin/clang-x86_64) :: test_unicode_input (TestUnicode.TestCase)
======================================================================
ERROR: test_unicode_input (TestUnicode.TestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 111, in expect_loop
    incoming = spawn.read_nonblocking(spawn.maxread, timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/pty_spawn.py", line 482, in read_nonblocking
    raise TIMEOUT('Timeout exceeded.')
pexpect.exceptions.TIMEOUT: Timeout exceeded.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 149, in wrapper
    return func(*args, **kwargs)
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/iohandler/unicode/TestUnicode.py", line 25, in test_unicode_input
    self.expect(u'\u1234', substrs=[u"error: '\u1234' is not a valid command.".encode('utf-8')])
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/lldbpexpect.py", line 64, in expect
    self.child.expect_exact(s)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/spawnbase.py", line 418, in expect_exact
    return exp.expect_loop(timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 119, in expect_loop
    return self.timeout(e)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 82, in timeout
    raise TIMEOUT(msg)
pexpect.exceptions.TIMEOUT: Timeout exceeded.
<pexpect.pty_spawn.spawn object at 0x7f004e20a610>
command: /home/teemperor/work/ci/build/bin/lldb
args: ['/home/teemperor/work/ci/build/bin/lldb', '--no-lldbinit', '--no-use-colors', '-O', 'settings clear -all', '-O', 'settings set symbols.enable-external-lookup false', '-O', 'settings set target.inherit-tcc true', '-O', 'settings set target.detach-on-error false', '-O', 'settings set target.auto-apply-fixits false', '-O', 'settings set plugin.process.gdb-remote.packet-timeout 60', '-O', 'settings set symbols.clang-modules-cache-path "/home/teemperor/work/ci/build/lldb-test-build.noindex/module-cache-lldb/lldb-api"', '-O', 'settings set use-color false', '-O', 'setting set target.prefer-dynamic-value no-dynamic-values']
buffer (last 100 chars): b'\\U+1234\r\n(lldb) '
before (last 100 chars): b'\\U+1234\r\n(lldb) '
after: <class 'pexpect.exceptions.TIMEOUT'>
match: None
match_index: None
exitstatus: None
flag_eof: False
pid: 609226
child_fd: 6
closed: False
timeout: 60
delimiter: <class 'pexpect.exceptions.EOF'>
logfile: None
logfile_read: None
logfile_send: None
maxread: 2000
ignorecase: False
searchwindowsize: None
delaybeforesend: 0.05
delayafterclose: 0.1
delayafterterminate: 0.1
searcher: searcher_string:
    0: b"error: '\xe1\x88\xb4' is not a valid command."
Config=x86_64-/home/teemperor/work/ci/build/bin/clang
----------------------------------------------------------------------
Ran 1 test in 60.551s

[nealsid]

:) Shoot. I definitely want to revert ASAP rather than keep the tree in a bad state. Just curious, since there are timeout messages in the log, would you be able to try rerunning just that one? I see this, too: 0: b"error: '\xe1\x88\xb4' is not a valid command. So I'm guessing the timeout is a red herring.

I'll create an Arch VM to test on for future patches. Thank you and sorry about that.

In D106035#2927817, @teemperor wrote:

I fear I might also have to congratulate you on your first revert (sorry, couldn't resist that joke). TestUnicode is failing for me with this patch on Arch Linux:

Command Output (stdout):
--
lldb version 14.0.0 ([e-mail]:Teemperor/llvm-project revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5)
  clang revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
  llvm revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
Skipping the following test categories: ['libc++', 'dsym', 'gmodules', 'debugserver', 'objc']

--
Command Output (stderr):
--
FAIL: LLDB (/home/teemperor/work/ci/build/bin/clang-x86_64) :: test_unicode_input (TestUnicode.TestCase)
======================================================================
ERROR: test_unicode_input (TestUnicode.TestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 111, in expect_loop
    incoming = spawn.read_nonblocking(spawn.maxread, timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/pty_spawn.py", line 482, in read_nonblocking
    raise TIMEOUT('Timeout exceeded.')
pexpect.exceptions.TIMEOUT: Timeout exceeded.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 149, in wrapper
    return func(*args, **kwargs)
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/iohandler/unicode/TestUnicode.py", line 25, in test_unicode_input
    self.expect(u'\u1234', substrs=[u"error: '\u1234' is not a valid command.".encode('utf-8')])
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/lldbpexpect.py", line 64, in expect
    self.child.expect_exact(s)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/spawnbase.py", line 418, in expect_exact
    return exp.expect_loop(timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 119, in expect_loop
    return self.timeout(e)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 82, in timeout
    raise TIMEOUT(msg)
pexpect.exceptions.TIMEOUT: Timeout exceeded.
<pexpect.pty_spawn.spawn object at 0x7f004e20a610>
command: /home/teemperor/work/ci/build/bin/lldb
args: ['/home/teemperor/work/ci/build/bin/lldb', '--no-lldbinit', '--no-use-colors', '-O', 'settings clear -all', '-O', 'settings set symbols.enable-external-lookup false', '-O', 'settings set target.inherit-tcc true', '-O', 'settings set target.detach-on-error false', '-O', 'settings set target.auto-apply-fixits false', '-O', 'settings set plugin.process.gdb-remote.packet-timeout 60', '-O', 'settings set symbols.clang-modules-cache-path "/home/teemperor/work/ci/build/lldb-test-build.noindex/module-cache-lldb/lldb-api"', '-O', 'settings set use-color false', '-O', 'setting set target.prefer-dynamic-value no-dynamic-values']
buffer (last 100 chars): b'\\U+1234\r\n(lldb) '
before (last 100 chars): b'\\U+1234\r\n(lldb) '
after: <class 'pexpect.exceptions.TIMEOUT'>
match: None
match_index: None
exitstatus: None
flag_eof: False
pid: 609226
child_fd: 6
closed: False
timeout: 60
delimiter: <class 'pexpect.exceptions.EOF'>
logfile: None
logfile_read: None
logfile_send: None
maxread: 2000
ignorecase: False
searchwindowsize: None
delaybeforesend: 0.05
delayafterclose: 0.1
delayafterterminate: 0.1
searcher: searcher_string:
    0: b"error: '\xe1\x88\xb4' is not a valid command."
Config=x86_64-/home/teemperor/work/ci/build/bin/clang
----------------------------------------------------------------------
Ran 1 test in 60.551s

[teemperor]

I ran it a few times and I'm sure it's an actual '"the output didn't show up" timeout and not a random failure. I also checked and my node doesn't have an .editrc file or something like that on the node. It's failing on a different Arch Linux bot so I think it's not a borked machine.

Arch should use just the vanilla libedit so I am not sure why it would be different from other distros. IIRC I ran all the tests when I first reviewed this, so I am also a bit confused why this is now failing. When I manually input unicode characters into the old and new prompt both seem to work, so maybe it's the pexpect test setup that is somehow dropping the input?

On a side note: I think this patch actually breaks the way backspace works. With this patch applied, if I enter a command such as '∂∂∂∂∂∂∂∂∂' and then press backspace, the cursor is now moved to the right by (what I assume) is the amount of bytes that I entered. I think there is some strlen logic going on that isn't unicode aware. See below:

In D106035#2927847, @nealsid wrote:

:) Shoot. I definitely want to revert ASAP rather than keep the tree in a bad state. Just curious, since there are timeout messages in the log, would you be able to try rerunning just that one? I see this, too: 0: b"error: '\xe1\x88\xb4' is not a valid command. So I'm guessing the timeout is a red herring.

I'll create an Arch VM to test on for future patches. Thank you and sorry about that.

In D106035#2927817, @teemperor wrote:

I fear I might also have to congratulate you on your first revert (sorry, couldn't resist that joke). TestUnicode is failing for me with this patch on Arch Linux:

Command Output (stdout):
--
lldb version 14.0.0 ([e-mail]:Teemperor/llvm-project revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5)
  clang revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
  llvm revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
Skipping the following test categories: ['libc++', 'dsym', 'gmodules', 'debugserver', 'objc']

--
Command Output (stderr):
--
FAIL: LLDB (/home/teemperor/work/ci/build/bin/clang-x86_64) :: test_unicode_input (TestUnicode.TestCase)
======================================================================
ERROR: test_unicode_input (TestUnicode.TestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 111, in expect_loop
    incoming = spawn.read_nonblocking(spawn.maxread, timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/pty_spawn.py", line 482, in read_nonblocking
    raise TIMEOUT('Timeout exceeded.')
pexpect.exceptions.TIMEOUT: Timeout exceeded.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 149, in wrapper
    return func(*args, **kwargs)
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/iohandler/unicode/TestUnicode.py", line 25, in test_unicode_input
    self.expect(u'\u1234', substrs=[u"error: '\u1234' is not a valid command.".encode('utf-8')])
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/lldbpexpect.py", line 64, in expect
    self.child.expect_exact(s)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/spawnbase.py", line 418, in expect_exact
    return exp.expect_loop(timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 119, in expect_loop
    return self.timeout(e)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 82, in timeout
    raise TIMEOUT(msg)
pexpect.exceptions.TIMEOUT: Timeout exceeded.
<pexpect.pty_spawn.spawn object at 0x7f004e20a610>
command: /home/teemperor/work/ci/build/bin/lldb
args: ['/home/teemperor/work/ci/build/bin/lldb', '--no-lldbinit', '--no-use-colors', '-O', 'settings clear -all', '-O', 'settings set symbols.enable-external-lookup false', '-O', 'settings set target.inherit-tcc true', '-O', 'settings set target.detach-on-error false', '-O', 'settings set target.auto-apply-fixits false', '-O', 'settings set plugin.process.gdb-remote.packet-timeout 60', '-O', 'settings set symbols.clang-modules-cache-path "/home/teemperor/work/ci/build/lldb-test-build.noindex/module-cache-lldb/lldb-api"', '-O', 'settings set use-color false', '-O', 'setting set target.prefer-dynamic-value no-dynamic-values']
buffer (last 100 chars): b'\\U+1234\r\n(lldb) '
before (last 100 chars): b'\\U+1234\r\n(lldb) '
after: <class 'pexpect.exceptions.TIMEOUT'>
match: None
match_index: None
exitstatus: None
flag_eof: False
pid: 609226
child_fd: 6
closed: False
timeout: 60
delimiter: <class 'pexpect.exceptions.EOF'>
logfile: None
logfile_read: None
logfile_send: None
maxread: 2000
ignorecase: False
searchwindowsize: None
delaybeforesend: 0.05
delayafterclose: 0.1
delayafterterminate: 0.1
searcher: searcher_string:
    0: b"error: '\xe1\x88\xb4' is not a valid command."
Config=x86_64-/home/teemperor/work/ci/build/bin/clang
----------------------------------------------------------------------
Ran 1 test in 60.551s

[nealsid]

Yikes - issue count starting to slowly increase :) I've reverted the patch, and sorry again about that.

I have to travel for a couple days but when I get my dev machine back up later this week I will investigate these issues in detail. I focussed my testing more on Unicode identifiers inside source files/debug information and missed the backspace problem, unfortunately. Thanks.

In D106035#2927942, @teemperor wrote:

I ran it a few times and I'm sure it's an actual '"the output didn't show up" timeout and not a random failure. I also checked and my node doesn't have an .editrc file or something like that on the node. It's failing on a different Arch Linux bot so I think it's not a borked machine.

Arch should use just the vanilla libedit so I am not sure why it would be different from other distros. IIRC I ran all the tests when I first reviewed this, so I am also a bit confused why this is now failing. When I manually input unicode characters into the old and new prompt both seem to work, so maybe it's the pexpect test setup that is somehow dropping the input?

On a side note: I think this patch actually breaks the way backspace works. With this patch applied, if I enter a command such as '∂∂∂∂∂∂∂∂∂' and then press backspace, the cursor is now moved to the right by (what I assume) is the amount of bytes that I entered. I think there is some strlen logic going on that isn't unicode aware. See below:

In D106035#2927847, @nealsid wrote:

:) Shoot. I definitely want to revert ASAP rather than keep the tree in a bad state. Just curious, since there are timeout messages in the log, would you be able to try rerunning just that one? I see this, too: 0: b"error: '\xe1\x88\xb4' is not a valid command. So I'm guessing the timeout is a red herring.

I'll create an Arch VM to test on for future patches. Thank you and sorry about that.

In D106035#2927817, @teemperor wrote:

I fear I might also have to congratulate you on your first revert (sorry, couldn't resist that joke). TestUnicode is failing for me with this patch on Arch Linux:

Command Output (stdout):
--
lldb version 14.0.0 ([e-mail]:Teemperor/llvm-project revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5)
  clang revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
  llvm revision f9f63e92243ecd6d0df5d6813967a49c8ca79ca5
Skipping the following test categories: ['libc++', 'dsym', 'gmodules', 'debugserver', 'objc']

--
Command Output (stderr):
--
FAIL: LLDB (/home/teemperor/work/ci/build/bin/clang-x86_64) :: test_unicode_input (TestUnicode.TestCase)
======================================================================
ERROR: test_unicode_input (TestUnicode.TestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 111, in expect_loop
    incoming = spawn.read_nonblocking(spawn.maxread, timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/pty_spawn.py", line 482, in read_nonblocking
    raise TIMEOUT('Timeout exceeded.')
pexpect.exceptions.TIMEOUT: Timeout exceeded.

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 149, in wrapper
    return func(*args, **kwargs)
  File "/home/teemperor/work/ci/llvm-project/lldb/test/API/iohandler/unicode/TestUnicode.py", line 25, in test_unicode_input
    self.expect(u'\u1234', substrs=[u"error: '\u1234' is not a valid command.".encode('utf-8')])
  File "/home/teemperor/work/ci/llvm-project/lldb/packages/Python/lldbsuite/test/lldbpexpect.py", line 64, in expect
    self.child.expect_exact(s)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/spawnbase.py", line 418, in expect_exact
    return exp.expect_loop(timeout)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 119, in expect_loop
    return self.timeout(e)
  File "/home/teemperor/work/ci/llvm-project/lldb/third_party/Python/module/pexpect-4.6/pexpect/expect.py", line 82, in timeout
    raise TIMEOUT(msg)
pexpect.exceptions.TIMEOUT: Timeout exceeded.
<pexpect.pty_spawn.spawn object at 0x7f004e20a610>
command: /home/teemperor/work/ci/build/bin/lldb
args: ['/home/teemperor/work/ci/build/bin/lldb', '--no-lldbinit', '--no-use-colors', '-O', 'settings clear -all', '-O', 'settings set symbols.enable-external-lookup false', '-O', 'settings set target.inherit-tcc true', '-O', 'settings set target.detach-on-error false', '-O', 'settings set target.auto-apply-fixits false', '-O', 'settings set plugin.process.gdb-remote.packet-timeout 60', '-O', 'settings set symbols.clang-modules-cache-path "/home/teemperor/work/ci/build/lldb-test-build.noindex/module-cache-lldb/lldb-api"', '-O', 'settings set use-color false', '-O', 'setting set target.prefer-dynamic-value no-dynamic-values']
buffer (last 100 chars): b'\\U+1234\r\n(lldb) '
before (last 100 chars): b'\\U+1234\r\n(lldb) '
after: <class 'pexpect.exceptions.TIMEOUT'>
match: None
match_index: None
exitstatus: None
flag_eof: False
pid: 609226
child_fd: 6
closed: False
timeout: 60
delimiter: <class 'pexpect.exceptions.EOF'>
logfile: None
logfile_read: None
logfile_send: None
maxread: 2000
ignorecase: False
searchwindowsize: None
delaybeforesend: 0.05
delayafterclose: 0.1
delayafterterminate: 0.1
searcher: searcher_string:
    0: b"error: '\xe1\x88\xb4' is not a valid command."
Config=x86_64-/home/teemperor/work/ci/build/bin/clang
----------------------------------------------------------------------
Ran 1 test in 60.551s

[nealsid]

Sorry, I haven't forgotten about this. Haven't had time to sit down for a proper debugging session this or last week. I definitely still plan to update and resend for review. Thanks!

lldb/cmake/modules/LLDBConfig.cmake

else()
   # cache variable.
   set(LLDB_EXPORT_ALL_SYMBOLS 0)
 endif()
 
 if ((NOT MSVC) OR MSVC12)
   add_definitions( -DHAVE_ROUND )
 endif()
 
-# Check if we libedit capable of handling wide characters (built with
-# '--enable-widec').
 if (LLDB_ENABLE_LIBEDIT)
   set(CMAKE_REQUIRED_LIBRARIES ${LibEdit_LIBRARIES})
   set(CMAKE_REQUIRED_INCLUDES ${LibEdit_INCLUDE_DIRS})
-  check_symbol_exists(el_winsertstr histedit.h LLDB_EDITLINE_USE_WCHAR)
   set(CMAKE_EXTRA_INCLUDE_FILES histedit.h)
-  check_type_size(el_rfunc_t LLDB_EL_RFUNC_T_SIZE)
-  if (LLDB_EL_RFUNC_T_SIZE STREQUAL "")
-    set(LLDB_HAVE_EL_RFUNC_T 0)
-  else()
-    set(LLDB_HAVE_EL_RFUNC_T 1)
-  endif()
   set(CMAKE_REQUIRED_LIBRARIES)
   set(CMAKE_REQUIRED_INCLUDES)
   set(CMAKE_EXTRA_INCLUDE_FILES)
 endif()
 
 if (LLDB_ENABLE_PYTHON)
   if(CMAKE_SYSTEM_NAME MATCHES "Windows")
     set(default_embed_python_home ON)

lldb/include/lldb/Host/Editline.h

 // ANSI sequences starting with escape.
 // d) Emoji support is fairly terrible, presumably it doesn't understand
 // composed characters?
 
 #ifndef LLDB_HOST_EDITLINE_H
 #define LLDB_HOST_EDITLINE_H
 #if defined(__cplusplus)
 
 #include "lldb/Host/Config.h"
 
-#if LLDB_EDITLINE_USE_WCHAR
-#include <codecvt>
-#endif
 #include <locale>
 #include <sstream>
 #include <vector>
 
 #include "lldb/lldb-private.h"
 
 #if !defined(_WIN32) && !defined(__ANDROID__)
 #include <histedit.h>

 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/StringList.h"
 
 #include "llvm/ADT/FunctionExtras.h"
 
 namespace lldb_private {
 namespace line_editor {
 
-// type alias's to help manage 8 bit and wide character versions of libedit
-#if LLDB_EDITLINE_USE_WCHAR
-using EditLineStringType = std::wstring;
-using EditLineStringStreamType = std::wstringstream;
-using EditLineCharType = wchar_t;
-#else
-using EditLineStringType = std::string;
-using EditLineStringStreamType = std::stringstream;
-using EditLineCharType = char;
-#endif
-
-// At one point the callback type of el_set getchar callback changed from char
-// to wchar_t. It is not possible to detect differentiate between the two
-// versions exactly, but this is a pretty good approximation and allows us to
-// build against almost any editline version out there.
-#if LLDB_EDITLINE_USE_WCHAR || defined(EL_CLIENTDATA) || LLDB_HAVE_EL_RFUNC_T
-using EditLineGetCharType = wchar_t;
-#else
-using EditLineGetCharType = char;
-#endif
-
 using EditlineGetCharCallbackType = int (*)(::EditLine *editline,
-                                            EditLineGetCharType *c);
+                                            wchar_t *c);
 using EditlineCommandCallbackType = unsigned char (*)(::EditLine *editline,
                                                       int ch);
 using EditlinePromptCallbackType = const char *(*)(::EditLine *editline);
 
 class EditlineHistory;
 
 using EditlineHistorySP = std::shared_ptr<EditlineHistory>;
 
private:
   /// end to reserve room for
   /// the rightmost cursor position.
   void DisplayInput(int firstIndex = 0);
 
   /// Counts the number of rows a given line of content will end up occupying,
   /// taking into account both
   /// the preceding prompt and a single trailing space occupied by a cursor when
   /// at the end of the line.
-  int CountRowsForLine(const EditLineStringType &content);
+  int CountRowsForLine(const std::string &content);
 
   /// Save the line currently being edited
   void SaveEditedLine();
 
   /// Convert the current input lines into a UTF8 StringList
   StringList GetInputAsStringList(int line_count = UINT32_MAX);
 
   /// Replaces the current multi-line session with the next entry from history.
   unsigned char RecallHistory(HistoryOperation op);
 
   /// Character reading implementation for EditLine that supports our multi-line
   /// editing trickery.
-  int GetCharacter(EditLineGetCharType *c);
+  int GetCharacter(wchar_t *c);
 
   /// Prompt implementation for EditLine.
   const char *Prompt();
 
   /// Line break command used when meta+return is pressed in multi-line mode.
   unsigned char BreakLineCommand(int ch);
 
   /// Command used when return is pressed in multi-line mode.
private:
 
   /// Revert line command used when moving between lines.
   unsigned char RevertLineCommand(int ch);
 
   /// Ensures that the current EditLine instance is properly configured for
   /// single or multi-line editing.
   void ConfigureEditor(bool multiline);
 
-  bool CompleteCharacter(char ch, EditLineGetCharType &out);
+  bool CompleteCharacter(char ch, wchar_t &out);
 
   void ApplyTerminalSizeChange();
 
   // The following set various editline parameters.  It's not any less
   // verbose to put the editline calls into a function, but it
   // provides type safety, since the editline functions take varargs
   // parameters.
-  void AddFunctionToEditLine(const EditLineCharType *command,
-                             const EditLineCharType *helptext,
+  void AddFunctionToEditLine(const char *command,
+                             const char *helptext,
                              EditlineCommandCallbackType callbackFn);
   void SetEditLinePromptCallback(EditlinePromptCallbackType callbackFn);
   void SetGetCharacterFunction(EditlineGetCharCallbackType callbackFn);
 
-#if LLDB_EDITLINE_USE_WCHAR
-  std::wstring_convert<std::codecvt_utf8<wchar_t>> m_utf8conv;
-#endif
   ::EditLine *m_editline = nullptr;
   EditlineHistorySP m_history_sp;
   bool m_in_history = false;
-  std::vector<EditLineStringType> m_live_history_lines;
+  std::vector<std::string> m_live_history_lines;
   bool m_multiline_enabled = false;
-  std::vector<EditLineStringType> m_input_lines;
+  std::vector<std::string> m_input_lines;
   EditorStatus m_editor_status;
   bool m_color_prompts = true;
   int m_terminal_width = 0;
   int m_base_line_number = 0;
   unsigned m_current_line_index = 0;
   int m_current_line_rows = -1;
   int m_revert_cursor_index = 0;
   int m_line_number_digits = 3;

lldb/source/Host/common/Editline.cpp

 //===-- Editline.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <climits>
+#include <codecvt>
 #include <iomanip>
 
 #include "lldb/Host/Editline.h"
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/SelectHelper.h"

 /// Normal colour or normal intensity (neither bold nor faint).
 #define ANSI_UNFAINT ESCAPE "[0m"
 #define ANSI_CLEAR_BELOW ESCAPE "[J"
 #define ANSI_CLEAR_RIGHT ESCAPE "[K"
 #define ANSI_SET_COLUMN_N ESCAPE "[%dG"
 #define ANSI_UP_N_ROWS ESCAPE "[%dA"
 #define ANSI_DOWN_N_ROWS ESCAPE "[%dB"
 
-#if LLDB_EDITLINE_USE_WCHAR
-
-#define EditLineConstString(str) L##str
-#define EditLineStringFormatSpec "%ls"
-
-#else
-
 #define EditLineConstString(str) str
 #define EditLineStringFormatSpec "%s"
 
-// use #defines so wide version functions and structs will resolve to old
-// versions for case of libedit not built with wide char support
-#define history_w history
-#define history_winit history_init
-#define history_wend history_end
-#define HistoryW History
-#define HistEventW HistEvent
-#define LineInfoW LineInfo
-
-#define el_wgets el_gets
-#define el_wgetc el_getc
-#define el_wpush el_push
-#define el_wparse el_parse
-#define el_wset el_set
-#define el_wget el_get
-#define el_wline el_line
-#define el_winsertstr el_insertstr
-#define el_wdeletestr el_deletestr
-
-#endif // #if LLDB_EDITLINE_USE_WCHAR
-
-bool IsOnlySpaces(const EditLineStringType &content) {
-  for (wchar_t ch : content) {
-    if (ch != EditLineCharType(' '))
+bool IsOnlySpaces(const std::string &content) {
+  for (char ch : content) {
+    if (ch != ' ')
       return false;
   }
   return true;
 }
 
 static int GetOperation(HistoryOperation op) {
   // The naming used by editline for the history operations is counter
   // intuitive to how it's used in LLDB's editline implementation.
switch(op) {
     case HistoryOperation::Newer:
       return H_PREV;
     case HistoryOperation::Newest:
       return H_FIRST;
   }
   llvm_unreachable("Fully covered switch!");
 }
 
 
-EditLineStringType CombineLines(const std::vector<EditLineStringType> &lines) {
-  EditLineStringStreamType combined_stream;
-  for (EditLineStringType line : lines) {
+std::string CombineLines(const std::vector<std::string> &lines) {
+  std::stringstream combined_stream;
+  for (const std::string& line : lines) {
     combined_stream << line.c_str() << "\n";
   }
   return combined_stream.str();
 }
 
-std::vector<EditLineStringType> SplitLines(const EditLineStringType &input) {
-  std::vector<EditLineStringType> result;
+std::vector<std::string> SplitLines(const std::string &input) {
+  std::vector<std::string> result;
   size_t start = 0;
   while (start < input.length()) {
     size_t end = input.find('\n', start);
     if (end == std::string::npos) {
       result.push_back(input.substr(start));
       break;
     }
     result.push_back(input.substr(start, end - start));
     start = end + 1;
   }
   // Treat an empty history session as a single command of zero-length instead
   // of returning an empty vector.
   if (result.empty()) {
     result.emplace_back();
   }
   return result;
 }
 
-EditLineStringType FixIndentation(const EditLineStringType &line,
+std::string FixIndentation(const std::string &line,
                                   int indent_correction) {
   if (indent_correction == 0)
     return line;
   if (indent_correction < 0)
     return line.substr(-indent_correction);
-  return EditLineStringType(indent_correction, EditLineCharType(' ')) + line;
+  return std::string(indent_correction, ' ') + line;
 }
 
-int GetIndentation(const EditLineStringType &line) {
-  int space_count = 0;
-  for (EditLineCharType ch : line) {
-    if (ch != EditLineCharType(' '))
-      break;
-    ++space_count;
-  }
-  return space_count;
+int GetIndentation(const std::string &line) {
+  auto firstNonSpace = std::find_if(line.begin(), line.end(), [] (const char ch) {
+    return ch != ' ';
+  });
+  return firstNonSpace - line.begin();
 }
 
 bool IsInputPending(FILE *file) {
   // FIXME: This will be broken on Windows if we ever re-enable Editline.  You
   // can't use select
   // on something that isn't a socket.  This will have to be re-written to not
   // use a FILE*, but instead use some kind of yet-to-be-created abstraction
   // that select-like functionality on non-socket objects.

 // instances with the same program name.
 
 class EditlineHistory {
 private:
   // Use static GetHistory() function to get a EditlineHistorySP to one of
   // these objects
   EditlineHistory(const std::string &prefix, uint32_t size, bool unique_entries)
       : m_history(nullptr), m_event(), m_prefix(prefix), m_path() {
-    m_history = history_winit();
-    history_w(m_history, &m_event, H_SETSIZE, size);
+    m_history = history_init();
+    history(m_history, &m_event, H_SETSIZE, size);
     if (unique_entries)
-      history_w(m_history, &m_event, H_SETUNIQUE, 1);
+      history(m_history, &m_event, H_SETUNIQUE, 1);
   }
 
   const char *GetHistoryFilePath() {
     // Compute the history path lazily.
     if (m_path.empty() && m_history && !m_prefix.empty()) {
       llvm::SmallString<128> lldb_history_file;
       FileSystem::Instance().GetHomeDirectory(lldb_history_file);
       llvm::sys::path::append(lldb_history_file, ".lldb");
 
       // LLDB stores its history in ~/.lldb/. If for some reason this directory
       // isn't writable or cannot be created, history won't be available.
       if (!llvm::sys::fs::create_directory(lldb_history_file)) {
-#if LLDB_EDITLINE_USE_WCHAR
-        std::string filename = m_prefix + "-widehistory";
-#else
         std::string filename = m_prefix + "-history";
-#endif
         llvm::sys::path::append(lldb_history_file, filename);
         m_path = std::string(lldb_history_file.str());
       }
     }
 
     if (m_path.empty())
       return nullptr;
 
     return m_path.c_str();
   }
 
 public:
   ~EditlineHistory() {
     Save();
 
     if (m_history) {
-      history_wend(m_history);
+      history_end(m_history);
       m_history = nullptr;
     }
   }
 
   static EditlineHistorySP GetHistory(const std::string &prefix) {
     typedef std::map<std::string, EditlineHistoryWP> WeakHistoryMap;
     static std::recursive_mutex g_mutex;
     static WeakHistoryMap g_weak_map;
     std::lock_guard<std::recursive_mutex> guard(g_mutex);
     WeakHistoryMap::const_iterator pos = g_weak_map.find(prefix);
     EditlineHistorySP history_sp;
     if (pos != g_weak_map.end()) {
       history_sp = pos->second.lock();
       if (history_sp)
         return history_sp;
       g_weak_map.erase(pos);
     }
     history_sp.reset(new EditlineHistory(prefix, 800, true));
     g_weak_map[prefix] = history_sp;
     return history_sp;
   }
 
   bool IsValid() const { return m_history != nullptr; }
 
-  HistoryW *GetHistoryPtr() { return m_history; }
+  History *GetHistoryPtr() { return m_history; }
 
-  void Enter(const EditLineCharType *line_cstr) {
+  void Enter(const char *line_cstr) {
     if (m_history)
-      history_w(m_history, &m_event, H_ENTER, line_cstr);
+      history(m_history, &m_event, H_ENTER, line_cstr);
   }
 
   bool Load() {
     if (m_history) {
       const char *path = GetHistoryFilePath();
       if (path) {
-        history_w(m_history, &m_event, H_LOAD, path);
+        history(m_history, &m_event, H_LOAD, path);
         return true;
       }
     }
     return false;
   }
 
   bool Save() {
     if (m_history) {
       const char *path = GetHistoryFilePath();
       if (path) {
-        history_w(m_history, &m_event, H_SAVE, path);
+        history(m_history, &m_event, H_SAVE, path);
         return true;
       }
     }
     return false;
   }
 
 protected:
-  HistoryW *m_history; // The history object
-  HistEventW m_event;  // The history event needed to contain all history events
+  History *m_history; // The history object
+  HistEvent m_event;  // The history event needed to contain all history events
   std::string m_prefix; // The prefix name (usually the editline program name)
                         // to use when loading/saving history
   std::string m_path;   // Path to the history file
 };
 }
 }
 
 // Editline private methods

 
 bool Editline::IsEmacs() {
   const char *editor;
   el_get(m_editline, EL_EDITOR, &editor);
   return editor[0] == 'e';
 }
 
 bool Editline::IsOnlySpaces() {
-  const LineInfoW *info = el_wline(m_editline);
-  for (const EditLineCharType *character = info->buffer;
+  const LineInfo *info = el_line(m_editline);
+  for (const char *character = info->buffer;
        character < info->lastchar; character++) {
     if (*character != ' ')
       return false;
   }
   return true;
 }
 
 int Editline::GetLineIndexForLocation(CursorLocation location, int cursor_row) {
if (location == CursorLocation::EditingCursor) {
       }
       --line;
     }
   }
   return line;
 }
 
 void Editline::MoveCursor(CursorLocation from, CursorLocation to) {
-  const LineInfoW *info = el_wline(m_editline);
+  const LineInfo *info = el_line(m_editline);
   int editline_cursor_position =
       (int)((info->cursor - info->buffer) + GetPromptWidth());
   int editline_cursor_row = editline_cursor_position / m_terminal_width;
 
   // Determine relative starting and ending lines
   int fromLine = GetLineIndexForLocation(from, editline_cursor_row);
   int toLine = GetLineIndexForLocation(to, editline_cursor_row);
   if (toLine != fromLine) {

 
 void Editline::DisplayInput(int firstIndex) {
   fprintf(m_output_file, ANSI_SET_COLUMN_N ANSI_CLEAR_BELOW, 1);
   int line_count = (int)m_input_lines.size();
   const char *faint = m_color_prompts ? ANSI_FAINT : "";
   const char *unfaint = m_color_prompts ? ANSI_UNFAINT : "";
 
   for (int index = firstIndex; index < line_count; index++) {
     fprintf(m_output_file, "%s"
                            "%s"
-                           "%s" EditLineStringFormatSpec " ",
+                           "%s%s ",
             faint, PromptForIndex(index).c_str(), unfaint,
             m_input_lines[index].c_str());
     if (index < line_count - 1)
       fprintf(m_output_file, "\n");
   }
 }
 
-int Editline::CountRowsForLine(const EditLineStringType &content) {
+int Editline::CountRowsForLine(const std::string &content) {
   std::string prompt =
       PromptForIndex(0); // Prompt width is constant during an edit session
   int line_length = (int)(content.length() + prompt.length());
   return (line_length / m_terminal_width) + 1;
 }
 
 void Editline::SaveEditedLine() {
-  const LineInfoW *info = el_wline(m_editline);
+  const LineInfo *info = el_line(m_editline);
   m_input_lines[m_current_line_index] =
-      EditLineStringType(info->buffer, info->lastchar - info->buffer);
+      std::string(info->buffer, info->lastchar - info->buffer);
 }
 
 StringList Editline::GetInputAsStringList(int line_count) {
   StringList lines;
-  for (EditLineStringType line : m_input_lines) {
+  for (std::string line : m_input_lines) {
     if (line_count == 0)
       break;
-#if LLDB_EDITLINE_USE_WCHAR
-    lines.AppendString(m_utf8conv.to_bytes(line));
-#else
     lines.AppendString(line);
-#endif
     --line_count;
   }
   return lines;
 }
 
 unsigned char Editline::RecallHistory(HistoryOperation op) {
   assert(op == HistoryOperation::Older || op == HistoryOperation::Newer);
   if (!m_history_sp || !m_history_sp->IsValid())
     return CC_ERROR;
 
-  HistoryW *pHistory = m_history_sp->GetHistoryPtr();
-  HistEventW history_event;
-  std::vector<EditLineStringType> new_input_lines;
+  History *pHistory = m_history_sp->GetHistoryPtr();
+  HistEvent history_event;
+  std::vector<std::string> new_input_lines;
 
   // Treat moving from the "live" entry differently
   if (!m_in_history) {
     switch (op) {
     case HistoryOperation::Newer:
       return CC_ERROR; // Can't go newer than the "live" entry
     case HistoryOperation::Older: {
-      if (history_w(pHistory, &history_event,
-                    GetOperation(HistoryOperation::Newest)) == -1)
+      if (history(pHistory, &history_event,
         return CC_ERROR;
       // Save any edits to the "live" entry in case we return by moving forward
       // in history (it would be more bash-like to save over any current entry,
       // but libedit doesn't offer the ability to add entries anywhere except
       // the end.)
       SaveEditedLine();
       m_live_history_lines = m_input_lines;
       m_in_history = true;
     } break;
     default:
       llvm_unreachable("unsupported history direction");
     }
   } else {
-    if (history_w(pHistory, &history_event, GetOperation(op)) == -1) {
+    if (history(pHistory, &history_event, GetOperation(op)) == -1) {
       switch (op) {
       case HistoryOperation::Older:
         // Can't move earlier than the earliest entry.
         return CC_ERROR;
       case HistoryOperation::Newer:
         // Moving to newer-than-the-newest entry yields the "live" entry.
         new_input_lines = m_live_history_lines;
         m_in_history = false;
unsigned char Editline::RecallHistory(HistoryOperation op) {
   default:
     llvm_unreachable("unsupported history direction");
   }
   SetCurrentLine(m_current_line_index);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
   return CC_NEWLINE;
 }
 
-int Editline::GetCharacter(EditLineGetCharType *c) {
-  const LineInfoW *info = el_wline(m_editline);
+int Editline::GetCharacter(wchar_t *c) {
+  const LineInfo *info = el_line(m_editline);
 
   // Paint a faint version of the desired prompt over the version libedit draws
   // (will only be requested if colors are supported)
   if (m_needs_prompt_repaint) {
     MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
     fprintf(m_output_file, "%s"
                            "%s"
                            "%s",
if (m_editor_status == EditorStatus::Interrupted) {
       while (read_count > 0 && status == lldb::eConnectionStatusSuccess)
         read_count =
             m_input_connection.Read(&ch, 1, llvm::None, status, nullptr);
       lldbassert(status == lldb::eConnectionStatusInterrupted);
       return 0;
     }
 
     if (read_count) {
-      if (CompleteCharacter(ch, *c))
+      if (CompleteCharacter(ch, *c)) {
         return 1;
+      }
     } else {
       switch (status) {
       case lldb::eConnectionStatusSuccess: // Success
         break;
 
       case lldb::eConnectionStatusInterrupted:
         llvm_unreachable("Interrupts should have been handled above.");
 

 const char *Editline::Prompt() {
   if (m_color_prompts)
     m_needs_prompt_repaint = true;
   return m_current_prompt.c_str();
 }
 
 unsigned char Editline::BreakLineCommand(int ch) {
   // Preserve any content beyond the cursor, truncate and save the current line
-  const LineInfoW *info = el_wline(m_editline);
+  const LineInfo *info = el_line(m_editline);
   auto current_line =
-      EditLineStringType(info->buffer, info->cursor - info->buffer);
+      std::string(info->buffer, info->cursor - info->buffer);
   auto new_line_fragment =
-      EditLineStringType(info->cursor, info->lastchar - info->cursor);
+      std::string(info->cursor, info->lastchar - info->cursor);
   m_input_lines[m_current_line_index] = current_line;
 
   // Ignore whitespace-only extra fragments when breaking a line
   if (::IsOnlySpaces(new_line_fragment))
-    new_line_fragment = EditLineConstString("");
+    new_line_fragment = "";
 
   // Establish the new cursor position at the start of a line when inserting a
   // line break
   m_revert_cursor_index = 0;
 
   // Don't perform automatic formatting when pasting
   if (!IsInputPending(m_input_file)) {
     // Apply smart indentation
     if (m_fix_indentation_callback) {
       StringList lines = GetInputAsStringList(m_current_line_index + 1);
-#if LLDB_EDITLINE_USE_WCHAR
-      lines.AppendString(m_utf8conv.to_bytes(new_line_fragment));
-#else
       lines.AppendString(new_line_fragment);
-#endif
 
       int indent_correction = m_fix_indentation_callback(this, lines, 0);
       new_line_fragment = FixIndentation(new_line_fragment, indent_correction);
       m_revert_cursor_index = GetIndentation(new_line_fragment);
     }
   }
 
   // Insert the new line and repaint everything from the split line on down
if (IsInputPending(m_input_file)) {
     return BreakLineCommand(ch);
   }
 
   // Save any edits to this line
   SaveEditedLine();
 
   // If this is the end of the last line, consider whether to add a line
   // instead
-  const LineInfoW *info = el_wline(m_editline);
+  const LineInfo *info = el_line(m_editline);
   if (m_current_line_index == m_input_lines.size() - 1 &&
       info->cursor == info->lastchar) {
     if (m_is_input_complete_callback) {
       auto lines = GetInputAsStringList();
       if (!m_is_input_complete_callback(this, lines)) {
         return BreakLineCommand(ch);
       }
 
       // The completion test is allowed to change the input lines when complete
       m_input_lines.clear();
       for (unsigned index = 0; index < lines.GetSize(); index++) {
-#if LLDB_EDITLINE_USE_WCHAR
-        m_input_lines.insert(m_input_lines.end(),
-                             m_utf8conv.from_bytes(lines[index]));
-#else
         m_input_lines.insert(m_input_lines.end(), lines[index]);
-#endif
       }
     }
   }
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockEnd);
   fprintf(m_output_file, "\n");
   m_editor_status = EditorStatus::Complete;
   return CC_NEWLINE;
 }
 
 unsigned char Editline::DeleteNextCharCommand(int ch) {
-  LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+  LineInfo *info = const_cast<LineInfo *>(el_line(m_editline));
 
   // Just delete the next character normally if possible
   if (info->cursor < info->lastchar) {
     info->cursor++;
     el_deletestr(m_editline, 1);
     return CC_REFRESH;
   }
 
   // Fail when at the end of the last line, except when ^D is pressed on the
   // line is empty, in which case it is treated as EOF
   if (m_current_line_index == m_input_lines.size() - 1) {
     if (ch == 4 && info->buffer == info->lastchar) {
       fprintf(m_output_file, "^D\n");
       m_editor_status = EditorStatus::EndOfInput;
       return CC_EOF;
     }
     return CC_ERROR;
   }
 
   // Prepare to combine this line with the one below
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
 
   // Insert the next line of text at the cursor and restore the cursor position
-  const EditLineCharType *cursor = info->cursor;
-  el_winsertstr(m_editline, m_input_lines[m_current_line_index + 1].c_str());
+  const char *cursor = info->cursor;
+  el_insertstr(m_editline, m_input_lines[m_current_line_index + 1].c_str());
   info->cursor = cursor;
   SaveEditedLine();
 
   // Delete the extra line
   m_input_lines.erase(m_input_lines.begin() + m_current_line_index + 1);
 
   // Clear and repaint from this line on down
   DisplayInput(m_current_line_index);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingCursor);
   return CC_REFRESH;
 }
 
 unsigned char Editline::DeletePreviousCharCommand(int ch) {
-  LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+  const LineInfo *info = el_line(m_editline);
 
   // Just delete the previous character normally when not at the start of a
   // line
   if (info->cursor > info->buffer) {
     el_deletestr(m_editline, 1);
     return CC_REFRESH;
   }
 
unsigned char Editline::DeletePreviousCharCommand(int ch) {
   // Repaint from the new line down
   fprintf(m_output_file, ANSI_UP_N_ROWS ANSI_SET_COLUMN_N,
           CountRowsForLine(priorLine), 1);
   DisplayInput(m_current_line_index);
 
   // Put the cursor back where libedit expects it to be before returning to
   // editing by telling libedit about the newly inserted text
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
-  el_winsertstr(m_editline, priorLine.c_str());
+  el_insertstr(m_editline, priorLine.c_str());
   return CC_REDISPLAY;
 }
 
 unsigned char Editline::PreviousLineCommand(int ch) {
   SaveEditedLine();
 
   if (m_current_line_index == 0) {
     return RecallHistory(HistoryOperation::Older);
if (m_current_line_index == m_input_lines.size() - 1) {
 
     // Determine indentation for the new line
     int indentation = 0;
     if (m_fix_indentation_callback) {
       StringList lines = GetInputAsStringList();
       lines.AppendString("");
       indentation = m_fix_indentation_callback(this, lines, 0);
     }
     m_input_lines.insert(
         m_input_lines.end(),
-        EditLineStringType(indentation, EditLineCharType(' ')));
+        std::string(indentation, ' '));
   }
 
   // Move down past the current line using newlines to force scrolling if
   // needed
   SetCurrentLine(m_current_line_index + 1);
-  const LineInfoW *info = el_wline(m_editline);
+  const LineInfo *info = el_line(m_editline);
   int cursor_position = (int)((info->cursor - info->buffer) + GetPromptWidth());
   int cursor_row = cursor_position / m_terminal_width;
   for (int line_count = 0; line_count < m_current_line_rows - cursor_row;
        line_count++) {
     fprintf(m_output_file, "\n");
   }
   return CC_NEWLINE;
 }
unsigned char Editline::NextHistoryCommand(int ch) {
   return RecallHistory(HistoryOperation::Newer);
 }
 
 unsigned char Editline::FixIndentationCommand(int ch) {
   if (!m_fix_indentation_callback)
     return CC_NORM;
 
   // Insert the character typed before proceeding
-  EditLineCharType inserted[] = {(EditLineCharType)ch, 0};
-  el_winsertstr(m_editline, inserted);
-  LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+  char inserted[] = {(char)ch, 0};
+  el_insertstr(m_editline, inserted);
+  const LineInfo *info = el_line(m_editline);
   int cursor_position = info->cursor - info->buffer;
 
   // Save the edits and determine the correct indentation level
   SaveEditedLine();
   StringList lines = GetInputAsStringList(m_current_line_index + 1);
   int indent_correction =
       m_fix_indentation_callback(this, lines, cursor_position);
 
   // If it is already correct no special work is needed
   if (indent_correction == 0)
     return CC_REFRESH;
 
   // Change the indentation level of the line
   std::string currentLine = lines.GetStringAtIndex(m_current_line_index);
   if (indent_correction > 0) {
     currentLine = currentLine.insert(0, indent_correction, ' ');
   } else {
     currentLine = currentLine.erase(0, -indent_correction);
   }
-#if LLDB_EDITLINE_USE_WCHAR
-  m_input_lines[m_current_line_index] = m_utf8conv.from_bytes(currentLine);
-#else
   m_input_lines[m_current_line_index] = currentLine;
-#endif
 
   // Update the display to reflect the change
   MoveCursor(CursorLocation::EditingCursor, CursorLocation::EditingPrompt);
   DisplayInput(m_current_line_index);
 
   // Reposition the cursor back on the original line and prepare to restart
   // editing with a new cursor position
   SetCurrentLine(m_current_line_index);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
   m_revert_cursor_index = cursor_position + indent_correction;
   return CC_NEWLINE;
 }
 
 unsigned char Editline::RevertLineCommand(int ch) {
-  el_winsertstr(m_editline, m_input_lines[m_current_line_index].c_str());
+  el_insertstr(m_editline, m_input_lines[m_current_line_index].c_str());
   if (m_revert_cursor_index >= 0) {
-    LineInfoW *info = const_cast<LineInfoW *>(el_wline(m_editline));
+    LineInfo *info = const_cast<LineInfo *>(el_line(m_editline));
     info->cursor = info->buffer + m_revert_cursor_index;
     if (info->cursor > info->lastchar) {
       info->cursor = info->lastchar;
     }
     m_revert_cursor_index = -1;
   }
   return CC_REFRESH;
 }
int toColumn =
         editline_cursor_position - (editline_cursor_row * m_terminal_width);
     fprintf(m_output_file, ANSI_SET_COLUMN_N, toColumn);
     return CC_REFRESH;
   }
 
   return CC_REDISPLAY;
 }
 
-void Editline::AddFunctionToEditLine(const EditLineCharType *command,
-                                     const EditLineCharType *helptext,
+void Editline::AddFunctionToEditLine(const char *command,
+                                     const char *helptext,
                                      EditlineCommandCallbackType callbackFn) {
-  el_wset(m_editline, EL_ADDFN, command, helptext, callbackFn);
+  el_set(m_editline, EL_ADDFN, command, helptext, callbackFn);
 }
 
 void Editline::SetEditLinePromptCallback(
     EditlinePromptCallbackType callbackFn) {
   el_set(m_editline, EL_PROMPT, callbackFn);
 }
 
 void Editline::SetGetCharacterFunction(EditlineGetCharCallbackType callbackFn) {
void Editline::ConfigureEditor(bool multiline) {
   m_editline =
       el_init(m_editor_name.c_str(), m_input_file, m_output_file, m_error_file);
   ApplyTerminalSizeChange();
 
   if (m_history_sp && m_history_sp->IsValid()) {
     if (!m_history_sp->Load()) {
         fputs("Could not load history file\n.", m_output_file);
     }
-    el_wset(m_editline, EL_HIST, history, m_history_sp->GetHistoryPtr());
+    el_set(m_editline, EL_HIST, history, m_history_sp->GetHistoryPtr());
   }
   el_set(m_editline, EL_CLIENTDATA, this);
   el_set(m_editline, EL_SIGNAL, 0);
   el_set(m_editline, EL_EDITOR, "emacs");
 
-  SetGetCharacterFunction([](EditLine *editline, EditLineGetCharType *c) {
+  SetGetCharacterFunction([](EditLine *editline, wchar_t *c) {
     return Editline::InstanceFor(editline)->GetCharacter(c);
   });
 
   SetEditLinePromptCallback([](EditLine *editline) {
     return Editline::InstanceFor(editline)->Prompt();
   });
 
   // Commands used for multiline support, registered whether or not they're
   // used
   AddFunctionToEditLine(
-      EditLineConstString("lldb-break-line"),
-      EditLineConstString("Insert a line break"),
+      "lldb-break-line",
+      "Insert a line break",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->BreakLineCommand(ch);
       });
 
   AddFunctionToEditLine(
-      EditLineConstString("lldb-end-or-add-line"),
-      EditLineConstString("End editing or continue when incomplete"),
+      "lldb-end-or-add-line",
+      "End editing or continue when incomplete",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->EndOrAddLineCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-delete-next-char"),
-      EditLineConstString("Delete next character"),
+      "lldb-delete-next-char",
+      "Delete next character",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->DeleteNextCharCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-delete-previous-char"),
-      EditLineConstString("Delete previous character"),
+      "lldb-delete-previous-char",
+      "Delete previous character",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->DeletePreviousCharCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-previous-line"),
-      EditLineConstString("Move to previous line"),
+      "lldb-previous-line",
+      "Move to previous line",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->PreviousLineCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-next-line"),
-      EditLineConstString("Move to next line"), [](EditLine *editline, int ch) {
+      "lldb-next-line",
+      "Move to next line", [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->NextLineCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-previous-history"),
-      EditLineConstString("Move to previous history"),
+      "lldb-previous-history",
+      "Move to previous history",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->PreviousHistoryCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-next-history"),
-      EditLineConstString("Move to next history"),
+      "lldb-next-history",
+      "Move to next history",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->NextHistoryCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-buffer-start"),
-      EditLineConstString("Move to start of buffer"),
+      "lldb-buffer-start",
+      "Move to start of buffer",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->BufferStartCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-buffer-end"),
-      EditLineConstString("Move to end of buffer"),
+      "lldb-buffer-end",
+      "Move to end of buffer",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->BufferEndCommand(ch);
       });
   AddFunctionToEditLine(
-      EditLineConstString("lldb-fix-indentation"),
-      EditLineConstString("Fix line indentation"),
+      "lldb-fix-indentation",
+      "Fix line indentation",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->FixIndentationCommand(ch);
       });
 
   // Register the complete callback under two names for compatibility with
   // older clients using custom .editrc files (largely because libedit has a
   // bad bug where if you have a bind command that tries to bind to a function
   // name that doesn't exist, it can corrupt the heap and crash your process
   // later.)
   EditlineCommandCallbackType complete_callback = [](EditLine *editline,
                                                      int ch) {
     return Editline::InstanceFor(editline)->TabCommand(ch);
   };
-  AddFunctionToEditLine(EditLineConstString("lldb-complete"),
-                        EditLineConstString("Invoke completion"),
+  AddFunctionToEditLine("lldb-complete",
+                        "Invoke completion",
                         complete_callback);
-  AddFunctionToEditLine(EditLineConstString("lldb_complete"),
-                        EditLineConstString("Invoke completion"),
+  AddFunctionToEditLine("lldb_complete",
+                        "Invoke completion",
                         complete_callback);
 
   // General bindings we don't mind being overridden
   if (!multiline) {
     el_set(m_editline, EL_BIND, "^r", "em-inc-search-prev",
            NULL); // Cycle through backwards search, entering string
 
     if (m_suggestion_callback) {
       AddFunctionToEditLine(
-          EditLineConstString("lldb-apply-complete"),
-          EditLineConstString("Adopt autocompletion"),
+          "lldb-apply-complete",
+          "Adopt autocompletion",
           [](EditLine *editline, int ch) {
             return Editline::InstanceFor(editline)->ApplyAutosuggestCommand(ch);
           });
 
       el_set(m_editline, EL_BIND, "^f", "lldb-apply-complete",
              NULL); // Apply a part that is suggested automatically
 
       AddFunctionToEditLine(
-          EditLineConstString("lldb-typed-character"),
-          EditLineConstString("Typed character"),
+          "lldb-typed-character",
+          "Typed character",
           [](EditLine *editline, int ch) {
             return Editline::InstanceFor(editline)->TypedCharacter(ch);
           });
 
       char bind_key[2] = {0, 0};
       llvm::StringRef ascii_chars =
           "abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY1234567890!\"#$%"
           "&'()*+,./:;<=>?@[]_`{|}~ ";
void Editline::ConfigureEditor(bool multiline) {
   el_set(m_editline, EL_BIND, ESCAPE ESCAPE "[D", "ed-prev-word", NULL);
 
   // Allow user-specific customization prior to registering bindings we
   // absolutely require
   el_source(m_editline, nullptr);
 
   // Register an internal binding that external developers shouldn't use
   AddFunctionToEditLine(
-      EditLineConstString("lldb-revert-line"),
-      EditLineConstString("Revert line to saved state"),
+      "lldb-revert-line",
+      "Revert line to saved state",
       [](EditLine *editline, int ch) {
         return Editline::InstanceFor(editline)->RevertLineCommand(ch);
       });
 
   // Register keys that perform auto-indent correction
   if (m_fix_indentation_callback && m_fix_indentation_callback_chars) {
     char bind_key[2] = {0, 0};
     const char *indent_chars = m_fix_indentation_callback_chars;
void Editline::ApplyTerminalSizeChange() {
   // vararg part, but in reality in was consuming arguments until the first
   // null pointer. This was fixed in libedit in April 2019
   // <http://mail-index.netbsd.org/source-changes/2019/04/26/msg105454.html>,
   // but we're keeping the workaround until a version with that fix is more
   // widely available.
   if (el_get(m_editline, EL_GETTC, "co", &columns, nullptr) == 0) {
     m_terminal_width = columns;
     if (m_current_line_rows != -1) {
-      const LineInfoW *info = el_wline(m_editline);
+      const LineInfo *info = el_line(m_editline);
       int lineLength =
           (int)((info->lastchar - info->buffer) + GetPromptWidth());
       m_current_line_rows = (lineLength / columns) + 1;
     }
   } else {
     m_terminal_width = INT_MAX;
     m_current_line_rows = 1;
   }
if (m_editor_status == EditorStatus::Editing) {
     result = m_input_connection.InterruptRead();
   }
   m_editor_status = EditorStatus::Interrupted;
   return result;
 }
 
 bool Editline::GetLine(std::string &line, bool &interrupted) {
   ConfigureEditor(false);
-  m_input_lines = std::vector<EditLineStringType>();
-  m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
+  m_input_lines = std::vector<std::string>();
+  m_input_lines.insert(m_input_lines.begin(), "");
 
   std::lock_guard<std::mutex> guard(m_output_mutex);
 
   lldbassert(m_editor_status != EditorStatus::Editing);
   if (m_editor_status == EditorStatus::Interrupted) {
     m_editor_status = EditorStatus::Complete;
     interrupted = true;
     return true;
   }
 
   SetCurrentLine(0);
   m_in_history = false;
   m_editor_status = EditorStatus::Editing;
   m_revert_cursor_index = -1;
 
   int count;
-  auto input = el_wgets(m_editline, &count);
+  auto input = el_gets(m_editline, &count);
 
   interrupted = m_editor_status == EditorStatus::Interrupted;
   if (!interrupted) {
     if (input == nullptr) {
       fprintf(m_output_file, "\n");
       m_editor_status = EditorStatus::EndOfInput;
     } else {
       m_history_sp->Enter(input);
-#if LLDB_EDITLINE_USE_WCHAR
-      line = m_utf8conv.to_bytes(SplitLines(input)[0]);
-#else
       line = SplitLines(input)[0];
-#endif
       m_editor_status = EditorStatus::Complete;
     }
   }
   return m_editor_status != EditorStatus::EndOfInput;
 }
 
 bool Editline::GetLines(int first_line_number, StringList &lines,
                         bool &interrupted) {
   ConfigureEditor(true);
 
   // Print the initial input lines, then move the cursor back up to the start
   // of input
   SetBaseLineNumber(first_line_number);
-  m_input_lines = std::vector<EditLineStringType>();
-  m_input_lines.insert(m_input_lines.begin(), EditLineConstString(""));
+  m_input_lines = std::vector<std::string>();
+  m_input_lines.insert(m_input_lines.begin(), "");
 
   std::lock_guard<std::mutex> guard(m_output_mutex);
   // Begin the line editing loop
   DisplayInput();
   SetCurrentLine(0);
   MoveCursor(CursorLocation::BlockEnd, CursorLocation::BlockStart);
   m_editor_status = EditorStatus::Editing;
   m_in_history = false;
 
   m_revert_cursor_index = -1;
   while (m_editor_status == EditorStatus::Editing) {
     int count;
     m_current_line_rows = -1;
-    el_wpush(m_editline, EditLineConstString(
-                             "\x1b[^")); // Revert to the existing line content
-    el_wgets(m_editline, &count);
+    el_push(m_editline, "\x1b[^"); // Revert to the existing line content
+    el_gets(m_editline, &count);
   }
 
   interrupted = m_editor_status == EditorStatus::Interrupted;
   if (!interrupted) {
     // Save the completed entry in history before returning
     m_history_sp->Enter(CombineLines(m_input_lines).c_str());
 
     lines = GetInputAsStringList();
void Editline::PrintAsync(Stream *stream, const char *s, size_t len) {
   stream->Write(s, len);
   stream->Flush();
   if (m_editor_status == EditorStatus::Editing) {
     DisplayInput();
     MoveCursor(CursorLocation::BlockEnd, CursorLocation::EditingCursor);
   }
 }
 
-bool Editline::CompleteCharacter(char ch, EditLineGetCharType &out) {
-#if !LLDB_EDITLINE_USE_WCHAR
-  if (ch == (char)EOF)
-    return false;
-
-  out = (unsigned char)ch;
-  return true;
-#else
+bool Editline::CompleteCharacter(char ch, wchar_t &out) {
   std::codecvt_utf8<wchar_t> cvt;
   llvm::SmallString<4> input;
   for (;;) {
     const char *from_next;
     wchar_t *to_next;
     std::mbstate_t state = std::mbstate_t();
     input.push_back(ch);
     switch (cvt.in(state, input.begin(), input.end(), from_next, &out, &out + 1,
                    to_next)) {
     case std::codecvt_base::ok:
       return out != (int)WEOF;
 
     case std::codecvt_base::error:
     case std::codecvt_base::noconv:
       return false;
 
     case std::codecvt_base::partial:
       lldb::ConnectionStatus status;
-      size_t read_count = m_input_connection.Read(
-          &ch, 1, std::chrono::seconds(0), status, nullptr);
+      size_t read_count = m_input_connection.Read(&ch, 1, std::chrono::seconds(0), status, nullptr);
       if (read_count == 0)
         return false;
       break;
     }
   }
-#endif
 }