Add preliminary support for string wrapping arguments

Author: spoonmilk

formatter/generic/genericformatter.cpp

@@ -16,6 +16,10 @@ enum ItemType
 	ArgumentSeparator,
 	Statement,
 	StatementSeparator,
+	StringComponent,
+	StringSeparator,
+	FormatSpecifier,
+	EscapeSequence,
 	Group,
 	Container,
 	StartOfContainer,
@@ -250,6 +254,184 @@ static vector<Item> CreateStatementItems(const vector<Item>& items)
 	return result;
 }
 
+static vector<InstructionTextToken> SeparateStringTokens(
+	const InstructionTextToken& unprocessedStringToken
+)
+{
+	// Takes a StringToken and breaks it into sub-StringTokens along boundaries of punctuation
+	// and spaces
+	//
+	// Ex.
+	// "this.that" -> {"this", ".", "that"}
+	// "format%llxsomething" -> {"format", "%llx", "something"}
+	// "meep\n"moop" -> {"meep", "\n", "moop"}
+
+	vector<InstructionTextToken> result;
+	string current;
+	size_t i = 0;
+	while (i < unprocessedStringToken.text.size())
+	{
+		char c = unprocessedStringToken.text[i];
+
+		// Handle format specifiers
+		if (c == '%')
+		{
+			if (!current.empty())
+			{
+				result.push_back(InstructionTextToken(StringToken, current));
+				current.clear();
+			}
+
+			string format = "%";
+			i++;
+			while (i < unprocessedStringToken.text.size())
+			{
+				c = unprocessedStringToken.text[i];
+				if (!isalnum(c) && c != '.' && c != '-')
+					break;
+				format += c;
+				i++;
+			}
+			result.push_back(InstructionTextToken(StringToken, format));
+			continue;
+		}
+
+		// Handle escape sequences
+		if (c == '\\')
+		{
+			if (!current.empty())
+			{
+				result.push_back(InstructionTextToken(StringToken, current));
+				current.clear();
+			}
+
+			string escape = "\\";
+			if (i + 1 < unprocessedStringToken.text.size())
+			{
+				escape += unprocessedStringToken.text[i + 1];
+				i += 2;
+			}
+			else
+				i++;
+			result.push_back(InstructionTextToken(StringToken, escape));
+			continue;
+		}
+
+		// Handle punctuation and spaces
+		if (c == ',' || c == '.' || c == ':' || c == ';')
+		{
+			if (!current.empty())
+			{
+				result.push_back(InstructionTextToken(StringToken, current));
+				current.clear();
+			}
+
+			string repeated;
+			repeated += c;
+			while (i + 1 < unprocessedStringToken.text.size())
+			{
+				char next = unprocessedStringToken.text[i + 1];
+				if (next == ',' || next == '.' || next == ':' || next == ';')
+				{
+					repeated += next;
+					i++;
+				}
+				else
+					break;
+			}
+			result.push_back(InstructionTextToken(StringToken, repeated));
+		}
+		else if (isspace(c))
+		{
+			if (!current.empty())
+			{
+				result.push_back(InstructionTextToken(StringToken, current));
+				current.clear();
+			}
+
+			string repeated;
+			repeated += c;
+			while (i + 1 < unprocessedStringToken.text.size())
+			{
+				char next = unprocessedStringToken.text[i + 1];
+				if (isspace(next))
+				{
+					repeated += next;
+					i++;
+				}
+				else
+					break;
+			}
+			result.push_back(InstructionTextToken(StringToken, repeated));
+		}
+		else
+		{
+			current += c;
+		}
+		i++;
+	}
+
+	if (!current.empty())
+		result.push_back(InstructionTextToken(StringToken, current));
+
+	return result;
+}
+
+static vector<Item> CreateStringGroups(const vector<Item>& items)
+{
+    vector<Item> result, pending;
+    bool hasStrings = false;
+    for (auto& i : items)
+    {
+		if (i.type == StringSeparator && !i.tokens.empty())
+		{
+			if (pending.empty())
+			{
+				result.push_back(Item {Atom, {}, {i.tokens}, 0});
+			}
+			else
+			{
+				for (auto& j : i.tokens)
+					pending.back().AddTokenToLastAtom(j);
+				result.push_back(Item {StringComponent, pending, {}, 0});
+			}
+			pending.clear();
+			hasStrings = true;
+		}
+    	else if (i.type == FormatSpecifier || i.type == EscapeSequence)
+    	{
+    		if (!pending.empty())
+    		{
+    			result.push_back(Item {StringComponent, pending, {}, 0 });
+    			pending.clear();
+    		}
+    		result.push_back(Item { Atom, i.items, i.tokens, i.width});
+    	}
+    	else if (i.type == StartOfContainer && pending.empty())
+    	{
+    		result.push_back(i);
+    	}
+    	else if (i.type == EndOfContainer && hasStrings && !pending.empty())
+    	{
+    		result.push_back(Item {StringComponent, pending, {}, 0});
+    		result.push_back(i);
+    	}
+    	else
+    	{
+    		pending.push_back(Item {i.type, CreateStringGroups(i.items), i.tokens, 0});
+    	}
+    }
+
+	if (!pending.empty())
+	{
+		if (hasStrings)
+			result.push_back(Item {StringComponent, pending, {}, 0});
+		else
+			result.insert(result.end(), pending.begin(), pending.end());
+	}
+
+	return result;
+}
 
 static vector<Item> CreateAssignmentOperatorGroups(const vector<Item>& items)
 {
@@ -576,8 +758,7 @@ vector<DisassemblyTextLine> GenericLineFormatter::FormatLines(
 		size_t tokenIndex = indentationTokens.size();
 
 		// First break the line down into nested container items. A container is anything between a pair of
-		// BraceTokens (except for strings, where the entire string, including the quotes, are treated as
-		// a single atom).
+		// BraceTokens
 		vector<Item> items;
 		stack<vector<Item>> itemStack;
 		for (; tokenIndex < currentLine.tokens.size(); tokenIndex++)
@@ -591,26 +772,26 @@ vector<DisassemblyTextLine> GenericLineFormatter::FormatLines(
 				if (tokenIndex + 1 < currentLine.tokens.size()
 					&& currentLine.tokens[tokenIndex + 1].type == StringToken)
 				{
-					// Treat string tokens surrounded by brace tokens as a unit (this is usually the quotes
-					// surrounding the string)
-					Item atom;
-					atom.type = Atom;
-					atom.tokens.push_back(token);
-					atom.tokens.push_back(currentLine.tokens[tokenIndex + 1]);
-					atom.width = 0;
-					tokenIndex++;
-					if (tokenIndex + 1 < currentLine.tokens.size()
-						&& currentLine.tokens[tokenIndex + 1].type == BraceToken)
-					{
-						atom.tokens.push_back(currentLine.tokens[tokenIndex + 1]);
-						tokenIndex++;
-					}
+					// Create a ContainerContents item and place it onto the item stack. This will hold anything
+					// inside the container once the end of the container is found.
+					items.push_back(Item {Container, {}, {}, 0});
+					itemStack.push(items);
 
-					items.push_back(atom);
-					break;
+					// Starting a new context
+					items.clear();
+					items.push_back(Item {StartOfContainer, {}, {token}, 0});
 				}
-
-				if (trimmedText == "(" || trimmedText == "[" || trimmedText == "{")
+				// Check for end of string - gross!
+				else if (currentLine.tokens[tokenIndex].type == StringToken
+					&& tokenIndex + 1 < currentLine.tokens.size()
+					&& currentLine.tokens[tokenIndex + 1].type == BraceToken)
+				{
+					// Create a ContainerContents item and place it onto the item stack. This will hold anything
+					// inside the container once the end of the container is found.
+					items.push_back(Item {Container, {}, {}, 0});
+					itemStack.push(items);
+				}
+				else if (trimmedText == "(" || trimmedText == "[" || trimmedText == "{")
 				{
 					// Create a ContainerContents item and place it onto the item stack. This will hold anything
 					// inside the container once the end of the container is found.
@@ -663,6 +844,26 @@ vector<DisassemblyTextLine> GenericLineFormatter::FormatLines(
 				else
 					items.push_back(Item {Operator, {}, {token}, 0});
 				break;
+			case StringToken:
+			{
+				vector<InstructionTextToken> stringTokens = SeparateStringTokens(token);
+				for (size_t k = 0; k < stringTokens.size(); k++)
+				{
+					InstructionTextToken subToken = stringTokens[k];
+					string trimmedSubText = TrimString(subToken.text);
+					if (trimmedSubText.empty())
+						items.push_back(Item {StringSeparator, {}, {subToken}, 0});
+					if (trimmedSubText[0] == '%')
+						items.push_back(Item {FormatSpecifier, {}, {subToken}, 0});
+					else if (!trimmedSubText.empty() && trimmedSubText[0] == '\\')
+						items.push_back(Item {EscapeSequence, {}, {subToken}, 0});
+					else if (trimmedSubText[0] == ',' || trimmedSubText[0] == '.' || trimmedSubText[0] == ':' || trimmedSubText[0] == ';')
+						items.push_back(Item {StringSeparator, {}, {subToken}, 0});
+					else
+						items.push_back(Item {Atom, {}, {subToken}, 0});
+				}
+				break;
+			}
 			default:
 				items.push_back(Item {Atom, {}, {token}, 0});
 				break;
@@ -699,6 +900,10 @@ vector<DisassemblyTextLine> GenericLineFormatter::FormatLines(
 		// the previous atom.
 		items = RelocateStartAndEndOfContainerItems(items);
 
+		// Create internal groupings for displaying strings -- grouping items by punctuation, format specifiers, and
+		// escape sequences
+		items = CreateStringGroups(items);
+
 		// Now that items are done, compute widths for layout
 		for (auto& j : items)
 			j.CalculateWidth();
@@ -765,7 +970,7 @@ vector<DisassemblyTextLine> GenericLineFormatter::FormatLines(
 					// is a container, always use the splitting behavior.
 					if (currentWidth == 0 || item->width > desiredContinuationWidth || item->type == Container)
 					{
-						if (item->type == Argument && currentWidth != 0)
+						if ((item->type == Argument || item->type == StringComponent) && currentWidth != 0)
 						{
 							// If an argument is too wide to show on a single line all by itself, start the argument
 							// on a new line, and add additional indentation for the continuation of the argument.