Don't remove backslashes from arguments unless the following char is recognized.

[zturner]

Summary

This fixes file paths on Windows, as you can now write, for example, d:\foo\bar.txt, but does not break the case that this tokenization logic was originally designed for, which is to allow escaping of things like quotes and double quotes, so that all of the escapable characters can appear in the same string together.

I think this is a much simpler and more straightforward fix than adding a different tokenizer. Having only 1 tokenizer means we don't have to worry in the future about tests breaking because someone wrote their test on unix and tried to execute a command with a syntax that wouldn't work on Windows, etc. So hopefully we can reach an agreement about this fix.

[clayborg]

Seems like it should work as long as the test suite passes fine.

[jingham]

If I had a path component that began with a space (dunno if you can do that on Windows) what would I have to do to enter that?

d:\\ foo\bar

?

I guess that's not too horrible...

Jim

[zturner]

In D7018#109970, @jingham wrote:

If I had a path component that began with a space (dunno if you can do that on Windows) what would I have to do to enter that?

d:\\ foo\bar

?

I guess that's not too horrible...

Jim

That's not a valid file path on Windows. (path components can't have leading or trailing whitespace). Although if for whatever reason you really wanted to specify it, you could still do "d:\ foo\bar"

[zturner]

Going to go ahead and commit this. Did not see test failures on Linux. My Mac is down at the moment, but I think any tests failures that were going to happen should have surfaced on Linux. If we do see failures, whoever sees it first is free to revert to green until I figure it out.

lldb/trunk/source/Interpreter/Args.cpp

 {
     m_args.clear();
     m_argv.clear();
     m_args_quote_char.clear();
 
     if (command && command[0])
     {
         static const char *k_space_separators = " \t";
-        static const char *k_space_separators_with_slash_and_quotes = " \t \\'\"";
+        static const char *k_escapable_characters = " \t\\'\"";
         const char *arg_end = nullptr;
         const char *arg_pos;
         for (arg_pos = command;
              arg_pos && arg_pos[0];
              arg_pos = arg_end)
         {
             // Skip any leading space separators
             const char *arg_start = ::strspn (arg_pos, k_space_separators) + arg_pos;
if (command && command[0])
             // argument "Hello world!") we remember the first quote character
             // we encounter and use that for the quote character.
             char first_quote_char = '\0';
             char quote_char = '\0';
             bool arg_complete = false;
 
             do
             {
-                arg_end = ::strcspn (arg_pos, k_space_separators_with_slash_and_quotes) + arg_pos;
+                arg_end = ::strcspn (arg_pos, k_escapable_characters) + arg_pos;
 
                 switch (arg_end[0])
                 {
                 default:
                     assert (!"Unhandled case statement, we must handle this...");
                     break;
 
                 case '\0':
                     // End of C string
                     if (arg_piece_start && arg_piece_start[0])
                         arg.append (arg_piece_start);
                     arg_complete = true;
                     break;
-                    
                 case '\\':
                     // Backslash character
                     switch (arg_end[1])
                     {
                         case '\0':
                             arg.append (arg_piece_start);
                             ++arg_end;
                             arg_complete = true;
                             break;
 
                         default:
-                            if (quote_char == '\0')
+                            // Only consider this two-character sequence an escape sequence if we're unquoted and
+                            // the character after the backslash is a whitelisted escapable character.  Otherwise
+                            // leave the character sequence untouched.
+                            if (quote_char == '\0' && (nullptr != strchr(k_escapable_characters, arg_end[1])))
                             {
                                 arg.append (arg_piece_start, arg_end - arg_piece_start);
-                                if (arg_end[1] != '\0')
-                                {
-                                    arg.append (arg_end + 1, 1);
-                                    arg_pos = arg_end + 2;
-                                    arg_piece_start = arg_pos;
-                                }
-                            }
                             else
                                 arg_pos = arg_end + 2;
                             break;
                     }
                     break;
-                
                 case '"':
                 case '\'':
                 case '`':
                     // Quote characters 
                     if (quote_char)
                     {
                         // We found a quote character while inside a quoted
                         // character argument. If it matches our current quote