Differential D26202 Diff 73510 src/kconfig_compiler/KCFGXmlParser.cpp

Changeset View

Standalone View

View Options

src/kconfig_compiler/KCFGXmlParser.cpp

  • This file was added.
1​/* This file is part of the KDE libraries
2​ Copyright (C) 2020 Tomaz Cananbrava (tcanabrava@kde.org)
3​
4​ This library is free software; you can redistribute it and/or
5​ modify it under the terms of the GNU Library General Public
6​ License as published by the Free Software Foundation; either
7​ version 2 of the License, or (at your option) any later version.
8​
9​ This library is distributed in the hope that it will be useful,
10​ but WITHOUT ANY WARRANTY; without even the implied warranty of
11​ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12​ Library General Public License for more details.
13​
14​ You should have received a copy of the GNU Library General Public License
15​ along with this library; see the file COPYING.LIB. If not, write to
16​ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17​ Boston, MA 02110-1301, USA.
18​*/
19​
20​#include "KCFGXmlParser.h"
21​#include "KConfigXTParameters.h"
dfaureUnsubmitted
Done

Yes ;)

dfaure: Yes ;)
22​
23​#include <QDomAttr>
24​#include <QDomElement>
25​#include <QDomNode>
26​#include <QFile>
27​#include <QList>
28​#include <QStringList>
29​#include <QTextStream>
30​
31​namespace
32​{
33​QTextStream cout(stdout);
34​QTextStream cerr(stderr);
35​}
36​
37​//TODO: Move preprocessDefault to Header / CPP implementation.
38​// it makes no sense for a parser to process those values and generate code.
39​
40​static void preProcessDefault(QString &defaultValue, const QString &name,
41​ const QString &type,
42​ const CfgEntry::Choices &choices,
43​ QString &code, const KConfigXTParameters &cfg)
44​{
45​ if (type == QLatin1String("String") && !defaultValue.isEmpty()) {
46​ defaultValue = literalString(defaultValue);
47​
48​ } else if (type == QLatin1String("Path") && !defaultValue.isEmpty()) {
49​ defaultValue = literalString(defaultValue);
50​ } else if (type == QLatin1String("Url") && !defaultValue.isEmpty()) {
51​ // Use fromUserInput in order to support absolute paths and absolute urls, like KDE4's KUrl(QString) did.
52​ defaultValue = QLatin1String("QUrl::fromUserInput( ") + literalString(defaultValue) + QLatin1Char(')');
53​ } else if ((type == QLatin1String("UrlList") || type == QLatin1String("StringList") || type == QLatin1String("PathList")) && !defaultValue.isEmpty()) {
54​ QTextStream cpp(&code, QIODevice::WriteOnly | QIODevice::Append);
55​ if (!code.isEmpty()) {
56​ cpp << endl;
57​ }
58​
59​ if (type == QLatin1String("UrlList")) {
60​ cpp << " QList<QUrl> default" << name << ";" << endl;
61​ } else {
62​ cpp << " QStringList default" << name << ";" << endl;
63​ }
64​ const QStringList defaults = defaultValue.split(QLatin1Char(','));
65​ QStringList::ConstIterator it;
66​ for (it = defaults.constBegin(); it != defaults.constEnd(); ++it) {
67​ cpp << " default" << name << ".append( ";
68​ if (type == QLatin1String("UrlList")) {
69​ cpp << "QUrl::fromUserInput(";
70​ }
71​ cpp << "QString::fromUtf8( \"" << *it << "\" ) ";
72​ if (type == QLatin1String("UrlList")) {
73​ cpp << ") ";
74​ }
75​ cpp << ");" << endl;
76​ }
77​ defaultValue = QLatin1String("default") + name;
78​
79​ } else if (type == QLatin1String("Color") && !defaultValue.isEmpty()) {
80​ const QRegularExpression colorRe(QRegularExpression::anchoredPattern(
81​ QStringLiteral("\\d+,\\s*\\d+,\\s*\\d+(,\\s*\\d+)?")));
82​
83​ if (colorRe.match(defaultValue).hasMatch()) {
84​ defaultValue = QLatin1String("QColor( ") + defaultValue + QLatin1String(" )");
85​ } else {
86​ defaultValue = QLatin1String("QColor( \"") + defaultValue + QLatin1String("\" )");
87​ }
88​
89​ } else if (type == QLatin1String("Enum")) {
90​ QList<CfgEntry::Choice>::ConstIterator it;
91​ for (it = choices.choices.constBegin(); it != choices.choices.constEnd(); ++it) {
92​ if ((*it).name == defaultValue) {
93​ if (cfg.globalEnums && choices.name().isEmpty()) {
94​ defaultValue.prepend(choices.prefix);
95​ } else {
96​ defaultValue.prepend(enumTypeQualifier(name, choices) + choices.prefix);
97​ }
98​ break;
99​ }
100​ }
101​
102​ } else if (type == QLatin1String("IntList")) {
103​ QTextStream cpp(&code, QIODevice::WriteOnly | QIODevice::Append);
104​ if (!code.isEmpty()) {
105​ cpp << endl;
106​ }
107​
108​ cpp << " QList<int> default" << name << ";" << endl;
109​ if (!defaultValue.isEmpty()) {
110​ const QStringList defaults = defaultValue.split(QLatin1Char(','));
111​ QStringList::ConstIterator it;
112​ for (it = defaults.constBegin(); it != defaults.constEnd(); ++it) {
113​ cpp << " default" << name << ".append( " << *it << " );"
114​ << endl;
115​ }
116​ }
117​ defaultValue = QLatin1String("default") + name;
118​ }
119​}
120​
121​static QString dumpNode(const QDomNode &node)
122​{
123​ QString msg;
124​ QTextStream s(&msg, QIODevice::WriteOnly);
125​ node.save(s, 0);
126​
127​ msg = msg.simplified();
128​ if (msg.length() > 40) {
129​ return msg.left(37) + QLatin1String("...");
130​ }
131​ return msg;
132​}
133​
134​void KCFGXmlParser::readParameterFromEntry(CfgEntry &readEntry, const QDomElement &e)
135​{
136​ readEntry.param = e.attribute(QStringLiteral("name"));
137​ readEntry.paramType = e.attribute(QStringLiteral("type"));
138​
139​ if (readEntry.param.isEmpty()) {
140​ cerr << "Parameter must have a name: " << dumpNode(e) << endl;
141​ exit (1);
142​ }
143​
144​ if (readEntry.paramType.isEmpty()) {
145​ cerr << "Parameter must have a type: " << dumpNode(e) << endl;
146​ exit(1);
147​ }
148​
149​ if ((readEntry.paramType == QLatin1String("Int")) || (readEntry.paramType == QLatin1String("UInt"))) {
150​ bool ok;
151​ readEntry.paramMax = e.attribute(QStringLiteral("max")).toInt(&ok);
152​ if (!ok) {
153​ cerr << "Integer parameter must have a maximum (e.g. max=\"0\"): " << dumpNode(e) << endl;
154​ exit(1);
155​ }
156​ } else if (readEntry.paramType == QLatin1String("Enum")) {
157​ for (QDomElement e2 = e.firstChildElement(); !e2.isNull(); e2 = e2.nextSiblingElement()) {
158​ if (e2.tagName() == QLatin1String("values")) {
159​ for (QDomElement e3 = e2.firstChildElement(); !e3.isNull(); e3 = e3.nextSiblingElement()) {
160​ if (e3.tagName() == QLatin1String("value")) {
161​ readEntry.paramValues.append(e3.text());
162​ }
163​ }
164​ break;
165​ }
166​ }
167​ if (readEntry.paramValues.isEmpty()) {
168​ cerr << "No values specified for parameter '" << readEntry.param << "'." << endl;
169​ exit(1);
170​ }
171​ readEntry.paramMax = readEntry.paramValues.count() - 1;
172​ } else {
173​ cerr << "Parameter '" << readEntry.param << "' has type " << readEntry.paramType
174​ << " but must be of type int, uint or Enum." << endl;
175​ exit(1);
176​ }
177​}
178​
179​bool KCFGXmlParser::hasDefaultCode(CfgEntry &readEntry, const QDomElement &element)
180​{
181​ for (QDomElement e = element.firstChildElement(); !e.isNull(); e = e.nextSiblingElement()) {
182​ if (e.attribute(QStringLiteral("param")).isEmpty()) {
183​ if (e.attribute(QStringLiteral("code")) == QLatin1String("true")) {
184​ return true;
185​ }
186​ }
187​ }
188​ return false;
189​}
190​
191​
192​void KCFGXmlParser::readChoicesFromEntry(CfgEntry &readEntry, const QDomElement &e)
193​{
194​ QList<CfgEntry::Choice> chlist;
195​ for (QDomElement e2 = e.firstChildElement(); !e2.isNull(); e2 = e2.nextSiblingElement()) {
196​ if (e2.tagName() != QLatin1String("choice")) {
197​ continue;
198​ }
199​ CfgEntry::Choice choice;
200​ choice.name = e2.attribute(QStringLiteral("name"));
201​ if (choice.name.isEmpty()) {
202​ cerr << "Tag <choice> requires attribute 'name'." << endl;
203​ }
204​ for (QDomElement e3 = e2.firstChildElement(); !e3.isNull(); e3 = e3.nextSiblingElement()) {
205​ if (e3.tagName() == QLatin1String("label")) {
206​ choice.label = e3.text();
207​ choice.context = e3.attribute(QStringLiteral("context"));
208​ }
209​ if (e3.tagName() == QLatin1String("tooltip")) {
210​ choice.toolTip = e3.text();
211​ choice.context = e3.attribute(QStringLiteral("context"));
212​ }
213​ if (e3.tagName() == QLatin1String("whatsthis")) {
214​ choice.whatsThis = e3.text();
215​ choice.context = e3.attribute(QStringLiteral("context"));
216​ }
217​ }
218​ chlist.append(choice);
219​ }
220​
221​ QString name = e.attribute(QStringLiteral("name"));
222​ QString prefix = e.attribute(QStringLiteral("prefix"));
223​
224​ readEntry.choices = CfgEntry::Choices(chlist, name, prefix);
225​}
226​
227​void KCFGXmlParser::readGroupElements(CfgEntry &readEntry, const QDomElement &element)
228​{
229​ for (QDomElement e = element.firstChildElement(); !e.isNull(); e = e.nextSiblingElement()) {
230​ QString tag = e.tagName();
231​ if (tag == QLatin1String("label")) {
232​ readEntry.label = e.text();
233​ readEntry.labelContext = e.attribute(QStringLiteral("context"));
234​ } else if (tag == QLatin1String("tooltip")) {
235​ readEntry.toolTip = e.text();
236​ readEntry.toolTipContext = e.attribute(QStringLiteral("context"));
237​ } else if (tag == QLatin1String("whatsthis")) {
238​ readEntry.whatsThis = e.text();
239​ readEntry.whatsThisContext = e.attribute(QStringLiteral("context"));
240​ } else if (tag == QLatin1String("min")) {
241​ readEntry.min = e.text();
242​ } else if (tag == QLatin1String("max")) {
243​ readEntry.max = e.text();
244​ } else if (tag == QLatin1String("code")) {
245​ readEntry.code = e.text();
246​ } else if (tag == QLatin1String("parameter")) {
247​ readParameterFromEntry(readEntry, e);
248​ } else if (tag == QLatin1String("default")) {
249​ if (e.attribute(QStringLiteral("param")).isEmpty()) {
250​ readEntry.defaultValue = e.text();
251​ }
252​ } else if (tag == QLatin1String("choices")) {
253​ readChoicesFromEntry(readEntry, e);
254​ } else if (tag == QLatin1String("emit")) {
255​ Signal signal;
256​ signal.name = e.attribute(QStringLiteral("signal"));
257​ readEntry.signalList.append(signal);
258​ }
259​ }
260​}
261​
262​void KCFGXmlParser::createChangedSignal(CfgEntry &readEntry)
263​{
264​ if (cfg.generateProperties && (cfg.allMutators || cfg.mutators.contains(readEntry.name))) {
265​ Signal s;
266​ s.name = changeSignalName(readEntry.name);
267​ s.modify = true;
268​ readEntry.signalList.append(s);
269​ }
270​}
271​
272​void KCFGXmlParser::validateNameAndKey(CfgEntry &readEntry, const QDomElement &element)
273​{
274​ bool nameIsEmpty = readEntry.name.isEmpty();
275​ if (nameIsEmpty && readEntry.key.isEmpty()) {
276​ cerr << "Entry must have a name or a key: " << dumpNode(element) << endl;
277​ exit (1);
278​ }
279​
280​ if (readEntry.key.isEmpty()) {
281​ readEntry.key = readEntry.name;
282​ }
283​
284​ if (nameIsEmpty) {
285​ readEntry.name = readEntry.key;
286​ readEntry.name.remove(QLatin1Char(' '));
287​ } else if (readEntry.name.contains(QLatin1Char(' '))) {
288​ cout << "Entry '" << readEntry.name << "' contains spaces! <name> elements can not contain spaces!" << endl;
289​ readEntry.name.remove(QLatin1Char(' '));
290​ }
291​
292​ if (readEntry.name.contains(QStringLiteral("$("))) {
293​ if (readEntry.param.isEmpty()) {
294​ cerr << "Name may not be parameterized: " << readEntry.name << endl;
295​ exit (1);
296​ }
297​ } else {
298​ if (!readEntry.param.isEmpty()) {
299​ cerr << "Name must contain '$(" << readEntry.param << ")': " << readEntry.name << endl;
300​ exit (1);
301​ }
302​ }
303​}
304​
305​void KCFGXmlParser::readParamDefaultValues(CfgEntry &readEntry, const QDomElement &element)
306​{
307​ if (readEntry.param.isEmpty()) {
308​ return;
309​ }
310​ // Adjust name
311​ readEntry.paramName = readEntry.name;
312​
313​ readEntry.name.remove(QStringLiteral("$(") + readEntry.param + QLatin1Char(')'));
314​ // Lookup defaults for indexed entries
315​ for (int i = 0; i <= readEntry.paramMax; i++) {
316​ readEntry.paramDefaultValues.append(QString());
317​ }
318​
319​ for (QDomElement e = element.firstChildElement(); !e.isNull(); e = e.nextSiblingElement()) {
320​ QString tag = e.tagName();
321​ if (tag != QLatin1String("default")) {
322​ continue;
323​ }
324​ QString index = e.attribute(QStringLiteral("param"));
325​ if (index.isEmpty()) {
326​ continue;
327​ }
328​
329​ bool ok;
330​ int i = index.toInt(&ok);
331​ if (!ok) {
332​ i = readEntry.paramValues.indexOf(index);
333​ if (i == -1) {
334​ cerr << "Index '" << index << "' for default value is unknown." << endl;
335​ exit (1);
336​ }
337​ }
338​
339​ if ((i < 0) || (i > readEntry.paramMax)) {
340​ cerr << "Index '" << i << "' for default value is out of range [0, " << readEntry.paramMax << "]." << endl;
341​ exit (1);
342​ }
343​
344​ QString tmpDefaultValue = e.text();
345​
346​ if (e.attribute(QStringLiteral("code")) != QLatin1String("true")) {
347​ preProcessDefault(tmpDefaultValue, readEntry.name, readEntry.type, readEntry.choices, readEntry.code, cfg);
348​ }
349​
350​ readEntry.paramDefaultValues[i] = tmpDefaultValue;
351​ }
352​}
353​
354​CfgEntry *KCFGXmlParser::parseEntry(const QString &group, const QDomElement &element)
355​{
356​ CfgEntry readEntry;
357​ readEntry.type = element.attribute(QStringLiteral("type"));
358​ readEntry.name = element.attribute(QStringLiteral("name"));
359​ readEntry.key = element.attribute(QStringLiteral("key"));
360​ readEntry.hidden = element.attribute(QStringLiteral("hidden")) == QLatin1String("true");;
361​ readEntry.group = group;
362​
363​ const bool nameIsEmpty = readEntry.name.isEmpty();
364​
365​ readGroupElements(readEntry, element);
366​
367​ createChangedSignal(readEntry);
368​ validateNameAndKey(readEntry, element);
369​
370​ if (readEntry.label.isEmpty()) {
371​ readEntry.label = readEntry.key;
372​ }
373​
374​ if (readEntry.type.isEmpty()) {
375​ readEntry.type = QStringLiteral("String"); // XXX : implicit type might be bad
376​ }
377​
378​ readParamDefaultValues(readEntry, element);
379​
380​ if (!mValidNameRegexp.match(readEntry.name).hasMatch()) {
381​ if (nameIsEmpty)
382​ cerr << "The key '" << readEntry.key << "' can not be used as name for the entry because "
383​ "it is not a valid name. You need to specify a valid name for this entry." << endl;
384​ else {
385​ cerr << "The name '" << readEntry.name << "' is not a valid name for an entry." << endl;
386​ }
387​ exit (1);
388​ }
389​
390​ if (mAllNames.contains(readEntry.name)) {
391​ if (nameIsEmpty)
392​ cerr << "The key '" << readEntry.key << "' can not be used as name for the entry because "
393​ "it does not result in a unique name. You need to specify a unique name for this entry." << endl;
394​ else {
395​ cerr << "The name '" << readEntry.name << "' is not unique." << endl;
396​ }
397​ exit (1);
398​ }
399​
400​ mAllNames.append(readEntry.name);
401​
402​ if (!hasDefaultCode(readEntry, element)) {
403​ // TODO: Move all the options to CfgEntry.
404​ preProcessDefault(readEntry.defaultValue, readEntry.name, readEntry.type, readEntry.choices, readEntry.code, cfg);
405​ }
406​
407​ // TODO: Try to Just return the CfgEntry we populated instead of
408​ // creating another one to fill the code.
409​ CfgEntry *result = new CfgEntry();
410​ result->group = readEntry.group;
411​ result->type = readEntry.type;
412​ result->key = readEntry.key;
413​ result->name = readEntry.name;
414​ result->labelContext = readEntry.labelContext;
415​ result->label = readEntry.label;
416​ result->toolTipContext = readEntry.toolTipContext;
417​ result->toolTip = readEntry.toolTip;
418​ result->whatsThisContext = readEntry.whatsThisContext;
419​ result->whatsThis = readEntry.whatsThis;
420​ result->code = readEntry.code;
421​ result->defaultValue = readEntry.defaultValue;
422​ result->choices = readEntry.choices;
423​ result->signalList = readEntry.signalList;
424​ result->hidden = readEntry.hidden;
425​
426​ if (!readEntry.param.isEmpty()) {
427​ result->param = readEntry.param;
428​ result->paramName = readEntry.paramName;
429​ result->paramType = readEntry.paramType;
430​ result->paramValues = readEntry.paramValues;
431​ result->paramDefaultValues = readEntry.paramDefaultValues;
432​ result->paramMax = readEntry.paramMax;
433​ }
434​ result->min = readEntry.min;
435​ result->max = readEntry.max;
436​
437​ return result;
438​}
439​
440​// TODO: Change the name of the config variable.
441​KCFGXmlParser::KCFGXmlParser(const KConfigXTParameters &cfg, const QString& inputFileName)
442​ : cfg(cfg), mInputFileName(inputFileName)
443​{
444​ mValidNameRegexp.setPattern(QRegularExpression::anchoredPattern(QStringLiteral("[a-zA-Z_][a-zA-Z0-9_]*")));
445​}
446​
447​void KCFGXmlParser::start()
ervinUnsubmitted
Done

