Differential D26202 Diff 73510 src/kconfig_compiler/KConfigHeaderGenerator.cpp

Changeset View

Standalone View

src/kconfig_compiler/KConfigHeaderGenerator.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 "KConfigHeaderGenerator.h"
21		#include "KConfigCommonStructs.h"
22
23		#include <QTextStream>
24		#include <QDebug>
25
26		namespace
27		{
28		QTextStream cout(stdout);
29		QTextStream cerr(stderr);
30		}
31
32		KConfigHeaderGenerator::KConfigHeaderGenerator(
33		const QString& inputFile,
34		const QString& baseDir,
35		const KConfigXTParameters &cfg,
36		ParseResult &parseResult)
37		: KConfigCodeGeneratorBase(inputFile, baseDir, baseDir + cfg.baseName + QLatin1Char('.') + cfg.headerExtension, cfg, parseResult)
38		{
39		}
40
	ervinUnsubmitted Done Ditto ervin: Ditto
41		void KConfigHeaderGenerator::start()
42		{
43		KConfigCodeGeneratorBase::start();
44		startHeaderGuards();
45		createHeaders();
46
47		beginNamespaces();
48
49		createForwardDeclarations();
50
51		doClassDefinition();
52
53		endNamespaces();
	dfaureUnsubmitted Done qAsConst() dfaure: qAsConst()
54		endHeaderGuards();
55		}
56
57		void KConfigHeaderGenerator::doClassDefinition()
58		{
59		stream << "class " << cfg.visibility << cfg.className << " : public " << cfg.inherits << endl;
60		startScope();
61
62		// Add Q_OBJECT macro if the config need signals.
63		if (!parseResult.signalList.isEmpty() \|\| cfg.generateProperties) {
64		stream << " Q_OBJECT" << endl;
65		}
66		stream << " public:" << endl;
67		implementEnums();
68		createConstructor();
69		createDestructor();
70
71		for (auto *entry : qAsConst(parseResult.entries)) {
72		const QString n = entry->name;
73		const QString t = entry->type;
74
75		const QString returnType = (cfg.useEnumTypes && t == QLatin1String("Enum"))
76		? enumType(entry, cfg.globalEnums)
77		: cppType(t);
78
79		createSetters(entry);
80		createProperties(entry, returnType);
81		createGetters(entry, returnType);
82		createDefaultValueMember(entry);
83		createItemAcessors(entry, returnType);
84		}
85
86		createSignals();
87		stream << " protected:" << endl;
88		createSingleton();
89
90		// TODO: Move those to functions too.
91		if (parseResult.hasNonModifySignals) {
92		stream << whitespace() << "bool usrSave() override;" << endl;
93		}
94
95		// Member variables
96		if (!cfg.memberVariables.isEmpty() && cfg.memberVariables != QLatin1String("private") && cfg.memberVariables != QLatin1String("dpointer")) {
97		stream << " " << cfg.memberVariables << ":" << endl;
98		}
99
100		// Class Parameters
101		for (const auto &parameter : qAsConst(parseResult.parameters)) {
102		stream << whitespace() << "" << cppType(parameter.type) << " mParam" << parameter.name << ";" << endl;
103		}
104
105		createNonDPointerHelpers();
106		createDPointer();
107
108		if (cfg.customAddons) {
109		stream << whitespace() << "// Include custom additions" << endl;
110		stream << whitespace() << "#include \"" << cfg.baseName << "_addons." << cfg.headerExtension << '"' << endl;
111		}
112
113		endScope(ScopeFinalizer::Semicolon);
114		}
115
116		void KConfigHeaderGenerator::createHeaders()
117		{
118		addHeaders(cfg.headerIncludes);
119		if (cfg.headerIncludes.size()) {
120		stream << endl;
121		}
122
123		if (!cfg.singleton && parseResult.parameters.isEmpty()) {
124		addHeaders({QStringLiteral("qglobal.h")});
125		}
126
127		if (cfg.inherits == QLatin1String("KCoreConfigSkeleton")) {
128		addHeaders({QStringLiteral("kcoreconfigskeleton.h")});
129		} else {
130		addHeaders({QStringLiteral("kconfigskeleton.h")});
131		}
132
133		addHeaders({QStringLiteral("QCoreApplication"), QStringLiteral("QDebug")});
134		stream << endl;
135
136		addHeaders(parseResult.includes);
137		if (parseResult.includes.size()) {
138		stream << endl;
139		}
140		}
141
	dfaureUnsubmitted Done s/spaces/newlines/ dfaure: s/spaces/newlines/
