takes | True Object-Oriented Java Web Framework without NULLs, Static Methods, Annotations, and Mutable Obje | HTTP library

No.

You have these options:

1. Use std::string as the "external" buffer in the first place.
2. Copy the external buffer into the string.
3. Don't use (reference to) std::string as the parameter.
   • std::string_view is a typically good choice. However, it's very easy to create non-null terminated string views, and your premise explicitly states null termination. If that's important, then you may need to avoid string view.
   • If string view isn't appropriate, then you can use const char* to point to the null terminated string.

Paragraph 2 says:

If, in the replacement list, a parameter is immediately preceded by a # preprocessing token, both are replaced by a single character string literal preprocessing token that contains the spelling of the preprocessing token sequence for the corresponding argument. Each occurrence of white space between the argument’s preprocessing tokens becomes a single space character in the character string literal. White space before the first preprocessing token and after the last preprocessing token composing the argument is deleted…

The X(Y,Y) macro invocation must have resulted in the tokens Y and Y, and we see in #define X(x,y) x y that they would have white space between them.

White-space in a macro replacement list is significant, per 6.10.3 1, which says:

Two replacement lists are identical if and only if the preprocessing tokens in both have the same number, ordering, spelling, and white-space separation, where all white-space separations are considered identical.

Thus, in #define X(x,y) x y, the replacement list should not be considered to be just the two tokens x and y, with white space disregarded. The replacement list is x, white space, and y.

Further, when the macro is replaced, it is replaced by the replacement list (and hence includes white space), not merely by the tokens in the replacement list, per 6.10.3 10:

… Each subsequent instance of the function-like macro name followed by a ( as the next preprocessing token introduces the sequence of preprocessing tokens that is replaced by the replacement list in the definition (an invocation of the macro)… Within the sequence of preprocessing tokens making up an invocation of a function-like macro, new-line is considered a normal white-space character.

This would be explained (and expected) if your files are stored on /mnt/c (a.k.a. C:, or /C under Git Bash) or any other Windows drive, as they would likely need to be to be accessed by Git Bash.

WSL2 uses the 9P protocol to access Windows drives, and it is currently known to be very slow when compared to:

• Native NTFS (obviously)
• The ext4 filesystem on the virtual disk used by WSL2
• And even the performance of WSL1 with Windows drives

I've seen a git clone of a large repo (the WSL2 Linux kernel Github) take 8 minutes on WSL2 on a Windows drive, but only seconds on the root filesystem.

Two possibilities:

• If possible (and it is for most Node projects), convert your WSL to version 1 with wsl --set-version 1. I always recommend making a backup with wsl --export first.

  And since you are making a backup anyway, you may as well just create a copy of the instance by wsl --importing your backup as --version 1 (as the last argument). WSL1 and WSL2 both have their uses, and you may find it helpful to keep both around.

  See this answer for more details on the exact syntax..

• Or just move the project over to somewhere under the WSL root, such as /home/username/src/.