bool QsCodeParser::makeFunctionNode(const QString& synopsis,
QStringList *parentPathPtr,
FunctionNode **funcPtr)
{
QRegExp funcRegExp(
"\\s*([A-Za-z0-9_]+)\\.([A-Za-z0-9_]+)\\s*\\((" +
balancedParens +
")\\)(?:\\s*:\\s*([A-Za-z0-9_]+))?\\s*");
QRegExp paramRegExp(
"\\s*(\\[)?\\s*(?:([A-Za-z0-9_]+)\\s*:\\s*)?"
"([A-Za-z0-9_]+|\\.\\.\\.)\\s*(\\[)?[\\s\\]]*");
if (!funcRegExp.exactMatch(synopsis))
return false;
ClassNode *classe = (ClassNode*)
qsTre->findNode(QStringList(funcRegExp.cap(1)),Node::Class);
if (classe == 0)
return false;
FunctionNode *clone = new FunctionNode(0, funcRegExp.cap(2));
bool optional = false;
QString paramStr = funcRegExp.cap(3);
QStringList params = paramStr.split(",");
QStringList::ConstIterator p = params.begin();
while (p != params.end()) {
if (paramRegExp.exactMatch(*p)) {
if (!paramRegExp.cap(1).isEmpty())
optional = true;
clone->addParameter(Parameter(paramRegExp.cap(3),
"",
paramRegExp.cap(2),
optional ? "undefined" : ""));
if (!paramRegExp.cap(4).isEmpty())
optional = true;
}
else {
delete clone;
return false;
}
++p;
}
QString returnType = funcRegExp.cap(4);
if (!returnType.isEmpty())
clone->setReturnType(returnType);
if (parentPathPtr != 0)
*parentPathPtr = QStringList() << classe->name();
if (funcPtr != 0) {
*funcPtr = clone;
}
else {
delete clone;
}
return true;
}
void DebugPrintVisitor::visit(ClassNode& cl)
{
os << "[Class]" << cl.name() << getPositionString(cl) << std::endl;
}
void QsCodeParser::quickifyClass(ClassNode *quickClass)
{
QString qtClassName = quickClass->name();
QString bare = quickClass->name();
if (bare != "Qt" && bare != "Object") {
if (bare.startsWith("Q")) {
bare = bare.mid(1);
}
else {
qtClassName.prepend("Q");
classesWithNoQ.insert(bare);
}
}
ClassNode *qtClass = 0;
ClassNode *wrapperClass = 0;
if ((wrapperClass = tryClass("Quick" + bare)) != 0 ||
(wrapperClass = tryClass("QS" + bare + "Class")) != 0) {
qtClass = tryClass(qtClassName);
if (qtClass == 0) {
qtClass = wrapperClass;
wrapperClass = 0;
}
}
else if ((wrapperClass = tryClass("Quick" + bare + "Ptr")) != 0) {
QRegExp ptrToQtType("(Q[A-Za-z0-9_]+)\\s*\\*");
FunctionNode *ctor =
wrapperClass->findFunctionNode(wrapperClass->name());
if (ctor != 0 && !ctor->parameters().isEmpty() &&
ptrToQtType.exactMatch(ctor->parameters().first().leftType()))
qtClassName = ptrToQtType.cap(1);
qtClass = tryClass(qtClassName);
}
else {
wrapperClass = tryClass("Q" + bare + "Ptr");
if (wrapperClass == 0)
wrapperClass = tryClass("Quick" + bare + "Interface");
qtClass = tryClass(qtClassName);
}
if (qtClass == 0) {
if (wrapperClass == 0) {
quickClass->location().warning(tr("Cannot find Qt class '%1'")
.arg(qtClassName));
}
else {
quickClass->location().warning(tr("Cannot find Qt class '%1'"
" wrapped by '%2'")
.arg(qtClassName)
.arg(wrapperClass->name()));
}
return;
}
QList<RelatedClass>::ConstIterator r = qtClass->baseClasses().begin();
while (r != qtClass->baseClasses().end()) {
ClassNode *quickBaseClass = cpp2qs.findClassNode(qsTre,
(*r).node->name());
if (quickBaseClass)
quickClass->addBaseClass((*r).access, quickBaseClass);
++r;
}
if (quickClass->baseClasses().isEmpty() && quickClass->name() != "Object")
quickClass->addBaseClass(Node::Public,
cpp2qs.findClassNode(qsTre,"Object"));
QSet<QString> funcBlackList;
QSet<QString> propertyBlackList;
NodeList children;
if (wrapperClass != 0) {
children = wrapperClass->childNodes();
funcBlackList.insert(wrapperClass->name());
funcBlackList.insert("~" + wrapperClass->name());
}
children += qtClass->childNodes();
for (int pass = 0; pass < 2; pass++) {
NodeList::ConstIterator c = children.begin();
while (c != children.end()) {
if ((*c)->access() != Node::Private &&
(*c)->status() == Node::Commendable) {
if (pass == 0) {
if ((*c)->type() == Node::Enum) {
EnumNode *enume = (EnumNode *) *c;
quickifyEnum(quickClass, enume);
}
else if ((*c)->type() == Node::Property) {
if (!propertyBlackList.contains((*c)->name())) {
PropertyNode *property = (PropertyNode *) *c;
quickifyProperty(quickClass, qtClass, property);
if (!property->getters().isEmpty())
funcBlackList.insert(property->getters().first()->name());
if (!property->setters().isEmpty())
funcBlackList.insert(property->setters().first()->name());
if (!property->resetters().isEmpty())
funcBlackList.insert(property->resetters().first()->name());
propertyBlackList.insert(property->name());
}
}
}
else if ((*c)->type() == Node::Function) {
FunctionNode *func = (FunctionNode *) *c;
quickifyFunction(quickClass, qtClass, func,
funcBlackList.contains((*c)->name()) &&
func->parameters().count() < 2);
}
}
++c;
}
}
setQtDoc(quickClass, qtClass->doc());
classesWithNoQuickDoc.insert(quickClass->name(), quickClass);
}
