2a8c48be4f
generating replacement includes exposed errors mostly dealing with globals like SkAlphaType and members. Rewrite finding and resolving links to hopefully make this area more robust. TBR=caryclark@google.com Docs-Preview: https://skia.org/?cl=107160 Bug: skia:6898 Change-Id: I9b8025160203d204286f3f6ca0cebd70da6253b4 Reviewed-on: https://skia-review.googlesource.com/107160 Commit-Queue: Cary Clark <caryclark@skia.org> Reviewed-by: Cary Clark <caryclark@skia.org>
2130 lines
84 KiB
C++
2130 lines
84 KiB
C++
/*
|
|
* 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 "bookmaker.h"
|
|
|
|
void IncludeWriter::constOut(const Definition* memberStart, const Definition& child,
|
|
const Definition* bmhConst) {
|
|
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
|
|
memberStart->fContentStart;
|
|
this->writeBlockTrim((int) (bodyEnd - fStart), fStart); // may write nothing
|
|
this->lf(2);
|
|
this->writeCommentHeader();
|
|
fIndent += 4;
|
|
this->descriptionOut(bmhConst, SkipFirstLine::kYes);
|
|
fIndent -= 4;
|
|
this->writeCommentTrailer();
|
|
fStart = memberStart->fContentStart;
|
|
}
|
|
|
|
void IncludeWriter::descriptionOut(const Definition* def, SkipFirstLine skipFirstLine) {
|
|
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);
|
|
if (def->fDeprecated) {
|
|
this->writeString(def->fToBeDeprecated ? "To be deprecated soon." : "Deprecated.");
|
|
this->lfcr();
|
|
}
|
|
for (auto prop : def->fChildren) {
|
|
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)) {
|
|
this->lf(2);
|
|
}
|
|
}
|
|
size_t childSize = prop->fChildren.size();
|
|
if (childSize) {
|
|
SkASSERT(1 == childSize || 2 == childSize); // incomplete
|
|
SkASSERT(MarkType::kLiteral == prop->fChildren[0]->fMarkType);
|
|
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 (!literalOutdent) {
|
|
fIndent += 4;
|
|
}
|
|
this->writeBlockIndent(commentLen, commentStart);
|
|
this->lf(2);
|
|
if (!literalOutdent) {
|
|
fIndent -= 4;
|
|
}
|
|
commentStart = prop->fTerminator;
|
|
SkDEBUGCODE(wroteCode = true);
|
|
}
|
|
} break;
|
|
case MarkType::kDefinedBy:
|
|
commentStart = prop->fTerminator;
|
|
break;
|
|
case MarkType::kBug: {
|
|
string bugstr("(see skbug.com/" + string(prop->fContentStart,
|
|
prop->fContentEnd - prop->fContentStart) + ')');
|
|
this->writeString(bugstr);
|
|
this->lfcr();
|
|
}
|
|
case MarkType::kDeprecated:
|
|
case MarkType::kPrivate:
|
|
commentLen = (int) (prop->fStart - commentStart);
|
|
if (commentLen > 0) {
|
|
SkASSERT(commentLen < 1000);
|
|
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, Phrase::kNo)) {
|
|
this->lfcr();
|
|
}
|
|
}
|
|
commentStart = prop->fContentStart;
|
|
if (def->fToBeDeprecated) {
|
|
commentStart += 4; // skip over "soon" // FIXME: this is awkward
|
|
} else if (MarkType::kBug == prop->fMarkType) {
|
|
commentStart = prop->fContentEnd;
|
|
}
|
|
commentLen = (int) (prop->fContentEnd - commentStart);
|
|
if (commentLen > 0) {
|
|
this->writeBlockIndent(commentLen, commentStart);
|
|
if ('\n' != commentStart[commentLen - 1] && '\n' == commentStart[commentLen]) {
|
|
this->lfcr();
|
|
}
|
|
}
|
|
commentStart = prop->fTerminator;
|
|
commentLen = (int) (def->fContentEnd - commentStart);
|
|
break;
|
|
case MarkType::kExperimental:
|
|
this->writeString("EXPERIMENTAL:");
|
|
this->writeSpace();
|
|
commentStart = prop->fContentStart;
|
|
commentLen = (int) (prop->fContentEnd - commentStart);
|
|
if (commentLen > 0) {
|
|
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, Phrase::kNo)) {
|
|
this->lfcr();
|
|
}
|
|
}
|
|
commentStart = prop->fTerminator;
|
|
commentLen = (int) (def->fContentEnd - commentStart);
|
|
break;
|
|
case MarkType::kFormula: {
|
|
commentLen = prop->fStart - commentStart;
|
|
if (commentLen > 0) {
|
|
if (Wrote::kNone != this->rewriteBlock(commentLen, commentStart, Phrase::kNo)) {
|
|
if (commentLen > 1 && '\n' == prop->fStart[-1] &&
|
|
'\n' == prop->fStart[-2]) {
|
|
this->lf(1);
|
|
} else {
|
|
this->writeSpace();
|
|
}
|
|
}
|
|
}
|
|
int saveIndent = fIndent;
|
|
if (fIndent < fColumn + 1) {
|
|
fIndent = fColumn + 1;
|
|
}
|
|
this->writeBlockIndent(prop->length(), prop->fContentStart);
|
|
fIndent = saveIndent;
|
|
commentStart = prop->fTerminator;
|
|
commentLen = (int) (def->fContentEnd - commentStart);
|
|
if (commentLen > 1 && '\n' == commentStart[0] && '\n' == commentStart[1]) {
|
|
this->lf(2);
|
|
} else {
|
|
SkASSERT('\n' == prop->fTerminator[0]);
|
|
if ('.' != prop->fTerminator[1] && !fLinefeeds) {
|
|
this->writeSpace();
|
|
}
|
|
}
|
|
} break;
|
|
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)) {
|
|
this->lfcr();
|
|
}
|
|
}
|
|
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)) {
|
|
this->lfcr();
|
|
}
|
|
}
|
|
for (auto row : prop->fChildren) {
|
|
SkASSERT(MarkType::kRow == row->fMarkType);
|
|
for (auto column : row->fChildren) {
|
|
SkASSERT(MarkType::kColumn == column->fMarkType);
|
|
this->writeString("-");
|
|
this->writeSpace();
|
|
this->descriptionOut(column, SkipFirstLine::kNo);
|
|
this->lf(1);
|
|
}
|
|
}
|
|
commentStart = prop->fTerminator;
|
|
commentLen = (int) (def->fContentEnd - commentStart);
|
|
if ('\n' == commentStart[0] && '\n' == commentStart[1]) {
|
|
this->lf(2);
|
|
}
|
|
break;
|
|
default:
|
|
commentLen = (int) (prop->fStart - commentStart);
|
|
breakOut = true;
|
|
}
|
|
if (breakOut) {
|
|
break;
|
|
}
|
|
}
|
|
SkASSERT(wroteCode || (commentLen > 0 && commentLen < 1500) || def->fDeprecated);
|
|
if (commentLen > 0) {
|
|
this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
|
|
}
|
|
}
|
|
|
|
void IncludeWriter::enumHeaderOut(const RootDefinition* root,
|
|
const Definition& child) {
|
|
const Definition* enumDef = nullptr;
|
|
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
|
|
child.fContentStart;
|
|
this->writeBlockTrim((int) (bodyEnd - fStart), fStart); // may write nothing
|
|
this->lf(2);
|
|
if (fIndentNext) {
|
|
fIndent += 4;
|
|
fIndentNext = false;
|
|
}
|
|
fDeferComment = nullptr;
|
|
fStart = child.fContentStart;
|
|
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);
|
|
}
|
|
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 wroteHeader = false;
|
|
bool lastAnchor = false;
|
|
SkDEBUGCODE(bool foundConst = false);
|
|
for (auto test : enumDef->fChildren) {
|
|
if (MarkType::kCode == test->fMarkType) {
|
|
SkASSERT(!codeBlock); // FIXME: check enum for correct order earlier
|
|
codeBlock = test;
|
|
commentStart = codeBlock->fTerminator;
|
|
continue;
|
|
}
|
|
if (!codeBlock) {
|
|
continue;
|
|
}
|
|
const char* commentEnd = test->fStart;
|
|
if (!wroteHeader &&
|
|
!this->contentFree((int) (commentEnd - commentStart), commentStart)) {
|
|
if (fIndentNext) {
|
|
fIndent += 4;
|
|
}
|
|
this->writeCommentHeader();
|
|
this->writeString("\\enum");
|
|
if (fullName.length() > 0) {
|
|
this->writeSpace();
|
|
this->writeString(fullName.c_str());
|
|
}
|
|
fIndent += 4;
|
|
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) {
|
|
bool newLine = commentEnd - commentStart > 1 &&
|
|
'\n' == commentEnd[-1] && '\n' == commentEnd[-2];
|
|
commentStart = test->fContentStart;
|
|
commentEnd = test->fChildren[0]->fStart;
|
|
if (newLine) {
|
|
this->lf(2);
|
|
} else {
|
|
this->writeSpace();
|
|
}
|
|
this->rewriteBlock((int) (commentEnd - commentStart), commentStart, Phrase::kNo);
|
|
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) {
|
|
fIndent -= 4;
|
|
this->lfcr();
|
|
this->writeCommentTrailer();
|
|
}
|
|
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 {"
|
|
fIndent += 4;
|
|
this->singleLF();
|
|
fStart = bodyEnd;
|
|
fEnumDef = enumDef;
|
|
}
|
|
|
|
void IncludeWriter::enumMembersOut(const RootDefinition* root, Definition& child) {
|
|
// 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 on preceding line?
|
|
const Definition* currentEnumItem = nullptr;
|
|
const char* commentStart = nullptr;
|
|
const char* lastEnd = nullptr;
|
|
int commentLen = 0;
|
|
enum class State {
|
|
kNoItem,
|
|
kItemName,
|
|
kItemValue,
|
|
kItemComment,
|
|
};
|
|
State state = State::kNoItem;
|
|
vector<IterState> iterStack;
|
|
iterStack.emplace_back(child.fTokens.begin(), child.fTokens.end());
|
|
IterState* iterState = &iterStack[0];
|
|
bool preprocessorWord = false;
|
|
const char* preprocessStart = nullptr;
|
|
const char* preprocessEnd = nullptr;
|
|
for (int onePast = 0; onePast < 2; onePast += iterState->fDefIter == iterState->fDefEnd) {
|
|
Definition* token = onePast ? nullptr : &*iterState->fDefIter++;
|
|
if (token && Definition::Type::kBracket == token->fType) {
|
|
if (Bracket::kSlashSlash == token->fBracket) {
|
|
fStart = token->fContentEnd;
|
|
continue; // ignore old inline comments
|
|
}
|
|
if (Bracket::kSlashStar == token->fBracket) {
|
|
fStart = token->fContentEnd + 1;
|
|
continue; // ignore old inline comments
|
|
}
|
|
if (Bracket::kPound == token->fBracket) { // preprocessor wraps member
|
|
preprocessStart = token->fContentStart;
|
|
if (KeyWord::kIf == token->fKeyWord || KeyWord::kIfdef == token->fKeyWord) {
|
|
iterStack.emplace_back(token->fTokens.begin(), token->fTokens.end());
|
|
iterState = &iterStack.back();
|
|
preprocessorWord = true;
|
|
} else if (KeyWord::kEndif == token->fKeyWord) {
|
|
iterStack.pop_back();
|
|
iterState = &iterStack.back();
|
|
preprocessEnd = token->fContentEnd;
|
|
} else {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
continue;
|
|
}
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
if (token && Definition::Type::kWord != token->fType) {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
if (preprocessorWord) {
|
|
preprocessorWord = false;
|
|
preprocessEnd = token->fContentEnd;
|
|
continue;
|
|
}
|
|
if (token && State::kItemName == state) {
|
|
TextParser enumLine(token->fFileName, lastEnd,
|
|
token->fContentStart, token->fLineCount);
|
|
const char* end = enumLine.anyOf(",}=");
|
|
SkASSERT(end);
|
|
state = '=' == *end ? State::kItemValue : State::kItemComment;
|
|
if (State::kItemValue == state) { // write enum value
|
|
this->indentToColumn(fEnumItemValueTab);
|
|
this->writeString("=");
|
|
this->writeSpace();
|
|
lastEnd = token->fContentEnd;
|
|
this->writeBlock((int) (lastEnd - token->fContentStart),
|
|
token->fContentStart); // write const value if any
|
|
continue;
|
|
}
|
|
}
|
|
if (token && State::kItemValue == state) {
|
|
TextParser valueEnd(token->fFileName, lastEnd,
|
|
token->fContentStart, token->fLineCount);
|
|
const char* end = valueEnd.anyOf(",}");
|
|
if (!end) { // write expression continuation
|
|
if (' ' == lastEnd[0]) {
|
|
this->writeSpace();
|
|
}
|
|
this->writeBlock((int) (token->fContentEnd - lastEnd), lastEnd);
|
|
continue;
|
|
}
|
|
}
|
|
if (State::kNoItem != state) {
|
|
this->writeString(",");
|
|
SkASSERT(currentEnumItem);
|
|
if (currentEnumItem->fShort) {
|
|
this->indentToColumn(fEnumItemCommentTab);
|
|
if (commentLen || currentEnumItem->fDeprecated) {
|
|
this->writeString("//!<");
|
|
this->writeSpace();
|
|
if (currentEnumItem->fDeprecated) {
|
|
this->writeString(child.fToBeDeprecated ? "to be deprecated soon"
|
|
: "deprecated");
|
|
} else {
|
|
this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
|
|
}
|
|
}
|
|
}
|
|
if (onePast) {
|
|
fIndent -= 4;
|
|
}
|
|
this->lfcr();
|
|
if (preprocessStart) {
|
|
SkASSERT(preprocessEnd);
|
|
int saveIndent = fIndent;
|
|
fIndent = SkTMax(0, fIndent - 8);
|
|
this->lf(2);
|
|
this->writeBlock((int) (preprocessEnd - preprocessStart), preprocessStart);
|
|
this->lfcr();
|
|
fIndent = saveIndent;
|
|
preprocessStart = nullptr;
|
|
preprocessEnd = nullptr;
|
|
}
|
|
if (token && State::kItemValue == state) {
|
|
fStart = token->fContentStart;
|
|
}
|
|
state = State::kNoItem;
|
|
}
|
|
SkASSERT(State::kNoItem == state);
|
|
if (onePast) {
|
|
break;
|
|
}
|
|
SkASSERT(token);
|
|
string itemName = root->fName + "::";
|
|
if (KeyWord::kClass == child.fParent->fKeyWord) {
|
|
itemName += child.fParent->fName + "::";
|
|
}
|
|
itemName += string(token->fContentStart, (int) (token->fContentEnd - token->fContentStart));
|
|
for (auto& enumItem : fEnumDef->fChildren) {
|
|
if (MarkType::kConst != enumItem->fMarkType) {
|
|
continue;
|
|
}
|
|
if (itemName != enumItem->fName) {
|
|
continue;
|
|
}
|
|
currentEnumItem = enumItem;
|
|
break;
|
|
}
|
|
SkASSERT(currentEnumItem);
|
|
// if description fits, it goes after item
|
|
commentStart = currentEnumItem->fContentStart;
|
|
const char* commentEnd;
|
|
if (currentEnumItem->fChildren.size() > 0) {
|
|
commentEnd = currentEnumItem->fChildren[0]->fStart;
|
|
} else {
|
|
commentEnd = currentEnumItem->fContentEnd;
|
|
}
|
|
TextParser enumComment(fFileName, commentStart, commentEnd, currentEnumItem->fLineCount);
|
|
bool isDeprecated = false;
|
|
if (enumComment.skipToLineStart()) { // skip const value
|
|
commentStart = enumComment.fChar;
|
|
commentLen = (int) (commentEnd - commentStart);
|
|
} else {
|
|
const Definition* childDef = currentEnumItem->fChildren[0];
|
|
isDeprecated = MarkType::kDeprecated == childDef->fMarkType;
|
|
if (MarkType::kPrivate == childDef->fMarkType || isDeprecated) {
|
|
commentStart = childDef->fContentStart;
|
|
if (currentEnumItem->fToBeDeprecated) {
|
|
SkASSERT(isDeprecated);
|
|
commentStart += 4; // skip over "soon" // FIXME: this is awkward
|
|
}
|
|
commentLen = (int) (childDef->fContentEnd - commentStart);
|
|
}
|
|
}
|
|
// FIXME: may assert here if there's no const value
|
|
// should have detected and errored on that earlier when enum fContentStart was set
|
|
SkASSERT((commentLen > 0 && commentLen < 1000) || isDeprecated);
|
|
if (!currentEnumItem->fShort) {
|
|
this->writeCommentHeader();
|
|
fIndent += 4;
|
|
bool wroteLineFeed = false;
|
|
if (isDeprecated) {
|
|
this->writeString(currentEnumItem->fToBeDeprecated
|
|
? "To be deprecated soon." : "Deprecated.");
|
|
}
|
|
wroteLineFeed = Wrote::kLF ==
|
|
this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
|
|
fIndent -= 4;
|
|
if (wroteLineFeed || fColumn > 100 - 3 /* space * / */ ) {
|
|
this->lfcr();
|
|
} else {
|
|
this->writeSpace();
|
|
}
|
|
this->writeCommentTrailer();
|
|
}
|
|
lastEnd = token->fContentEnd;
|
|
this->lfcr();
|
|
if (',' == fStart[0]) {
|
|
++fStart;
|
|
}
|
|
this->writeBlock((int) (lastEnd - fStart), fStart); // enum item name
|
|
fStart = token->fContentEnd;
|
|
state = State::kItemName;
|
|
}
|
|
}
|
|
|
|
void IncludeWriter::enumSizeItems(const Definition& child) {
|
|
enum class State {
|
|
kNoItem,
|
|
kItemName,
|
|
kItemValue,
|
|
kItemComment,
|
|
};
|
|
State state = State::kNoItem;
|
|
int longestName = 0;
|
|
int longestValue = 0;
|
|
int valueLen = 0;
|
|
const char* lastEnd = nullptr;
|
|
// SkASSERT(child.fChildren.size() == 1 || child.fChildren.size() == 2);
|
|
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];
|
|
bool preprocessorWord = false;
|
|
while (iterState->fDefIter != iterState->fDefEnd) {
|
|
auto& token = *iterState->fDefIter++;
|
|
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::kPound == token.fBracket) { // preprocessor wraps member
|
|
if (KeyWord::kIf == token.fKeyWord || KeyWord::kIfdef == token.fKeyWord) {
|
|
iterStack.emplace_back(token.fTokens.begin(), token.fTokens.end());
|
|
iterState = &iterStack.back();
|
|
preprocessorWord = true;
|
|
} else if (KeyWord::kEndif == token.fKeyWord) {
|
|
iterStack.pop_back();
|
|
iterState = &iterStack.back();
|
|
} else {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
continue;
|
|
}
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
if (Definition::Type::kWord != token.fType) {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
if (preprocessorWord) {
|
|
preprocessorWord = false;
|
|
continue;
|
|
}
|
|
if (State::kItemName == state) {
|
|
TextParser enumLine(token.fFileName, lastEnd,
|
|
token.fContentStart, token.fLineCount);
|
|
const char* end = enumLine.anyOf(",}=");
|
|
SkASSERT(end);
|
|
state = '=' == *end ? State::kItemValue : State::kItemComment;
|
|
if (State::kItemValue == state) {
|
|
valueLen = (int) (token.fContentEnd - token.fContentStart);
|
|
lastEnd = token.fContentEnd;
|
|
continue;
|
|
}
|
|
}
|
|
if (State::kItemValue == state) {
|
|
TextParser valueEnd(token.fFileName, lastEnd,
|
|
token.fContentStart, token.fLineCount);
|
|
const char* end = valueEnd.anyOf(",}");
|
|
if (!end) { // write expression continuation
|
|
valueLen += (int) (token.fContentEnd - lastEnd);
|
|
continue;
|
|
}
|
|
}
|
|
if (State::kNoItem != state) {
|
|
longestValue = SkTMax(longestValue, valueLen);
|
|
state = State::kNoItem;
|
|
}
|
|
SkASSERT(State::kNoItem == state);
|
|
lastEnd = token.fContentEnd;
|
|
longestName = SkTMax(longestName, (int) (lastEnd - token.fContentStart));
|
|
state = State::kItemName;
|
|
}
|
|
if (State::kItemValue == state) {
|
|
longestValue = SkTMax(longestValue, valueLen);
|
|
}
|
|
fEnumItemValueTab = longestName + fIndent + 1 /* space before = */ ;
|
|
if (longestValue) {
|
|
longestValue += 3; /* = space , */
|
|
}
|
|
fEnumItemCommentTab = fEnumItemValueTab + longestValue + 1 /* space before //!< */ ;
|
|
// iterate through bmh children and see which comments fit on include lines
|
|
for (auto& enumItem : fEnumDef->fChildren) {
|
|
if (MarkType::kConst != enumItem->fMarkType) {
|
|
continue;
|
|
}
|
|
TextParser enumLine(enumItem);
|
|
enumLine.trimEnd();
|
|
enumLine.skipToLineStart(); // skip const value
|
|
const char* commentStart = enumLine.fChar;
|
|
enumLine.skipLine();
|
|
ptrdiff_t lineLen = enumLine.fChar - commentStart + 5 /* //!< space */ ;
|
|
if (!enumLine.eof()) {
|
|
enumLine.skipWhiteSpace();
|
|
}
|
|
enumItem->fShort = enumLine.eof() && fEnumItemCommentTab + lineLen < 100;
|
|
}
|
|
}
|
|
|
|
// walk children and output complete method doxygen description
|
|
void IncludeWriter::methodOut(const Definition* method, const Definition& child) {
|
|
if (fPendingMethod) {
|
|
fIndent -= 4;
|
|
fPendingMethod = false;
|
|
}
|
|
fBmhMethod = method;
|
|
fMethodDef = &child;
|
|
fContinuation = nullptr;
|
|
fDeferComment = nullptr;
|
|
if (0 == fIndent || fIndentNext) {
|
|
fIndent += 4;
|
|
fIndentNext = false;
|
|
}
|
|
this->writeCommentHeader();
|
|
fIndent += 4;
|
|
this->descriptionOut(method, SkipFirstLine::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) {
|
|
const char* partStart = methodPart->fContentStart;
|
|
const char* partEnd = methodPart->fContentEnd;
|
|
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;
|
|
}
|
|
while ('\n' == partEnd[-1]) {
|
|
--partEnd;
|
|
}
|
|
while ('#' == partEnd[-1]) { // FIXME: so wrong; should not be before fContentEnd
|
|
--partEnd;
|
|
}
|
|
this->indentToColumn(column);
|
|
int partLen = (int) (partEnd - partStart);
|
|
// FIXME : detect this earlier; assert if #Return is empty
|
|
SkASSERT(partLen > 0 && partLen < 300); // may assert if param desc is especially long
|
|
fIndent = column;
|
|
this->rewriteBlock(partLen, partStart, Phrase::kYes);
|
|
fIndent = saveIndent;
|
|
this->lfcr();
|
|
}
|
|
} else {
|
|
this->lfcr();
|
|
}
|
|
fIndent -= 4;
|
|
this->lfcr();
|
|
this->writeCommentTrailer();
|
|
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();
|
|
if (child.fDeprecated) {
|
|
this->writeString(child.fToBeDeprecated ? "to be deprecated soon" : "deprecated");
|
|
} else {
|
|
this->rewriteBlock((int)(commentEnd - commentStart), commentStart, Phrase::kNo);
|
|
}
|
|
fIndent -= 4;
|
|
this->lfcr();
|
|
this->writeCommentTrailer();
|
|
}
|
|
|
|
Definition* IncludeWriter::findMemberCommentBlock(const vector<Definition*>& bmhChildren,
|
|
const string& name) const {
|
|
for (auto memberDef : bmhChildren) {
|
|
if (memberDef->fName.length() - name.length() == memberDef->fName.find(name)) {
|
|
return memberDef;
|
|
}
|
|
}
|
|
for (auto memberDef : bmhChildren) {
|
|
if (MarkType::kSubtopic == memberDef->fMarkType || MarkType::kTopic == memberDef->fMarkType) {
|
|
Definition* result = this->findMemberCommentBlock(memberDef->fChildren, name);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
Definition* IncludeWriter::structMemberOut(const Definition* memberStart, const Definition& child) {
|
|
const char* blockStart = !fWroteMethod && fDeferComment ? fLastComment->fContentEnd : fStart;
|
|
const char* blockEnd = fWroteMethod && fDeferComment ? fDeferComment->fStart - 1 :
|
|
memberStart->fStart;
|
|
this->writeBlockTrim((int) (blockEnd - blockStart), blockStart);
|
|
if (fIndentNext) {
|
|
fIndent += 4;
|
|
fIndentNext = false;
|
|
}
|
|
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");
|
|
}
|
|
const char* commentStart = commentBlock->fContentStart;
|
|
ptrdiff_t commentLen = commentBlock->fContentEnd - commentStart;
|
|
bool isShort = commentBlock->fShort;
|
|
SkASSERT(!isShort || commentBlock->fChildren.size() == 0);
|
|
|
|
if (!isShort) {
|
|
this->writeCommentHeader();
|
|
bool wroteLineFeed = false;
|
|
fIndent += 4;
|
|
for (auto child : commentBlock->fChildren) {
|
|
commentLen = child->fStart - commentStart;
|
|
wroteLineFeed |= Wrote::kLF == this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
|
|
if (MarkType::kFormula == child->fMarkType) {
|
|
this->writeSpace();
|
|
this->writeBlock((int) (child->fContentEnd - child->fContentStart),
|
|
child->fContentStart);
|
|
}
|
|
commentStart = child->fTerminator;
|
|
}
|
|
commentLen = commentBlock->fContentEnd - commentStart;
|
|
wroteLineFeed |= Wrote::kLF == this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
|
|
fIndent -= 4;
|
|
if (wroteLineFeed || fColumn > 100 - 3 /* space * / */ ) {
|
|
this->lfcr();
|
|
} else {
|
|
this->writeSpace();
|
|
}
|
|
this->writeCommentTrailer();
|
|
}
|
|
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 (isShort) {
|
|
this->indentToColumn(fStructCommentTab);
|
|
this->writeString("//!<");
|
|
this->writeSpace();
|
|
this->rewriteBlock(commentLen, commentStart, Phrase::kNo);
|
|
}
|
|
this->lf(2);
|
|
return valueEnd;
|
|
}
|
|
|
|
void IncludeWriter::structSizeMembers(const Definition& child) {
|
|
int longestType = 0;
|
|
Definition* typeStart = nullptr;
|
|
int longestName = 0;
|
|
int longestValue = 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;
|
|
}
|
|
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::kSize_t:
|
|
case KeyWord::kFloat:
|
|
case KeyWord::kBool:
|
|
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 {
|
|
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;
|
|
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 /* ; */ ;
|
|
}
|
|
// iterate through bmh children and see which comments fit on include lines
|
|
for (auto& member : fBmhStructDef->fChildren) {
|
|
if (MarkType::kMember != member->fMarkType) {
|
|
continue;
|
|
}
|
|
TextParser memberLine(member);
|
|
memberLine.trimEnd();
|
|
const char* commentStart = memberLine.fChar;
|
|
memberLine.skipLine();
|
|
ptrdiff_t lineLen = memberLine.fChar - commentStart + 5 /* //!< space */ ;
|
|
if (!memberLine.eof()) {
|
|
memberLine.skipWhiteSpace();
|
|
}
|
|
member->fShort = memberLine.eof() && fStructCommentTab + lineLen < 100;
|
|
}
|
|
}
|
|
|
|
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;
|
|
const Definition* method = nullptr;
|
|
const 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;
|
|
const Definition* requireDense = nullptr;
|
|
const Definition* startDef = nullptr;
|
|
for (auto& child : def->fTokens) {
|
|
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;
|
|
fStart = child.fContentStart + 1;
|
|
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);
|
|
break;
|
|
}
|
|
++alternate;
|
|
string alternateMethod = methodName + '_' + to_string(alternate);
|
|
clonedMethod = root->find(alternateMethod,
|
|
RootDefinition::AllowParens::kNo);
|
|
} while (clonedMethod);
|
|
if (!clonedMethod) {
|
|
return this->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;
|
|
}
|
|
methodName += string(fContinuation, continueEnd - fContinuation);
|
|
method = root->find(methodName, RootDefinition::AllowParens::kNo);
|
|
if (!method) {
|
|
if (fBmhStructDef && fBmhStructDef->fDeprecated) {
|
|
fContinuation = nullptr;
|
|
continue;
|
|
}
|
|
fLineCount = child.fLineCount;
|
|
return this->reportError<bool>("method not found");
|
|
}
|
|
this->methodOut(method, child);
|
|
continue;
|
|
}
|
|
if (Definition::Type::kPunctuation == child.fType &&
|
|
Punctuation::kAsterisk == child.fPunctuation &&
|
|
clonedMethod) {
|
|
continue;
|
|
}
|
|
if (inConstructor) {
|
|
continue;
|
|
}
|
|
method = root->find(methodName + "()", RootDefinition::AllowParens::kNo);
|
|
if (method && MarkType::kDefinedBy == method->fMarkType) {
|
|
method = method->fParent;
|
|
}
|
|
if (method) {
|
|
if (method->fCloned) {
|
|
clonedMethod = method;
|
|
continue;
|
|
}
|
|
this->methodOut(method, child);
|
|
continue;
|
|
} else if (fBmhStructDef && fBmhStructDef->fDeprecated) {
|
|
fContinuation = nullptr;
|
|
continue;
|
|
}
|
|
fLineCount = child.fLineCount;
|
|
return this->reportError<bool>("method not found");
|
|
}
|
|
if (Bracket::kSlashSlash == child.fBracket || Bracket::kSlashStar == child.fBracket) {
|
|
if (!fDeferComment) {
|
|
fDeferComment = &child;
|
|
}
|
|
fLastComment = &child;
|
|
continue;
|
|
}
|
|
if (MarkType::kMethod == child.fMarkType) {
|
|
if (this->internalName(child)) {
|
|
continue;
|
|
}
|
|
const char* bodyEnd = fDeferComment ? fDeferComment->fContentStart - 1 :
|
|
fAttrDeprecated ? fAttrDeprecated->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);
|
|
if (blockSize) {
|
|
string debugstr(fStart, blockSize);
|
|
this->writeBlock(blockSize, fStart);
|
|
}
|
|
startDef = &child;
|
|
fStart = child.fContentStart;
|
|
methodName = root->fName + "::" + child.fName;
|
|
inConstructor = root->fName == child.fName;
|
|
fContinuation = child.fContentEnd;
|
|
method = root->find(methodName, RootDefinition::AllowParens::kNo);
|
|
// if (!method) {
|
|
// method = root->find(methodName + "()", RootDefinition::AllowParens::kNo);
|
|
// }
|
|
if (!method) {
|
|
continue;
|
|
}
|
|
if (method->fCloned) {
|
|
clonedMethod = method;
|
|
continue;
|
|
}
|
|
this->methodOut(method, child);
|
|
if (fAttrDeprecated) {
|
|
startDef = fAttrDeprecated;
|
|
fStart = fAttrDeprecated->fContentStart;
|
|
fAttrDeprecated = nullptr;
|
|
}
|
|
continue;
|
|
}
|
|
if (Definition::Type::kKeyWord == child.fType) {
|
|
if (fIndentNext) {
|
|
// too soon
|
|
#if 0 // makes struct Lattice indent when it oughtn't
|
|
if (KeyWord::kEnum == child.fKeyWord) {
|
|
fIndent += 4;
|
|
}
|
|
if (KeyWord::kPublic != child.fKeyWord) {
|
|
fIndentNext = false;
|
|
}
|
|
#endif
|
|
}
|
|
const Definition* cIncludeStructDef = nullptr;
|
|
switch (child.fKeyWord) {
|
|
case KeyWord::kStruct:
|
|
case KeyWord::kClass:
|
|
// 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;
|
|
const RootDefinition* search = root;
|
|
const Definition* parent = search->fParent;
|
|
do {
|
|
string name;
|
|
if (0 == trial) {
|
|
name = child.fName;
|
|
} else if (1 == trial) {
|
|
name = root->fName + "::" + child.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 = const_cast<RootDefinition*>(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) {
|
|
fIndent -= 4;
|
|
fPendingMethod = false;
|
|
}
|
|
startDef = requireDense ? requireDense : &child;
|
|
fStart = requireDense ? requireDense->fContentStart : child.fContentStart;
|
|
requireDense = nullptr;
|
|
if (!fInStruct && child.fName != root->fName) {
|
|
root = &fBmhParser->fClassMap[child.fName];
|
|
fRootTopic = root->fParent;
|
|
SkASSERT(!root->fVisited);
|
|
root->clearVisited();
|
|
fIndent = 0;
|
|
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;
|
|
const char* commentEnd = root->fChildren[0]->fStart;
|
|
this->structOut(root, *root, commentStart, commentEnd);
|
|
} else {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
} else {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
} else {
|
|
SkASSERT(fInStruct);
|
|
#if 0
|
|
fBmhStructDef = root->find(child.fName, RootDefinition::AllowParens::kNo);
|
|
if (nullptr == fBmhStructDef) {
|
|
fBmhStructDef = root->find(root->fName + "::" + child.fName,
|
|
RootDefinition::AllowParens::kNo);
|
|
}
|
|
if (!fBmhStructDef) {
|
|
this->lf(2);
|
|
fIndent = 0;
|
|
this->writeBlock((int) (fStart - bodyEnd), bodyEnd);
|
|
this->lfcr();
|
|
continue;
|
|
}
|
|
#endif
|
|
Definition* codeBlock = nullptr;
|
|
Definition* nextBlock = nullptr;
|
|
for (auto test : fBmhStructDef->fChildren) {
|
|
if (MarkType::kCode == test->fMarkType) {
|
|
SkASSERT(!codeBlock); // FIXME: check enum for correct order earlier
|
|
codeBlock = test;
|
|
continue;
|
|
}
|
|
if (codeBlock) {
|
|
nextBlock = test;
|
|
break;
|
|
}
|
|
}
|
|
// FIXME: trigger error earlier if inner #Struct or #Class is missing #Code
|
|
if (!fBmhStructDef->fDeprecated) {
|
|
SkASSERT(codeBlock);
|
|
SkASSERT(nextBlock); // FIXME: check enum for correct order earlier
|
|
const char* commentStart = codeBlock->fTerminator;
|
|
const char* commentEnd = nextBlock->fStart;
|
|
fIndentNext = true;
|
|
this->structOut(root, *fBmhStructDef, commentStart, commentEnd);
|
|
}
|
|
}
|
|
fDeferComment = nullptr;
|
|
} else {
|
|
; // empty forward reference, nothing to do here
|
|
}
|
|
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;
|
|
}
|
|
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::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::kPublic:
|
|
case KeyWord::kPrivate:
|
|
case KeyWord::kProtected:
|
|
case KeyWord::kFriend:
|
|
case KeyWord::kInline:
|
|
case KeyWord::kSK_API:
|
|
case KeyWord::kTypedef:
|
|
break;
|
|
case KeyWord::kSK_BEGIN_REQUIRE_DENSE:
|
|
requireDense = &child;
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
if (cIncludeStructDef) {
|
|
TextParser structName(&child);
|
|
SkAssertResult(structName.skipToEndBracket('{'));
|
|
startDef = &child;
|
|
fStart = structName.fChar + 1;
|
|
this->writeBlock((int) (fStart - child.fStart), child.fStart);
|
|
this->lf(2);
|
|
fIndent += 4;
|
|
if (!this->populate(&child, &pair, const_cast<Definition*>(cIncludeStructDef)->asRoot())) {
|
|
return false;
|
|
}
|
|
// output any remaining definitions at current indent level
|
|
const char* structEnd = child.fContentEnd;
|
|
SkAssertResult('}' == structEnd[-1]);
|
|
--structEnd;
|
|
this->writeBlockTrim((int) (structEnd - fStart), fStart);
|
|
this->lf(2);
|
|
fStart = structEnd;
|
|
fIndent -= 4;
|
|
fContinuation = nullptr;
|
|
fDeferComment = nullptr;
|
|
} else if (KeyWord::kUint8_t == child.fKeyWord) {
|
|
continue;
|
|
} else {
|
|
if (fInEnum && 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) {
|
|
fStructMemberTab = 0;
|
|
if (fInStruct) {
|
|
fInStruct = false;
|
|
do {
|
|
SkASSERT(root);
|
|
root = const_cast<RootDefinition*>(root->fParent->asRoot());
|
|
} while (MarkType::kTopic == root->fMarkType ||
|
|
MarkType::kSubtopic == root->fMarkType);
|
|
SkASSERT(MarkType::kStruct == root->fMarkType ||
|
|
MarkType::kClass == root->fMarkType);
|
|
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(root, child);
|
|
this->writeString("};");
|
|
this->lf(2);
|
|
startDef = child.fParent;
|
|
fStart = child.fParent->fContentEnd;
|
|
SkASSERT(';' == fStart[0]);
|
|
++fStart;
|
|
fDeferComment = nullptr;
|
|
fInEnum = false;
|
|
if (fIndentNext) {
|
|
// fIndent -= 4;
|
|
fIndentNext = false;
|
|
}
|
|
continue;
|
|
}
|
|
if (fAttrDeprecated) {
|
|
continue;
|
|
}
|
|
fDeferComment = nullptr;
|
|
if (KeyWord::kClass == def->fKeyWord || KeyWord::kStruct == def->fKeyWord) {
|
|
fIndentNext = true;
|
|
}
|
|
if (!this->populate(&child, &pair, root)) {
|
|
return false;
|
|
}
|
|
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;
|
|
// SkASSERT(!fIndentNext);
|
|
fIndentNext = true;
|
|
}
|
|
}
|
|
SkASSERT(fBmhStructDef);
|
|
if (!fBmhStructDef->fDeprecated) {
|
|
memberEnd = this->structMemberOut(memberStart, child);
|
|
startDef = &child;
|
|
fStart = child.fContentEnd + 1;
|
|
fDeferComment = nullptr;
|
|
}
|
|
} else if (MarkType::kNone == child.fMarkType && sawConst
|
|
&& fEnumDef && !fEnumDef->fDeprecated) {
|
|
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, child, bmhConst);
|
|
fDeferComment = nullptr;
|
|
sawConst = false;
|
|
}
|
|
}
|
|
if (child.fMemberStart) {
|
|
memberStart = &child;
|
|
staticOnly = false;
|
|
}
|
|
const char attrDeprecated[] = "SK_ATTR_DEPRECATED";
|
|
const size_t attrDeprecatedLen = sizeof(attrDeprecated) - 1;
|
|
if (attrDeprecatedLen == child.fContentEnd - child.fContentStart &&
|
|
!strncmp(attrDeprecated, child.fStart, attrDeprecatedLen)) {
|
|
fAttrDeprecated = &child;
|
|
}
|
|
continue;
|
|
}
|
|
if (Definition::Type::kPunctuation == child.fType) {
|
|
if (Punctuation::kSemicolon == child.fPunctuation) {
|
|
memberStart = nullptr;
|
|
sawConst = false;
|
|
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);
|
|
fOut = fopen(fileName.c_str(), "wb");
|
|
if (!fOut) {
|
|
SkDebugf("could not open output file %s\n", fileName.c_str());
|
|
return false;
|
|
}
|
|
if (bmhParser.fClassMap.end() == bmhParser.fClassMap.find(skClassName)) {
|
|
return this->reportError<bool>("could not find bmh class");
|
|
}
|
|
fBmhParser = &bmhParser;
|
|
RootDefinition* root = &bmhParser.fClassMap[skClassName];
|
|
fRootTopic = root->fParent;
|
|
root->clearVisited();
|
|
fStart = includeMapper.second.fContentStart;
|
|
fEnd = includeMapper.second.fContentEnd;
|
|
fAnonymousEnumCount = 1;
|
|
allPassed &= this->populate(&includeMapper.second, nullptr, root);
|
|
this->writeBlock((int) (fEnd - fStart), fStart);
|
|
fIndent = 0;
|
|
this->lfcr();
|
|
this->writePending();
|
|
fclose(fOut);
|
|
fflush(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 (this->writtenFileDiffers(fileName, readname)) {
|
|
SkDebugf("wrote updated %s\n", fileName.c_str());
|
|
} else {
|
|
remove(fileName.c_str());
|
|
}
|
|
}
|
|
return allPassed;
|
|
}
|
|
|
|
// change Xxx_Xxx to xxx xxx
|
|
static string ConvertRef(const string str, bool first) {
|
|
string substitute;
|
|
for (char c : str) {
|
|
if ('_' == c) {
|
|
c = ' '; // change Xxx_Xxx to xxx xxx
|
|
} else if (isupper(c) && !first) {
|
|
c = tolower(c);
|
|
}
|
|
substitute += c;
|
|
first = false;
|
|
}
|
|
return substitute;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
SkASSERT(parent);
|
|
auto defRef = parent->find(parent->fName + "::" + methodname,
|
|
RootDefinition::AllowParens::kNo);
|
|
if (defRef && MarkType::kMethod == defRef->fMarkType) {
|
|
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::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 && !substitute.length()) {
|
|
auto aliasIter = fBmhParser->fAliasMap.find(undername);
|
|
if (fBmhParser->fAliasMap.end() != aliasIter) {
|
|
rootDef = aliasIter->second;
|
|
} else if (!first) {
|
|
SkDebugf("unfound: %s\n", undername.c_str());
|
|
this->reportError("reference unfound");
|
|
return "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (rootDef) {
|
|
MarkType rootType = rootDef->fMarkType;
|
|
bool isTopic = MarkType::kSubtopic == rootType || MarkType::kTopic == rootType;
|
|
auto substituteParent = MarkType::kAlias == rootType ? rootDef->fParent :
|
|
isTopic ? rootDef : nullptr;
|
|
if (substituteParent) {
|
|
for (auto child : substituteParent->fChildren) {
|
|
if (MarkType::kSubstitute == child->fMarkType) {
|
|
substitute = string(child->fContentStart,
|
|
(int) (child->fContentEnd - child->fContentStart));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
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 = substituteParent ? substituteParent : 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::kEnum == child->fMarkType && !child->fAnonymous) ||
|
|
MarkType::kEnumClass == child->fMarkType) && (match == child->fName ||
|
|
skmatch == child->fName)) {
|
|
substitute = child->fName;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!substitute.length()) {
|
|
for (auto child : rootDef->fChildren) {
|
|
// there may be more than one
|
|
// if so, it's a bug since it's unknown which is the right one
|
|
if (MarkType::kClass == child->fMarkType ||
|
|
MarkType::kStruct == child->fMarkType ||
|
|
(MarkType::kEnum == child->fMarkType && !child->fAnonymous) ||
|
|
MarkType::kEnumClass == child->fMarkType) {
|
|
SkASSERT("" == substitute);
|
|
substitute = child->fName;
|
|
if (MarkType::kEnum == child->fMarkType) {
|
|
size_t parentClassEnd = substitute.find("::");
|
|
SkASSERT(string::npos != parentClassEnd);
|
|
string subEnd = substitute.substr(parentClassEnd + 2);
|
|
if (fInEnum) {
|
|
substitute = subEnd;
|
|
}
|
|
if (subEnd == undername) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!substitute.length()) {
|
|
const Definition* parent = rootDef;
|
|
do {
|
|
parent = parent->fParent;
|
|
} while (parent && (MarkType::kSubtopic == parent->fMarkType
|
|
|| MarkType::kTopic == parent->fMarkType));
|
|
if (parent) {
|
|
if (MarkType::kClass == parent->fMarkType ||
|
|
MarkType::kStruct == parent->fMarkType ||
|
|
(MarkType::kEnum == parent->fMarkType && !parent->fAnonymous) ||
|
|
MarkType::kEnumClass == parent->fMarkType) {
|
|
if (parent->fParent != fRootTopic) {
|
|
substitute = parent->fName;
|
|
substitute += ' ';
|
|
substitute += ConvertRef(undername, false);
|
|
} else {
|
|
substitute += ConvertRef(undername, first);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Ensure first word after period is capitalized if substitute is lower cased.
|
|
if (first && isupper(start[0]) && substitute.length() > 0 && islower(substitute[0])) {
|
|
substitute[0] = start[0];
|
|
}
|
|
return substitute;
|
|
}
|
|
|
|
int IncludeWriter::lookupMethod(const PunctuationState punctuation, const Word word,
|
|
const int lastSpace, const int run, int lastWrite, const char* data,
|
|
bool hasIndirection) {
|
|
int wordStart = lastSpace;
|
|
while (' ' >= data[wordStart]) {
|
|
++wordStart;
|
|
}
|
|
const int wordEnd = PunctuationState::kDelimiter == punctuation ||
|
|
PunctuationState::kPeriod == punctuation ? run - 1 : run;
|
|
string temp;
|
|
if (hasIndirection && '(' != data[wordEnd - 1] && ')' != data[wordEnd - 1]) {
|
|
// FIXME: hard-coded to assume a.b or a->b is a.b() or a->b().
|
|
// need to check class a for member b to see if this is so
|
|
TextParser parser(fFileName, &data[wordStart], &data[wordEnd], fLineCount);
|
|
const char* indirection = parser.anyOf(".>");
|
|
if (&data[wordEnd] <= &indirection[2] || 'f' != indirection[1] ||
|
|
!isupper(indirection[2])) {
|
|
temp = string(&data[wordStart], wordEnd - wordStart) + "()";
|
|
}
|
|
} else {
|
|
temp = this->resolveMethod(&data[wordStart], &data[wordEnd], Word::kFirst == word);
|
|
}
|
|
if (temp.length()) {
|
|
if (wordStart > lastWrite) {
|
|
SkASSERT(data[wordStart - 1] >= ' ');
|
|
if (' ' == data[lastWrite]) {
|
|
this->writeSpace();
|
|
}
|
|
this->writeBlockTrim(wordStart - lastWrite, &data[lastWrite]);
|
|
if (' ' == data[wordStart - 1]) {
|
|
this->writeSpace();
|
|
}
|
|
}
|
|
SkASSERT(temp[temp.length() - 1] > ' ');
|
|
this->writeString(temp.c_str());
|
|
lastWrite = wordEnd;
|
|
}
|
|
return lastWrite;
|
|
}
|
|
|
|
int IncludeWriter::lookupReference(const PunctuationState punctuation, const Word word,
|
|
const int start, const int run, int lastWrite, const char last, const char* data) {
|
|
const int end = PunctuationState::kDelimiter == punctuation ||
|
|
PunctuationState::kPeriod == punctuation ? run - 1 : run;
|
|
RefType refType = RefType::kUndefined;
|
|
string resolved = string(&data[start], (size_t) (end - start));
|
|
string temp = this->resolveRef(&data[start], &data[end], Word::kFirst == word, &refType);
|
|
if (!temp.length()) {
|
|
if (Word::kFirst != word && '_' != last) {
|
|
temp = ConvertRef(resolved, false);
|
|
}
|
|
}
|
|
if (temp.length()) {
|
|
if (start > lastWrite) {
|
|
SkASSERT(data[start - 1] >= ' ');
|
|
if (' ' == data[lastWrite]) {
|
|
this->writeSpace();
|
|
}
|
|
this->writeBlockTrim(start - lastWrite, &data[lastWrite]);
|
|
if (' ' == data[start - 1]) {
|
|
this->writeSpace();
|
|
}
|
|
}
|
|
SkASSERT(temp[temp.length() - 1] > ' ');
|
|
this->writeString(temp.c_str());
|
|
lastWrite = end;
|
|
}
|
|
return lastWrite;
|
|
}
|
|
|
|
/* returns true if rewriteBlock wrote linefeeds */
|
|
IncludeWriter::Wrote IncludeWriter::rewriteBlock(int size, const char* data, Phrase phrase) {
|
|
bool wroteLineFeeds = false;
|
|
while (size > 0 && data[0] <= ' ') {
|
|
--size;
|
|
++data;
|
|
}
|
|
while (size > 0 && data[size - 1] <= ' ') {
|
|
--size;
|
|
}
|
|
if (0 == size) {
|
|
return Wrote::kNone;
|
|
}
|
|
int run = 0;
|
|
Word word = Word::kStart;
|
|
PunctuationState punctuation = Phrase::kNo == phrase ?
|
|
PunctuationState::kStart : PunctuationState::kSpace;
|
|
int start = 0;
|
|
int lastWrite = 0;
|
|
int lineFeeds = 0;
|
|
int lastPrintable = 0;
|
|
int lastSpace = -1;
|
|
char c = 0;
|
|
char last = 0;
|
|
bool embeddedIndirection = false;
|
|
bool embeddedSymbol = false;
|
|
bool hasLower = false;
|
|
bool hasUpper = false;
|
|
bool hasIndirection = false;
|
|
bool hasSymbol = false;
|
|
while (run < size) {
|
|
last = c;
|
|
c = data[run];
|
|
SkASSERT(' ' <= c || '\n' == c);
|
|
if (lineFeeds && ' ' < c) {
|
|
if (lastPrintable >= lastWrite) {
|
|
if (' ' == data[lastWrite]) {
|
|
this->writeSpace();
|
|
lastWrite++;
|
|
}
|
|
this->writeBlock(lastPrintable - lastWrite + 1, &data[lastWrite]);
|
|
}
|
|
if (lineFeeds > 1) {
|
|
this->lf(2);
|
|
}
|
|
this->lfcr(); // defer the indent until non-whitespace is seen
|
|
lastWrite = run;
|
|
lineFeeds = 0;
|
|
}
|
|
if (' ' < c) {
|
|
lastPrintable = run;
|
|
}
|
|
switch (c) {
|
|
case '\n':
|
|
++lineFeeds;
|
|
wroteLineFeeds = true;
|
|
case ' ':
|
|
switch (word) {
|
|
case Word::kStart:
|
|
break;
|
|
case Word::kUnderline:
|
|
case Word::kCap:
|
|
case Word::kFirst:
|
|
if (!hasLower) {
|
|
break;
|
|
}
|
|
lastWrite = this->lookupReference(punctuation, word, start, run,
|
|
lastWrite, last, data);
|
|
break;
|
|
case Word::kMixed:
|
|
if (hasUpper && hasLower && !hasSymbol && lastSpace > 0) {
|
|
lastWrite = this->lookupMethod(punctuation, word, lastSpace, run,
|
|
lastWrite, data, hasIndirection && !hasSymbol);
|
|
}
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
punctuation = PunctuationState::kPeriod == punctuation ||
|
|
(PunctuationState::kStart == punctuation && ' ' >= last) ?
|
|
PunctuationState::kStart : PunctuationState::kSpace;
|
|
word = Word::kStart;
|
|
embeddedIndirection = false;
|
|
embeddedSymbol = false;
|
|
hasLower = false;
|
|
hasUpper = false;
|
|
hasIndirection = false;
|
|
hasSymbol = false;
|
|
lastSpace = run;
|
|
break;
|
|
case '.':
|
|
switch (word) {
|
|
case Word::kStart:
|
|
punctuation = PunctuationState::kDelimiter;
|
|
case Word::kCap:
|
|
case Word::kFirst:
|
|
case Word::kUnderline:
|
|
case Word::kMixed:
|
|
if (PunctuationState::kDelimiter == punctuation ||
|
|
PunctuationState::kPeriod == punctuation) {
|
|
word = Word::kMixed;
|
|
}
|
|
punctuation = PunctuationState::kPeriod;
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
embeddedIndirection = true;
|
|
break;
|
|
case ',': case ';': case ':':
|
|
switch (word) {
|
|
case Word::kStart:
|
|
punctuation = PunctuationState::kDelimiter;
|
|
case Word::kCap:
|
|
case Word::kFirst:
|
|
case Word::kUnderline:
|
|
case Word::kMixed:
|
|
if (PunctuationState::kDelimiter == punctuation ||
|
|
PunctuationState::kPeriod == punctuation) {
|
|
word = Word::kMixed;
|
|
}
|
|
punctuation = PunctuationState::kDelimiter;
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
embeddedSymbol = true;
|
|
break;
|
|
case '>':
|
|
if ('-' == last) {
|
|
embeddedIndirection = true;
|
|
break;
|
|
}
|
|
case '\'': // possessive apostrophe isn't treated as delimiting punctation
|
|
case '\"': // quote is passed straight through
|
|
case '=':
|
|
case '!': // assumed not to be punctuation, but a programming symbol
|
|
case '&': case '<': case '{': case '}': case '/': case '*': case '[': case ']':
|
|
word = Word::kMixed;
|
|
embeddedSymbol = true;
|
|
break;
|
|
case '(':
|
|
if (' ' == last) {
|
|
punctuation = PunctuationState::kDelimiter;
|
|
} else {
|
|
word = Word::kMixed;
|
|
}
|
|
embeddedSymbol = true;
|
|
break;
|
|
case ')': // assume word type has already been set
|
|
punctuation = PunctuationState::kDelimiter;
|
|
embeddedSymbol = true;
|
|
break;
|
|
case '_':
|
|
switch (word) {
|
|
case Word::kStart:
|
|
word = Word::kMixed;
|
|
break;
|
|
case Word::kCap:
|
|
case Word::kFirst:
|
|
case Word::kUnderline:
|
|
word = Word::kUnderline;
|
|
break;
|
|
case Word::kMixed:
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
hasSymbol |= embeddedSymbol;
|
|
break;
|
|
case '+':
|
|
// hackery to allow C++
|
|
SkASSERT('C' == last || '+' == last); // FIXME: don't allow + outside of #Formula
|
|
break;
|
|
case 'A': case 'B': case 'C': case 'D': case 'E':
|
|
case 'F': case 'G': case 'H': case 'I': case 'J':
|
|
case 'K': case 'L': case 'M': case 'N': case 'O':
|
|
case 'P': case 'Q': case 'R': case 'S': case 'T':
|
|
case 'U': case 'V': case 'W': case 'X': case 'Y':
|
|
case 'Z':
|
|
switch (word) {
|
|
case Word::kStart:
|
|
word = PunctuationState::kStart == punctuation ? Word::kFirst : Word::kCap;
|
|
start = run;
|
|
break;
|
|
case Word::kCap:
|
|
case Word::kFirst:
|
|
if (!isupper(last) && '~' != last) {
|
|
word = Word::kMixed;
|
|
}
|
|
break;
|
|
case Word::kUnderline:
|
|
// some word in Xxx_XXX_Xxx can be all upper, but all can't: XXX_XXX
|
|
if ('_' != last && !isupper(last)) {
|
|
word = Word::kMixed;
|
|
}
|
|
break;
|
|
case Word::kMixed:
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
hasUpper = true;
|
|
if (PunctuationState::kPeriod == punctuation ||
|
|
PunctuationState::kDelimiter == punctuation) {
|
|
word = Word::kMixed;
|
|
}
|
|
hasIndirection |= embeddedIndirection;
|
|
hasSymbol |= embeddedSymbol;
|
|
break;
|
|
case 'a': case 'b': case 'c': case 'd': case 'e':
|
|
case 'f': case 'g': case 'h': case 'i': case 'j':
|
|
case 'k': case 'l': case 'm': case 'n': case 'o':
|
|
case 'p': case 'q': case 'r': case 's': case 't':
|
|
case 'u': case 'v': case 'w': case 'x': case 'y':
|
|
case 'z':
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
case '-':
|
|
switch (word) {
|
|
case Word::kStart:
|
|
word = Word::kMixed;
|
|
break;
|
|
case Word::kMixed:
|
|
case Word::kCap:
|
|
case Word::kFirst:
|
|
case Word::kUnderline:
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
hasLower = true;
|
|
punctuation = PunctuationState::kStart;
|
|
hasIndirection |= embeddedIndirection;
|
|
hasSymbol |= embeddedSymbol;
|
|
break;
|
|
case '~':
|
|
SkASSERT(Word::kStart == word);
|
|
word = PunctuationState::kStart == punctuation ? Word::kFirst : Word::kCap;
|
|
start = run;
|
|
hasUpper = true;
|
|
hasIndirection |= embeddedIndirection;
|
|
hasSymbol |= embeddedSymbol;
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
++run;
|
|
}
|
|
if ((word == Word::kCap || word == Word::kFirst || word == Word::kUnderline) && hasLower) {
|
|
lastWrite = this->lookupReference(punctuation, word, start, run, lastWrite, last, data);
|
|
} else if (word == Word::kMixed && hasUpper && hasLower && !hasSymbol && lastSpace > 0) {
|
|
lastWrite = this->lookupMethod(punctuation, word, lastSpace, run, lastWrite, data,
|
|
hasIndirection && !hasSymbol);
|
|
}
|
|
if (run > lastWrite) {
|
|
if (' ' == data[lastWrite]) {
|
|
this->writeSpace();
|
|
}
|
|
this->writeBlock(run - lastWrite, &data[lastWrite]);
|
|
}
|
|
return wroteLineFeeds ? Wrote::kLF : Wrote::kChars;
|
|
}
|