142		void KConfigHeaderGenerator::startHeaderGuards()
143		{
144		const bool hasNamespace = !cfg.nameSpace.isEmpty();
145		const QString namespaceName = QString(QString(cfg.nameSpace).replace(QLatin1String("::"), QLatin1String("_"))).toUpper();
146		const QString namespaceStr = hasNamespace ? namespaceName + QLatin1Char('_') : QStringLiteral("");
147		const QString defineName = namespaceStr + cfg.className.toUpper() + QStringLiteral("_H");
148
149		stream << "#ifndef " << defineName << endl;
150		stream << "#define " << defineName << endl;
151		stream << endl;
152		}
153
154		void KConfigHeaderGenerator::endHeaderGuards()
155		{
156		stream << endl;
157		stream << "#endif";
158		stream << endl;
159		// HACK: Original files ended with two last newlines, add them.
160		stream << endl;
161		}
162
163		void KConfigHeaderGenerator::implementChoiceEnums(const CfgEntry *entry, const CfgEntry::Choices &choices)
164		{
165		const QList<CfgEntry::Choice> chlist = choices.choices;
166
167		if (chlist.isEmpty()) {
168		return;
169		}
170
171		QStringList values;
172		for (const auto choice : qAsConst(chlist)) {
173		values.append(choices.prefix + choice.name);
174		}
175
176		if (choices.name().isEmpty()) {
177		if (cfg.globalEnums) {
178		stream << whitespace() << "enum " << enumName(entry->name, entry->choices) << " { " << values.join(QStringLiteral(", ")) << " };" << endl;
179		} else {
180		// Create an automatically named enum
181		stream << whitespace() << "class " << enumName(entry->name, entry->choices) << endl;
182		stream << whitespace() << "{" << endl;
183		stream << whitespace() << " public:" << endl;
184		stream << whitespace() << " enum type { " << values.join(QStringLiteral(", ")) << ", COUNT };" << endl;
185		stream << whitespace() << "};" << endl;
186		}
187		} else if (!choices.external()) {
188		// Create a named enum
189		stream << whitespace() << "enum " << enumName(entry->name, entry->choices) << " { " << values.join(QStringLiteral(", ")) << " };" << endl;
190		}
191		}
192
193		void KConfigHeaderGenerator::implementValueEnums(const CfgEntry *entry, const QStringList &values)
194		{
195		if (values.isEmpty()) {
196		return;
197		}
198
199		if (cfg.globalEnums) {
200		// ### FIXME!!
201		// make the following string table an index-based string search!
202		// ###
203		stream << whitespace() << "enum " << enumName(entry->param) << " { " << values.join(QStringLiteral(", ")) << " };" << endl;
204		stream << whitespace() << "static const char* const " << enumName(entry->param) << "ToString[];" << endl;
205		} else {
206		stream << whitespace() << "class " << enumName(entry->param) << endl;
207		stream << whitespace() << "{" << endl;
208		stream << whitespace() << " public:" << endl;
209		stream << whitespace() << " enum type { " << values.join(QStringLiteral(", ")) << ", COUNT };" << endl;
210		stream << whitespace() << " static const char* const enumToString[];" << endl;
211		stream << whitespace() << "};" << endl;
212		}
213		}
214
215		void KConfigHeaderGenerator::implementEnums()
	dfaureUnsubmitted Done nothing here? dfaure: nothing here?
