78de751969
add self-check looking for #In markup on every method, pointing to an existing #Subtopic to reference the method. Docs-Preview: https://skia.org/?cl=104325 Bug: skia:6898 Change-Id: I749a25b9a43033ae68d193249b2c0b810dcf8fc8 Reviewed-on: https://skia-review.googlesource.com/104325 Commit-Queue: Cary Clark <caryclark@skia.org> Reviewed-by: Cary Clark <caryclark@skia.org>
1384 lines
48 KiB
C++
1384 lines
48 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"
|
|
#include "SkOSPath.h"
|
|
|
|
static size_t count_indent(const string& text, size_t test, size_t end) {
|
|
size_t result = test;
|
|
while (test < end) {
|
|
if (' ' != text[test]) {
|
|
break;
|
|
}
|
|
++test;
|
|
}
|
|
return test - result;
|
|
}
|
|
|
|
static void add_code(const string& text, int pos, int end,
|
|
size_t outIndent, size_t textIndent, string& example) {
|
|
do {
|
|
// fix this to move whole paragraph in, out, but preserve doc indent
|
|
int nextIndent = count_indent(text, pos, end);
|
|
size_t len = text.find('\n', pos);
|
|
if (string::npos == len) {
|
|
len = end;
|
|
}
|
|
if ((size_t) (pos + nextIndent) < len) {
|
|
size_t indent = outIndent + nextIndent;
|
|
SkASSERT(indent >= textIndent);
|
|
indent -= textIndent;
|
|
for (size_t index = 0; index < indent; ++index) {
|
|
example += ' ';
|
|
}
|
|
pos += nextIndent;
|
|
while ((size_t) pos < len) {
|
|
example += '"' == text[pos] ? "\\\"" :
|
|
'\\' == text[pos] ? "\\\\" :
|
|
text.substr(pos, 1);
|
|
++pos;
|
|
}
|
|
example += "\\n";
|
|
} else {
|
|
pos += nextIndent;
|
|
}
|
|
if ('\n' == text[pos]) {
|
|
++pos;
|
|
}
|
|
} while (pos < end);
|
|
}
|
|
|
|
#ifdef CONST
|
|
#undef CONST
|
|
#endif
|
|
|
|
#ifdef FRIEND
|
|
#undef FRIEND
|
|
#endif
|
|
|
|
#ifdef BLANK
|
|
#undef BLANK
|
|
#endif
|
|
|
|
#ifdef ANY
|
|
#undef ANY
|
|
#endif
|
|
|
|
#ifdef DEFOP
|
|
#undef DEFOP
|
|
#endif
|
|
|
|
#define CONST 1
|
|
#define STATIC 2
|
|
#define BLANK 0
|
|
#define ANY -1
|
|
#define DEFOP Definition::Operator
|
|
|
|
enum class OpType : int8_t {
|
|
kNone,
|
|
kVoid,
|
|
kBool,
|
|
kChar,
|
|
kFloat,
|
|
kInt,
|
|
kScalar,
|
|
kSizeT,
|
|
kThis,
|
|
kAny,
|
|
};
|
|
|
|
enum class OpMod : int8_t {
|
|
kNone,
|
|
kArray,
|
|
kMove,
|
|
kPointer,
|
|
kReference,
|
|
kAny,
|
|
};
|
|
|
|
const struct OperatorParser {
|
|
DEFOP fOperator;
|
|
const char* fSymbol;
|
|
const char* fName;
|
|
int8_t fFriend;
|
|
OpType fReturnType;
|
|
OpMod fReturnMod;
|
|
int8_t fConstMethod;
|
|
struct Param {
|
|
int8_t fConst;
|
|
OpType fType;
|
|
OpMod fMod;
|
|
} fParams[2];
|
|
} opData[] = {
|
|
{ DEFOP::kUnknown, "??", "???", BLANK, OpType::kNone, OpMod::kNone, BLANK,
|
|
{ } },
|
|
{ DEFOP::kAdd, "+", "add", BLANK, OpType::kThis, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kAddTo, "+=", "addto", BLANK, OpType::kVoid, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kAddTo, "+=", "addto1", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kAddTo, "+=", "addto2", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ CONST, OpType::kChar, OpMod::kArray, }}},
|
|
{ DEFOP::kAddTo, "+=", "addto3", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ CONST, OpType::kChar, OpMod::kNone, }}},
|
|
{ DEFOP::kArray, "[]", "array", BLANK, OpType::kScalar, OpMod::kNone, CONST,
|
|
{{ BLANK, OpType::kInt, OpMod::kNone, }}},
|
|
{ DEFOP::kArray, "[]", "array1", BLANK, OpType::kScalar, OpMod::kReference, BLANK,
|
|
{{ BLANK, OpType::kInt, OpMod::kNone, }}},
|
|
{ DEFOP::kArray, "[]", "array2", BLANK, OpType::kChar, OpMod::kNone, CONST,
|
|
{{ BLANK, OpType::kSizeT, OpMod::kNone, }}},
|
|
{ DEFOP::kArray, "[]", "array3", BLANK, OpType::kChar, OpMod::kReference, BLANK,
|
|
{{ BLANK, OpType::kSizeT, OpMod::kNone, }}},
|
|
{ DEFOP::kCast, "()", "cast", BLANK, OpType::kAny, OpMod::kAny, ANY,
|
|
{{ ANY, OpType::kAny, OpMod::kAny, }}},
|
|
{ DEFOP::kCopy, "=", "copy", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kCopy, "=", "copy1", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ CONST, OpType::kChar, OpMod::kArray, }}},
|
|
{ DEFOP::kDelete, "delete", "delete", BLANK, OpType::kVoid, OpMod::kNone, BLANK,
|
|
{{ BLANK, OpType::kVoid, OpMod::kPointer, }}},
|
|
{ DEFOP::kDereference, "->", "deref", ANY, OpType::kThis, OpMod::kPointer, CONST,
|
|
{ } },
|
|
{ DEFOP::kDereference, "*", "deref", BLANK, OpType::kThis, OpMod::kReference, CONST,
|
|
{ } },
|
|
{ DEFOP::kEqual, "==", "equal", BLANK, OpType::kBool, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kEqual, "==", "equal1", BLANK, OpType::kBool, OpMod::kNone, CONST,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kEqual, "==", "equal2", ANY, OpType::kBool, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kMinus, "-", "minus", BLANK, OpType::kThis, OpMod::kNone, CONST,
|
|
{ } },
|
|
{ DEFOP::kMove, "=", "move", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ BLANK, OpType::kThis, OpMod::kMove, }}},
|
|
{ DEFOP::kMultiply, "*", "multiply", BLANK, OpType::kThis, OpMod::kNone, CONST,
|
|
{{ BLANK, OpType::kScalar, OpMod::kNone, }}},
|
|
{ DEFOP::kMultiply, "*", "multiply1", BLANK, OpType::kThis, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kMultiplyBy, "*=", "multiplyby", BLANK, OpType::kThis, OpMod::kReference, BLANK,
|
|
{{ BLANK, OpType::kScalar, OpMod::kNone, }}},
|
|
{ DEFOP::kNew, "new", "new", BLANK, OpType::kVoid, OpMod::kPointer, BLANK,
|
|
{{ BLANK, OpType::kSizeT, OpMod::kNone, }}},
|
|
{ DEFOP::kNotEqual, "!=", "notequal", BLANK, OpType::kBool, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kNotEqual, "!=", "notequal1", BLANK, OpType::kBool, OpMod::kNone, CONST,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kNotEqual, "!=", "notequal2", ANY, OpType::kBool, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kSubtract, "-", "subtract", BLANK, OpType::kThis, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, },
|
|
{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
{ DEFOP::kSubtractFrom, "-=", "subtractfrom", BLANK, OpType::kVoid, OpMod::kNone, BLANK,
|
|
{{ CONST, OpType::kThis, OpMod::kReference, }}},
|
|
};
|
|
|
|
OpType lookup_type(const string& typeWord, const string& name) {
|
|
if (typeWord == name || (typeWord == "SkIVector" && name == "SkIPoint")
|
|
|| (typeWord == "SkVector" && name == "SkPoint")) {
|
|
return OpType::kThis;
|
|
}
|
|
const char* keyWords[] = { "void", "bool", "char", "float", "int", "SkScalar", "size_t" };
|
|
for (unsigned i = 0; i < SK_ARRAY_COUNT(keyWords); ++i) {
|
|
if (typeWord == keyWords[i]) {
|
|
return (OpType) (i + 1);
|
|
}
|
|
}
|
|
return OpType::kNone;
|
|
}
|
|
|
|
OpMod lookup_mod(TextParser& iParser) {
|
|
OpMod mod = OpMod::kNone;
|
|
if ('&' == iParser.peek()) {
|
|
mod = OpMod::kReference;
|
|
iParser.next();
|
|
if ('&' == iParser.peek()) {
|
|
mod = OpMod::kMove;
|
|
iParser.next();
|
|
}
|
|
} else if ('*' == iParser.peek()) {
|
|
mod = OpMod::kPointer;
|
|
iParser.next();
|
|
}
|
|
iParser.skipWhiteSpace();
|
|
return mod;
|
|
}
|
|
|
|
bool Definition::parseOperator(size_t doubleColons, string& result) {
|
|
const char operatorStr[] = "operator";
|
|
size_t opPos = fName.find(operatorStr, doubleColons);
|
|
if (string::npos == opPos) {
|
|
return false;
|
|
}
|
|
string className(fName, 0, doubleColons - 2);
|
|
TextParser iParser(fFileName, fStart, fContentStart, fLineCount);
|
|
SkAssertResult(iParser.skipWord("#Method"));
|
|
iParser.skipExact("SK_API");
|
|
iParser.skipWhiteSpace();
|
|
bool isStatic = iParser.skipExact("static");
|
|
iParser.skipWhiteSpace();
|
|
iParser.skipExact("SK_API");
|
|
iParser.skipWhiteSpace();
|
|
bool returnsConst = iParser.skipExact("const");
|
|
if (returnsConst) {
|
|
SkASSERT(0); // incomplete
|
|
}
|
|
SkASSERT(isStatic == false || returnsConst == false);
|
|
iParser.skipWhiteSpace();
|
|
const char* returnTypeStart = iParser.fChar;
|
|
iParser.skipToNonAlphaNum();
|
|
SkASSERT(iParser.fChar > returnTypeStart);
|
|
string returnType(returnTypeStart, iParser.fChar - returnTypeStart);
|
|
OpType returnOpType = lookup_type(returnType, className);
|
|
iParser.skipWhiteSpace();
|
|
OpMod returnMod = lookup_mod(iParser);
|
|
SkAssertResult(iParser.skipExact("operator"));
|
|
iParser.skipWhiteSpace();
|
|
fMethodType = Definition::MethodType::kOperator;
|
|
TextParser::Save save(&iParser);
|
|
for (auto parser : opData) {
|
|
save.restore();
|
|
if (!iParser.skipExact(parser.fSymbol)) {
|
|
continue;
|
|
}
|
|
iParser.skipWhiteSpace();
|
|
if ('(' != iParser.peek()) {
|
|
continue;
|
|
}
|
|
if (parser.fFriend != ANY && (parser.fFriend == STATIC) != isStatic) {
|
|
continue;
|
|
}
|
|
if (parser.fReturnType != OpType::kAny && parser.fReturnType != returnOpType) {
|
|
continue;
|
|
}
|
|
if (parser.fReturnMod != OpMod::kAny && parser.fReturnMod != returnMod) {
|
|
continue;
|
|
}
|
|
iParser.next(); // skip '('
|
|
iParser.skipWhiteSpace();
|
|
int parserCount = (parser.fParams[0].fType != OpType::kNone) +
|
|
(parser.fParams[1].fType != OpType::kNone);
|
|
bool countsMatch = true;
|
|
for (int pIndex = 0; pIndex < 2; ++pIndex) {
|
|
if (')' == iParser.peek()) {
|
|
countsMatch = pIndex == parserCount;
|
|
break;
|
|
}
|
|
if (',' == iParser.peek()) {
|
|
iParser.next();
|
|
iParser.skipWhiteSpace();
|
|
}
|
|
bool paramConst = iParser.skipExact("const");
|
|
if (parser.fParams[pIndex].fConst != ANY &&
|
|
paramConst != (parser.fParams[pIndex].fConst == CONST)) {
|
|
countsMatch = false;
|
|
break;
|
|
}
|
|
iParser.skipWhiteSpace();
|
|
const char* paramStart = iParser.fChar;
|
|
iParser.skipToNonAlphaNum();
|
|
SkASSERT(iParser.fChar > paramStart);
|
|
string paramType(paramStart, iParser.fChar - paramStart);
|
|
OpType paramOpType = lookup_type(paramType, className);
|
|
if (parser.fParams[pIndex].fType != OpType::kAny &&
|
|
parser.fParams[pIndex].fType != paramOpType) {
|
|
countsMatch = false;
|
|
break;
|
|
}
|
|
iParser.skipWhiteSpace();
|
|
OpMod paramMod = lookup_mod(iParser);
|
|
if (parser.fParams[pIndex].fMod != OpMod::kAny &&
|
|
parser.fParams[pIndex].fMod != paramMod) {
|
|
countsMatch = false;
|
|
break;
|
|
}
|
|
iParser.skipToNonAlphaNum();
|
|
if ('[' == iParser.peek()) {
|
|
paramMod = OpMod::kArray;
|
|
SkAssertResult(iParser.skipExact("[]"));
|
|
}
|
|
iParser.skipWhiteSpace();
|
|
}
|
|
if (!countsMatch) {
|
|
continue;
|
|
}
|
|
if (')' != iParser.peek()) {
|
|
continue;
|
|
}
|
|
iParser.next();
|
|
bool constMethod = iParser.skipExact("_const");
|
|
if (parser.fConstMethod != ANY && (parser.fConstMethod == CONST) != constMethod) {
|
|
continue;
|
|
}
|
|
result += parser.fName;
|
|
result += "_operator";
|
|
fOperator = parser.fOperator;
|
|
fOperatorConst = constMethod;
|
|
return true;
|
|
}
|
|
SkASSERT(0); // incomplete
|
|
return false;
|
|
#if 0
|
|
if ('!' == fName[opPos]) {
|
|
SkASSERT('=' == fName[opPos + 1]);
|
|
result += "not_equal_operator";
|
|
} else if ('=' == fName[opPos]) {
|
|
if ('(' == fName[opPos + 1]) {
|
|
result += isMove ? "move_" : "copy_";
|
|
result += "assignment_operator";
|
|
} else {
|
|
SkASSERT('=' == fName[opPos + 1]);
|
|
result += "equal_operator";
|
|
}
|
|
} else if ('[' == fName[opPos]) {
|
|
result += "subscript_operator";
|
|
const char* end = fContentStart;
|
|
while (end > fStart && ' ' >= end[-1]) {
|
|
--end;
|
|
}
|
|
string constCheck(fStart, end - fStart);
|
|
size_t constPos = constCheck.rfind("const");
|
|
if (constCheck.length() == constPos + 5) {
|
|
result += "_const";
|
|
}
|
|
} else if ('*' == fName[opPos]) {
|
|
result += "multiply_operator";
|
|
} else if ('-' == fName[opPos]) {
|
|
result += "subtract_operator";
|
|
} else if ('+' == fName[opPos]) {
|
|
result += "add_operator";
|
|
} else {
|
|
SkASSERT(0); // todo: incomplete
|
|
}
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
#undef CONST
|
|
#undef FRIEND
|
|
#undef BLANK
|
|
#undef DEFOP
|
|
|
|
bool Definition::boilerplateIfDef(Definition* parent) {
|
|
const Definition& label = fTokens.front();
|
|
if (Type::kWord != label.fType) {
|
|
return false;
|
|
}
|
|
fName = string(label.fContentStart, label.fContentEnd - label.fContentStart);
|
|
return true;
|
|
}
|
|
|
|
// todo: this is matching #ifndef SkXXX_DEFINED for no particular reason
|
|
// it doesn't do anything useful with arbitrary input, e.g. #ifdef SK_SUPPORT_LEGACY_CANVAS_HELPERS
|
|
// also doesn't know what to do with SK_REQUIRE_LOCAL_VAR()
|
|
bool Definition::boilerplateDef(Definition* parent) {
|
|
if (!this->boilerplateIfDef(parent)) {
|
|
return false;
|
|
}
|
|
const char* s = fName.c_str();
|
|
const char* e = strchr(s, '_');
|
|
return true; // fixme: if this is trying to do something useful with define, do it here
|
|
if (!e) {
|
|
return false;
|
|
}
|
|
string prefix(s, e - s);
|
|
const char* inName = strstr(parent->fName.c_str(), prefix.c_str());
|
|
if (!inName) {
|
|
return false;
|
|
}
|
|
if ('/' != inName[-1] && '\\' != inName[-1]) {
|
|
return false;
|
|
}
|
|
if (strcmp(inName + prefix.size(), ".h")) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// fixme: this will need to be more complicated to handle all of Skia
|
|
// for now, just handle paint -- maybe fiddle will loosen naming restrictions
|
|
void Definition::setCanonicalFiddle() {
|
|
fMethodType = Definition::MethodType::kNone;
|
|
size_t doubleColons = fName.find("::", 0);
|
|
SkASSERT(string::npos != doubleColons);
|
|
string base = fName.substr(0, doubleColons);
|
|
string result = base + "_";
|
|
doubleColons += 2;
|
|
if (string::npos != fName.find('~', doubleColons)) {
|
|
fMethodType = Definition::MethodType::kDestructor;
|
|
result += "destructor";
|
|
} else if (!this->parseOperator(doubleColons, result)) {
|
|
bool isMove = string::npos != fName.find("&&", doubleColons);
|
|
size_t parens = fName.find("()", doubleColons);
|
|
if (string::npos != parens) {
|
|
string methodName = fName.substr(doubleColons, parens - doubleColons);
|
|
do {
|
|
size_t nextDouble = methodName.find("::");
|
|
if (string::npos == nextDouble) {
|
|
break;
|
|
}
|
|
base = methodName.substr(0, nextDouble);
|
|
result += base + '_';
|
|
methodName = methodName.substr(nextDouble + 2);
|
|
doubleColons += nextDouble + 2;
|
|
} while (true);
|
|
if (base == methodName) {
|
|
fMethodType = Definition::MethodType::kConstructor;
|
|
result += "empty_constructor";
|
|
} else {
|
|
result += fName.substr(doubleColons, fName.length() - doubleColons - 2);
|
|
}
|
|
} else {
|
|
size_t openParen = fName.find('(', doubleColons);
|
|
if (string::npos == openParen) {
|
|
result += fName.substr(doubleColons);
|
|
} else {
|
|
size_t comma = fName.find(',', doubleColons);
|
|
if (string::npos == comma) {
|
|
result += isMove ? "move_" : "copy_";
|
|
}
|
|
fMethodType = Definition::MethodType::kConstructor;
|
|
// name them by their param types,
|
|
// e.g. SkCanvas__int_int_const_SkSurfaceProps_star
|
|
// TODO: move forward until parens are balanced and terminator =,)
|
|
TextParser params("", &fName[openParen] + 1, &*fName.end(), 0);
|
|
bool underline = false;
|
|
while (!params.eof()) {
|
|
// SkDEBUGCODE(const char* end = params.anyOf("(),=")); // unused for now
|
|
// SkASSERT(end[0] != '('); // fixme: put off handling nested parentheseses
|
|
if (params.startsWith("const") || params.startsWith("int")
|
|
|| params.startsWith("Sk")) {
|
|
const char* wordStart = params.fChar;
|
|
params.skipToNonAlphaNum();
|
|
if (underline) {
|
|
result += '_';
|
|
} else {
|
|
underline = true;
|
|
}
|
|
result += string(wordStart, params.fChar - wordStart);
|
|
} else {
|
|
params.skipToNonAlphaNum();
|
|
}
|
|
if (!params.eof() && '*' == params.peek()) {
|
|
if (underline) {
|
|
result += '_';
|
|
} else {
|
|
underline = true;
|
|
}
|
|
result += "star";
|
|
params.next();
|
|
params.skipSpace();
|
|
}
|
|
params.skipToAlpha();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fFiddle = Definition::NormalizedName(result);
|
|
}
|
|
|
|
void Definition::setWrapper() {
|
|
const char drawWrapper[] = "void draw(SkCanvas* canvas) {";
|
|
const char drawNoCanvas[] = "void draw(SkCanvas* ) {";
|
|
string text = this->extractText(Definition::TrimExtract::kNo);
|
|
size_t nonSpace = 0;
|
|
while (nonSpace < text.length() && ' ' >= text[nonSpace]) {
|
|
++nonSpace;
|
|
}
|
|
bool hasFunc = !text.compare(nonSpace, sizeof(drawWrapper) - 1, drawWrapper);
|
|
bool noCanvas = !text.compare(nonSpace, sizeof(drawNoCanvas) - 1, drawNoCanvas);
|
|
bool hasCanvas = string::npos != text.find("SkCanvas canvas");
|
|
SkASSERT(!hasFunc || !noCanvas);
|
|
bool preprocessor = text[0] == '#';
|
|
bool wrapCode = !hasFunc && !noCanvas && !preprocessor;
|
|
if (wrapCode) {
|
|
fWrapper = hasCanvas ? string(drawNoCanvas) : string(drawWrapper);
|
|
}
|
|
}
|
|
|
|
bool Definition::exampleToScript(string* result, ExampleOptions exampleOptions) const {
|
|
bool hasFiddle = true;
|
|
const Definition* platform = this->hasChild(MarkType::kPlatform);
|
|
if (platform) {
|
|
TextParser platParse(platform);
|
|
hasFiddle = !platParse.strnstr("!fiddle", platParse.fEnd);
|
|
}
|
|
if (!hasFiddle) {
|
|
*result = "";
|
|
return true;
|
|
}
|
|
string text = this->extractText(Definition::TrimExtract::kNo);
|
|
bool textOut = string::npos != text.find("SkDebugf(")
|
|
|| string::npos != text.find("dump(")
|
|
|| string::npos != text.find("dumpHex(");
|
|
string heightStr = "256";
|
|
string widthStr = "256";
|
|
string normalizedName(fFiddle);
|
|
string code;
|
|
string imageStr = "0";
|
|
string srgbStr = "false";
|
|
string durationStr = "0";
|
|
for (auto const& iter : fChildren) {
|
|
switch (iter->fMarkType) {
|
|
case MarkType::kDuration:
|
|
durationStr = string(iter->fContentStart, iter->fContentEnd - iter->fContentStart);
|
|
break;
|
|
case MarkType::kHeight:
|
|
heightStr = string(iter->fContentStart, iter->fContentEnd - iter->fContentStart);
|
|
break;
|
|
case MarkType::kWidth:
|
|
widthStr = string(iter->fContentStart, iter->fContentEnd - iter->fContentStart);
|
|
break;
|
|
case MarkType::kDescription:
|
|
// ignore for now
|
|
break;
|
|
case MarkType::kFunction: {
|
|
// emit this, but don't wrap this in draw()
|
|
string funcText(iter->fContentStart, iter->fContentEnd - iter->fContentStart);
|
|
size_t pos = 0;
|
|
while (pos < funcText.length() && ' ' > funcText[pos]) {
|
|
++pos;
|
|
}
|
|
size_t indent = count_indent(funcText, pos, funcText.length());
|
|
add_code(funcText, pos, funcText.length(), 0, indent, code);
|
|
code += "\\n";
|
|
} break;
|
|
case MarkType::kComment:
|
|
break;
|
|
case MarkType::kImage:
|
|
imageStr = string(iter->fContentStart, iter->fContentEnd - iter->fContentStart);
|
|
break;
|
|
case MarkType::kToDo:
|
|
break;
|
|
case MarkType::kBug:
|
|
case MarkType::kMarkChar:
|
|
case MarkType::kPlatform:
|
|
// ignore for now
|
|
break;
|
|
case MarkType::kSet:
|
|
if ("sRGB" == string(iter->fContentStart,
|
|
iter->fContentEnd - iter->fContentStart)) {
|
|
srgbStr = "true";
|
|
} else {
|
|
SkASSERT(0); // more work to do
|
|
return false;
|
|
}
|
|
break;
|
|
case MarkType::kStdOut:
|
|
textOut = true;
|
|
break;
|
|
default:
|
|
SkASSERT(0); // more coding to do
|
|
}
|
|
}
|
|
string animatedStr = "0" != durationStr ? "true" : "false";
|
|
string textOutStr = textOut ? "true" : "false";
|
|
size_t pos = 0;
|
|
while (pos < text.length() && ' ' > text[pos]) {
|
|
++pos;
|
|
}
|
|
size_t end = text.length();
|
|
size_t outIndent = 0;
|
|
size_t textIndent = count_indent(text, pos, end);
|
|
if (fWrapper.length() > 0) {
|
|
code += fWrapper;
|
|
code += "\\n";
|
|
outIndent = 4;
|
|
}
|
|
add_code(text, pos, end, outIndent, textIndent, code);
|
|
if (fWrapper.length() > 0) {
|
|
code += "}";
|
|
}
|
|
string example = "\"" + normalizedName + "\": {\n";
|
|
size_t nameStart = fFileName.find(SkOSPath::SEPARATOR, 0);
|
|
SkASSERT(string::npos != nameStart);
|
|
string baseFile = fFileName.substr(nameStart + 1, fFileName.length() - nameStart - 5);
|
|
if (ExampleOptions::kText == exampleOptions) {
|
|
example += " \"code\": \"" + code + "\",\n";
|
|
example += " \"hash\": \"" + fHash + "\",\n";
|
|
example += " \"file\": \"" + baseFile + "\",\n";
|
|
example += " \"name\": \"" + fName + "\",";
|
|
} else {
|
|
example += " \"code\": \"" + code + "\",\n";
|
|
if (ExampleOptions::kPng == exampleOptions) {
|
|
example += " \"width\": " + widthStr + ",\n";
|
|
example += " \"height\": " + heightStr + ",\n";
|
|
example += " \"hash\": \"" + fHash + "\",\n";
|
|
example += " \"file\": \"" + baseFile + "\",\n";
|
|
example += " \"name\": \"" + fName + "\"\n";
|
|
example += "}";
|
|
} else {
|
|
example += " \"options\": {\n";
|
|
example += " \"width\": " + widthStr + ",\n";
|
|
example += " \"height\": " + heightStr + ",\n";
|
|
example += " \"source\": " + imageStr + ",\n";
|
|
example += " \"srgb\": " + srgbStr + ",\n";
|
|
example += " \"f16\": false,\n";
|
|
example += " \"textOnly\": " + textOutStr + ",\n";
|
|
example += " \"animated\": " + animatedStr + ",\n";
|
|
example += " \"duration\": " + durationStr + "\n";
|
|
example += " },\n";
|
|
example += " \"fast\": true";
|
|
}
|
|
}
|
|
*result = example;
|
|
return true;
|
|
}
|
|
|
|
string Definition::extractText(TrimExtract trimExtract) const {
|
|
string result;
|
|
TextParser parser(fFileName, fContentStart, fContentEnd, fLineCount);
|
|
int childIndex = 0;
|
|
char mc = '#';
|
|
while (parser.fChar < parser.fEnd) {
|
|
if (TrimExtract::kYes == trimExtract && !parser.skipWhiteSpace()) {
|
|
break;
|
|
}
|
|
if (parser.next() == mc) {
|
|
if (parser.next() == mc) {
|
|
if (parser.next() == mc) {
|
|
mc = parser.next();
|
|
}
|
|
} else {
|
|
// fixme : more work to do if # style comment is in text
|
|
// if in method definition, could be alternate method name
|
|
--parser.fChar;
|
|
if (' ' < parser.fChar[0]) {
|
|
if (islower(parser.fChar[0])) {
|
|
result += '\n';
|
|
parser.skipLine();
|
|
} else {
|
|
SkASSERT(isupper(parser.fChar[0]));
|
|
parser.skipTo(fChildren[childIndex]->fTerminator);
|
|
if (mc == parser.fChar[0] && mc == parser.fChar[1]) {
|
|
parser.next();
|
|
parser.next();
|
|
}
|
|
childIndex++;
|
|
}
|
|
} else {
|
|
parser.skipLine();
|
|
}
|
|
continue;
|
|
}
|
|
} else {
|
|
--parser.fChar;
|
|
}
|
|
const char* end = parser.fEnd;
|
|
const char* mark = parser.strnchr(mc, end);
|
|
if (mark) {
|
|
end = mark;
|
|
}
|
|
string fragment(parser.fChar, end - parser.fChar);
|
|
trim_end(fragment);
|
|
if (TrimExtract::kYes == trimExtract) {
|
|
trim_start(fragment);
|
|
if (result.length()) {
|
|
result += '\n';
|
|
result += '\n';
|
|
}
|
|
}
|
|
if (TrimExtract::kYes == trimExtract || has_nonwhitespace(fragment)) {
|
|
result += fragment;
|
|
}
|
|
parser.skipTo(end);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void space_pad(string* str) {
|
|
size_t len = str->length();
|
|
if (len == 0) {
|
|
return;
|
|
}
|
|
char last = (*str)[len - 1];
|
|
if ('~' == last || ' ' >= last) {
|
|
return;
|
|
}
|
|
*str += ' ';
|
|
}
|
|
|
|
//start here;
|
|
// see if it possible to abstract this a little bit so it can
|
|
// additionally be used to find params and return in method prototype that
|
|
// does not have corresponding doxygen comments
|
|
bool Definition::checkMethod() const {
|
|
SkASSERT(MarkType::kMethod == fMarkType);
|
|
// if method returns a value, look for a return child
|
|
// for each parameter, look for a corresponding child
|
|
const char* end = fContentStart;
|
|
while (end > fStart && ' ' >= end[-1]) {
|
|
--end;
|
|
}
|
|
TextParser methodParser(fFileName, fStart, end, fLineCount);
|
|
methodParser.skipWhiteSpace();
|
|
SkASSERT(methodParser.startsWith("#Method"));
|
|
methodParser.skipName("#Method");
|
|
methodParser.skipSpace();
|
|
string name = this->methodName();
|
|
if (MethodType::kNone == fMethodType && name.length() > 2 &&
|
|
"()" == name.substr(name.length() - 2)) {
|
|
name = name.substr(0, name.length() - 2);
|
|
}
|
|
bool expectReturn = this->methodHasReturn(name, &methodParser);
|
|
bool foundReturn = false;
|
|
bool foundException = false;
|
|
for (auto& child : fChildren) {
|
|
foundException |= MarkType::kDeprecated == child->fMarkType
|
|
|| MarkType::kExperimental == child->fMarkType;
|
|
if (MarkType::kReturn != child->fMarkType) {
|
|
if (MarkType::kParam == child->fMarkType) {
|
|
child->fVisited = false;
|
|
}
|
|
continue;
|
|
}
|
|
if (!expectReturn) {
|
|
return methodParser.reportError<bool>("no #Return expected");
|
|
}
|
|
if (foundReturn) {
|
|
return methodParser.reportError<bool>("multiple #Return markers");
|
|
}
|
|
foundReturn = true;
|
|
}
|
|
if (expectReturn && !foundReturn && !foundException) {
|
|
return methodParser.reportError<bool>("missing #Return marker");
|
|
}
|
|
const char* paren = methodParser.strnchr('(', methodParser.fEnd);
|
|
if (!paren) {
|
|
return methodParser.reportError<bool>("missing #Method function definition");
|
|
}
|
|
const char* nextEnd = paren;
|
|
do {
|
|
string paramName;
|
|
methodParser.fChar = nextEnd + 1;
|
|
methodParser.skipSpace();
|
|
if (!this->nextMethodParam(&methodParser, &nextEnd, ¶mName)) {
|
|
continue;
|
|
}
|
|
bool foundParam = false;
|
|
for (auto& child : fChildren) {
|
|
if (MarkType::kParam != child->fMarkType) {
|
|
continue;
|
|
}
|
|
if (paramName != child->fName) {
|
|
continue;
|
|
}
|
|
if (child->fVisited) {
|
|
return methodParser.reportError<bool>("multiple #Method param with same name");
|
|
}
|
|
child->fVisited = true;
|
|
if (foundParam) {
|
|
TextParser paramError(child);
|
|
return methodParser.reportError<bool>("multiple #Param with same name");
|
|
}
|
|
foundParam = true;
|
|
|
|
}
|
|
if (!foundParam && !foundException) {
|
|
return methodParser.reportError<bool>("no #Param found");
|
|
}
|
|
if (')' == nextEnd[0]) {
|
|
break;
|
|
}
|
|
} while (')' != nextEnd[0]);
|
|
for (auto& child : fChildren) {
|
|
if (MarkType::kParam != child->fMarkType) {
|
|
continue;
|
|
}
|
|
if (!child->fVisited) {
|
|
TextParser paramError(child);
|
|
return paramError.reportError<bool>("#Param without param in #Method");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Definition::crossCheck2(const Definition& includeToken) const {
|
|
TextParser parser(fFileName, fStart, fContentStart, fLineCount);
|
|
parser.skipExact("#");
|
|
bool isMethod = parser.skipName("Method");
|
|
const char* contentEnd;
|
|
if (isMethod) {
|
|
contentEnd = fContentStart;
|
|
} else if (parser.skipName("DefinedBy")) {
|
|
contentEnd = fContentEnd;
|
|
while (parser.fChar < contentEnd && ' ' >= contentEnd[-1]) {
|
|
--contentEnd;
|
|
}
|
|
if (parser.fChar < contentEnd - 1 && ')' == contentEnd[-1] && '(' == contentEnd[-2]) {
|
|
contentEnd -= 2;
|
|
}
|
|
} else {
|
|
return parser.reportError<bool>("unexpected crosscheck marktype");
|
|
}
|
|
return crossCheckInside(parser.fChar, contentEnd, includeToken);
|
|
}
|
|
|
|
bool Definition::crossCheck(const Definition& includeToken) const {
|
|
return crossCheckInside(fContentStart, fContentEnd, includeToken);
|
|
}
|
|
|
|
bool Definition::crossCheckInside(const char* start, const char* end,
|
|
const Definition& includeToken) const {
|
|
TextParser def(fFileName, start, end, fLineCount);
|
|
TextParser inc("", includeToken.fContentStart, includeToken.fContentEnd, 0);
|
|
if (inc.startsWith("SK_API")) {
|
|
inc.skipWord("SK_API");
|
|
}
|
|
if (inc.startsWith("friend")) {
|
|
inc.skipWord("friend");
|
|
}
|
|
if (inc.startsWith("SK_API")) {
|
|
inc.skipWord("SK_API");
|
|
}
|
|
inc.skipExact("SkDEBUGCODE(");
|
|
do {
|
|
bool defEof;
|
|
bool incEof;
|
|
do {
|
|
defEof = def.eof() || !def.skipWhiteSpace();
|
|
incEof = inc.eof() || !inc.skipWhiteSpace();
|
|
if (!incEof && '/' == inc.peek() && (defEof || '/' != def.peek())) {
|
|
inc.next();
|
|
if ('*' == inc.peek()) {
|
|
inc.skipToEndBracket("*/");
|
|
inc.next();
|
|
} else if ('/' == inc.peek()) {
|
|
inc.skipToEndBracket('\n');
|
|
}
|
|
} else if (!incEof && '#' == inc.peek() && (defEof || '#' != def.peek())) {
|
|
inc.next();
|
|
if (inc.startsWith("if")) {
|
|
inc.skipToEndBracket("\n");
|
|
} else if (inc.startsWith("endif")) {
|
|
inc.skipToEndBracket("\n");
|
|
} else {
|
|
SkASSERT(0); // incomplete
|
|
return false;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
inc.next();
|
|
} while (true);
|
|
if (defEof || incEof) {
|
|
if (defEof == incEof || (!defEof && ';' == def.peek())) {
|
|
return true;
|
|
}
|
|
return false; // allow setting breakpoint on failure
|
|
}
|
|
char defCh;
|
|
do {
|
|
defCh = def.next();
|
|
char incCh = inc.next();
|
|
if (' ' >= defCh && ' ' >= incCh) {
|
|
break;
|
|
}
|
|
if (defCh != incCh) {
|
|
if ('_' != defCh || ' ' != incCh || !fOperatorConst || !def.startsWith("const")) {
|
|
return false;
|
|
}
|
|
}
|
|
if (';' == defCh) {
|
|
return true;
|
|
}
|
|
} while (!def.eof() && !inc.eof());
|
|
} while (true);
|
|
return false;
|
|
}
|
|
|
|
string Definition::formatFunction(Format format) const {
|
|
const char* end = fContentStart;
|
|
while (end > fStart && ' ' >= end[-1]) {
|
|
--end;
|
|
}
|
|
TextParser methodParser(fFileName, fStart, end, fLineCount);
|
|
methodParser.skipWhiteSpace();
|
|
SkASSERT(methodParser.startsWith("#Method"));
|
|
methodParser.skipName("#Method");
|
|
methodParser.skipSpace();
|
|
const char* lastStart = methodParser.fChar;
|
|
const int limit = 100; // todo: allow this to be set by caller or in global or something
|
|
string name = this->methodName();
|
|
const char* nameInParser = methodParser.strnstr(name.c_str(), methodParser.fEnd);
|
|
methodParser.skipTo(nameInParser);
|
|
const char* lastEnd = methodParser.fChar;
|
|
if (Format::kOmitReturn == format) {
|
|
lastStart = lastEnd;
|
|
}
|
|
const char* paren = methodParser.strnchr('(', methodParser.fEnd);
|
|
size_t indent;
|
|
if (paren) {
|
|
indent = (size_t) (paren - lastStart) + 1;
|
|
} else {
|
|
indent = (size_t) (lastEnd - lastStart);
|
|
}
|
|
// trim indent so longest line doesn't exceed box width
|
|
TextParser::Save savePlace(&methodParser);
|
|
const char* saveStart = lastStart;
|
|
ptrdiff_t maxLine = 0;
|
|
do {
|
|
const char* nextStart = lastEnd;
|
|
const char* delimiter = methodParser.anyOf(",)");
|
|
const char* nextEnd = delimiter ? delimiter : methodParser.fEnd;
|
|
if (delimiter) {
|
|
while (nextStart < nextEnd && ' ' >= nextStart[0]) {
|
|
++nextStart;
|
|
}
|
|
}
|
|
while (nextEnd > nextStart && ' ' >= nextEnd[-1]) {
|
|
--nextEnd;
|
|
}
|
|
if (delimiter) {
|
|
nextEnd += 1;
|
|
delimiter += 1;
|
|
}
|
|
if (lastEnd > lastStart) {
|
|
maxLine = SkTMax(maxLine, lastEnd - lastStart);
|
|
}
|
|
if (delimiter) {
|
|
methodParser.skipTo(delimiter);
|
|
}
|
|
lastStart = nextStart;
|
|
lastEnd = nextEnd;
|
|
} while (lastStart < lastEnd);
|
|
savePlace.restore();
|
|
lastStart = saveStart;
|
|
lastEnd = methodParser.fChar;
|
|
indent = SkTMin(indent, (size_t) (limit - maxLine));
|
|
// write string wtih trimmmed indent
|
|
string methodStr;
|
|
int written = 0;
|
|
do {
|
|
const char* nextStart = lastEnd;
|
|
SkASSERT(written < limit);
|
|
const char* delimiter = methodParser.anyOf(",)");
|
|
const char* nextEnd = delimiter ? delimiter : methodParser.fEnd;
|
|
if (delimiter) {
|
|
while (nextStart < nextEnd && ' ' >= nextStart[0]) {
|
|
++nextStart;
|
|
}
|
|
}
|
|
while (nextEnd > nextStart && ' ' >= nextEnd[-1]) {
|
|
--nextEnd;
|
|
}
|
|
if (delimiter) {
|
|
nextEnd += 1;
|
|
delimiter += 1;
|
|
}
|
|
if (lastEnd > lastStart) {
|
|
if (lastStart[0] != ' ') {
|
|
space_pad(&methodStr);
|
|
}
|
|
methodStr += string(lastStart, (size_t) (lastEnd - lastStart));
|
|
written += (size_t) (lastEnd - lastStart);
|
|
}
|
|
if (delimiter) {
|
|
if (nextEnd - nextStart >= (ptrdiff_t) (limit - written)) {
|
|
written = indent;
|
|
if (Format::kIncludeReturn == format) {
|
|
methodStr += '\n';
|
|
methodStr += string(indent, ' ');
|
|
}
|
|
}
|
|
methodParser.skipTo(delimiter);
|
|
}
|
|
lastStart = nextStart;
|
|
lastEnd = nextEnd;
|
|
} while (lastStart < lastEnd);
|
|
return methodStr;
|
|
}
|
|
|
|
string Definition::fiddleName() const {
|
|
string result;
|
|
size_t start = 0;
|
|
string parent;
|
|
const Definition* parentDef = this;
|
|
while ((parentDef = parentDef->fParent)) {
|
|
if (MarkType::kClass == parentDef->fMarkType || MarkType::kStruct == parentDef->fMarkType) {
|
|
parent = parentDef->fFiddle;
|
|
break;
|
|
}
|
|
}
|
|
if (parent.length() && 0 == fFiddle.compare(0, parent.length(), parent)) {
|
|
start = parent.length();
|
|
while (start < fFiddle.length() && '_' == fFiddle[start]) {
|
|
++start;
|
|
}
|
|
}
|
|
size_t end = fFiddle.find_first_of('(', start);
|
|
return fFiddle.substr(start, end - start);
|
|
}
|
|
|
|
const Definition* Definition::findClone(string match) const {
|
|
for (auto child : fChildren) {
|
|
if (!child->fClone) {
|
|
continue;
|
|
}
|
|
if (match == child->fName) {
|
|
return child;
|
|
}
|
|
auto inner = child->findClone(match);
|
|
if (inner) {
|
|
return inner;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const Definition* Definition::hasChild(MarkType markType) const {
|
|
for (auto iter : fChildren) {
|
|
if (markType == iter->fMarkType) {
|
|
return iter;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const Definition* Definition::hasParam(const string& ref) const {
|
|
SkASSERT(MarkType::kMethod == fMarkType);
|
|
for (auto iter : fChildren) {
|
|
if (MarkType::kParam != iter->fMarkType) {
|
|
continue;
|
|
}
|
|
if (iter->fName == ref) {
|
|
return &*iter;
|
|
}
|
|
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool Definition::hasMatch(const string& name) const {
|
|
for (auto child : fChildren) {
|
|
if (name == child->fName) {
|
|
return true;
|
|
}
|
|
if (child->hasMatch(name)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Definition::isStructOrClass() const {
|
|
if (MarkType::kStruct != fMarkType && MarkType::kClass != fMarkType) {
|
|
return false;
|
|
}
|
|
if (string::npos != fFileName.find("undocumented.bmh")) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Definition::methodHasReturn(const string& name, TextParser* methodParser) const {
|
|
if (methodParser->skipExact("static")) {
|
|
methodParser->skipWhiteSpace();
|
|
}
|
|
const char* lastStart = methodParser->fChar;
|
|
const char* nameInParser = methodParser->strnstr(name.c_str(), methodParser->fEnd);
|
|
methodParser->skipTo(nameInParser);
|
|
const char* lastEnd = methodParser->fChar;
|
|
const char* returnEnd = lastEnd;
|
|
while (returnEnd > lastStart && ' ' == returnEnd[-1]) {
|
|
--returnEnd;
|
|
}
|
|
bool expectReturn = 4 != returnEnd - lastStart || strncmp("void", lastStart, 4);
|
|
if (MethodType::kNone != fMethodType && MethodType::kOperator != fMethodType && !expectReturn) {
|
|
return methodParser->reportError<bool>("unexpected void");
|
|
}
|
|
switch (fMethodType) {
|
|
case MethodType::kNone:
|
|
case MethodType::kOperator:
|
|
// either is fine
|
|
break;
|
|
case MethodType::kConstructor:
|
|
expectReturn = true;
|
|
break;
|
|
case MethodType::kDestructor:
|
|
expectReturn = false;
|
|
break;
|
|
}
|
|
return expectReturn;
|
|
}
|
|
|
|
string Definition::methodName() const {
|
|
string result;
|
|
size_t start = 0;
|
|
string parent;
|
|
const Definition* parentDef = this;
|
|
while ((parentDef = parentDef->fParent)) {
|
|
if (MarkType::kClass == parentDef->fMarkType || MarkType::kStruct == parentDef->fMarkType) {
|
|
parent = parentDef->fName;
|
|
break;
|
|
}
|
|
}
|
|
if (parent.length() && 0 == fName.compare(0, parent.length(), parent)) {
|
|
start = parent.length();
|
|
while (start < fName.length() && ':' == fName[start]) {
|
|
++start;
|
|
}
|
|
}
|
|
if (fClone) {
|
|
int lastUnder = fName.rfind('_');
|
|
return fName.substr(start, (size_t) (lastUnder - start));
|
|
}
|
|
size_t end = fName.find_first_of('(', start);
|
|
if (string::npos == end) {
|
|
return fName.substr(start);
|
|
}
|
|
return fName.substr(start, end - start);
|
|
}
|
|
|
|
bool Definition::nextMethodParam(TextParser* methodParser, const char** nextEndPtr,
|
|
string* paramName) const {
|
|
int parenCount = 0;
|
|
TextParser::Save saveState(methodParser);
|
|
while (true) {
|
|
if (methodParser->eof()) {
|
|
return methodParser->reportError<bool>("#Method function missing close paren");
|
|
}
|
|
char ch = methodParser->peek();
|
|
if ('(' == ch) {
|
|
++parenCount;
|
|
}
|
|
if (parenCount == 0 && (')' == ch || ',' == ch)) {
|
|
*nextEndPtr = methodParser->fChar;
|
|
break;
|
|
}
|
|
if (')' == ch) {
|
|
if (0 > --parenCount) {
|
|
return this->reportError<bool>("mismatched parentheses");
|
|
}
|
|
}
|
|
methodParser->next();
|
|
}
|
|
saveState.restore();
|
|
const char* nextEnd = *nextEndPtr;
|
|
const char* paramEnd = nextEnd;
|
|
const char* assign = methodParser->strnstr(" = ", paramEnd);
|
|
if (assign) {
|
|
paramEnd = assign;
|
|
}
|
|
const char* closeBracket = methodParser->strnstr("]", paramEnd);
|
|
if (closeBracket) {
|
|
const char* openBracket = methodParser->strnstr("[", paramEnd);
|
|
if (openBracket && openBracket < closeBracket) {
|
|
while (openBracket < --closeBracket && isdigit(closeBracket[0]))
|
|
;
|
|
if (openBracket == closeBracket) {
|
|
paramEnd = openBracket;
|
|
}
|
|
}
|
|
}
|
|
const char* function = methodParser->strnstr(")(", paramEnd);
|
|
if (function) {
|
|
paramEnd = function;
|
|
}
|
|
while (paramEnd > methodParser->fChar && ' ' == paramEnd[-1]) {
|
|
--paramEnd;
|
|
}
|
|
const char* paramStart = paramEnd;
|
|
while (paramStart > methodParser->fChar && isalnum(paramStart[-1])) {
|
|
--paramStart;
|
|
}
|
|
if (paramStart > methodParser->fChar && paramStart >= paramEnd) {
|
|
return methodParser->reportError<bool>("#Method missing param name");
|
|
}
|
|
*paramName = string(paramStart, paramEnd - paramStart);
|
|
if (!paramName->length()) {
|
|
if (')' != nextEnd[0]) {
|
|
return methodParser->reportError<bool>("#Method malformed param");
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
string Definition::NormalizedName(string name) {
|
|
string normalizedName = name;
|
|
std::replace(normalizedName.begin(), normalizedName.end(), '-', '_');
|
|
do {
|
|
size_t doubleColon = normalizedName.find("::", 0);
|
|
if (string::npos == doubleColon) {
|
|
break;
|
|
}
|
|
normalizedName = normalizedName.substr(0, doubleColon)
|
|
+ '_' + normalizedName.substr(doubleColon + 2);
|
|
} while (true);
|
|
return normalizedName;
|
|
}
|
|
|
|
static string unpreformat(const string& orig) {
|
|
string result;
|
|
int amp = 0;
|
|
for (auto c : orig) {
|
|
switch (amp) {
|
|
case 0:
|
|
if ('&' == c) {
|
|
amp = 1;
|
|
} else {
|
|
amp = 0;
|
|
result += c;
|
|
}
|
|
break;
|
|
case 1:
|
|
if ('l' == c) {
|
|
amp = 2;
|
|
} else if ('g' == c) {
|
|
amp = 3;
|
|
} else {
|
|
amp = 0;
|
|
result += "&";
|
|
result += c;
|
|
}
|
|
break;
|
|
case 2:
|
|
if ('t' == c) {
|
|
amp = 4;
|
|
} else {
|
|
amp = 0;
|
|
result += "&l";
|
|
result += c;
|
|
}
|
|
break;
|
|
case 3:
|
|
if ('t' == c) {
|
|
amp = 5;
|
|
} else {
|
|
amp = 0;
|
|
result += "&g";
|
|
result += c;
|
|
}
|
|
break;
|
|
case 4:
|
|
if (';' == c) {
|
|
result += '<';
|
|
} else {
|
|
result += "<";
|
|
result += c;
|
|
}
|
|
amp = 0;
|
|
break;
|
|
case 5:
|
|
if (';' == c) {
|
|
result += '>';
|
|
} else {
|
|
result += ">";
|
|
result += c;
|
|
}
|
|
amp = 0;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool Definition::paramsMatch(const string& matchFormatted, const string& name) const {
|
|
if (string::npos != matchFormatted.find("readPixels")) {
|
|
SkDebugf("");
|
|
}
|
|
string match = unpreformat(matchFormatted);
|
|
TextParser def(fFileName, fStart, fContentStart, fLineCount);
|
|
const char* dName = def.strnstr(name.c_str(), fContentStart);
|
|
if (!dName) {
|
|
return false;
|
|
}
|
|
def.skipTo(dName);
|
|
TextParser m(fFileName, &match.front(), &match.back() + 1, fLineCount);
|
|
const char* mName = m.strnstr(name.c_str(), m.fEnd);
|
|
if (!mName) {
|
|
return false;
|
|
}
|
|
m.skipTo(mName);
|
|
while (!def.eof() && ')' != def.peek() && !m.eof() && ')' != m.peek()) {
|
|
const char* ds = def.fChar;
|
|
const char* ms = m.fChar;
|
|
const char* de = def.anyOf(") \n");
|
|
const char* me = m.anyOf(") \n");
|
|
def.skipTo(de);
|
|
m.skipTo(me);
|
|
if (def.fChar - ds != m.fChar - ms) {
|
|
return false;
|
|
}
|
|
if (strncmp(ds, ms, (int) (def.fChar - ds))) {
|
|
return false;
|
|
}
|
|
def.skipWhiteSpace();
|
|
m.skipWhiteSpace();
|
|
}
|
|
return !def.eof() && ')' == def.peek() && !m.eof() && ')' == m.peek();
|
|
}
|
|
|
|
void RootDefinition::clearVisited() {
|
|
fVisited = false;
|
|
for (auto& leaf : fLeaves) {
|
|
leaf.second.fVisited = false;
|
|
}
|
|
for (auto& branch : fBranches) {
|
|
branch.second->clearVisited();
|
|
}
|
|
}
|
|
|
|
bool RootDefinition::dumpUnVisited() {
|
|
bool success = true;
|
|
for (auto& leaf : fLeaves) {
|
|
if (!leaf.second.fVisited) {
|
|
// FIXME: bugs requiring long tail fixes, suppressed here:
|
|
// SkBitmap::validate() is wrapped in SkDEBUGCODE in .h and not parsed
|
|
if ("SkBitmap::validate()" == leaf.first) {
|
|
continue;
|
|
}
|
|
// SkPath::pathRefIsValid in #ifdef ; prefer to remove chrome dependency to fix
|
|
if ("SkPath::pathRefIsValid" == leaf.first) {
|
|
continue;
|
|
}
|
|
// FIXME: end of long tail bugs
|
|
SkDebugf("defined in bmh but missing in include: %s\n", leaf.first.c_str());
|
|
success = false;
|
|
}
|
|
}
|
|
for (auto& branch : fBranches) {
|
|
success &= branch.second->dumpUnVisited();
|
|
}
|
|
return success;
|
|
}
|
|
|
|
const Definition* RootDefinition::find(const string& ref, AllowParens allowParens) const {
|
|
const auto leafIter = fLeaves.find(ref);
|
|
if (leafIter != fLeaves.end()) {
|
|
return &leafIter->second;
|
|
}
|
|
if (AllowParens::kYes == allowParens && string::npos == ref.find("()")) {
|
|
string withParens = ref + "()";
|
|
const auto parensIter = fLeaves.find(withParens);
|
|
if (parensIter != fLeaves.end()) {
|
|
return &parensIter->second;
|
|
}
|
|
}
|
|
const auto branchIter = fBranches.find(ref);
|
|
if (branchIter != fBranches.end()) {
|
|
const RootDefinition* rootDef = branchIter->second;
|
|
return rootDef;
|
|
}
|
|
const Definition* result = nullptr;
|
|
for (const auto& branch : fBranches) {
|
|
const RootDefinition* rootDef = branch.second;
|
|
result = rootDef->find(ref, allowParens);
|
|
if (result) {
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|