1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include "qmlcodemarker.h"
#include <QtCore/qregularexpression.h>
#include "atom.h"
#include "node.h"
#include "qmlmarkupvisitor.h"
#include "text.h"
#ifndef QT_NO_DECLARATIVE
# include <private/qqmljsast_p.h>
# include <private/qqmljsastfwd_p.h>
# include <private/qqmljsengine_p.h>
# include <private/qqmljslexer_p.h>
# include <private/qqmljsparser_p.h>
#endif
QT_BEGIN_NAMESPACE
/*!
Returns \c true if the \a code is recognized by the parser.
*/
bool QmlCodeMarker::recognizeCode(const QString &code)
{
#ifndef QT_NO_DECLARATIVE
// Naive pre-check; starts with an import statement or 'CamelCase {'
static const QRegularExpression regExp(QStringLiteral("^\\s*(import |([A-Z][a-z0-9]*)+\\s?{)"));
if (!regExp.match(code).hasMatch())
return false;
QQmlJS::Engine engine;
QQmlJS::Lexer lexer(&engine);
QQmlJS::Parser parser(&engine);
QString newCode = code;
extractPragmas(newCode);
lexer.setCode(newCode, 1);
return parser.parse();
#else
Q_UNUSED(code);
return false;
#endif
}
/*!
Returns \c true if \a ext is any of a list of file extensions
for the QML language.
*/
bool QmlCodeMarker::recognizeExtension(const QString &ext)
{
return ext == "qml";
}
/*!
Returns \c true if the \a language is recognized. Only "QML" is
recognized by this marker.
*/
bool QmlCodeMarker::recognizeLanguage(const QString &language)
{
return language == "QML";
}
/*!
Returns the type of atom used to represent QML code in the documentation.
*/
Atom::AtomType QmlCodeMarker::atomType() const
{
return Atom::Qml;
}
QString QmlCodeMarker::markedUpCode(const QString &code, const Node *relative,
const Location &location)
{
return addMarkUp(code, relative, location);
}
/*!
Constructs and returns the marked up name for the \a node.
If the node is any kind of QML function (a method,
signal, or handler), "()" is appended to the marked up name.
*/
QString QmlCodeMarker::markedUpName(const Node *node)
{
QString name = linkTag(node, taggedNode(node));
if (node->isFunction())
name += "()";
return name;
}
QString QmlCodeMarker::markedUpInclude(const QString &include)
{
return addMarkUp("import " + include, nullptr, Location{});
}
QString QmlCodeMarker::addMarkUp(const QString &code, const Node * /* relative */,
const Location &location)
{
#ifndef QT_NO_DECLARATIVE
QQmlJS::Engine engine;
QQmlJS::Lexer lexer(&engine);
QString newCode = code;
QList<QQmlJS::SourceLocation> pragmas = extractPragmas(newCode);
lexer.setCode(newCode, 1);
QQmlJS::Parser parser(&engine);
QString output;
if (parser.parse()) {
QQmlJS::AST::UiProgram *ast = parser.ast();
// Pass the unmodified code to the visitor so that pragmas and other
// unhandled source text can be output.
QmlMarkupVisitor visitor(code, pragmas, &engine);
QQmlJS::AST::Node::accept(ast, &visitor);
if (visitor.hasError()) {
location.warning(
location.fileName()
+ QStringLiteral("Unable to analyze QML snippet. The output is incomplete."));
}
output = visitor.markedUpCode();
} else {
location.warning(QStringLiteral("Unable to parse QML snippet: \"%1\" at line %2, column %3")
.arg(parser.errorMessage())
.arg(parser.errorLineNumber())
.arg(parser.errorColumnNumber()));
output = protect(code);
}
return output;
#else
Q_UNUSED(code);
location.warning("QtDeclarative not installed; cannot parse QML or JS.");
return QString();
#endif
}
#ifndef QT_NO_DECLARATIVE
/*
Copied and pasted from
src/declarative/qml/qqmlscriptparser.cpp.
*/
void replaceWithSpace(QString &str, int idx, int n); // qmlcodeparser.cpp
/*
Copied and pasted from
src/declarative/qml/qqmlscriptparser.cpp then modified to
return a list of removed pragmas.
Searches for ".pragma <value>" or ".import <stuff>" declarations
in \a script. Currently supported pragmas are: library
*/
QList<QQmlJS::SourceLocation> QmlCodeMarker::extractPragmas(QString &script)
{
QList<QQmlJS::SourceLocation> removed;
QQmlJS::Lexer l(nullptr);
l.setCode(script, 0);
int token = l.lex();
while (true) {
if (token != QQmlJSGrammar::T_DOT)
break;
int startOffset = l.tokenOffset();
int startLine = l.tokenStartLine();
int startColumn = l.tokenStartColumn();
token = l.lex();
if (token != QQmlJSGrammar::T_PRAGMA && token != QQmlJSGrammar::T_IMPORT)
break;
int endOffset = 0;
while (startLine == l.tokenStartLine()) {
endOffset = l.tokenLength() + l.tokenOffset();
token = l.lex();
}
replaceWithSpace(script, startOffset, endOffset - startOffset);
removed.append(QQmlJS::SourceLocation(startOffset, endOffset - startOffset, startLine,
startColumn));
}
return removed;
}
#endif
QT_END_NAMESPACE
|