216		{
217		if (!parseResult.entries.size()) {
218		return;
219		}
220
221		for (const auto entry : qAsConst(parseResult.entries)) {
222		const CfgEntry::Choices &choices = entry->choices;
223		const QStringList values = entry->paramValues;
224
225		implementChoiceEnums(entry, choices);
226		implementValueEnums(entry, values);
227		}
228		stream << endl;
229		}
230
231		void KConfigHeaderGenerator::createSignals()
232		{
233		// Signal definition.
234		const bool hasSignals = !parseResult.signalList.isEmpty();
235
236		unsigned val = 1 << parseResult.signalList.size();
237		if (!val) {
238		cerr << "Too many signals to create unique bit masks" << endl;
239		exit(1);
240		}
241
242		if (!hasSignals) {
243		return;
244		}
245
246		stream << "\n enum {" << endl;
247		val = 1;
248
249		// HACK: Use C-Style for add a comma in all but the last element,
250		// just to make the source generated code equal to the old one.
251		// When we are sure, revert this to a range-based-for and just add
252		// a last comma, as it's valid c++.
253		for (int i = 0, end = parseResult.signalList.size(); i < end; i++) {
254		auto signal = parseResult.signalList.at(i);
255		stream << whitespace() << " " << signalEnumName(signal.name) << " = 0x" << hex << val;
256		if (i != end-1) {
257		stream << "," << endl;
258		}
259
260		val <<= 1;
261		}
262		stream << endl;
263		stream << whitespace() << "};" << dec << endl << endl;
264
265		stream << " Q_SIGNALS:";
266		for (const Signal &signal : qAsConst(parseResult.signalList)) {
267		stream << endl;
268		if (!signal.label.isEmpty()) {
269		stream << whitespace() << "/**" << endl;
270		stream << whitespace() << " " << signal.label << endl;
271		stream << whitespace() << "*/" << endl;
272		}
273		stream << whitespace() << "void " << signal.name << "(";
274		QList<Param>::ConstIterator it, itEnd = signal.arguments.constEnd();
275		for (it = signal.arguments.constBegin(); it != itEnd;) {
276		Param argument = *it;
277		QString type = param(argument.type);
278		if (cfg.useEnumTypes && argument.type == QLatin1String("Enum")) {
279		for (auto *entry : qAsConst(parseResult.entries)) {
280		if (entry->name == argument.name) {
281		type = enumType(entry, cfg.globalEnums);
282		break;
283		}
284		}
285		}
286		stream << type << " " << argument.name;
287		if (++it != itEnd) {
288		stream << ", ";
289		}
290		}
291		stream << ");" << endl;
292		}
293		stream << endl;
294
295		stream << " private:" << endl;
296		stream << whitespace() << "void itemChanged(quint64 flags);" << endl;
297		stream << endl;
298		}
299
300		void KConfigHeaderGenerator::createDPointer()
301		{
302		if (!cfg.dpointer) {
303		return;
304		}
305
306		// use a private class for both member variables and items
307		stream << " private:" << endl;
308		for (const auto &entry : qAsConst(parseResult.entries)) {
309		if (cfg.allDefaultGetters \|\| cfg.defaultGetters.contains(entry->name)) {
310		stream << whitespace() << "";
311		if (cfg.staticAccessors) {
312		stream << "static ";
313		}
314		stream << cppType(entry->type) << " " << getDefaultFunction(entry->name) << "_helper(";
315		if (!entry->param.isEmpty()) {
316		stream << " " << cppType(entry->paramType) << " i ";
317		}
318		stream << ")" << Const << ";" << endl;
319		}
320		}
321		stream << whitespace() << "" << cfg.className << "Private *d;" << endl;
322		}
323
324		void KConfigHeaderGenerator::createConstructor()
325		{
326		if (cfg.singleton) {
327		stream << whitespace() << "static " << cfg.className << " *self();" << endl;
328		if (parseResult.cfgFileNameArg) {
329		stream << whitespace() << "static void instance(const QString& cfgfilename);" << endl;
330		stream << whitespace() << "static void instance(KSharedConfig::Ptr config);" << endl;
331		}
332		return;
333		}
334
335		stream << whitespace() << "" << cfg.className << "(";
336		if (parseResult.cfgFileNameArg) {
337		if (cfg.forceStringFilename)
338		stream << " const QString &cfgfilename" << (parseResult.parameters.isEmpty() ? " = QString()" : ", ");
339		else
340		stream << " KSharedConfig::Ptr config" << (parseResult.parameters.isEmpty() ? " = KSharedConfig::openConfig()" : ", ");
341		}
342
343		bool first = true;
344		for (const auto parameter : qAsConst(parseResult.parameters)) {
345		if (first) {
346		first = false;
347		} else {
348		stream << ",";
349		}
350
351		stream << " " << param(parameter.type) << " " << parameter.name;
352		}
353
354		if (cfg.parentInConstructor) {
355		if (parseResult.cfgFileNameArg \|\| !parseResult.parameters.isEmpty()) {
356		stream << ",";
357		}
358		stream << " QObject *parent = nullptr";
359		}
360		stream << " );" << endl;
361		}
362
363		void KConfigHeaderGenerator::createDestructor()
364		{
365		stream << whitespace() << "~" << cfg.className << "();" << endl << endl;
366		}
367
368		void KConfigHeaderGenerator::createForwardDeclarations()
369		{
370		// Private class declaration
371		if (cfg.dpointer) {
372		stream << "class " << cfg.className << "Private;" << endl << endl;
373		}
374		}
375
376		void KConfigHeaderGenerator::createProperties(const CfgEntry *entry, const QString& returnType)
377		{
378		if (!cfg.generateProperties) {
379		return;
380		}
381		stream << whitespace() << "Q_PROPERTY(" << returnType << ' ' << getFunction(entry->name);
382		stream << " READ " << getFunction(entry->name);
383
	ervinUnsubmitted Done Ditto ervin: Ditto
384		if (cfg.allMutators \|\| cfg.mutators.contains(entry->name)) {
385		const QString signal = changeSignalName(entry->name);
386		stream << " WRITE " << setFunction(entry->name);
387		stream << " NOTIFY " << signal;
388
389		//If we have the modified signal, we'll also need
390		//the changed signal as well
391		Signal s;
392		s.name = signal;
393		s.modify = true;
394		parseResult.signalList.append(s);
395		} else {
396		stream << " CONSTANT";
397		}
398		stream << ")" << endl;
399		}
400
401		void KConfigHeaderGenerator::createSetters(const CfgEntry *entry)
402		{
403		// Manipulator
404		if (!cfg.allMutators && !cfg.mutators.contains(entry->name)) {
405		return;
406		}
407
408		stream << whitespace() << "/**" << endl;
409		stream << whitespace() << " Set " << entry->label << endl;
410		stream << whitespace() << "*/" << endl;
411
412		if (cfg.staticAccessors) {
413		stream << whitespace() << "static" << endl;
414		}
415
416		stream << whitespace() << "void " << setFunction(entry->name) << "( ";
417		if (!entry->param.isEmpty()) {
418		stream <<cppType(entry->paramType) << " i, ";
419		}
420
421		stream << (cfg.useEnumTypes && entry->type == QLatin1String("Enum")
422		? enumType(entry, cfg.globalEnums)
423		: param(entry->type));
424
425		stream << " v )";
426
427		// function body inline only if not using dpointer
428		// for BC mode
429		if (!cfg.dpointer) {
430		stream << endl;
431		startScope();
432		memberMutatorBody(entry);
433		endScope();
434		stream << endl;
435		} else {
436		stream << ";" << endl << endl;
437		}
438		}
439
440		void KConfigHeaderGenerator::createGetters(const CfgEntry *entry, const QString& returnType)
441		{
442		// Accessor
443		stream << whitespace() << "/**" << endl;
444		stream << whitespace() << " Get " << entry->label << endl;
445		stream << whitespace() << "*/" << endl;
446		if (cfg.staticAccessors) {
447		stream << whitespace() << "static" << endl;
	ervinUnsubmitted Done Ditto ervin: Ditto
448		}
449		stream << whitespace() << "";
450		stream << returnType;
451		stream << " " << getFunction(entry->name) << "(";
452		if (!entry->param.isEmpty()) {
453		stream << " " << cppType(entry->paramType) << " i ";
454		}
455		stream << ")" << Const;
456
457		// function body inline only if not using dpointer
458		// for BC mode
459		if (!cfg.dpointer) {
460		stream << endl;
461		startScope();
462		stream << whitespace() << memberAccessorBody(entry, cfg.globalEnums);
463		endScope();
464		stream << endl;
465		} else {
466		stream << ";" << endl << endl;
467		}
468		}
469
470		void KConfigHeaderGenerator::createItemAcessors(const CfgEntry *entry, const QString& returnType)
471		{
472		// Item accessor
473		if (!cfg.itemAccessors) {
474		return;
475		}
476		stream << whitespace() << "/**" << endl;
477		stream << whitespace() << " Get Item object corresponding to " << entry->name << "()"
	ervinUnsubmitted Done Ditto ervin: Ditto
478		<< endl;
479		stream << whitespace() << "*/" << endl;
480		stream << whitespace() << "Item" << itemType(entry->type) << " *"
481		<< getFunction(entry->name) << "Item(";
482		if (!entry->param.isEmpty()) {
483		stream << " " << cppType(entry->paramType) << " i ";
484		}
485		stream << ")";
486		if (!cfg.dpointer) {
487		stream << endl;
488		startScope();
489		stream << whitespace() << itemAccessorBody(entry, cfg);
490		endScope();
491		} else {
492		stream << ";" << endl;
493		}
494
495		stream <<endl;
496		}
497
498		void KConfigHeaderGenerator::createDefaultValueMember(const CfgEntry *entry)
499		{
500		// Default value Accessor
501		if (! ((cfg.allDefaultGetters \|\| cfg.defaultGetters.contains(entry->name)) && !entry->defaultValue.isEmpty())) {
502		return;
503		}
504		stream << whitespace() << "/**" << endl;
505		stream << whitespace() << " Get " << entry->label << " default value" << endl;
506		stream << whitespace() << "*/" << endl;
507		if (cfg.staticAccessors) {
508		stream << whitespace() << "static" << endl;
509		}
510		stream << whitespace() << "";
511		if (cfg.useEnumTypes && entry->type == QLatin1String("Enum")) {
512		stream << enumType(entry, cfg.globalEnums);
513		} else {
514		stream << cppType(entry->type);
515		}
516		stream << " " << getDefaultFunction(entry->name) << "(";
517		if (!entry->param.isEmpty()) {
518		stream << " " << cppType(entry->paramType) << " i ";
519		}
520		stream << ")" << Const << endl;
521		stream << whitespace() << "{" << endl;
522		stream << whitespace() << " return ";
523		if (cfg.useEnumTypes && entry->type == QLatin1String("Enum")) {
524		stream << "static_cast<" << enumType(entry, cfg.globalEnums) << ">(";
525		}
526		stream << getDefaultFunction(entry->name) << "_helper(";
527		if (!entry->param.isEmpty()) {
528		stream << " i ";
529		}
530		stream << ")";
531		if (cfg.useEnumTypes && entry->type == QLatin1String("Enum")) {
532		stream << ")";
533		}
534		stream << ";" << endl;
535		stream << whitespace() << "}" << endl;
536		stream << endl;
537		}
538
539		void KConfigHeaderGenerator::createSingleton()
540		{
541		// Private constructor for singleton
542		if (!cfg.singleton) {
543		return;
544		}
545
546		stream << whitespace() << "" << cfg.className << "(";
547		if (parseResult.cfgFileNameArg) {
548		stream << "KSharedConfig::Ptr config";
549		}
550		if (cfg.parentInConstructor) {
551		if (parseResult.cfgFileNameArg) {
552		stream << ", ";
553		}
554		stream << "QObject *parent = nullptr";
555		}
556		stream << ");" << endl;
557		stream << whitespace() << "friend class " << cfg.className << "Helper;" << endl << endl;
558		}
559
560		void KConfigHeaderGenerator::createNonDPointerHelpers()
561		{
562		if (cfg.memberVariables == QLatin1String("dpointer")) {
563		return;
564		}
565
566		QString group;
567		for (auto *entry : qAsConst(parseResult.entries)) {
568		if (entry->group != group) {
569		group = entry->group;
570		stream << endl;
571		stream << whitespace() << "// " << group << endl;
572		}
573		stream << whitespace() << "" << cppType(entry->type) << " " << varName(entry->name, cfg);
574		if (!entry->param.isEmpty()) {
575		stream << QStringLiteral("[%1]").arg(entry->paramMax + 1);
576		}
577		stream << ";" << endl;
578
579		if (cfg.allDefaultGetters \|\| cfg.defaultGetters.contains(entry->name)) {
580		stream << whitespace() << "";
581		if (cfg.staticAccessors) {
582		stream << "static ";
583		}
584		stream << cppType(entry->type) << " " << getDefaultFunction(entry->name) << "_helper(";
585		if (!entry->param.isEmpty()) {
586		stream << " " << cppType(entry->paramType) << " i ";
587		}
588		stream << ")" << Const << ";" << endl;
589		}
590		}
591
592		stream << endl << " private:" << endl;
593		if (cfg.itemAccessors) {
594		for (auto *entry : qAsConst(parseResult.entries)) {
595		stream << whitespace() << "Item" << itemType(entry->type) << " *" << itemVar(entry, cfg);
596		if (!entry->param.isEmpty()) {
597		stream << QStringLiteral("[%1]").arg(entry->paramMax + 1);
598		}
599		stream << ";" << endl;
600		}
601		}
602
603		if (parseResult.hasNonModifySignals) {
604		stream << whitespace() << "uint " << varName(QStringLiteral("settingsChanged"), cfg) << ";" << endl;
605		}
606		}