}
}
+/*!
+ Returns true if the file being parsed is a .h file.
+ */
+bool CodeParser::isParsingH() const
+{
+ return currentFile_.endsWith(".h");
+}
+
+/*!
+ Returns true if the file being parsed is a .cpp file.
+ */
+bool CodeParser::isParsingCpp() const
+{
+ return currentFile_.endsWith(".cpp");
+}
+
+/*!
+ Returns true if the file being parsed is a .qdoc file.
+ */
+bool CodeParser::isParsingQdoc() const
+{
+ return currentFile_.endsWith(".qdoc");
+}
+
QT_END_NAMESPACE
virtual void doneParsingHeaderFiles(Tree *tree);
virtual void doneParsingSourceFiles(Tree *tree) = 0;
+ bool isParsingH() const;
+ bool isParsingCpp() const;
+ bool isParsingQdoc() const;
+ const QString& currentFile() const { return currentFile_; }
+
void createOutputSubdirectory(const Location& location, const QString& filePath);
static void initialize(const Config& config);
static void extractPageLinkAndDesc(const QString& arg,
QString* link,
QString* desc);
+ QString currentFile_;
private:
static QString currentSubDir_;
Tree *tree)
{
QFile in(filePath);
+ currentFile_ = filePath;
if (!in.open(QIODevice::ReadOnly)) {
location.error(tr("Cannot open C++ header file '%1'").arg(filePath));
+ currentFile_.clear();
return;
}
createOutputSubdirectory(location, filePath);
if (fileLocation.fileName() == "qiterator.h")
parseQiteratorDotH(location, filePath);
+ currentFile_.clear();
}
/*!
Tree *tree)
{
QFile in(filePath);
+ currentFile_ = filePath;
if (!in.open(QIODevice::ReadOnly)) {
location.error(tr("Cannot open C++ source file '%1' (%2)").arg(filePath).arg(strerror(errno)));
+ currentFile_.clear();
return;
}
createOutputSubdirectory(location, filePath);
matchDocsAndStuff();
in.close();
+ currentFile_.clear();
}
/*!
}
/*!
- Process the topic \a command in context \a doc with argument \a arg.
+ Process the topic \a command found in the \a doc with argument \a arg.
*/
Node* CppCodeParser::processTopicCommand(const Doc& doc,
const QString& command,
if (!makeFunctionNode(arg.first, &parentPath, &clone) &&
!makeFunctionNode("void " + arg.first, &parentPath, &clone)) {
- arg.second.warning(tr("Invalid syntax in '\\%1'").arg(COMMAND_FN));
+ doc.startLocation().warning(tr("Invalid syntax in '\\%1'").arg(COMMAND_FN));
}
else {
if (!activeNamespaces_.isEmpty()) {
if (makeFunctionNode(arg.first, &parentPath, &func, tree_->root())) {
if (!parentPath.isEmpty()) {
- arg.second.warning(tr("Invalid syntax in '\\%1'").arg(COMMAND_MACRO));
+ doc.startLocation().warning(tr("Invalid syntax in '\\%1'").arg(COMMAND_MACRO));
delete func;
func = 0;
}
else if (QRegExp("[A-Za-z_][A-Za-z0-9_]+").exactMatch(arg.first)) {
func = new FunctionNode(tree_->root(), arg.first);
func->setAccess(Node::Public);
- func->setLocation(arg.second);
+ func->setLocation(doc.startLocation());
func->setMetaness(FunctionNode::MacroWithoutParams);
}
else {
else if (command == COMMAND_EXAMPLE) {
if (Config::generateExamples) {
ExampleNode* en = new ExampleNode(tree_->root(), arg.first);
- en->setLocation(arg.second);
+ en->setLocation(doc.startLocation());
createExampleFileNodes(en);
return en;
}
}
else if (command == COMMAND_EXTERNALPAGE) {
FakeNode* fn = new FakeNode(tree_->root(), arg.first, Node::ExternalPage, Node::ArticlePage);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_FILE) {
FakeNode* fn = new FakeNode(tree_->root(), arg.first, Node::File, Node::NoPageType);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_GROUP) {
FakeNode* fn = new FakeNode(tree_->root(), arg.first, Node::Group, Node::OverviewPage);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_HEADERFILE) {
FakeNode* fn = new FakeNode(tree_->root(), arg.first, Node::HeaderFile, Node::ApiPage);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_MODULE) {
FakeNode* fn = new FakeNode(tree_->root(), arg.first, Node::Module, Node::OverviewPage);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_QMLMODULE) {
FakeNode* fn = FakeNode::lookupQmlModuleNode(tree_, arg);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_PAGE) {
fn = new DitaMapNode(tree_->root(), args[0]);
else
fn = new FakeNode(tree_->root(), args[0], Node::Page, ptype);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
if (ncn) {
ncn->addCollision(fn);
}
}
else if (command == COMMAND_DITAMAP) {
FakeNode* fn = new DitaMapNode(tree_->root(), arg.first);
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
else if (command == COMMAND_QMLCLASS) {
*/
NameCollisionNode* ncn = tree_->checkForCollision(names[0]);
QmlClassNode* qcn = new QmlClassNode(tree_->root(), names[0], classNode);
- qcn->setLocation(arg.second);
+ qcn->setLocation(doc.startLocation());
+ if (isParsingCpp() || isParsingQdoc()) {
+ qcn->requireCppClass();
+ if (names.size() < 2) {
+ QString msg = "C++ class name not specified for class documented as "
+ "QML type: '\\qmlclass " + arg.first + " <class name>'";
+ doc.startLocation().warning(tr(msg.toLatin1().data()));
+ }
+ else if (!classNode) {
+ QString msg = "C++ class not found in any .h file for class documented "
+ "as QML type: '\\qmlclass " + arg.first + "'";
+ doc.startLocation().warning(tr(msg.toLatin1().data()));
+ }
+ }
if (ncn)
ncn->addCollision(qcn);
return qcn;
}
else if (command == COMMAND_QMLBASICTYPE) {
QmlBasicTypeNode* n = new QmlBasicTypeNode(tree_->root(), arg.first);
- n->setLocation(arg.second);
+ n->setLocation(doc.startLocation());
return n;
}
else if ((command == COMMAND_QMLSIGNAL) ||
attached,
command);
if (fn)
- fn->setLocation(arg.second);
+ fn->setLocation(doc.startLocation());
return fn;
}
}
}
/*!
- Process the topic \a command group with arguments \a args.
+ Process the topic \a command group found in the \a doc with arguments \a args.
Currently, this function is called only for \e{qmlproperty}
and \e{qmlattachedproperty}.
*/
-Node *CppCodeParser::processTopicCommandGroup(const QString& command, const ArgList& args)
+Node* CppCodeParser::processTopicCommandGroup(const Doc& doc,
+ const QString& command,
+ const ArgList& args)
{
QmlPropGroupNode* qmlPropGroup = 0;
if ((command == COMMAND_QMLPROPERTY) ||
qmlClass = tree_->findQmlClassNode(module,element);
if (qmlClass) {
qmlPropGroup = new QmlPropGroupNode(qmlClass,property); //,attached);
- qmlPropGroup->setLocation(location());
+ qmlPropGroup->setLocation(doc.startLocation());
}
}
if (qmlPropGroup) {
- const PropertyNode *correspondingProperty = 0;
if (qmlClass->hasProperty(property)) {
- location().warning(tr("QML property documented multiple times: '%1'").arg(arg));
+ doc.startLocation().warning(tr("QML property documented multiple times: '%1'").arg(arg));
}
else {
- ClassNode *correspondingClass = static_cast<QmlClassNode*>(qmlPropGroup->parent())->classNode();
QmlPropertyNode *qmlPropNode = new QmlPropertyNode(qmlPropGroup,property,type,attached);
- qmlPropNode->setLocation(location());
- qmlPropNode->setQPropertyFlag();
-
- if (correspondingClass) {
- correspondingProperty = qmlPropNode->correspondingProperty(tree_);
- }
- if (correspondingProperty) {
- bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
- qmlPropNode->setReadOnly(!(writableList || correspondingProperty->isWritable()));
- }
+ qmlPropNode->setLocation(doc.startLocation());
}
++argsIter;
while (argsIter != args.constEnd()) {
arg = argsIter->first;
if (splitQmlPropertyArg(arg,type,module,element,property)) {
if (qmlClass->hasProperty(property)) {
- location().warning(tr("QML property documented multiple times: '%1'").arg(arg));
+ doc.startLocation().warning(tr("QML property documented multiple times: '%1'").arg(arg));
}
else {
QmlPropertyNode* qmlPropNode = new QmlPropertyNode(qmlPropGroup,
property,
type,
attached);
- qmlPropNode->setLocation(location());
- qmlPropNode->setQPropertyFlag();
- if (correspondingProperty) {
- bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
- qmlPropNode->setReadOnly(!(writableList || correspondingProperty->isWritable()));
- }
+ qmlPropNode->setLocation(doc.startLocation());
}
}
++argsIter;
if ((topic == COMMAND_QMLPROPERTY) ||
(topic == COMMAND_QMLATTACHEDPROPERTY)) {
Doc nodeDoc = doc;
- Node *node = processTopicCommandGroup(topic,args);
+ Node *node = processTopicCommandGroup(nodeDoc, topic,args);
if (node != 0) {
nodes.append(node);
docs.append(nodeDoc);
protected:
virtual QSet<QString> topicCommands();
- virtual Node *processTopicCommand(const Doc& doc,
+ virtual Node* processTopicCommand(const Doc& doc,
const QString& command,
const ArgLocPair& arg);
- virtual Node *processTopicCommandGroup(const QString& command, const ArgList& args);
+ virtual Node *processTopicCommandGroup(const Doc& doc,
+ const QString& command,
+ const ArgList& args);
bool splitQmlPropertyArg(const QString& arg,
QString& type,
QString& module,
priv->text.stripFirstAtom();
}
+/*!
+ Returns the current location.
+ */
Location &DocParser::location()
{
while (!openedInputs.isEmpty() && openedInputs.top() <= pos) {
return priv == 0 ? dummy : priv->start_loc;
}
+/*!
+ Returns the starting location of a qdoc comment.
+ */
+const Location& Doc::startLocation() const
+{
+ return location();
+}
+
+/*!
+ Returns the ending location of a qdoc comment.
+ */
+const Location& Doc::endLocation() const
+{
+ static const Location dummy;
+ return priv == 0 ? dummy : priv->end_loc;
+}
+
const QString &Doc::source() const
{
static QString null;
const DitaRefList& ditamap() const;
const Location &location() const;
+ const Location& startLocation() const;
+ const Location& endLocation() const;
bool isEmpty() const;
const QString& source() const;
const Text& body() const;
out() << "<td class=\"tblQmlPropNode\"><p>";
out() << "<a name=\"" + refForNode(qpn) + "\"></a>";
- if (!qpn->isReadOnlySet())
- qpn->setReadOnly(!qpn->isWritable(tree_));
- if (qpn->isReadOnly())
+ if (!qpn->isWritable(tree_))
out() << "<span class=\"qmlreadonly\">read-only</span>";
if (qpn->isDefault())
out() << "<span class=\"qmldefault\">default</span>";
QSet<QString> excludedDirs;
QSet<QString> excludedFiles;
- QSet<QString> headers;
- QSet<QString> sources;
QStringList headerList;
QStringList sourceList;
QStringList excludedDirsList;
}
headerList = config.getAllFiles(CONFIG_HEADERS,CONFIG_HEADERDIRS,excludedDirs,excludedFiles);
- headers = QSet<QString>::fromList(headerList);
+ QMap<QString,QString> headers;
+ for (int i=0; i<headerList.size(); ++i)
+ headers.insert(headerList[i],headerList[i]);
sourceList = config.getAllFiles(CONFIG_SOURCES,CONFIG_SOURCEDIRS,excludedDirs,excludedFiles);
- sources = QSet<QString>::fromList(sourceList);
-
+ QMap<QString,QString> sources;
+ for (int i=0; i<sourceList.size(); ++i)
+ sources.insert(sourceList[i],sourceList[i]);
+ QFile* files = new QFile("/Users/msmith/depot/qt5/qtdoc/files.out");
+ files->open(QFile::WriteOnly);
+ QTextStream* filesout = new QTextStream(files);
+#if 0
+ {
+ QSet<QString>::ConstIterator i = headers.begin();
+ while (i != headers.end()) {
+ //(*filesout) << (*i).mid((*i).lastIndexOf('/')+1) << "\n";
+ ++i;
+ }
+ i = sources.begin();
+ while (i != sources.end()) {
+ //(*filesout) << (*i).mid((*i).lastIndexOf('/')+1) << "\n";
+ ++i;
+ }
+ }
+ //filesout->flush();
+ //files->close();
+#endif
/*
Parse each header file in the set using the appropriate parser and add it
to the big tree.
*/
QSet<CodeParser *> usedParsers;
- QSet<QString>::ConstIterator h = headers.constBegin();
+ int parsed = 0;
+ QMap<QString,QString>::ConstIterator h = headers.constBegin();
while (h != headers.constEnd()) {
- CodeParser *codeParser = CodeParser::parserForHeaderFile(*h);
+ CodeParser *codeParser = CodeParser::parserForHeaderFile(h.key());
if (codeParser) {
- codeParser->parseHeaderFile(config.location(), *h, tree);
+ ++parsed;
+ codeParser->parseHeaderFile(config.location(), h.key(), tree);
usedParsers.insert(codeParser);
+ (*filesout) << (h.key()).mid((h.key()).lastIndexOf('/')+1) << "\n";
}
++h;
}
Parse each source text file in the set using the appropriate parser and
add it to the big tree.
*/
- QSet<QString>::ConstIterator s = sources.constBegin();
+ parsed = 0;
+ QMap<QString,QString>::ConstIterator s = sources.constBegin();
while (s != sources.constEnd()) {
- CodeParser *codeParser = CodeParser::parserForSourceFile(*s);
+ CodeParser *codeParser = CodeParser::parserForSourceFile(s.key());
if (codeParser) {
- codeParser->parseSourceFile(config.location(), *s, tree);
+ ++parsed;
+ codeParser->parseSourceFile(config.location(), s.key(), tree);
usedParsers.insert(codeParser);
+ (*filesout) << s.key().mid((s.key()).lastIndexOf('/')+1) << "\n";
}
++s;
}
+ filesout->flush();
+ files->close();
foreach (CodeParser *codeParser, usedParsers)
codeParser->doneParsingSourceFiles(tree);
: InnerNode(Class, parent, name)
{
hidden = false;
- abstract = false;
+ abstract_ = false;
qmlelement = 0;
setPageType(ApiPage);
}
const QString& name,
ClassNode* cn)
: FakeNode(parent, name, QmlClass, Node::ApiPage),
- abstract(false),
+ abstract_(false),
+ cnodeRequired_(false),
cnode_(cn),
base_(0)
{
return true;
}
else
- arg.second.warning(tr("Minor version number missing for '\\qmlmodule' or '\\inqmlmodule'; 0 assumed."));
+ arg.second.warning(tr("Minor version number must be included in second arg of '\\qmlmodule' and '\\inqmlmodule'; '.0' assumed."));
}
else
- arg.second.warning(tr("Module version number missing for '\\qmlmodule' or '\\inqmlmodule'; 1.0 assumed."));
+ arg.second.warning(tr("Module version number 'major.minor' must be second arg of '\\qmlmodule' and '\\inqmlmodule'; '1.0' assumed."));
return false;
}
designable_(FlagValueDefault),
isdefault_(false),
attached_(attached),
- qproperty_(false),
readOnly_(FlagValueDefault)
{
setPageType(ApiPage);
designable_(FlagValueDefault),
isdefault_(false),
attached_(attached),
- qproperty_(false),
readOnly_(FlagValueDefault)
{
setPageType(ApiPage);
designable_(FlagValueDefault),
isdefault_(false),
attached_(attached),
- qproperty_(false),
readOnly_(FlagValueDefault)
{
setPageType(ApiPage);
}
+#if 0
+ const PropertyNode *correspondingProperty = 0;
+ ClassNode *correspondingClass = static_cast<QmlClassNode*>(qmlPropGroup->parent())->classNode();
+ if (correspondingClass) {
+ correspondingProperty = qmlPropNode->correspondingProperty(tree_);
+ }
+ if (correspondingProperty) {
+ bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
+ qmlPropNode->setReadOnly(!(writableList || correspondingProperty->isWritable()));
+ }
+
+ if (correspondingProperty) {
+ bool writableList = type.startsWith("list") && correspondingProperty->dataType().endsWith('*');
+ qmlPropNode->setReadOnly(!(writableList || correspondingProperty->isWritable()));
+ }
+#endif
/*!
Returns true if a QML property or attached property is
- read-only. The algorithm for figuring this out is long
+ not read-only. The algorithm for figuring this out is long
amd tedious and almost certainly will break. It currently
- doesn't work for qmlproperty bool PropertyChanges::explicit,
- because the tokenizer gets confused on "explicit".
+ doesn't work for the qmlproperty:
+
+ \code
+ bool PropertyChanges::explicit,
+ \endcode
+
+ ...because the tokenizer gets confused on \e{explicit}.
*/
bool QmlPropertyNode::isWritable(Tree* tree)
{
if (readOnly_ != FlagValueDefault)
return !fromFlagValue(readOnly_, false);
- if (qproperty_) {
- PropertyNode* pn = correspondingProperty(tree);
- if (pn)
- return pn->isWritable();
-
- location().warning(tr("Can't detect if QML property %1::%2::%3 is read-only; "
- "writable assumed.")
- .arg(qmlModuleIdentifier()).arg(qmlTypeName()).arg(name()));
+ QmlClassNode* qcn = qmlClassNode();
+ if (qcn) {
+ if (qcn->cppClassRequired()) {
+ if (qcn->classNode()) {
+ PropertyNode* pn = correspondingProperty(tree);
+ if (pn)
+ return pn->isWritable();
+ else
+ location().warning(tr("No Q_PROPERTY for QML property %1::%2::%3 "
+ "in C++ class documented as QML type: "
+ "(property not found in the C++ class or its base classes)")
+ .arg(qmlModuleIdentifier()).arg(qmlTypeName()).arg(name()));
+ }
+ else
+ location().warning(tr("No Q_PROPERTY for QML property %1::%2::%3 "
+ "in C++ class documented as QML type: "
+ "(C++ class not specified or not found).")
+ .arg(qmlModuleIdentifier()).arg(qmlTypeName()).arg(name()));
+ }
}
return true;
}
void setServiceName(const QString& value) { sname = value; }
QmlClassNode* qmlElement() { return qmlelement; }
void setQmlElement(QmlClassNode* qcn) { qmlelement = qcn; }
- virtual bool isAbstract() const { return abstract; }
- virtual void setAbstract(bool b) { abstract = b; }
+ virtual bool isAbstract() const { return abstract_; }
+ virtual void setAbstract(bool b) { abstract_ = b; }
PropertyNode* findPropertyNode(const QString& name);
QmlClassNode* findQmlBaseNode();
QList<RelatedClass> derived;
QList<RelatedClass> ignoredBases;
bool hidden;
- bool abstract;
+ bool abstract_;
QString sname;
QmlClassNode* qmlelement;
};
virtual void clearCurrentChild();
virtual const ImportList* importList() const { return &importList_; }
virtual void setImportList(const ImportList& il) { importList_ = il; }
- virtual bool isAbstract() const { return abstract; }
- virtual void setAbstract(bool b) { abstract = b; }
+ virtual bool isAbstract() const { return abstract_; }
+ virtual void setAbstract(bool b) { abstract_ = b; }
const FakeNode* qmlBase() const { return base_; }
void resolveInheritance(Tree* tree);
+ void requireCppClass() { cnodeRequired_ = true; }
+ bool cppClassRequired() const { return cnodeRequired_; }
static void addInheritedBy(const QString& base, Node* sub);
static void subclasses(const QString& base, NodeList& subs);
static void terminate();
static QMap<QString, QmlClassNode*> qmlModuleMemberMap_;
private:
- bool abstract;
+ bool abstract_;
+ bool cnodeRequired_;
ClassNode* cnode_;
FakeNode* base_;
ImportList importList_;
const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); }
void appendQmlPropNode(QmlPropertyNode* p) { qmlPropNodes_.append(p); }
const NodeList& qmlPropNodes() const { return qmlPropNodes_; }
- void setQPropertyFlag() { qproperty_ = true; }
private:
QString type_;
FlagValue designable_;
bool isdefault_;
bool attached_;
- bool qproperty_;
FlagValue readOnly_;
NodeList qmlPropNodes_;
};
Tree *tree)
{
QFile in(filePath);
+ currentFile_ = filePath;
if (!in.open(QIODevice::ReadOnly)) {
location.error(tr("Can't open source file '%1' (%2)").arg(filePath).arg(strerror(errno)));
+ currentFile_.clear();
return;
}
createOutputSubdirectory(location, filePath);
processQdocComments();
in.close();
+ currentFile_.clear();
}
/*!
if ((topic == COMMAND_QMLPROPERTY) ||
(topic == COMMAND_QMLATTACHEDPROPERTY)) {
Doc nodeDoc = doc;
- Node* node = processTopicCommandGroup(topic,args);
+ Node* node = processTopicCommandGroup(nodeDoc,topic,args);
if (node != 0) {
nodes.append(node);
docs.append(nodeDoc);
Tree *tree)
{
QFile in(filePath);
+ currentFile_ = filePath;
if (!in.open(QIODevice::ReadOnly)) {
location.error(tr("Cannot open QML file '%1'").arg(filePath));
+ currentFile_.clear();
return;
}
createOutputSubdirectory(location, filePath);
<< ": QML syntax error at col " << msg.loc.startColumn
<< ": " << qPrintable(msg.message);
}
+ currentFile_.clear();
}
/*!
projects / profile / ivi / qtbase.git / commitdiff