blob: 5a8529874f58d3ad66a2912eba7495c7e2de9bbb [file] [log] [blame]
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <chrono>
#include <ctime>
#include "bmhParser.h"
#include "includeWriter.h"
bool IncludeWriter::checkChildCommentLength(const Definition* parent, MarkType childType) const {
bool oneMember = false;
for (auto& item : parent->fChildren) {
if (childType != item->fMarkType) {
continue;
}
oneMember = true;
int lineLen = 0;
for (auto& itemChild : item->fChildren) {
if (MarkType::kLine == itemChild->fMarkType) {
lineLen = itemChild->length();
break;
}
}
if (!lineLen) {
item->reportError<void>("missing #Line");
}
if (fEnumItemCommentTab + lineLen >= 100) {
// if too long, remove spaces until it fits, or wrap
// item->reportError<void>("#Line comment too long");
}
}
return oneMember;
}
void IncludeWriter::checkEnumLengths(const Definition& child, string enumName, ItemLength* length) const {
const Definition* enumItem = this->matchMemberName(enumName, child);
if (std::any_of(enumItem->fChildren.begin(), enumItem->fChildren.end(),
[](Definition* child){return MarkType::kNoJustify == child->fMarkType;})) {
return;
}
string comment = this->enumMemberComment(enumItem, child);
int lineLimit = 100 - fIndent - 7; // 7: , space //!< space
if (length->fCurValue) {
lineLimit -= 3; // space = space
}
if (length->fCurName + length->fCurValue + (int) comment.length() < lineLimit) {
length->fLongestName = SkTMax(length->fLongestName, length->fCurName);
length->fLongestValue = SkTMax(length->fLongestValue, length->fCurValue);
}
}
void IncludeWriter::constOut(const Definition* memberStart, const Definition* bmhConst) {
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
memberStart->fContentStart;
this->firstBlockTrim((int) (bodyEnd - fStart), fStart); // may write nothing
this->lf(2);
this->indentDeferred(IndentKind::kConstOut);
if (fStructEnded) {
fIndent = fICSStack.size() * 4;
fStructEnded = false;
}
// comment may be legitimately empty; typedef may not have separate comment (for now)
fReturnOnWrite = true;
bool commentHasLength = this->descriptionOut(bmhConst, SkipFirstLine::kYes, Phrase::kNo);
fReturnOnWrite = false;
if (commentHasLength) {
this->writeCommentHeader();
fIndent += 4;
if (!this->descriptionOut(bmhConst, SkipFirstLine::kYes, Phrase::kNo)) {
return memberStart->reportError<void>("expected description for const");
}
fIndent -= 4;
this->writeCommentTrailer(OneLine::kNo);
}
this->setStart(memberStart->fContentStart, memberStart);
}
bool IncludeWriter::descriptionOut(const Definition* def, SkipFirstLine skipFirstLine,
Phrase phrase) {
bool wroteSomething = false;
const char* commentStart = def->fContentStart;
if (SkipFirstLine::kYes == skipFirstLine) {
TextParser parser(def);
SkAssertResult(parser.skipLine());
commentStart = parser.fChar;
}
int commentLen = (int) (def->fContentEnd - commentStart);
bool breakOut = false;
SkDEBUGCODE(bool wroteCode = false);
const Definition* lastDescription = def;
for (auto prop : def->fChildren) {
fLastDescription = lastDescription;
lastDescription = prop;
switch (prop->fMarkType) {
case MarkType::kCode: {
bool literal = false;
bool literalOutdent = false;
commentLen = (int) (prop->fStart - commentStart);
if (commentLen > 0) {
SkASSERT(commentLen < 1000);
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, Phrase::kNo)) {
if (fReturnOnWrite) {
return true;
}
this->lf(2);
wroteSomething = true;
}
}
size_t childSize = prop->fChildren.size();
if (childSize) {
if (MarkType::kLiteral == prop->fChildren[0]->fMarkType) {
SkASSERT(1 == childSize || 2 == childSize); // incomplete
SkASSERT(1 == childSize || MarkType::kOutdent == prop->fChildren[1]->fMarkType);
commentStart = prop->fChildren[childSize - 1]->fContentStart;
literal = true;
literalOutdent = 2 == childSize &&
MarkType::kOutdent == prop->fChildren[1]->fMarkType;
}
}
commentLen = (int) (prop->fContentEnd - commentStart);
SkASSERT(commentLen > 0);
if (literal) {
if (!fReturnOnWrite && !literalOutdent) {
fIndent += 4;
}
wroteSomething |= this->writeBlockIndent(commentLen, commentStart, false);
if (fReturnOnWrite) {
return true;
}
if (!fReturnOnWrite) {
this->lf(2);
if (!literalOutdent) {
fIndent -= 4;
}
}
SkDEBUGCODE(wroteCode = true);
}
commentStart = prop->fTerminator;
} break;
case MarkType::kBug: {
if (fReturnOnWrite) {
return true;
}
string bugstr("(see skbug.com/" + string(prop->fContentStart,
prop->fContentEnd - prop->fContentStart) + ')');
this->writeString(bugstr);
this->lfcr();
wroteSomething = true;
}
case MarkType::kFormula: {
commentLen = prop->fStart - commentStart;
if (commentLen > 0) {
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, Phrase::kNo)) {
if (fReturnOnWrite) {
return true;
}
if (commentLen > 1 && '\n' == prop->fStart[-1]) {
this->lf(1);
} else {
this->writeSpace();
}
wroteSomething = true;
}
}
int saveIndent = fIndent;
if (fIndent < fColumn + 1) {
fIndent = fColumn + 1;
}
wroteSomething |= this->writeBlockIndent(prop->length(), prop->fContentStart, true);
fIndent = saveIndent;
if (wroteSomething && fReturnOnWrite) {
return true;
}
commentStart = prop->fTerminator;
commentLen = (int) (def->fContentEnd - commentStart);
if (!fReturnOnWrite) {
if (commentLen > 1 && ' ' == commentStart[0] && !fLinefeeds) {
this->writeSpace();
}
}
} break;
case MarkType::kDetails:
case MarkType::kIn:
case MarkType::kLine:
case MarkType::kToDo:
commentLen = (int) (prop->fStart - commentStart);
if (commentLen > 0) {
SkASSERT(commentLen < 1000);
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, Phrase::kNo)) {
if (fReturnOnWrite) {
return true;
}
this->lfcr();
wroteSomething = true;
}
}
commentStart = prop->fTerminator;
commentLen = (int) (def->fContentEnd - commentStart);
break;
case MarkType::kList:
commentLen = prop->fStart - commentStart;
if (commentLen > 0) {
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart,
Phrase::kNo)) {
if (fReturnOnWrite) {
return true;
}
this->lfcr();
wroteSomething = true;
}
}
for (auto row : prop->fChildren) {
SkASSERT(MarkType::kRow == row->fMarkType);
for (auto column : row->fChildren) {
SkASSERT(MarkType::kColumn == column->fMarkType);
if (fReturnOnWrite) {
return true;
}
this->writeString("-");
this->writeSpace();
wroteSomething |= this->descriptionOut(column, SkipFirstLine::kNo, Phrase::kNo);
this->lf(1);
}
}
commentStart = prop->fTerminator;
commentLen = (int) (def->fContentEnd - commentStart);
if ('\n' == commentStart[0] && '\n' == commentStart[1]) {
this->lf(2);
}
break;
case MarkType::kPhraseRef: {
commentLen = prop->fStart - commentStart;
if (commentLen > 0) {
if (fReturnOnWrite) {
return true;
}
this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
// ince we don't do line wrapping, always insert LF before phrase
this->lfcr(); // TODO: remove this once rewriteBlock rewraps paragraphs
wroteSomething = true;
}
auto iter = fBmhParser->fPhraseMap.find(prop->fName);
if (fBmhParser->fPhraseMap.end() == iter) {
return this->reportError<bool>("missing phrase definition");
}
Definition* phraseDef = iter->second;
// TODO: given TextParser(commentStart, prop->fStart + up to #) return if
// it ends with two of more linefeeds, ignoring other whitespace
Phrase defIsPhrase = '\n' == prop->fStart[0] && '\n' == prop->fStart[-1] ?
Phrase::kNo : Phrase::kYes;
if (Phrase::kNo == defIsPhrase) {
this->lf(2);
}
const char* start = phraseDef->fContentStart;
int length = phraseDef->length();
auto propParams = prop->fChildren.begin();
// can this share code or logic with mdout somehow?
for (auto child : phraseDef->fChildren) {
if (MarkType::kPhraseParam == child->fMarkType) {
continue;
}
int localLength = child->fStart - start;
if (fReturnOnWrite) {
return true;
}
this->rewriteBlock(localLength, start, defIsPhrase);
start += localLength;
length -= localLength;
SkASSERT(propParams != prop->fChildren.end());
if (fColumn > 0) {
this->writeSpace();
}
this->writeString((*propParams)->fName);
localLength = child->fContentEnd - child->fStart;
start += localLength;
length -= localLength;
if (isspace(start[0])) {
this->writeSpace();
}
defIsPhrase = Phrase::kYes;
wroteSomething = true;
}
if (length > 0) {
if (fReturnOnWrite) {
return true;
}
this->rewriteBlock(length, start, defIsPhrase);
}
commentStart = prop->fContentStart;
commentLen = (int) (def->fContentEnd - commentStart);
if (!fReturnOnWrite) {
if ('\n' == commentStart[0] && '\n' == commentStart[1]) {
this->lf(2);
}
}
} break;
default:
commentLen = (int) (prop->fStart - commentStart);
breakOut = true;
}
if (breakOut) {
break;
}
}
if (!breakOut) {
commentLen = (int) (def->fContentEnd - commentStart);
}
SkASSERT(wroteCode || (commentLen > 0 && commentLen < 1500));
if (commentLen > 0) {
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, phrase)) {
if (fReturnOnWrite) {
return true;
}
wroteSomething = true;
}
}
SkASSERT(!fReturnOnWrite || !wroteSomething);
return wroteSomething;
}
void IncludeWriter::enumHeaderOut(RootDefinition* root, const Definition& child) {
const Definition* enumDef = nullptr;
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
child.fContentStart;
this->firstBlockTrim((int) (bodyEnd - fStart), fStart); // may write nothing
this->lf(2);
this->indentDeferred(IndentKind::kEnumHeader);
fDeferComment = nullptr;
this->setStart(child.fContentStart, &child);
const auto& nameDef = child.fTokens.front();
string fullName;
if (nullptr != nameDef.fContentEnd) {
TextParser enumClassCheck(&nameDef);
const char* start = enumClassCheck.fStart;
size_t len = (size_t) (enumClassCheck.fEnd - start);
bool enumClass = enumClassCheck.skipExact("class ");
if (enumClass) {
start = enumClassCheck.fChar;
const char* end = enumClassCheck.anyOf(" \n;{");
len = (size_t) (end - start);
}
string enumName(start, len);
if (enumClass) {
child.fChildren[0]->fName = enumName;
}
fullName = root->fName + "::" + enumName;
enumDef = root->find(enumName, RootDefinition::AllowParens::kNo);
if (!enumDef) {
enumDef = root->find(fullName, RootDefinition::AllowParens::kNo);
}
if (!enumDef) {
auto mapEntry = fBmhParser->fEnumMap.find(enumName);
if (fBmhParser->fEnumMap.end() != mapEntry) {
enumDef = &mapEntry->second;
}
}
if (!enumDef && enumName == root->fName) {
enumDef = root;
}
SkASSERT(enumDef);
// child[0] should be #Code comment starts at child[0].fTerminator
// though skip until #Code is found (in case there's a #ToDo, etc)
// child[1] should be #Const comment ends at child[1].fStart
// comment becomes enum header (if any)
} else {
string enumName(root->fName);
enumName += "::_anonymous";
if (fAnonymousEnumCount > 1) {
enumName += '_' + to_string(fAnonymousEnumCount);
}
enumDef = root->find(enumName, RootDefinition::AllowParens::kNo);
SkASSERT(enumDef);
++fAnonymousEnumCount;
}
Definition* codeBlock = nullptr;
const char* commentStart = nullptr;
bool firstCodeBlocks = true;
bool wroteHeader = false;
bool lastAnchor = false;
// SkDEBUGCODE(bool foundConst = false);
for (auto test : enumDef->fChildren) {
if (MarkType::kCode == test->fMarkType && firstCodeBlocks) {
codeBlock = test;
commentStart = codeBlock->fTerminator;
continue;
} else if (codeBlock) {
firstCodeBlocks = false;
}
if (!codeBlock) {
continue;
}
const char* commentEnd = test->fStart;
if (!wroteHeader &&
!this->contentFree((int) (commentEnd - commentStart), commentStart)) {
if (fIndentNext) {
// FIXME: how can I tell where fIdentNext gets cleared?
this->indentIn(IndentKind::kEnumChild);
}
this->writeCommentHeader();
this->writeString("\\enum");
if (fullName.length() > 0) {
this->writeSpace();
this->writeString(fullName.c_str());
}
this->indentIn(IndentKind::kEnumChild2);
this->lfcr();
wroteHeader = true;
}
if (lastAnchor) {
if (commentEnd - commentStart > 1) {
SkASSERT('\n' == commentStart[0]);
if (' ' == commentStart[1]) {
this->writeSpace();
}
}
lastAnchor = false;
}
this->rewriteBlock((int) (commentEnd - commentStart), commentStart, Phrase::kNo);
if (MarkType::kAnchor == test->fMarkType || MarkType::kCode == test->fMarkType) {
bool newLine = commentEnd - commentStart > 1 &&
'\n' == commentEnd[-1] && '\n' == commentEnd[-2];
commentStart = test->fContentStart;
commentEnd = MarkType::kAnchor == test->fMarkType ? test->fChildren[0]->fStart :
test->fContentEnd;
if (newLine) {
this->lf(2);
} else {
this->writeSpace();
}
if (MarkType::kAnchor == test->fMarkType) {
this->rewriteBlock((int) (commentEnd - commentStart), commentStart, Phrase::kNo);
} else {
this->writeBlock((int) (commentEnd - commentStart), commentStart);
this->lf(2);
}
lastAnchor = true; // this->writeSpace();
}
commentStart = test->fTerminator;
if (MarkType::kConst == test->fMarkType) {
SkASSERT(codeBlock); // FIXME: check enum for correct order earlier
// SkDEBUGCODE(foundConst = true);
break;
}
}
// SkASSERT(codeBlock);
// SkASSERT(foundConst);
if (wroteHeader) {
this->indentOut();
this->lfcr();
this->writeCommentTrailer(OneLine::kNo);
}
Definition* braceHolder = child.fChildren[0];
if (KeyWord::kClass == braceHolder->fKeyWord) {
braceHolder = braceHolder->fChildren[0];
}
bodyEnd = braceHolder->fContentStart;
SkASSERT('{' == bodyEnd[0]);
++bodyEnd;
this->lfcr();
this->writeBlock((int) (bodyEnd - fStart), fStart); // write include "enum Name {"
this->indentIn(IndentKind::kEnumHeader2);
this->singleLF();
this->setStart(bodyEnd, braceHolder);
fEnumDef = enumDef;
}
const Definition* IncludeWriter::enumMemberForComment(const Definition* currentEnumItem) const {
for (auto constItem : currentEnumItem->fChildren) {
if (MarkType::kLine == constItem->fMarkType) {
return constItem;
}
}
SkASSERT(0);
return nullptr;
}
string IncludeWriter::enumMemberComment(const Definition* currentEnumItem,
const Definition& child) const {
// #Const should always be followed by #Line, so description follows that
string shortComment;
for (auto constItem : currentEnumItem->fChildren) {
if (MarkType::kLine == constItem->fMarkType) {
shortComment = string(constItem->fContentStart, constItem->length());
break;
}
}
if (!shortComment.length()) {
currentEnumItem->reportError<void>("missing #Line or #Deprecated or #Experimental");
}
return shortComment;
}
IncludeWriter::ItemState IncludeWriter::enumMemberName(
const Definition& child, const Definition* token, Item* item, LastItem* last,
const Definition** currentEnumItem) {
TextParser parser(fFileName, last->fStart, last->fEnd, fLineCount);
parser.skipWhiteSpace();
item->fName = string(parser.fChar, (int) (last->fEnd - parser.fChar));
*currentEnumItem = this->matchMemberName(item->fName, child);
if (token) {
this->setStart(token->fContentEnd, token);
TextParser enumLine(token->fFileName, last->fEnd, token->fContentStart, token->fLineCount);
const char* end = enumLine.anyOf(",}=");
SkASSERT(end);
if ('=' == *end) { // write enum value
last->fEnd = token->fContentEnd;
item->fValue = string(token->fContentStart, (int) (last->fEnd - token->fContentStart));
return ItemState::kValue;
}
}
return ItemState::kComment;
}
void IncludeWriter::enumMemberOut(const Definition* currentEnumItem, const Definition& child,
const Item& item, Preprocessor& preprocessor) {
SkASSERT(currentEnumItem);
string shortComment = this->enumMemberComment(currentEnumItem, child);
int enumItemValueTab =
SkTMax((int) item.fName.length() + fIndent + 1, fEnumItemValueTab); // 1: ,
int valueLength = item.fValue.length();
int assignLength = valueLength ? valueLength + 3 : 0; // 3: space = space
int enumItemCommentTab = SkTMax(enumItemValueTab + assignLength, fEnumItemCommentTab);
int trimNeeded = enumItemCommentTab + shortComment.length() - (100 - (sizeof("//!< ") - 1));
bool crAfterName = false;
if (trimNeeded > 0) {
if (item.fValue.length()) {
int valueSpare = SkTMin(trimNeeded, // 3 below: space = space
(int) (enumItemCommentTab - enumItemValueTab - item.fValue.length() - 3));
SkASSERT(valueSpare >= 0);
trimNeeded -= valueSpare;
enumItemCommentTab -= valueSpare;
}
if (trimNeeded > 0) {
int nameSpare = SkTMin(trimNeeded, (int) (enumItemValueTab - item.fName.length()
- fIndent - 1)); // 1: ,
SkASSERT(nameSpare >= 0);
trimNeeded -= nameSpare;
enumItemValueTab -= nameSpare;
enumItemCommentTab -= nameSpare;
}
if (trimNeeded > 0) {
crAfterName = true;
if (!valueLength) {
this->enumMemberForComment(currentEnumItem)->reportError<void>("comment too long");
} else if (valueLength + fIndent + 8 + shortComment.length() > // 8: addtional indent
100 - (sizeof(", //!< ") - 1)) { // -1: zero-terminated string
this->enumMemberForComment(currentEnumItem)->reportError<void>("comment 2 long");
} // 2: = space
enumItemValueTab = fEnumItemValueTab + 2 // 2: , space
- SkTMax(0, fEnumItemValueTab + 2 + valueLength + 2 - fEnumItemCommentTab);
enumItemCommentTab = SkTMax(enumItemValueTab + valueLength + 2, fEnumItemCommentTab);
}
}
this->lfcr();
this->writeString(item.fName);
int saveIndent = fIndent;
if (item.fValue.length()) {
if (!crAfterName) {
this->indentToColumn(enumItemValueTab);
} else {
this->writeSpace();
}
this->writeString("=");
if (crAfterName) {
this->lfcr();
fIndent = enumItemValueTab;
} else {
this->writeSpace();
}
this->writeString(item.fValue);
}
this->writeString(",");
this->indentToColumn(enumItemCommentTab);
this->writeString("//!<");
this->writeSpace();
this->rewriteBlock(shortComment.length(), shortComment.c_str(), Phrase::kYes);
this->lfcr();
fIndent = saveIndent;
if (preprocessor.fStart) {
SkASSERT(preprocessor.fEnd);
int saveIndent = fIndent;
fIndent = SkTMax(0, fIndent - 8);
this->lf(2);
this->writeBlock(
(int) (preprocessor.fEnd - preprocessor.fStart), preprocessor.fStart);
this->lfcr();
fIndent = saveIndent;
preprocessor.reset();
}
}
// iterate through include tokens and find how much remains for 1 line comments
// put ones that fit on same line, ones that are too big wrap
void IncludeWriter::enumMembersOut(Definition& child) {
ItemState state = ItemState::kNone;
const Definition* currentEnumItem = nullptr;
LastItem last = { nullptr, nullptr };
auto brace = child.fChildren[0];
if (KeyWord::kClass == brace->fKeyWord) {
brace = brace->fChildren[0];
}
SkASSERT(Bracket::kBrace == brace->fBracket);
vector<IterState> iterStack;
iterStack.emplace_back(brace->fTokens.begin(), brace->fTokens.end());
IterState* iterState = &iterStack[0];
Preprocessor preprocessor;
Item item;
while (iterState->fDefIter != iterState->fDefEnd) {
auto& token = *iterState->fDefIter++;
if (this->enumPreprocessor(&token, MemberPass::kOut, iterStack, &iterState,
&preprocessor)) {
continue;
}
if (ItemState::kName == state) {
state = this->enumMemberName(child, &token, &item, &last, &currentEnumItem);
}
if (ItemState::kValue == state) {
TextParser valueEnd(token.fFileName, last.fEnd, token.fContentStart, token.fLineCount);
const char* end = valueEnd.anyOf(",}");
if (!end) { // write expression continuation
item.fValue += string(last.fEnd, (int) (token.fContentEnd - last.fEnd));
continue;
}
}
if (ItemState::kNone != state && currentEnumItem) {
this->enumMemberOut(currentEnumItem, child, item, preprocessor);
item.reset();
this->setStartBack(token.fContentStart, &token);
state = ItemState::kNone;
last.fStart = nullptr;
}
SkASSERT(ItemState::kNone == state || !currentEnumItem);
if (!last.fStart) {
last.fStart = fStart;
}
last.fEnd = token.fContentEnd;
state = ItemState::kName;
}
if (ItemState::kName == state) {
state = this->enumMemberName(child, nullptr, &item, &last, &currentEnumItem);
}
if ((ItemState::kValue == state || ItemState::kComment == state) && currentEnumItem) {
this->enumMemberOut(currentEnumItem, child, item, preprocessor);
}
this->indentOut();
}
bool IncludeWriter::enumPreprocessor(Definition* token, MemberPass pass,
vector<IterState>& iterStack, IterState** iterState, Preprocessor* preprocessor) {
if (token && Definition::Type::kBracket == token->fType) {
if (Bracket::kSlashSlash == token->fBracket) {
if (MemberPass::kOut == pass) {
this->setStart(token->fContentEnd, token);
}
return true; // ignore old inline comments
}
if (Bracket::kSlashStar == token->fBracket) {
if (MemberPass::kOut == pass) {
this->setStart(token->fContentEnd + 1, token);
}
return true; // ignore old inline comments
}
if (Bracket::kPound == token->fBracket) { // preprocessor wraps member
preprocessor->fDefinition = token;
preprocessor->fStart = token->fContentStart;
if (KeyWord::kIf == token->fKeyWord || KeyWord::kIfdef == token->fKeyWord) {
iterStack.emplace_back(token->fTokens.begin(), token->fTokens.end());
*iterState = &iterStack.back();
preprocessor->fWord = true;
} else if (KeyWord::kEndif == token->fKeyWord || KeyWord::kElif == token->fKeyWord
|| KeyWord::kElse == token->fKeyWord) {
iterStack.pop_back();
*iterState = &iterStack.back();
preprocessor->fEnd = token->fContentEnd;
if (KeyWord::kElif == token->fKeyWord) {
iterStack.emplace_back(token->fTokens.begin(), token->fTokens.end());
*iterState = &iterStack.back();
preprocessor->fWord = true;
}
} else {
SkASSERT(0); // incomplete
}
return true;
}
if (preprocessor->fDefinition) {
if (Bracket::kParen == token->fBracket) {
preprocessor->fEnd = token->fContentEnd;
SkASSERT(')' == *preprocessor->fEnd);
++preprocessor->fEnd;
return true;
}
SkASSERT(0); // incomplete
}
return true;
}
if (token && Definition::Type::kWord != token->fType) {
SkASSERT(0); // incomplete
}
if (preprocessor->fWord) {
preprocessor->fWord = false;
preprocessor->fEnd = token->fContentEnd;
return true;
}
return false;
}
void IncludeWriter::enumSizeItems(const Definition& child) {
ItemState state = ItemState::kNone;
ItemLength lengths = { 0, 0, 0, 0 };
const char* lastEnd = nullptr;
auto brace = child.fChildren[0];
if (KeyWord::kClass == brace->fKeyWord) {
brace = brace->fChildren[0];
}
SkASSERT(Bracket::kBrace == brace->fBracket);
vector<IterState> iterStack;
iterStack.emplace_back(brace->fTokens.begin(), brace->fTokens.end());
IterState* iterState = &iterStack[0];
Preprocessor preprocessor;
string enumName;
bool undocumented = false;
while (iterState->fDefIter != iterState->fDefEnd) {
auto& token = *iterState->fDefIter++;
if (this->enumPreprocessor(&token, MemberPass::kCount, iterStack, &iterState,
&preprocessor)) {
continue;
}
if (ItemState::kName == state) {
TextParser enumLine(token.fFileName, lastEnd, token.fContentStart, token.fLineCount);
const char* end = enumLine.anyOf(",}=");
SkASSERT(end);
state = '=' == *end ? ItemState::kValue : ItemState::kComment;
if (ItemState::kValue == state) {
lastEnd = token.fContentEnd;
lengths.fCurValue = (int) (lastEnd - token.fContentStart);
continue;
}
}
if (ItemState::kValue == state) {
TextParser valueEnd(token.fFileName, lastEnd, token.fContentStart, token.fLineCount);
const char* end = valueEnd.anyOf(",}");
if (!end) { // write expression continuation
lengths.fCurValue += (int) (token.fContentEnd - lastEnd);
continue;
}
}
if (ItemState::kNone != state) {
if (!undocumented) {
this->checkEnumLengths(child, enumName, &lengths);
}
lengths.fCurValue = 0;
state = ItemState::kNone;
}
SkASSERT(ItemState::kNone == state);
lastEnd = token.fContentEnd;
lengths.fCurName = (int) (lastEnd - token.fContentStart);
enumName = string(token.fContentStart, lengths.fCurName);
undocumented = token.fUndocumented;
state = ItemState::kName;
}
if (ItemState::kNone != state && !undocumented) {
this->checkEnumLengths(child, enumName, &lengths);
}
fEnumItemValueTab = lengths.fLongestName + fIndent + 1 /* 1: , */ ;
if (lengths.fLongestValue) {
lengths.fLongestValue += 3; // 3: space = space
}
fEnumItemCommentTab = fEnumItemValueTab + lengths.fLongestValue + 1 ; // 1: space before //!<
// iterate through bmh children and see which comments fit on include lines
if (!this->checkChildCommentLength(fEnumDef, MarkType::kConst)) {
fEnumDef->reportError<void>("expected at least one #Const in #Enum");
}
}
const Definition* IncludeWriter::matchMemberName(string matchName, const Definition& child) const {
const Definition* parent = &child;
if (KeyWord::kEnum == child.fKeyWord && child.fChildren.size() > 0
&& KeyWord::kClass == child.fChildren[0]->fKeyWord) {
matchName = child.fChildren[0]->fName + "::" + matchName;
}
do {
if (KeyWord::kStruct == parent->fKeyWord || KeyWord::kClass == parent->fKeyWord) {
matchName = parent->fName + "::" + matchName;
}
} while ((parent = parent->fParent));
const Definition* enumItem = nullptr;
for (auto testItem : fEnumDef->fChildren) {
if (MarkType::kConst != testItem->fMarkType) {
continue;
}
if (matchName != testItem->fName) {
continue;
}
enumItem = testItem;
break;
}
return enumItem; // returns nullptr if matchName is undocumented
}
// walk children and output complete method doxygen description
void IncludeWriter::methodOut(Definition* method, const Definition& child) {
if (fPendingMethod) {
this->indentOut();
fPendingMethod = false;
}
fBmhMethod = method;
fMethodDef = &child;
fContinuation = nullptr;
fDeferComment = nullptr;
Definition* csParent = method->csParent();
if (csParent && (0 == fIndent || fIndentNext)) {
this->indentIn(IndentKind::kMethodOut);
fIndentNext = false;
}
if (method->fChildren.end() != std::find_if(method->fChildren.begin(), method->fChildren.end(),
[](const Definition* def) { return MarkType::kPopulate == def->fMarkType; } )) {
std::list<Definition>::iterator iter;
const Definition* childPtr = &child;
SkDEBUGCODE(bool sawMethod = false);
do {
int commentIndex = childPtr->fParentIndex;
iter = childPtr->fParent->fTokens.begin();
std::advance(iter, commentIndex);
SkDEBUGCODE(sawMethod |= MarkType::kMethod == iter->fMarkType);
while (--commentIndex >= 0) {
std::advance(iter, -1);
if (Bracket::kSlashStar == iter->fBracket) {
SkASSERT(sawMethod);
break;
}
SkASSERT(!sawMethod);
SkDEBUGCODE(sawMethod |= MarkType::kMethod == iter->fMarkType);
}
if (MarkType::kMethod != iter->fMarkType) {
break;
}
childPtr = childPtr->fParent;
SkDEBUGCODE(sawMethod = true);
} while (true);
SkASSERT(Bracket::kSlashSlash == iter->fBracket || Bracket::kSlashStar == iter->fBracket);
this->lf(2);
this->writeString("/");
this->writeBlock(iter->length(), iter->fContentStart);
this->lfcr();
} else {
this->writeCommentHeader();
fIndent += 4;
this->descriptionOut(method, SkipFirstLine::kNo, Phrase::kNo);
// compute indention column
size_t column = 0;
bool hasParmReturn = false;
for (auto methodPart : method->fChildren) {
if (MarkType::kParam == methodPart->fMarkType) {
column = SkTMax(column, methodPart->fName.length());
hasParmReturn = true;
} else if (MarkType::kReturn == methodPart->fMarkType) {
hasParmReturn = true;
}
}
if (hasParmReturn) {
this->lf(2);
column += fIndent + sizeof("@return ");
int saveIndent = fIndent;
for (auto methodPart : method->fChildren) {
if (MarkType::kParam == methodPart->fMarkType) {
this->writeString("@param");
this->writeSpace();
this->writeString(methodPart->fName.c_str());
} else if (MarkType::kReturn == methodPart->fMarkType) {
this->writeString("@return");
} else {
continue;
}
this->indentToColumn(column);
fIndent = column;
this->descriptionOut(methodPart, SkipFirstLine::kNo, Phrase::kYes);
fIndent = saveIndent;
this->lfcr();
}
} else {
this->lfcr();
}
fIndent -= 4;
this->lfcr();
this->writeCommentTrailer(OneLine::kNo);
}
fBmhMethod = nullptr;
fMethodDef = nullptr;
fEnumDef = nullptr;
fWroteMethod = true;
}
void IncludeWriter::structOut(const Definition* root, const Definition& child,
const char* commentStart, const char* commentEnd) {
this->writeCommentHeader();
this->writeString("\\");
SkASSERT(MarkType::kClass == child.fMarkType || MarkType::kStruct == child.fMarkType);
this->writeString(MarkType::kClass == child.fMarkType ? "class" : "struct");
this->writeSpace();
this->writeString(child.fName.c_str());
fIndent += 4;
this->lfcr();
this->rewriteBlock((int)(commentEnd - commentStart), commentStart, Phrase::kNo);
fIndent -= 4;
this->lfcr();
this->writeCommentTrailer(OneLine::kNo);
}
bool IncludeWriter::findEnumSubtopic(string undername, const Definition** rootDefPtr) const {
const Definition* subtopic = fEnumDef->fParent;
string subcheck = subtopic->fFiddle + '_' + undername;
auto iter = fBmhParser->fTopicMap.find(subcheck);
if (iter == fBmhParser->fTopicMap.end()) {
return false;
}
*rootDefPtr = iter->second;
return true;
}
Definition* IncludeWriter::findMemberCommentBlock(const vector<Definition*>& bmhChildren,
string name) const {
for (auto memberDef : bmhChildren) {
if (MarkType::kMember != memberDef->fMarkType) {
continue;
}
string match = memberDef->fName;
// if match.endsWith(name) ...
if (match.length() >= name.length() &&
0 == match.compare(match.length() - name.length(), name.length(), name)) {
return memberDef;
}
}
for (auto memberDef : bmhChildren) {
if (MarkType::kSubtopic != memberDef->fMarkType && MarkType::kTopic != memberDef->fMarkType) {
continue;
}
Definition* result = this->findMemberCommentBlock(memberDef->fChildren, name);
if (result) {
return result;
}
}
return nullptr;
}
Definition* IncludeWriter::findMethod(string name, RootDefinition* root) const {
if (root) {
return root->find(name, RootDefinition::AllowParens::kNo);
}
auto methodIter = fBmhParser->fMethodMap.find(name);
if (fBmhParser->fMethodMap.end() == methodIter) {
return nullptr;
}
return &methodIter->second;
}
void IncludeWriter::firstBlock(int size, const char* data) {
SkAssertResult(this->firstBlockTrim(size, data));
}
bool IncludeWriter::firstBlockTrim(int size, const char* data) {
bool result = this->writeBlockTrim(size, data);
if (fFirstWrite) {
auto fileInfo = std::find_if(fRootTopic->fChildren.begin(), fRootTopic->fChildren.end(),
[](const Definition* def){ return MarkType::kFile == def->fMarkType; } );
if (fRootTopic->fChildren.end() != fileInfo) {
this->writeCommentHeader();
this->writeString("\\file");
this->writeSpace();
size_t lastSlash = fFileName.rfind('/');
if (string::npos == lastSlash) {
lastSlash = fFileName.rfind('\\');
}
string fileName = fFileName.substr(lastSlash + 1);
this->writeString(fileName);
this->lf(2);
fIndent += 4;
this->descriptionOut(*fileInfo, SkipFirstLine::kNo, Phrase::kNo);
fIndent -= 4;
this->writeCommentTrailer(OneLine::kNo);
}
fFirstWrite = false;
}
return result;
}
void IncludeWriter::setStart(const char* start, const Definition* def) {
SkASSERT(start >= fStart);
this->setStartBack(start, def);
}
void IncludeWriter::setStartBack(const char* start, const Definition* def) {
fStartSetter = def;
fStart = start;
}
Definition* IncludeWriter::structMemberOut(const Definition* memberStart, const Definition& child) {
const char* blockStart = !fWroteMethod && fDeferComment ? fDeferComment->fContentEnd : fStart;
const char* blockEnd = fWroteMethod && fDeferComment ? fDeferComment->fStart - 1 :
memberStart->fStart;
this->firstBlockTrim((int) (blockEnd - blockStart), blockStart);
this->indentDeferred(IndentKind::kStructMember);
fWroteMethod = false;
string name(child.fContentStart, (int) (child.fContentEnd - child.fContentStart));
Definition* commentBlock = this->findMemberCommentBlock(fBmhStructDef->fChildren, name);
if (!commentBlock) {
return memberStart->reportError<Definition*>("member missing comment block 2");
}
auto lineIter = std::find_if(commentBlock->fChildren.begin(), commentBlock->fChildren.end(),
[](const Definition* def){ return MarkType::kLine == def->fMarkType; } );
SkASSERT(commentBlock->fChildren.end() != lineIter);
const Definition* lineDef = *lineIter;
if (fStructMemberLength > 100) {
this->writeCommentHeader();
this->writeSpace();
this->rewriteBlock(lineDef->length(), lineDef->fContentStart, Phrase::kYes);
this->writeCommentTrailer(OneLine::kYes);
}
this->lfcr();
this->writeBlock((int) (child.fStart - memberStart->fContentStart),
memberStart->fContentStart);
this->indentToColumn(fStructMemberTab);
this->writeString(name.c_str());
auto tokenIter = child.fParent->fTokens.begin();
std::advance(tokenIter, child.fParentIndex + 1);
Definition* valueStart = &*tokenIter;
while (Definition::Type::kPunctuation != tokenIter->fType) {
std::advance(tokenIter, 1);
SkASSERT(child.fParent->fTokens.end() != tokenIter);
}
Definition* valueEnd = &*tokenIter;
if (valueStart != valueEnd) {
this->indentToColumn(fStructValueTab);
this->writeString("=");
this->writeSpace();
this->writeBlock((int) (valueEnd->fStart - valueStart->fContentStart),
valueStart->fContentStart);
}
this->writeString(";");
if (fStructMemberLength <= 100) {
this->indentToColumn(fStructCommentTab);
this->writeString("//!<");
this->writeSpace();
this->rewriteBlock(lineDef->length(), lineDef->fContentStart, Phrase::kYes);
}
this->lf(1);
return valueEnd;
}
// const and constexpr and #define aren't contained in a braces like struct and enum.
// use a bmh subtopic to group like ones together, then measure them in the include as if
// they were formally linked together
void IncludeWriter::constSizeMembers(const RootDefinition* root) {
// fBmhConst->fParent is subtopic containing all grouped const expressions
// fConstDef is token of const include name, hopefully on same line as const start
string rootPrefix = root ? root->fName + "::" : "";
const Definition* test = fConstDef;
int tokenIndex = test->fParentIndex;
int longestName = 0;
int longestValue = 0;
int longestComment = 0;
const Definition* subtopic = fBmhConst->fParent;
SkASSERT(subtopic);
SkASSERT(MarkType::kSubtopic == subtopic->fMarkType);
// back up to first token on line
size_t lineCount = test->fLineCount;
const Definition* last;
auto tokenIter = test->fParent->fTokens.begin();
std::advance(tokenIter, tokenIndex);
do {
last = test;
std::advance(tokenIter, -1);
test = &*tokenIter;
SkASSERT(test->fParentIndex == --tokenIndex);
} while (lineCount == test->fLineCount);
test = last;
for (auto child : subtopic->fChildren) {
if (MarkType::kConst != child->fMarkType) {
continue;
}
// expect found name to be on the left of assign
// expect assign
// expect semicolon
// no parens, no braces
while (rootPrefix + test->fName != child->fName) {
std::advance(tokenIter, 1);
test = &*tokenIter;
SkASSERT(lineCount >= test->fLineCount);
}
++lineCount;
TextParser constText(test);
const char* nameEnd = constText.trimmedBracketEnd('=');
SkAssertResult(constText.skipToEndBracket('='));
const char* valueEnd = constText.trimmedBracketEnd(';');
auto lineIter = std::find_if(child->fChildren.begin(), child->fChildren.end(),
[](const Definition* def){ return MarkType::kLine == def->fMarkType; });
SkASSERT(child->fChildren.end() != lineIter);
longestName = SkTMax(longestName, (int) (nameEnd - constText.fStart));
longestValue = SkTMax(longestValue, (int) (valueEnd - constText.fChar));
longestComment = SkTMax(longestComment, (*lineIter)->length());
}
// write fStructValueTab, fStructCommentTab
fConstValueTab = longestName + fIndent + 1;
fConstCommentTab = fConstValueTab + longestValue + 2;
fConstLength = fConstCommentTab + longestComment + (int) sizeof("//!<");
}
bool IncludeWriter::defineOut(const Definition& def) {
if (def.fTokens.size() < 1) {
return false;
}
auto& child = def.fTokens.front();
string name(child.fContentStart, child.length());
auto defIter = fBmhParser->fDefineMap.find(name);
if (fBmhParser->fDefineMap.end() == defIter) {
return false;
}
const Definition& bmhDef = defIter->second;
this->constOut(&def, &bmhDef);
return true;
}
void IncludeWriter::structSizeMembers(const Definition& child) {
int longestType = 0;
Definition* typeStart = nullptr;
int longestName = 0;
int longestValue = 0;
int longestComment = 0;
SkASSERT(child.fChildren.size() == 1 || child.fChildren.size() == 2);
bool inEnum = false;
bool inMethod = false;
bool inMember = false;
auto brace = child.fChildren[0];
SkASSERT(Bracket::kBrace == brace->fBracket);
for (auto& token : brace->fTokens) {
if (Definition::Type::kBracket == token.fType) {
if (Bracket::kSlashSlash == token.fBracket) {
continue; // ignore old inline comments
}
if (Bracket::kSlashStar == token.fBracket) {
continue; // ignore old inline comments
}
if (Bracket::kParen == token.fBracket) {
if (inMethod) {
continue;
}
break;
}
if (Bracket::kAngle == token.fBracket) {
// in template param
continue;
}
SkASSERT(0); // incomplete
}
if (Definition::Type::kKeyWord == token.fType) {
switch (token.fKeyWord) {
case KeyWord::kEnum:
inEnum = true;
break;
case KeyWord::kConst:
case KeyWord::kConstExpr:
case KeyWord::kStatic:
case KeyWord::kInt:
case KeyWord::kUint8_t:
case KeyWord::kUint16_t:
case KeyWord::kUint32_t:
case KeyWord::kUint64_t:
case KeyWord::kUintPtr_t:
case KeyWord::kUnsigned:
case KeyWord::kSize_t:
case KeyWord::kFloat:
case KeyWord::kBool:
case KeyWord::kChar:
case KeyWord::kVoid:
if (!typeStart) {
typeStart = &token;
}
break;
default:
break;
}
continue;
}
if (Definition::Type::kPunctuation == token.fType) {
if (inEnum) {
SkASSERT(Punctuation::kSemicolon == token.fPunctuation);
inEnum = false;
}
if (inMethod) {
if (Punctuation::kColon == token.fPunctuation) {
inMethod = false;
} else if (Punctuation::kLeftBrace == token.fPunctuation) {
inMethod = false;
} else if (Punctuation::kSemicolon == token.fPunctuation) {
inMethod = false;
} else if (Punctuation::kAsterisk == token.fPunctuation) {
inMethod = false;
} else {
SkASSERT(0); // incomplete
}
}
if (inMember) {
SkASSERT(Punctuation::kSemicolon == token.fPunctuation);
typeStart = nullptr;
inMember = false;
}
continue;
}
if (Definition::Type::kWord != token.fType) {
SkASSERT(0); // incomplete
}
if (MarkType::kMember == token.fMarkType) {
TextParser typeStr(token.fFileName, typeStart->fContentStart, token.fContentStart,
token.fLineCount);
typeStr.trimEnd();
longestType = SkTMax(longestType, (int) (typeStr.fEnd - typeStr.fStart));
longestName = SkTMax(longestName, (int) (token.fContentEnd - token.fContentStart));
typeStart->fMemberStart = true;
inMember = true;
string tokenName(token.fContentStart, (int) (token.fContentEnd - token.fContentStart));
Definition* commentBlock = this->findMemberCommentBlock(fBmhStructDef->fChildren,
tokenName);
if (!commentBlock) {
return token.reportError<void>("member missing comment block 1");
}
auto lineIter = std::find_if(commentBlock->fChildren.begin(),
commentBlock->fChildren.end(),
[](const Definition* def){ return MarkType::kLine == def->fMarkType; } );
SkASSERT(commentBlock->fChildren.end() != lineIter);
const Definition* lineDef = *lineIter;
longestComment = SkTMax(longestComment, lineDef->length());
continue;
}
if (MarkType::kMethod == token.fMarkType) {
inMethod = true;
continue;
}
SkASSERT(MarkType::kNone == token.fMarkType);
if (typeStart) {
if (inMember) {
longestValue =
SkTMax(longestValue, (int) (token.fContentEnd - token.fContentStart));
}
} else {
typeStart = &token;
}
}
fStructMemberTab = longestType + fIndent + 1 /* space before name */ ;
fStructValueTab = fStructMemberTab + longestName + 2 /* space ; */ ;
fStructCommentTab = fStructValueTab;
if (longestValue) {
fStructCommentTab += longestValue + 3 /* space = space */ ;
fStructValueTab -= 1 /* ; */ ;
}
fStructMemberLength = fStructCommentTab + longestComment;
// iterate through struct to ensure that members' comments fit on line
// struct or class may not have any members
(void) this->checkChildCommentLength(fBmhStructDef, MarkType::kMember);
}
static bool find_start(const Definition* startDef, const char* start) {
for (const auto& child : startDef->fTokens) {
if (child.fContentStart == start) {
return MarkType::kMethod == child.fMarkType;
}
if (child.fContentStart >= start) {
break;
}
if (find_start(&child, start)) {
return true;
}
}
return false;
}
bool IncludeWriter::populate(Definition* def, ParentPair* prevPair, RootDefinition* root) {
if (!def->fTokens.size()) {
return true;
}
ParentPair pair = { def, prevPair };
// write bulk of original include up to class, method, enum, etc., excepting preceding comment
// find associated bmh object
// write any associated comments in Doxygen form
// skip include comment
// if there is a series of same named methods, write one set of comments, then write all methods
string methodName;
Definition* method = nullptr;
Definition* clonedMethod = nullptr;
const Definition* memberStart = nullptr;
const Definition* memberEnd = nullptr;
fContinuation = nullptr;
bool inStruct = false;
bool inConstructor = false;
bool inInline = false;
bool eatOperator = false;
bool sawConst = false;
bool staticOnly = false;
bool sawTypedef = false;
Definition* deferredTypedefComment = nullptr;
const Definition* requireDense = nullptr;
const Definition* startDef = nullptr;
for (auto& child : def->fTokens) {
if (KeyWord::kInline == child.fKeyWord) {
continue;
}
if (KeyWord::kOperator == child.fKeyWord && method &&
Definition::MethodType::kOperator == method->fMethodType) {
eatOperator = true;
continue;
}
if (eatOperator) {
if (Bracket::kSquare == child.fBracket || Bracket::kParen == child.fBracket) {
continue;
}
eatOperator = false;
fContinuation = nullptr;
if (KeyWord::kConst == child.fKeyWord) {
continue;
}
}
if (memberEnd) {
if (memberEnd != &child) {
continue;
}
startDef = &child;
this->setStart(child.fContentStart + 1, &child);
memberEnd = nullptr;
}
if (child.fPrivate) {
if (MarkType::kMethod == child.fMarkType) {
inInline = true;
}
continue;
}
if (inInline) {
if (Definition::Type::kKeyWord == child.fType) {
SkASSERT(MarkType::kMethod != child.fMarkType);
continue;
}
if (Definition::Type::kPunctuation == child.fType) {
if (Punctuation::kLeftBrace == child.fPunctuation) {
inInline = false;
} else {
SkASSERT(Punctuation::kAsterisk == child.fPunctuation);
}
continue;
}
if (Definition::Type::kWord == child.fType) {
string name(child.fContentStart, child.fContentEnd - child.fContentStart);
SkASSERT(string::npos != name.find("::"));
continue;
}
if (Definition::Type::kBracket == child.fType) {
SkASSERT(Bracket::kParen == child.fBracket);
continue;
}
}
if (fContinuation) {
if (Definition::Type::kKeyWord == child.fType) {
if (KeyWord::kFriend == child.fKeyWord ||
KeyWord::kSK_API == child.fKeyWord) {
continue;
}
const IncludeKey& includeKey = kKeyWords[(int) child.fKeyWord];
if (KeyProperty::kNumber == includeKey.fProperty) {
continue;
}
}
if (Definition::Type::kBracket == child.fType) {
if (Bracket::kAngle == child.fBracket) {
continue;
}
if (Bracket::kParen == child.fBracket) {
if (!clonedMethod) {
if (inConstructor) {
fContinuation = child.fContentStart;
}
continue;
}
int alternate = 1;
ptrdiff_t childLen = child.fContentEnd - child.fContentStart;
SkASSERT(')' == child.fContentStart[childLen]);
++childLen;
do {
TextParser params(clonedMethod->fFileName, clonedMethod->fStart,
clonedMethod->fContentStart, clonedMethod->fLineCount);
params.skipToEndBracket('(');
if (params.startsWith(child.fContentStart, childLen)) {
this->methodOut(clonedMethod, child);
sawConst = false;
break;
}
++alternate;
string alternateMethod = methodName + '_' + to_string(alternate);
clonedMethod = this->findMethod(alternateMethod, root);
} while (clonedMethod);
if (!clonedMethod) {
return child.reportError<bool>("cloned method not found");
}
clonedMethod = nullptr;
continue;
}
}
if (Definition::Type::kWord == child.fType) {
if (clonedMethod) {
continue;
}
size_t len = (size_t) (child.fContentEnd - child.fContentStart);
const char operatorStr[] = "operator";
size_t operatorLen = sizeof(operatorStr) - 1;
if (len >= operatorLen && !strncmp(child.fContentStart, operatorStr, operatorLen)) {
fContinuation = child.fContentEnd;
continue;
}
}
if (Definition::Type::kPunctuation == child.fType &&
(Punctuation::kSemicolon == child.fPunctuation ||
Punctuation::kLeftBrace == child.fPunctuation ||
(Punctuation::kColon == child.fPunctuation && inConstructor))) {
SkASSERT(fContinuation[0] == '(');
const char* continueEnd = child.fContentStart;
while (continueEnd > fContinuation && isspace(continueEnd[-1])) {
--continueEnd;
}
const char defaultTag[] = " = default";
size_t tagSize = sizeof(defaultTag) - 1;
const char* tokenEnd = continueEnd - tagSize;
if (tokenEnd <= fContinuation || strncmp(tokenEnd, defaultTag, tagSize)) {
tokenEnd = continueEnd;
}
methodName += string(fContinuation, tokenEnd - fContinuation);
if (string::npos != methodName.find('\n')) {
methodName.erase(std::remove(methodName.begin(), methodName.end(), '\n'),
methodName.end());
}
method = this->findMethod(methodName, root);
if (!method) {
return child.reportError<bool>("method not found");
}
this->methodOut(method, child);
sawConst = false;
continue;
}
if (Definition::Type::kPunctuation == child.fType &&
Punctuation::kAsterisk == child.fPunctuation &&
clonedMethod) {
continue;
}
if (inConstructor) {
continue;
}
method = this->findMethod(methodName + "()", root);
if (method) {
if (method->fCloned) {
clonedMethod = method;
continue;
}
this->methodOut(method, child);
sawConst = false;
continue;
}
if (KeyWord::kTemplate == child.fParent->fKeyWord) {
// incomplete; no support to template specialization in public includes
fContinuation = nullptr;
continue;
}
return child.reportError<bool>("method not found");
}
if (Bracket::kSlashSlash == child.fBracket || Bracket::kSlashStar == child.fBracket) {
if (!fDeferComment) {
fDeferComment = &child;
}
continue;
}
if (MarkType::kMethod == child.fMarkType) {
if (this->isInternalName(child)) {
continue;
}
if (child.fUndocumented) {
continue;
}
if (KeyWord::kTemplate == child.fParent->fKeyWord) {
// todo: support template specializations
continue;
}
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
child.fContentStart;
if (Definition::Type::kBracket == def->fType && Bracket::kDebugCode == def->fBracket) {
auto tokenIter = def->fParent->fTokens.begin();
std::advance(tokenIter, def->fParentIndex - 1);
Definition* prior = &*tokenIter;
if (Definition::Type::kBracket == def->fType &&
Bracket::kSlashStar == prior->fBracket) {
bodyEnd = prior->fContentStart - 1;
}
}
// FIXME: roll end-trimming into writeBlockTrim call
while (fStart < bodyEnd && ' ' >= bodyEnd[-1]) {
--bodyEnd;
}
int blockSize = (int) (bodyEnd - fStart);
SkASSERT(blockSize >= 0);
if (blockSize) {
string debugstr(fStart, blockSize);
this->writeBlock(blockSize, fStart);
}
startDef = &child;
this->setStart(child.fContentStart, &child);
auto mapFind = fBmhParser->fMethodMap.find(child.fName);
if (fBmhParser->fMethodMap.end() != mapFind) {
inConstructor = false;
method = &mapFind->second;
methodName = child.fName;
} else if (root) {
methodName = root->fName + "::" + child.fName;
size_t lastName = root->fName.rfind(':');
lastName = string::npos == lastName ? 0 : lastName + 1;
inConstructor = root->fName.substr(lastName) == child.fName;
method = root->find(methodName, RootDefinition::AllowParens::kNo);
}
fContinuation = child.fContentEnd;
if (!method) {
continue;
}
if (method->fCloned) {
clonedMethod = method;
continue;
}
this->methodOut(method, child);
sawConst = false;
continue;
}
if (Definition::Type::kKeyWord == child.fType) {
if (child.fUndocumented) {
continue;
}
switch (child.fKeyWord) {
case KeyWord::kStruct:
case KeyWord::kClass:
fICSStack.push_back(&child);
fStructEnded = false;
fStructMemberTab = 0;
// if struct contains members, compute their name and comment tabs
if (child.fChildren.size() > 0) {
const ParentPair* testPair = &pair;
while ((testPair = testPair->fPrev)) {
if (KeyWord::kClass == testPair->fParent->fKeyWord) {
inStruct = fInStruct = true;
break;
}
}
}
if (fInStruct) {
// try child; root+child; root->parent+child; etc.
int trial = 0;
RootDefinition* search = root;
Definition* parent = search->fParent;
do {
string name;
if (0 == trial) {
name = child.fName;
} else if (1 == trial) {
name = root->fName + "::" + child.fName;
} else if (2 == trial) {
name = root->fName;
} else {
SkASSERT(parent);
name = parent->fName + "::" + child.fName;
search = parent->asRoot();
parent = search->fParent;
}
fBmhStructDef = search->find(name, RootDefinition::AllowParens::kNo);
} while (!fBmhStructDef && ++trial);
root = fBmhStructDef->asRoot();
SkASSERT(root);
fIndent += 4;
this->structSizeMembers(child);
fIndent -= 4;
SkASSERT(!fIndentNext);
fIndentNext = true;
}
if (child.fChildren.size() > 0) {
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
child.fContentStart;
this->writeBlockTrim((int) (bodyEnd - fStart), fStart);
if (fPendingMethod) {
if (fIndent >= 4) {
this->indentOut();
}
fPendingMethod = false;
}
startDef = requireDense ? requireDense : &child;
if (requireDense) {
startDef = requireDense;
this->setStart(requireDense->fContentStart, requireDense);
} else {
startDef = &child;
this->setStart(child.fContentStart, &child);
}
requireDense = nullptr;
if (!fInStruct && (!root || child.fName != root->fName)) {
root = &fBmhParser->fClassMap[child.fName];
fRootTopic = root->fParent;
SkASSERT(!root->fVisited);
root->clearVisited();
#if 0
// this seems better balanced; but real problem is probably fInStruct
if (fIndentStack.size() > 0) {
this->indentOut();
}
SkASSERT(!fIndent);
#else
fIndent = 0;
#endif
fBmhStructDef = root;
}
if (child.fName == root->fName) {
if (Definition* parent = root->fParent) {
if (MarkType::kTopic == parent->fMarkType ||
MarkType::kSubtopic == parent->fMarkType) {
const char* commentStart = root->fContentStart;
unsigned index = 0;
const char* commentEnd = root->fChildren[0]->fStart;
int line = 1;
do {
TextParser parser(root->fFileName, commentStart, commentEnd, line);
if (!parser.eof()) {
parser.skipWhiteSpace();
}
if (!parser.eof()) {
break;
}
commentStart = root->fChildren[index]->fTerminator;
++index;
SkASSERT(index < root->fChildren.size());
commentEnd = root->fChildren[index]->fStart;
} while (true);
this->structOut(root, *root, commentStart, commentEnd);
} else {
SkASSERT(0); // incomplete
}
} else {
SkASSERT(0); // incomplete
}
} else {
SkASSERT(fInStruct);
Definition* priorBlock = fBmhStructDef;
Definition* codeBlock = nullptr;
Definition* nextBlock = nullptr;
for (auto test : fBmhStructDef->fChildren) {
if (MarkType::kCode == test->fMarkType) {
SkASSERT(!codeBlock); // FIXME: check enum earlier
codeBlock = test;
continue;
}
if (codeBlock) {
nextBlock = test;
break;
}
priorBlock = test;
}
// FIXME: trigger error earlier if inner #Struct or #Class is missing #Code
SkASSERT(codeBlock);
SkASSERT(nextBlock); // FIXME: check enum for correct order earlier
const char* commentStart = codeBlock->fTerminator;
const char* commentEnd = nextBlock->fStart;
// FIXME: trigger error if #Code is present but comment is before it earlier
SkASSERT(priorBlock); // code always preceded by #Line (I think)
TextParser priorComment(priorBlock->fFileName,
priorBlock->fTerminator, codeBlock->fStart,
priorBlock->fLineCount);
priorComment.trimEnd();
if (!priorComment.eof()) {
return priorBlock->reportError<bool>(
"expect no comment before #Code");
}
TextParser nextComment(codeBlock->fFileName, commentStart,
commentEnd, codeBlock->fLineCount);
nextComment.trimEnd();
if (!priorComment.eof()) {
return priorBlock->reportError<bool>(
"expect comment after #Code");
}
if (!nextComment.eof()) {
}
fIndentNext = true;
this->structOut(root, *fBmhStructDef, commentStart, commentEnd);
}
fDeferComment = nullptr;
} else {
// empty forward reference
bool writeTwo = '\n' == child.fContentStart[-1]
&& '\n' == child.fContentStart[-2];
if (writeTwo) {
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
child.fContentStart;
this->writeBlockTrim((int) (bodyEnd - fStart), fStart);
this->lf(writeTwo ? 2 : 1);
fIndent = 0;
this->writeBlockTrim(child.length() + 1, child.fContentStart);
writeTwo = '\n' == child.fContentEnd[1]
&& '\n' == child.fContentStart[2];
this->lf(writeTwo ? 2 : 1);
fStart = child.fContentEnd + 1;
fDeferComment = nullptr;
}
}
break;
case KeyWord::kEnum: {
fInEnum = true;
this->enumHeaderOut(root, child);
this->enumSizeItems(child);
} break;
case KeyWord::kConst:
case KeyWord::kConstExpr:
sawConst = !memberStart || staticOnly;
if (!memberStart) {
memberStart = &child;
staticOnly = true;
}
if (MarkType::kConst == child.fMarkType) {
auto constIter = fBmhParser->fConstMap.find(child.fName);
if (fBmhParser->fConstMap.end() != constIter) {
const RootDefinition& bmhConst = constIter->second;
this->constOut(&child, &bmhConst);
fDeferComment = nullptr;
}
}
break;
case KeyWord::kStatic:
if (!memberStart) {
memberStart = &child;
staticOnly = true;
}
break;
case KeyWord::kInt:
case KeyWord::kUint8_t:
case KeyWord::kUint16_t:
case KeyWord::kUint32_t:
case KeyWord::kUint64_t:
case KeyWord::kUintPtr_t:
case KeyWord::kUnsigned:
case KeyWord::kSize_t:
case KeyWord::kFloat:
case KeyWord::kBool:
case KeyWord::kChar:
case KeyWord::kVoid:
staticOnly = false;
if (!memberStart) {
memberStart = &child;
}
break;
case KeyWord::kAlignAs:
case KeyWord::kPublic:
case KeyWord::kPrivate:
case KeyWord::kProtected:
case KeyWord::kFriend:
case KeyWord::kInline:
case KeyWord::kSK_API:
case KeyWord::kTemplate:
case KeyWord::kUsing:
break;
case KeyWord::kTypedef:
SkASSERT(!memberStart);
memberStart = &child;
deferredTypedefComment = fDeferComment;
sawTypedef = true;
break;
case KeyWord::kSK_BEGIN_REQUIRE_DENSE:
requireDense = &child;
break;
default:
SkASSERT(0);
}
if (KeyWord::kUint8_t == child.fKeyWord || KeyWord::kUint32_t == child.fKeyWord) {
continue;
} else {
if (fInEnum && child.fChildren.size() > 0
&& KeyWord::kClass == child.fChildren[0]->fKeyWord) {
if (!this->populate(child.fChildren[0], &pair, root)) {
return false;
}
} else {
if (!this->populate(&child, &pair, root)) {
return false;
}
if (KeyWord::kClass == child.fKeyWord || KeyWord::kStruct == child.fKeyWord) {
fICSStack.pop_back();
fStructEnded = true;
if (fInStruct) {
fInStruct = false;
do {
SkASSERT(root);
root = const_cast<RootDefinition*>(root->fParent->asRoot());
} while (MarkType::kTopic == root->fMarkType ||
MarkType::kSubtopic == root->fMarkType);
#if 0
}
if (MarkType::kStruct == root->fMarkType ||
MarkType::kClass == root->fMarkType) {
#else
SkASSERT(MarkType::kStruct == root->fMarkType ||
MarkType::kClass == root->fMarkType);
#endif
fPendingMethod = false;
if (startDef) {
fPendingMethod = find_start(startDef, fStart);
}
fOutdentNext = !fPendingMethod;
}
}
}
}
continue;
}
if (Definition::Type::kBracket == child.fType) {
if (KeyWord::kEnum == child.fParent->fKeyWord ||
(KeyWord::kClass == child.fParent->fKeyWord && child.fParent->fParent &&
KeyWord::kEnum == child.fParent->fParent->fKeyWord)) {
SkASSERT(Bracket::kBrace == child.fBracket);
this->enumMembersOut(*child.fParent);
this->writeString("};");
this->lf(2);
startDef = child.fParent;
this->setStart(child.fParent->fContentEnd, child.fParent);
SkASSERT(';' == fStart[0]);
++fStart;
fDeferComment = nullptr;
fInEnum = false;
if (fIndentNext) {
// fIndent -= 4;
fIndentNext = false;
}
continue;
}
if (KeyWord::kDefine == child.fKeyWord && this->defineOut(child)) {
fDeferComment = nullptr;
continue;
}
fDeferComment = nullptr;
if (KeyWord::kClass == def->fKeyWord || KeyWord::kStruct == def->fKeyWord) {
fIndentNext = true;
}
if (!this->populate(&child, &pair, root)) {
return false;
}
if (KeyWord::kClass == def->fKeyWord || KeyWord::kStruct == def->fKeyWord) {
if (def->iRootParent() && (!fStartSetter
|| MarkType::kMethod != fStartSetter->fMarkType)) {
this->setStart(child.fContentEnd, &child);
fDeferComment = nullptr;
}
}
continue;
}
if (Definition::Type::kWord == child.fType) {
if (MarkType::kMember == child.fMarkType) {
if (!memberStart) {
auto iter = def->fTokens.begin();
std::advance(iter, child.fParentIndex - 1);
memberStart = &*iter;
staticOnly = false;
}
if (!fStructMemberTab) {
SkASSERT(KeyWord::kStruct == def->fParent->fKeyWord);
fIndent += 4;
this->structSizeMembers(*def->fParent);
fIndent -= 4;
fIndentNext = true;
}
SkASSERT(fBmhStructDef);
memberEnd = this->structMemberOut(memberStart, child);
startDef = &child;
this->setStart(child.fContentEnd + 1, &child);
fDeferComment = nullptr;
} else if (MarkType::kNone == child.fMarkType && sawConst && fEnumDef) {
const Definition* bmhConst = nullptr;
string match;
if (root) {
match = root->fName + "::";
}
match += string(child.fContentStart, child.fContentEnd - child.fContentStart);
for (auto enumChild : fEnumDef->fChildren) {
if (MarkType::kConst == enumChild->fMarkType && enumChild->fName == match) {
bmhConst = enumChild;
break;
}
}
if (bmhConst) {
this->constOut(memberStart, bmhConst);
fDeferComment = nullptr;
sawConst = false;
}
} else if (MarkType::kNone == child.fMarkType && sawConst && !fEnumDef) {
string match;
if (root) {
match = root->fName + "::";
match += string(child.fContentStart, child.fContentEnd - child.fContentStart);
auto bmhClassIter = fBmhParser->fClassMap.find(root->fName);
if (fBmhParser->fClassMap.end() != bmhClassIter) {
RootDefinition& bmhClass = bmhClassIter->second;
auto constIter = std::find_if(bmhClass.fLeaves.begin(), bmhClass.fLeaves.end(),
[match](std::pair<const string, Definition>& leaf){ return match == leaf.second.fName; } );
if (bmhClass.fLeaves.end() != constIter) {
const Definition& bmhConst = constIter->second;
if (MarkType::kConst == bmhConst.fMarkType
&& MarkType::kSubtopic == bmhConst.fParent->fMarkType) {
fBmhConst = &bmhConst;
fConstDef = &child;
}
}
}
}
}
if (child.fMemberStart) {
memberStart = &child;
staticOnly = false;
}
continue;
}
if (Definition::Type::kPunctuation == child.fType) {
if (Punctuation::kSemicolon == child.fPunctuation) {
if (sawConst && fBmhConst) { // find bmh documentation. Parent must be subtopic.
const Definition* subtopic = fBmhConst->fParent;
SkASSERT(subtopic);
SkASSERT(MarkType::kSubtopic == subtopic->fMarkType);
auto firstConst = std::find_if(subtopic->fChildren.begin(),
subtopic->fChildren.end(),
[](const Definition* def){ return MarkType::kConst == def->fMarkType;});
SkASSERT(firstConst != subtopic->fChildren.end());
bool constIsFirst = *firstConst == fBmhConst;
if (constIsFirst) { // If first #Const child, output subtopic description.
this->constOut(memberStart, subtopic);
// find member / value / comment tabs
// look for a one-to-one correspondence between bmh and include
this->constSizeMembers(root);
fDeferComment = nullptr;
}
// after const code, output #Line description as short comment
auto lineIter = std::find_if(fBmhConst->fChildren.begin(),
fBmhConst->fChildren.end(),
[](const Definition* def){ return MarkType::kLine == def->fMarkType; });
SkASSERT(fBmhConst->fChildren.end() != lineIter);
const Definition* lineDef = *lineIter;
if (fConstLength > 100) {
this->writeCommentHeader();
this->writeSpace();
this->rewriteBlock(lineDef->length(), lineDef->fContentStart, Phrase::kYes);
this->writeCommentTrailer(OneLine::kYes);
}
this->lfcr();
TextParser constText(memberStart);
const char* nameEnd = constText.trimmedBracketEnd('=');
SkAssertResult(constText.skipToEndBracket('='));
const char* valueEnd = constText.trimmedBracketEnd(';');
this->writeBlock((int) (nameEnd - memberStart->fContentStart),
memberStart->fContentStart);
this->indentToColumn(fConstValueTab);
this->writeBlock((int) (valueEnd - constText.fChar), constText.fChar);
this->writeString(";");
if (fConstLength <= 100) {
this->indentToColumn(fConstCommentTab);
this->writeString("//!<");
this->writeSpace();
this->rewriteBlock(lineDef->length(), lineDef->fContentStart, Phrase::kYes);
}
this->setStart(child.fContentStart + 1, &child);
fDeferComment = nullptr;
fBmhConst = nullptr;
sawConst = false;
} else if (sawTypedef) {
const Definition* bmhTypedef = nullptr;
if (root) {
SkDEBUGCODE(auto classIter = fBmhParser->fClassMap.find(root->fName));
SkASSERT(fBmhParser->fClassMap.end() != classIter);
RootDefinition& classDef = fBmhParser->fClassMap[root->fName];
auto leafIter = classDef.fLeaves.find(memberStart->fName);
if (classDef.fLeaves.end() != leafIter) {
bmhTypedef = &leafIter->second;
}
}
if (!bmhTypedef) {
auto typedefIter = fBmhParser->fTypedefMap.find(memberStart->fName);
SkASSERT(fBmhParser->fTypedefMap.end() != typedefIter);
bmhTypedef = &typedefIter->second;
}
fDeferComment = deferredTypedefComment;
this->constOut(memberStart, bmhTypedef);
fDeferComment = nullptr;
sawTypedef = false;
}
memberStart = nullptr;
staticOnly = false;
if (inStruct) {
fInStruct = false;
}
continue;
}
if (Punctuation::kLeftBrace == child.fPunctuation ||
Punctuation::kColon == child.fPunctuation ||
Punctuation::kAsterisk == child.fPunctuation
) {
continue;
}
}
}
return true;
}
bool IncludeWriter::populate(BmhParser& bmhParser) {
bool allPassed = true;
for (auto& includeMapper : fIncludeMap) {
size_t lastSlash = includeMapper.first.rfind('/');
if (string::npos == lastSlash) {
lastSlash = includeMapper.first.rfind('\\');
}
if (string::npos == lastSlash || lastSlash >= includeMapper.first.length() - 1) {
return this->reportError<bool>("malformed include name");
}
string fileName = includeMapper.first.substr(lastSlash + 1);
if (".h" != fileName.substr(fileName.length() - 2)) {
return this->reportError<bool>("expected fileName.h");
}
string skClassName = fileName.substr(0, fileName.length() - 2);
this->reset();
fOut = fopen(fileName.c_str(), "wb");
if (!fOut) {
SkDebugf("could not open output file %s\n", fileName.c_str());
return false;
}
RootDefinition* root =
bmhParser.fClassMap.end() == bmhParser.fClassMap.find(skClassName) ?
nullptr : &bmhParser.fClassMap[skClassName];
fBmhParser = &bmhParser;
if (root) {
fRootTopic = root->fParent;
root->clearVisited();
} else {
SkASSERT("Sk" == skClassName.substr(0, 2));
string topicName = skClassName.substr(2);
auto topicIter = bmhParser.fTopicMap.find(topicName);
SkASSERT(bmhParser.fTopicMap.end() != topicIter);
fRootTopic = topicIter->second->asRoot();
fFirstWrite = true; // write file information after includes
}
fFileName = includeMapper.second.fFileName;
this->setStartBack(includeMapper.second.fContentStart, &includeMapper.second);
fEnd = includeMapper.second.fContentEnd;
fAnonymousEnumCount = 1;
this->writeHeader(includeMapper);
allPassed &= this->populate(&includeMapper.second, nullptr, root);
this->writeBlock((int) (fEnd - fStart), fStart);
#if 0
if (fIndentStack.size() > 0) {
this->indentOut();
}
SkASSERT(!fIndent);
#else
fIndent = 0;
#endif
this->lfcr();
this->writePending();
fclose(fOut);
size_t slash = fFileName.find_last_of('/');
if (string::npos == slash) {
slash = 0;
}
size_t back = fFileName.find_last_of('\\');
if (string::npos == back) {
back = 0;
}
string dir = fFileName.substr(0, SkTMax(slash, back) + 1);
string readname = dir + fileName;
if (ParserCommon::WrittenFileDiffers(fileName, readname)) {
SkDebugf("wrote updated %s\n", fileName.c_str());
} else {
remove(fileName.c_str());
}
}
return allPassed;
}
string IncludeWriter::resolveMethod(const char* start, const char* end, bool first) {
string methodname(start, end - start);
if (string::npos != methodname.find("()")) {
return "";
}
string substitute;
auto rootDefIter = fBmhParser->fMethodMap.find(methodname);
if (fBmhParser->fMethodMap.end() != rootDefIter) {
substitute = methodname + "()";
} else {
RootDefinition* parent = nullptr;
for (auto candidate : fRootTopic->fChildren) {
if (MarkType::kClass == candidate->fMarkType
|| MarkType::kStruct == candidate->fMarkType) {
parent = candidate->asRoot();
break;
}
}
if (parent) {
auto defRef = parent->find(parent->fName + "::" + methodname,
RootDefinition::AllowParens::kNo);
if (defRef && MarkType::kMethod == defRef->fMarkType) {
substitute = methodname + "()";
} else {
auto defineIter = fBmhParser->fDefineMap.find(methodname);
if (fBmhParser->fDefineMap.end() != defineIter) {
const RootDefinition& defineDef = defineIter->second;
auto codeIter = std::find_if(defineDef.fChildren.begin(),
defineDef.fChildren.end(),
[](Definition* child){ return MarkType::kCode == child->fMarkType; } );
if (defineDef.fChildren.end() != codeIter) {
const Definition* codeDef = *codeIter;
string codeContents(codeDef->fContentStart, codeDef->length());
size_t namePos = codeContents.find(methodname);
if (string::npos != namePos) {
size_t parenPos = namePos + methodname.length();
if (parenPos < codeContents.length() && '(' == codeContents[parenPos]) {
substitute = methodname + "()";
}
}
}
}
}
}
}
if (fMethodDef && methodname == fMethodDef->fName) {
TextParser report(fBmhMethod);
report.reportError("method should not include references to itself");
return "";
}
if (fBmhMethod) {
for (auto child : fBmhMethod->fChildren) {
if (MarkType::kParam != child->fMarkType) {
continue;
}
if (methodname == child->fName) {
return "";
}
}
}
return substitute;
}
string IncludeWriter::resolveAlias(const Definition* def) {
for (auto child : def->fChildren) {
if (MarkType::kSubstitute == child->fMarkType) {
return string(child->fContentStart, (int) (child->fContentEnd - child->fContentStart));
}
if (MarkType::kAlias == child->fMarkType && def->fName == child->fName) {
return this->resolveAlias(child);
}
}
return "";
}
string IncludeWriter::resolveRef(const char* start, const char* end, bool first,
RefType* refType) {
// look up Xxx_Xxx
string undername(start, end - start);
for (const auto& external : fBmhParser->fExternals) {
if (external.fName == undername) {
*refType = RefType::kExternal;
return external.fName;
}
}
*refType = RefType::kNormal;
SkASSERT(string::npos == undername.find(' '));
const Definition* rootDef = nullptr;
string substitute;
{
auto rootDefIter = fBmhParser->fTopicMap.find(undername);
if (fBmhParser->fTopicMap.end() != rootDefIter) {
rootDef = rootDefIter->second;
} else {
string prefixedName = fRootTopic->fName + '_' + undername;
rootDefIter = fBmhParser->fTopicMap.find(prefixedName);
if (fBmhParser->fTopicMap.end() != rootDefIter) {
rootDef = rootDefIter->second;
} else if (fBmhStructDef) {
string localPrefix = fBmhStructDef->fFiddle + '_' + undername;
rootDefIter = fBmhParser->fTopicMap.find(localPrefix);
if (fBmhParser->fTopicMap.end() != rootDefIter) {
rootDef = rootDefIter->second;
}
if (!rootDef) {
size_t doubleColon = fBmhStructDef->fName.rfind("::");
if (string::npos != doubleColon && undername
== fBmhStructDef->fName.substr(doubleColon + 2)) {
substitute = fBmhStructDef->fName;
}
}
}
if (!rootDef && fEnumDef && "Sk" + prefixedName == fEnumDef->fFiddle) {
rootDef = fEnumDef;
}
if (!rootDef && !substitute.length()) {
auto aliasIter = fBmhParser->fAliasMap.find(undername);
if (fBmhParser->fAliasMap.end() != aliasIter) {
rootDef = aliasIter->second;
} else if (fInEnum && fEnumDef && this->findEnumSubtopic(undername, &rootDef)) {
} else if (!first) {
this->fChar = start;
this->fLine = start;
this->fEnd = end;
this->reportError("reference unfound");
return "";
}
}
}
}
if (rootDef) {
MarkType rootType = rootDef->fMarkType;
if (MarkType::kSubtopic == rootType || MarkType::kTopic == rootType
|| MarkType::kAlias == rootType) {
substitute = this->resolveAlias(rootDef);
}
if (!substitute.length()) {
string match = rootDef->fName;
size_t index;
while (string::npos != (index = match.find('_'))) {
match.erase(index, 1);
}
string skmatch = "Sk" + match;
auto parent = MarkType::kAlias == rootType ? rootDef->fParent : rootDef;
for (auto child : parent->fChildren) {
// there may be more than one
// prefer the one mostly closely matching in text
if ((MarkType::kClass == child->fMarkType ||
MarkType::kStruct == child->fMarkType ||
MarkType::kTypedef == child->fMarkType ||
(MarkType::kEnum == child->fMarkType && !child->fAnonymous) ||