Space before & not after

ervin: Space before & not after
448​{
449​ QFile input(mInputFileName);
450​ QDomDocument doc;
451​ QString errorMsg;
452​ int errorRow;
453​ int errorCol;
454​ if (!doc.setContent(&input, &errorMsg, &errorRow, &errorCol)) {
455​ cerr << "Unable to load document." << endl;
456​ cerr << "Parse error in " << mInputFileName << ", line " << errorRow << ", col " << errorCol << ": " << errorMsg << endl;
457​ exit (1);
458​ }
459​
460​ QDomElement cfgElement = doc.documentElement();
461​ if (cfgElement.isNull()) {
462​ cerr << "No document in kcfg file" << endl;
463​ exit (1);
464​ }
465​
466​ for (QDomElement element = cfgElement.firstChildElement(); !element.isNull(); element = element.nextSiblingElement()) {
467​ QString tag = element.tagName();
468​
469​ if (tag == QLatin1String("include")) {
470​ readIncludeTag(element);
471​ } else if (tag == QLatin1String("kcfgfile")) {
472​ readKcfgfileTag(element);
473​ } else if (tag == QLatin1String("group")) {
474​ readGroupTag(element);
475​ } else if (tag == QLatin1String("signal")) {
476​ readSignalTag(element);
477​ }
478​ }
479​}
480​
481​ParseResult KCFGXmlParser::getParseResult() const
482​{
483​ return mParseResult;
484​}
485​
486​void KCFGXmlParser::readIncludeTag(const QDomElement &e)
487​{
488​ QString includeFile = e.text();
489​ if (!includeFile.isEmpty()) {
490​ mParseResult.includes.append(includeFile);
491​ }
492​}
493​
494​void KCFGXmlParser::readGroupTag(const QDomElement &e)
495​{
496​ QString group = e.attribute(QStringLiteral("name"));
497​ if (group.isEmpty()) {
498​ cerr << "Group without name" << endl;
499​ exit (1);
500​ }
501​
502​ for (QDomElement e2 = e.firstChildElement(); !e2.isNull(); e2 = e2.nextSiblingElement()) {
503​ if (e2.tagName() != QLatin1String("entry")) {
504​ continue;
505​ }
506​ CfgEntry *entry = parseEntry(group, e2);
507​ if (entry) {
508​ mParseResult.entries.append(entry);
509​ } else {
510​ cerr << "Can not parse entry." << endl;
511​ exit (1);
512​ }
513​ }
514​}
515​
516​void KCFGXmlParser::readKcfgfileTag(const QDomElement &e)
517​{
518​ mParseResult.cfgFileName = e.attribute(QStringLiteral("name"));
519​ mParseResult.cfgFileNameArg = e.attribute(QStringLiteral("arg")).toLower() == QLatin1String("true");
520​ for (QDomElement e2 = e.firstChildElement(); !e2.isNull(); e2 = e2.nextSiblingElement()) {
521​ if (e2.tagName() == QLatin1String("parameter")) {
522​ Param p;
523​ p.name = e2.attribute(QStringLiteral("name"));
524​ p.type = e2.attribute(QStringLiteral("type"));
525​ if (p.type.isEmpty()) {
526​ p.type = QStringLiteral("String");
527​ }
528​ mParseResult.parameters.append(p);
529​ }
530​ }
531​}
532​
533​void KCFGXmlParser::readSignalTag(const QDomElement &e)
534​{
535​ QString signalName = e.attribute(QStringLiteral("name"));
536​ if (signalName.isEmpty()) {
537​ cerr << "Signal without name." << endl;
538​ exit (1);
539​ }
540​ Signal theSignal;
541​ theSignal.name = signalName;
542​
543​ for (QDomElement e2 = e.firstChildElement(); !e2.isNull(); e2 = e2.nextSiblingElement()) {
544​ if (e2.tagName() == QLatin1String("argument")) {
545​ Param argument;
546​ argument.type = e2.attribute(QStringLiteral("type"));
547​ if (argument.type.isEmpty()) {
548​ cerr << "Signal argument without type." << endl;
549​ exit (1);
550​ }
551​ argument.name= e2.text();
552​ theSignal.arguments.append(argument);
553​ } else if (e2.tagName() == QLatin1String("label")) {
554​ theSignal.label = e2.text();
555​ }
556​ }
557​
558​ mParseResult.signalList.append(theSignal);
559​}