[lldb] Remove lldbassert from CommandInterpreter::PrintCommandOutput

[JDevlieghere]

Summary

The assertion checks that the command output doesn't contain any null
bytes. I'm not sure if the intention was to make sure the string wasn't
shorter than the reported length or if this was a way to catch us
accidentally writing an (unformatted) null byte.

Regardless, the command output can be based on user input, so an
assertion doesn't make sense. For example, you should be totally allowed
to call print("\0") from Python. The latter doesn't trigger this bug
because it writes directly to the output stream and therefore bypasses
PrintCommandOutput but that's just an implementation detail.

[jingham]

I think it makes sense to require that the CommandResultObject's command output is UTF-8 string with no embedded '\0'-s. We wouldn't do smart things with rendering command output with nulls in it, and I don't see any reason to support such a thing.

OTOH, this seems like the wrong place to check that, since it's pretty far removed from whoever would have added the null's. If we wanted to do this right, we would sanitize when you write to the CommandResultObject.

[labath]

Agreed we generally don't want to have embedded nuls in the command output, but I don't think we have to go to such great lengths to enforce it.

The latter doesn't trigger this bug because it writes directly to the output stream and therefore bypasses PrintCommandOutput but that's just an implementation detail.

I guess this would be triggered by sb_command_return_object.PutOutput("\0")

lldb/source/Interpreter/CommandInterpreter.cpp

2986–2989

I guess this could now be something like std::tie(line, str) = str.split('\n');

[JDevlieghere]

Use StringRef::split

lldb/source/Interpreter/CommandInterpreter.cpp

 
 void CommandInterpreter::PrintCommandOutput(IOHandler &io_handler,
                                             llvm::StringRef str,
                                             bool is_stdout) {
 
   lldb::StreamFileSP stream = is_stdout ? io_handler.GetOutputStreamFileSP()
                                         : io_handler.GetErrorStreamFileSP();
   // Split the output into lines and poll for interrupt requests
-  const char *data = str.data();
   size_t size = str.size();
   while (size > 0 && !WasInterrupted()) {
-    size_t chunk_size = 0;
-    for (; chunk_size < size; ++chunk_size) {
-      lldbassert(data[chunk_size] != '\0');
-      if (data[chunk_size] == '\n') {
-        ++chunk_size;
-        break;
-      }
-    }
+    llvm::StringRef line;
+    size_t written = 0;
+    std::tie(line, str) = str.split('\n');
     {
       std::lock_guard<std::recursive_mutex> guard(io_handler.GetOutputMutex());
-      chunk_size = stream->Write(data, chunk_size);
+      written += stream->Write(line.data(), line.size());
+      written += stream->Write("\n", 1);
     }
-    lldbassert(size >= chunk_size);
-    data += chunk_size;
-    size -= chunk_size;
+    lldbassert(size >= written);
+    size -= written;
   }
 
   std::lock_guard<std::recursive_mutex> guard(io_handler.GetOutputMutex());
   if (size > 0)
     stream->Printf("\n... Interrupted.\n");
   stream->Flush();
 }