forked from mozilla/sccache
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Response file parsing for GCC and Clang
This fixes mozilla#1780 This moves the response file parsing code implemented by @temportalflux out of the MSVC compiler and shares it for all compilers. This enables GCC and Clang to use response files with quoted arguments. I've added some lib tests to the response file module, so that it can be reasoned about, separately from the compilers using it.
- Loading branch information
1 parent
7416904
commit b985902
Showing
4 changed files
with
174 additions
and
130 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -23,6 +23,7 @@ mod diab; | |
| mod gcc; | ||
| mod msvc; | ||
| mod nvcc; | ||
| mod response_file; | ||
| mod rust; | ||
| mod tasking_vx; | ||
| #[macro_use] | ||
|
|
||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,165 @@ | ||
| /// An iterator over the arguments in a response file. | ||
| /// | ||
| /// This produces results identical to `CommandLineToArgvW` except in the | ||
| /// following cases: | ||
| /// | ||
| /// 1. When passed an empty string, CommandLineToArgvW returns the path to the | ||
| /// current executable file. Here, the iterator will simply be empty. | ||
| /// 2. CommandLineToArgvW interprets the first argument differently than the | ||
| /// rest. Here, all arguments are treated in identical fashion. | ||
| /// | ||
| /// Parsing rules: | ||
| /// | ||
| /// - Arguments are delimited by whitespace (either a space or tab). | ||
| /// - A string surrounded by double quotes is interpreted as a single argument. | ||
| /// - Backslashes are interpreted literally unless followed by a double quote. | ||
| /// - 2n backslashes followed by a double quote reduce to n backslashes and we | ||
| /// enter the "in quote" state. | ||
| /// - 2n+1 backslashes followed by a double quote reduces to n backslashes, | ||
| /// we do *not* enter the "in quote" state, and the double quote is | ||
| /// interpreted literally. | ||
| /// | ||
| /// References: | ||
| /// - https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391(v=vs.85).aspx | ||
| /// - https://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx | ||
| #[derive(Clone, Debug)] | ||
| pub struct SplitResponseFileArgs<'a> { | ||
| /// String slice of the file content that is being parsed. | ||
| /// Slice is mutated as this iterator is executed. | ||
| file_content: &'a str, | ||
| } | ||
|
|
||
| impl<'a, T> From<&'a T> for SplitResponseFileArgs<'a> | ||
| where | ||
| T: AsRef<str> + 'static, | ||
| { | ||
| fn from(file_content: &'a T) -> Self { | ||
| Self { | ||
| file_content: file_content.as_ref(), | ||
| } | ||
| } | ||
| } | ||
|
|
||
| impl<'a> SplitResponseFileArgs<'a> { | ||
| /// Appends backslashes to `target` by decrementing `count`. | ||
| /// If `step` is >1, then `count` is decremented by `step`, resulting in 1 backslash appended for every `step`. | ||
| fn append_backslashes_to(target: &mut String, count: &mut usize, step: usize) { | ||
| while *count >= step { | ||
| target.push('\\'); | ||
| *count -= step; | ||
| } | ||
| } | ||
| } | ||
|
|
||
| impl<'a> Iterator for SplitResponseFileArgs<'a> { | ||
| type Item = String; | ||
|
|
||
| fn next(&mut self) -> Option<String> { | ||
| let mut in_quotes = false; | ||
| let mut backslash_count: usize = 0; | ||
|
|
||
| // Strip any leading whitespace before relevant characters | ||
| let is_whitespace = |c| matches!(c, ' ' | '\t' | '\n' | '\r'); | ||
| self.file_content = self.file_content.trim_start_matches(is_whitespace); | ||
|
|
||
| if self.file_content.is_empty() { | ||
| return None; | ||
| } | ||
|
|
||
| // The argument string to return, built by analyzing the current slice in the iterator. | ||
| let mut arg = String::new(); | ||
| // All characters still in the string slice. Will be mutated by consuming | ||
| // values until the current arg is built. | ||
| let mut chars = self.file_content.chars(); | ||
| // Build the argument by evaluating each character in the string slice. | ||
| for c in &mut chars { | ||
| match c { | ||
| // In order to handle the escape character based on the char(s) which come after it, | ||
| // they are counted instead of appended literally, until a non-backslash character is encountered. | ||
| '\\' => backslash_count += 1, | ||
| // Either starting or ending a quoted argument, or appending a literal character (if the quote was escaped). | ||
| '"' => { | ||
| // Only append half the number of backslashes encountered, because this is an escaped string. | ||
| // This will reduce `backslash_count` to either 0 or 1. | ||
| Self::append_backslashes_to(&mut arg, &mut backslash_count, 2); | ||
| match backslash_count == 0 { | ||
| // If there are no remaining encountered backslashes, | ||
| // then we have found either the start or end of a quoted argument. | ||
| true => in_quotes = !in_quotes, | ||
| // The quote character is escaped, so it is treated as a literal and appended to the arg string. | ||
| false => { | ||
| backslash_count = 0; | ||
| arg.push('"'); | ||
| } | ||
| } | ||
| } | ||
| // If whitespace is encountered, only preserve it if we are currently in quotes. | ||
| // Otherwise it marks the end of the current argument. | ||
| ' ' | '\t' | '\n' | '\r' => { | ||
| Self::append_backslashes_to(&mut arg, &mut backslash_count, 1); | ||
| // If not in a quoted string, then this is the end of the argument. | ||
| if !in_quotes { | ||
| break; | ||
| } | ||
| // Otherwise, the whitespace must be preserved in the argument. | ||
| arg.push(c); | ||
| } | ||
| // All other characters treated as is | ||
| _ => { | ||
| Self::append_backslashes_to(&mut arg, &mut backslash_count, 1); | ||
| arg.push(c); | ||
| } | ||
| } | ||
| } | ||
|
|
||
| // Flush any backslashes at the end of the string. | ||
| Self::append_backslashes_to(&mut arg, &mut backslash_count, 1); | ||
| // Save the current remaining characters for the next step in the iterator. | ||
| self.file_content = chars.as_str(); | ||
|
|
||
| Some(arg) | ||
| } | ||
| } | ||
|
|
||
| #[cfg(test)] | ||
| mod test { | ||
| use super::*; | ||
|
|
||
| #[test] | ||
| fn parse_simple_args() { | ||
| let content = "-A1 -A2 -A3 -I ../includes"; | ||
| let args = SplitResponseFileArgs::from(&content).collect::<Vec<_>>(); | ||
| assert_eq!(args[0], "-A1"); | ||
| assert_eq!(args[1], "-A2"); | ||
| assert_eq!(args[2], "-A3"); | ||
| assert_eq!(args[3], "-I"); | ||
| assert_eq!(args[4], "../includes"); | ||
| } | ||
|
|
||
| #[test] | ||
| fn parse_quoted_path_arg() { | ||
| let content = "-I \"../included headers\""; | ||
| let args = SplitResponseFileArgs::from(&content).collect::<Vec<_>>(); | ||
| assert_eq!(args[0], "-I"); | ||
| assert_eq!(args[1], "../included headers"); | ||
| } | ||
|
|
||
| #[test] | ||
| fn parse_escaped_quoted_path_arg() { | ||
| let content = "-I \"../included \\\"headers\\\"\""; | ||
| let args = SplitResponseFileArgs::from(&content).collect::<Vec<_>>(); | ||
| assert_eq!(args[0], "-I"); | ||
| assert_eq!(args[1], "../included \"headers\""); | ||
| } | ||
|
|
||
| #[test] | ||
| fn parse_various_whitespace_characters() { | ||
| let content = "-A1 -A2\n-A3\n\r-A4\r-A5\n "; | ||
| let args = SplitResponseFileArgs::from(&content).collect::<Vec<_>>(); | ||
| assert_eq!(args[0], "-A1"); | ||
| assert_eq!(args[1], "-A2"); | ||
| assert_eq!(args[2], "-A3"); | ||
| assert_eq!(args[3], "-A4"); | ||
| assert_eq!(args[4], "-A5"); | ||
| } | ||
| } |