Differential D26202 Diff 72338 src/kconfig_compiler/KCFGXmlParser.cpp

Changeset View

Standalone View

View Options

src/kconfig_compiler/KCFGXmlParser.cpp

  • This file was added.
1​#include "KCFGXmlParser.h"
2​#include "KConfigXTParameters.h"
3​
4​#include <QDomAttr>
5​#include <QDomNode>
6​#include <QDomElement>
7​
8​#include <QTextStream>
9​#include <QList>
10​#include <QStringList>
11​
12​namespace
13​{
14​QTextStream cout(stdout);
15​QTextStream cerr(stderr);
16​}
17​
18​// TODO: Remove those global.
19​extern QStringList allNames;
20​extern QRegExp *validNameRegexp;
21​
dfaureUnsubmitted
Done

Yes ;)

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

Space before & not after

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