{

Atom,

Comment,

Operator,

FieldAccessor,

Argument,

ArgumentSeparator,

Statement,

StatementSeparator,

StringComponent,

StringSeparator,

StringWhitespace,

FormatSpecifier,

EscapeSequence,

Group,

Container,

StartOfContainer,

ContainerContents,

EndOfContainer,

{

size_t startPos = 0;

size_t endPos = 0;

bool start = true;

for (size_t i = 0; i < str.size(); i++)

{

if (isspace(str[i]))

{

if (start)

{

startPos = i + 1;

endPos = i + 1;

}

}

else

{

start = false;

endPos = i + 1;

}

}

return str.substr(startPos, endPos - startPos);

{

size_t startPos = 0;

for (size_t i = 0; i < str.size(); i++)

{

if (!isspace(str[i]))

{

startPos = i;

break;

}

}

return str.substr(startPos);

{

if (str.empty())

return str;

size_t endPos = str.size();

for (size_t i = str.size() - 1; i > 0; i--)

{

if (!isspace(str[i]))

{

endPos = i + 1;

break;

}

}

return str.substr(0, endPos);

{

string trimmedText = TrimString(token.text);

auto i = g_operatorPrecedenceMap.find(trimmedText);

if (i != g_operatorPrecedenceMap.end())

{

if (i->second == TernaryOperatorPrecedence && ternary)

{

// HLIL uses ':' in additional contexts, so look for active ternary operators before

// treating it as part of a ternary

if (trimmedText == "?")

{

(*ternary)++;

}

else if (trimmedText == ":")

{

if (*ternary)

(*ternary)--;

else

return MemberAndFunctionOperatorPrecedence;

}

}

return i->second;

}

return MemberAndFunctionOperatorPrecedence;

{

ItemType type;

vector<Item> items;

vector<InstructionTextToken> tokens;

size_t width;

void AppendAllTokens(vector<InstructionTextToken>& output, bool& firstTokenOfLine)

{

if (firstTokenOfLine)

{

if (!tokens.empty())

{

InstructionTextToken token = tokens.front();

string trimmedText = TrimLeadingWhitespace(token.text);

token.width -= token.text.size() - trimmedText.size();

token.text = trimmedText;

output.emplace_back(token);

output.insert(output.end(), tokens.begin() + 1, tokens.end());

firstTokenOfLine = false;

}

}

else

{

output.insert(output.end(), tokens.begin(), tokens.end());

}

for (auto& item : items)

item.AppendAllTokens(output, firstTokenOfLine);

}

void AddTokenToLastAtom(const InstructionTextToken& token)

{

if (!tokens.empty())

tokens.emplace_back(token);

else if (items.empty())

items.emplace_back(Item {Atom, {}, {token}, 0});

else

items.back().AddTokenToLastAtom(token);

}

void AddTokenToLastStringComponent(const InstructionTextToken& token)

{

if (!tokens.empty())

tokens.emplace_back(token);

else if (items.empty())

items.emplace_back(Item {StringComponent, {}, {token}, 0});

else

items.back().AddTokenToLastStringComponent(token);

}

void CalculateWidth()

{

width = 0;

for (auto& token : tokens)

width += token.width;

for (auto& item : items)

{

item.CalculateWidth();

width += item.width;

}

}

{

vector<Item> items;

size_t additionalContinuationIndentation;

size_t desiredWidth;

size_t desiredContinuationWidth;

size_t desiredStringWidth;

bool newLineOnReenteringScope;

{

vector<Item> result;

result.reserve(items.size());

vector<Item> pending;

pending.reserve(items.size());

bool hasArgs = false;

auto flushStatement = [&]() {

if (!pending.empty()) {

result.emplace_back(

Item{

Statement,

std::move(pending),

vector<InstructionTextToken>{},

0

}

);

pending.clear();

}

};

for (auto const& orig : items) {

// copy so we can move out of i.tokens / i.items safely

Item i = orig;

if (i.type == StatementSeparator) {

hasArgs = true;

if (pending.empty()) {

// first separator in this statement

result.emplace_back(

Item{

Atom,

{},

std::move(i.tokens),

0

}

);

} else {

// append tokens to last atom in pending, then flush

for (auto& t : i.tokens)

pending.back().AddTokenToLastAtom(std::move(t));

flushStatement();

}

}

else if (i.type == StartOfContainer && pending.empty()) {

// emit container boundary directly if no pending args

result.emplace_back(std::move(i));

}

else if (i.type == EndOfContainer && hasArgs && !pending.empty()) {

// flush any accumulated args as a Statement, then emit the container end

flushStatement();

result.emplace_back(std::move(i));

}

else {

// accumulate everything else for possible statement grouping

vector<Item> nested;

if (!i.items.empty())

nested = CreateStatementItems(i.items);

pending.emplace_back(

Item{

i.type,

std::move(nested),

std::move(i.tokens),

0

}

);

}

}

// final tail: either flush into a Statement or append raw

if (!pending.empty()) {

if (hasArgs) {

flushStatement();

} else {

result.insert(

result.end(),

make_move_iterator(pending.begin()),

make_move_iterator(pending.end())

);

}

}

return result;

const InstructionTextToken& unprocessedStringToken,

const size_t maxParsingLength

)

{

const string_view src = unprocessedStringToken.text;

const size_t tail = src.size();

vector<InstructionTextToken> result;

size_t curStart = 0, curEnd = 0;

auto ConstructToken = [&](size_t start, size_t end)

{

InstructionTextToken token = unprocessedStringToken;

token.text = string(src.substr(start, end - start));

token.width = token.text.size();

result.emplace_back(std::move(token));

};

auto flushToken = [&](size_t start, size_t end)

{

if (start < end)

ConstructToken(start, end);

};

// We generally split along spaces while keeping words intact, but some cases have

// specific splitting behavior:

//

// - Any format specifier (starting with %) will be treated as an atom even if embedded

// within a word

// - Any escape sequence will also be treated as an atom

// - We split along punctuation like commas, colons, periods, and semicolons, grouping

// trailing punctuation together.

while (curEnd < tail)

{

char c = src[curEnd];

if (c == '%')

{

// Flush before format specifier

flushToken(curStart, curEnd);

size_t start = curEnd;

curEnd++;

while (curEnd < tail && (isalnum(src[curEnd]) || src[curEnd]=='.' || src[curEnd]=='-'))

curEnd++;

ConstructToken(start, curEnd);

curStart = curEnd;

}

else if (c == '\\')

{

// Flush before escape sequence

flushToken(curStart, curEnd);

size_t start = curEnd;

curEnd++; // consume '\'

if (curEnd < tail)

curEnd++; // consume escaped char

ConstructToken(start, curEnd);

curStart = curEnd;

}

else if (isspace(c))

{

// Flush before whitespace

flushToken(curStart, curEnd);

size_t start = curEnd;

while (curEnd < tail && isspace(src[curEnd]))

curEnd++;

ConstructToken(start, curEnd);

curStart = curEnd;

}

else if (c == ',' || c == '.' || c == ':' || c == ';')

{

// Flush before punctuation

flushToken(curStart, curEnd);

// Group together repeated punctuation

size_t start = curEnd;

while (curEnd < tail && src[curEnd] == c)

curEnd++;

ConstructToken(start, curEnd);

curStart = curEnd;

}

else

{

curEnd++;

}

// Check if we've exceeded max parsing length

if (curEnd > maxParsingLength)

{

// Flush any pending token

flushToken(curStart, maxParsingLength);

// Create single token with remaining text

InstructionTextToken remainingToken = unprocessedStringToken;

remainingToken.text = string(src.substr(maxParsingLength));

remainingToken.width = remainingToken.text.size();

result.emplace_back(std::move(remainingToken));

return result;

}

}

flushToken(curStart, curEnd);

return result;

{

// We handle strings mostly the same as other types except the introduction

// of the StringComponent and StringWhitespace types.

//

// The reason we introduce these is for the specific behaviors when formatting multiline

// string annotations. String annotations have a different desired width than tokens

// like arguments, comments, etc.

//

// Additionally, we don't wrap trailing whitespace until the preceding token is within

// the wrapping width, unlike other token types.

vector<Item> result;

result.reserve(items.size());

vector<Item> pending;

pending.reserve(items.size());

bool hasStrings = false;

// flush pending into one StringComponent

auto flushString = [&]() {

if (!pending.empty()) {

result.emplace_back(

Item{ StringComponent,

std::move(pending),

{},

0 }

);

pending.clear();

}

};

for (auto const& orig : items) {

Item i = orig;

if (i.type == StringSeparator && !i.tokens.empty()) {

if (pending.empty()) {

result.emplace_back(

Item{ StringComponent,

vector<Item>{},

std::move(i.tokens),

0 }

);

} else {

for (auto& t : i.tokens)

pending.back().AddTokenToLastStringComponent(std::move(t));

flushString();

}

hasStrings = true;

}

else if (i.type == StringWhitespace) {

flushString();

result.emplace_back(

Item{ StringWhitespace,

std::move(i.items),

std::move(i.tokens),

0 }

);

}

else if (i.type == FormatSpecifier || i.type == EscapeSequence) {

flushString();

result.emplace_back(

Item{ StringComponent,

std::move(i.items),

std::move(i.tokens),

0 }

);

}

else if (i.type == StartOfContainer && pending.empty()) {

result.emplace_back(std::move(i));

}

else if (i.type == EndOfContainer && hasStrings && !pending.empty()) {

result.emplace_back(

Item{ Group,

std::move(pending),

vector<InstructionTextToken>{},

0 }

);

result.emplace_back(std::move(i));

pending.clear();

}

else {

vector<Item> nested;

if (!i.items.empty())

nested = CreateStringGroups(i.items);

pending.emplace_back(

Item{ i.type,

std::move(nested),

std::move(i.tokens),

0 }

);

}

}

if (!pending.empty()) {

if (hasStrings) {

flushString();

} else {

result.insert(

result.end(),

make_move_iterator(pending.begin()),

make_move_iterator(pending.end())

);

}

}

return result;

{

vector<Item> result;

result.reserve(items.size());

vector<Item> pending;

pending.reserve(items.size());

bool hasOperators = false;

auto flushStatement = [&]()

{

if (!pending.empty())

{

result.emplace_back(Item {Statement, std::move(pending), {}, 0});

pending.clear();

}

};

for (auto& i : items)

{

if (i.type == Operator && !i.tokens.empty())

{

BNOperatorPrecedence precedence = GetOperatorPrecedence(i.tokens[0]);

if (precedence == AssignmentOperatorPrecedence)

{

if (pending.empty())

{

result.emplace_back(Item {Atom, {}, std::move(i.tokens), 0});

}

else

{

for (auto& j : i.tokens)

pending.back().AddTokenToLastAtom(j);

flushStatement();

}

hasOperators = true;

continue;

}

}

if (i.type == StartOfContainer && pending.empty())

{

result.emplace_back(std::move(i));

}

else if (i.type == EndOfContainer && hasOperators && !pending.empty())

{

result.emplace_back(Item {Group, std::move(pending), {}, 0});

result.emplace_back(i);

pending.clear();

}

else

{

pending.emplace_back(Item {i.type, CreateAssignmentOperatorGroups(i.items), i.tokens, 0});

}

}

if (!pending.empty())

{

if (hasOperators)

result.emplace_back(Item {Group, std::move(pending), {}, 0});

else

result.insert(result.end(), pending.begin(), pending.end());

}

return result;

{

vector<Item> result;

result.reserve(items.size());

vector<Item> pending;

pending.reserve(items.size());

bool hasArgs = false;

auto flushArgument = [&]()

{

if (!pending.empty())

{

result.emplace_back(

Item{

inContainer ? Argument : Group,

std::move(pending),

vector<InstructionTextToken>{},

0

}

);

pending.clear();

}

};

for (auto const& orig: items)

{

Item i = orig;

if (i.type == ArgumentSeparator)

{

if (pending.empty())

{

result.emplace_back(

Item{

Atom,

vector<Item>{},

std::move(i.tokens),

0

}

);

}

else

{

for (auto& t: i.tokens)

pending.back().AddTokenToLastAtom(std::move(t));

flushArgument();

}

hasArgs = true;

}

else if (i.type == StartOfContainer && pending.empty())

{

result.emplace_back(std::move(i));

}

else if (i.type == EndOfContainer && hasArgs && !pending.empty())

{

flushArgument();

result.emplace_back(std::move(i));

}

else

{

vector<Item> nested;

if (!i.items.empty())

nested = CreateArgumentItems(i.items, i.type == Container);

pending.emplace_back(

Item{

i.type,

std::move(nested),

std::move(i.tokens),

0

}

);

}

}

if (!pending.empty())

{

if (hasArgs)

{

flushArgument();

}

else

{

result.insert(

result.end(),

make_move_iterator(pending.begin()),

make_move_iterator(pending.end())

);

}

}

return result;

{

vector<Item> result;

result.reserve(items.size());

vector<Item> pending;

pending.reserve(items.size());

bool hasOperators = false;

auto flushOperator = [&]()

{

if (!pending.empty())

{

if (pending.size() == 1)

{

result.emplace_back(std::move(pending[0]));

}

else

{

result.emplace_back(

Item{

Group,

std::move(pending),

{},

0

}

);

}

pending.clear();

}

};

for (auto const& orig: items)

{

Item i = orig;

if (i.type == Operator)

{

flushOperator();

result.emplace_back(std::move(i));

hasOperators = true;

}

else if (i.type == StartOfContainer && pending.empty())

{

result.emplace_back(std::move(i));

}

else if (i.type == EndOfContainer && hasOperators && pending.size() > 1)

{

flushOperator();

result.emplace_back(std::move(i));

}

else

{

vector<Item> nested;

if (!i.items.empty())

nested = CreateOperatorGroups(i.items);

pending.emplace_back(

Item{

i.type,

std::move(nested),

std::move(i.tokens),

0

}

);

}

}

if (!pending.empty())

{

if (hasOperators && pending.size() > 1)

{

flushOperator();

}

else

{

result.insert(

result.end(),

make_move_iterator(pending.begin()),

make_move_iterator(pending.end())

);

}

}

return result;

{

// Look for the operator with the lowest precedence. These will be grouped first.

optional<BNOperatorPrecedence> lowestPrecedence;

size_t ternary = 0;

for (auto i = items.begin(); i != items.end(); ++i)

{

if (i != items.begin() && i->type == Operator && !i->tokens.empty())

{

BNOperatorPrecedence precedence = GetOperatorPrecedence(i->tokens[0], &ternary);

if (!lowestPrecedence.has_value() || precedence < lowestPrecedence.value())

lowestPrecedence = precedence;

}

}

// If there were no operators, no need to group at this level. Just traverse down into child items.

if (!lowestPrecedence.has_value())

{

vector<Item> result;

result.reserve(items.size());

for (auto& i : items)

result.emplace_back(Item {i.type, CreateOperatorPrecedenceGroups(i.items), i.tokens, 0});

return result;

}

// Go through the items and split the items into groups around the lowest precedence operator

vector<Item> result, pending;

ternary = 0;

for (auto i = items.begin(); i != items.end(); ++i)

{

if (i != items.begin() && i->type == Operator && !i->tokens.empty())

{

BNOperatorPrecedence precedence = GetOperatorPrecedence(i->tokens[0], &ternary);

if (precedence == lowestPrecedence.value())

{

if (pending.size() == 1)

result.emplace_back(pending[0]);

else if (!pending.empty())

result.emplace_back(Item {Group, std::move(pending), {}, 0});

else

result.insert(result.end(), pending.begin(), pending.end());

pending.clear();

}

}

if (i->type == StartOfContainer && pending.empty())

{

result.emplace_back(*i);

}

else if (i->type == EndOfContainer && pending.size() > 1 && !result.empty())

{

result.emplace_back(Item {Group, std::move(pending), {}, 0});

result.emplace_back(*i);

pending.clear();

}

else

{

pending.emplace_back(*i);

}

}

if (!pending.empty())

{

if (pending.size() > 1 && !result.empty())

result.emplace_back(Item {Group, pending, {}, 0});

else

result.insert(result.end(), pending.begin(), pending.end());

}

// Recurse into these groups and process the next lowest precedence in each

vector<Item> processed;

processed.reserve(result.size());

for (auto& i : result)

processed.emplace_back(Item{i.type, CreateOperatorPrecedenceGroups(i.items), i.tokens, 0});

return processed;

{

vector<Item> result;

for (auto& i : items)

{

if (!result.empty() && i.type == Container && !i.items.empty() && i.items.front().type == StartOfContainer)

{

Item startOfContainer = i.items.front();

for (auto& j : startOfContainer.tokens)

result.back().AddTokenToLastAtom(j);

auto containerContents = i.items.begin() + 1;

if (containerContents != i.items.end() && containerContents->type == EndOfContainer)

{

for (auto& j : containerContents->tokens)

result.back().AddTokenToLastAtom(j);

++containerContents;

}

vector<Item> containerItems(containerContents, i.items.end());

containerItems = RelocateStartAndEndOfContainerItems(containerItems);

if (!containerItems.empty())

result.emplace_back(Item {Container, containerItems, {}, 0});

}

else if (i.type == EndOfContainer && !result.empty())

{

for (auto& j : i.tokens)

result.back().AddTokenToLastAtom(j);

}

else

{

result.emplace_back(Item {i.type, RelocateStartAndEndOfContainerItems(i.items), i.tokens, 0});

}

}

return result;

const vector<DisassemblyTextLine>& lines, const LineFormatterSettings& settings)

{

vector<DisassemblyTextLine> result;

for (size_t i = 0; i < lines.size(); i++)

{

const DisassemblyTextLine& currentLine = lines[i];

size_t totalLength = currentLine.GetTotalWidth();

size_t indentation = currentLine.GetAddressAndIndentationWidth();

// Check width against settings

size_t contentLength = totalLength - indentation;

if (totalLength <= settings.desiredLineLength || contentLength <= settings.minimumContentLength)

{

// Line fits, emit as-is

result.emplace_back(currentLine);

continue;

}

// Calculate indentation for continuation lines. If the next line in the input is more indented, make

// the continuation lines more indented than that to separate the continuation from the new scope.

size_t continuationIndentation = indentation + settings.tabWidth;

if ((i + 1) < lines.size())

{

size_t nextLineIndentation = lines[i + 1].GetAddressAndIndentationWidth();

if (nextLineIndentation > indentation)

continuationIndentation = nextLineIndentation + settings.tabWidth;

}

size_t additionalContinuationIndentation = continuationIndentation - indentation;

// Compute the target length for this line

size_t desiredWidth = settings.minimumContentLength;

if (indentation < settings.desiredLineLength)

{

size_t remainingWidth = settings.desiredLineLength - indentation;

if (remainingWidth > desiredWidth)

desiredWidth = remainingWidth;

}

// Compute the target length for the continuation lines

size_t desiredContinuationWidth = settings.minimumContentLength;

if (continuationIndentation < settings.desiredLineLength)

{

size_t remainingWidth = settings.desiredLineLength - continuationIndentation;

if (remainingWidth > desiredContinuationWidth)

desiredContinuationWidth = remainingWidth;

}

// Compute target string width for this line

size_t desiredStringWidth = settings.stringWrappingWidth;

if (indentation < settings.desiredLineLength)

{

size_t remainingStringWidth = settings.desiredLineLength - indentation;

if (remainingStringWidth > desiredStringWidth)

desiredStringWidth = remainingStringWidth;

}

// Gather the indentation tokens at the beginning of the line

vector<InstructionTextToken> indentationTokens = currentLine.GetAddressAndIndentationTokens();

size_t tokenIndex = indentationTokens.size();

// First break the line down into nested container items. A container is anything between a pair of

// BraceTokens

vector<Item> items;

stack<vector<Item>> itemStack;

for (; tokenIndex < currentLine.tokens.size(); tokenIndex++)

{

const InstructionTextToken& token = currentLine.tokens[tokenIndex];

string trimmedText = TrimString(token.text);

switch (token.type)

{

case BraceToken:

// Beginning of string

if (trimmedText == "\"" && tokenIndex + 1 < currentLine.tokens.size() && currentLine.tokens[tokenIndex + 1].type == StringToken)

{

// 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.emplace_back(Item {Container, {}, {}, 0});

itemStack.push(items);

// Starting a new context

items.clear();

items.emplace_back(Item {StartOfContainer, {}, {token}, 0});

}

// End of string

else if (trimmedText == "\"" && tokenIndex > 0 && currentLine.tokens[tokenIndex - 1].type == StringToken)

{

items.emplace_back(Item {EndOfContainer, {}, {token}, 0});

if (itemStack.empty())

break;

// Go back up the item stack and add the items to the container

vector<Item> parent = itemStack.top();

itemStack.pop();

parent.back().items.insert(parent.back().items.end(), items.begin(), items.end());

items = parent;

}

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.

items.emplace_back(Item {Container, {}, {}, 0});

itemStack.push(items);