Differential D26202 Diff 72371 src/kconfig_compiler/KConfigSourceGenerator.cpp

Changeset View

Standalone View

View Options

src/kconfig_compiler/KConfigSourceGenerator.cpp

  • This file was added.
1​#include "KConfigSourceGenerator.h"
2​#include "KConfigCommonStructs.h"
3​
4​#include <QDebug>
5​
6​KConfigSourceGenerator::KConfigSourceGenerator(
7​ const QString& inputFile,
8​ const QString& baseDir,
9​ const KConfigXTParameters &cfg,
10​ ParseResult &parseResult)
11​ : KConfigCodeGenerator(inputFile, baseDir, cfg.baseName + QLatin1Char('.') + cfg.sourceExtension, cfg, parseResult)
12​{
13​}
14​
15​void KConfigSourceGenerator::start()
16​{
17​ KConfigCodeGenerator::start();
18​ stream << endl;
19​ createHeaders();
20​ stream << endl;
21​
22​ if (!cfg.nameSpace.isEmpty()) {
23​ stream << "using namespace " << cfg.nameSpace << ";";
24​ stream << endl << endl;
25​ }
26​
27​ createPrivateDPointerImplementation();
28​ createSingletonImplementation();
29​ createPreamble();
30​ doConstructor();
31​ doGetterSetterDPointerMode();
32​ createDefaultValueGetterSetter();
ervinUnsubmitted
Done

Ditto

ervin: Ditto
33​ createDestructor();
34​ createNonModifyingSignalsHelper();
35​ createSignalFlagsHandler();
36​ includeMoc();
37​}
38​
39​void KConfigSourceGenerator::createHeaders()
40​{
41​ qDebug() << "Source Includes" << cfg.sourceIncludes;
dfaureUnsubmitted
Done

remove (or switch to qCDebug)

dfaure: remove (or switch to qCDebug)
tcanabravaAuthorUnsubmitted
Done

removed, those are temporaries debug calls that I used to be sure things are as supposed.

tcanabrava: removed, those are temporaries debug calls that I used to be sure things are as supposed.
42​
43​
44​ QString headerName = cfg.baseName + QLatin1Char('.') + cfg.headerExtension;
45​
46​ // TODO: Make addQuotes return a string instead of replacing it inplace.
47​ addQuotes(headerName);
48​
49​ addHeaders({ headerName });
50​ addHeaders(cfg.sourceIncludes);
51​ if (cfg.setUserTexts && cfg.translationSystem == KConfigXTParameters::KdeTranslation) {
52​ addHeaders({QStringLiteral("klocalizedstring")});
53​ stream << endl;
54​ }
55​
56​ // Header required by singleton implementation
57​ if (cfg.singleton) {
58​ addHeaders({QStringLiteral("qglobal.h"), QStringLiteral("QFile")});
59​ }
60​ if (cfg.singleton && parseResult.cfgFileNameArg) {
dfaureUnsubmitted
Done

There are still some qDebugs, please do a patch-wide search.

dfaure: There are still some qDebugs, please do a patch-wide search.
61​ addHeaders({QStringLiteral("QDebug")});
62​ }
63​}
64​
65​void KConfigSourceGenerator::createPrivateDPointerImplementation()
66​{
67​ // private class implementation
68​ if (!cfg.dpointer) {
69​ return;
70​ }
71​
72​ QString group;
73​ beginNamespaces();
74​ stream << "class " << cfg.className << "Private" << endl;
75​ stream << "{" << endl;
76​ stream << " public:" << endl;
77​
78​ // Create Members
79​ for (auto *entry : qAsConst(parseResult.entries)) {
80​ if (entry->group != group) {
81​ group = entry->group;
82​ stream << endl;
83​ stream << " // " << group << endl;
84​ }
85​ stream << " " << cppType(entry->type) << " " << varName(entry->name, cfg);
86​ if (!entry->param.isEmpty()) {
87​ stream << QStringLiteral("[%1]").arg(entry->paramMax + 1);
88​ }
89​ stream << ";" << endl;
90​ }
91​ stream << endl << " // items" << endl;
92​
93​ // Create Items.
94​ for (auto *entry : qAsConst(parseResult.entries)) {
95​ const QString declType = entry->signalList.isEmpty()
96​ ? QString(cfg.inherits + QStringLiteral("::Item") + itemType(entry->type))
97​ : QStringLiteral("KConfigCompilerSignallingItem");
98​
99​ stream << " " << declType << " *" << itemVar( entry, cfg );
100​ if (!entry->param.isEmpty()) {
101​ stream << QStringLiteral("[%1]").arg(entry->paramMax + 1);
102​ }
103​ stream << ";" << endl;
104​ }
105​
106​ if (parseResult.hasNonModifySignals) {
107​ stream << " uint " << varName(QStringLiteral("settingsChanged"), cfg) << ";" << endl;
108​ }
109​
110​ stream << "};" << endl << endl;
111​ endNamespaces();
112​}
113​
114​void KConfigSourceGenerator::createSingletonImplementation()
115​{
116​ // Singleton implementation
117​ if (!cfg.singleton) {
118​ return;
119​ }
120​
121​ beginNamespaces();
122​ stream << "class " << cfg.className << "Helper" << endl;
123​ stream << '{' << endl;
124​ stream << " public:" << endl;
125​ stream << " " << cfg.className << "Helper() : q(nullptr) {}" << endl;
126​ stream << " ~" << cfg.className << "Helper() { delete q; }" << endl;
127​ stream << " " << cfg.className << "Helper(const " << cfg.className << "Helper&) = delete;" << endl;
128​ stream << " " << cfg.className << "Helper& operator=(const " << cfg.className << "Helper&) = delete;" << endl;
129​ stream << " " << cfg.className << " *q;" << endl;
130​ stream << "};" << endl;
131​ endNamespaces();
132​
133​ stream << "Q_GLOBAL_STATIC(" << cfg.className << "Helper, s_global" << cfg.className << ")" << endl;
134​
135​ stream << cfg.className << " *" << cfg.className << "::self()" << endl;
136​ stream << "{" << endl;
137​ if (parseResult.cfgFileNameArg) {
138​ stream << " if (!s_global" << cfg.className << "()->q)" << endl;
139​ stream << " qFatal(\"you need to call " << cfg.className << "::instance before using\");" << endl;
140​ } else {
141​ stream << " if (!s_global" << cfg.className << "()->q) {" << endl;
142​ stream << " new " << cfg.className << ';' << endl;
143​ stream << " s_global" << cfg.className << "()->q->read();" << endl;
144​ stream << " }" << endl << endl;
145​ }
146​ stream << " return s_global" << cfg.className << "()->q;" << endl;
147​ stream << "}" << endl << endl;
148​
149​ if (parseResult.cfgFileNameArg) {
150​ auto instance = [this] (const QString &type, const QString &arg, bool isString) {
151​ stream << "void " << cfg.className << "::instance(" << type << " " << arg << ")" << endl;
152​ stream << "{" << endl;
153​ stream << " if (s_global" << cfg.className << "()->q) {" << endl;
154​ stream << " qDebug() << \"" << cfg.className << "::instance called after the first use - ignoring\";" << endl;
155​ stream << " return;" << endl;
156​ stream << " }" << endl;
157​ stream << " new " << cfg.className << "(";
158​ if (isString) {
159​ stream << "KSharedConfig::openConfig(" << arg << ")";
160​ } else {
161​ stream << "std::move(" << arg << ")";
162​ }
163​ stream << ");" << endl;
164​ stream << " s_global" << cfg.className << "()->q->read();" << endl;
165​ stream << "}" << endl << endl;
166​ };
167​ instance(QStringLiteral("const QString&"), QStringLiteral("cfgfilename"), true);
168​ instance(QStringLiteral("KSharedConfig::Ptr"), QStringLiteral("config"), false);
169​ }
170​}
171​
172​void KConfigSourceGenerator::createPreamble()
173​{
174​ QString cppPreamble;
175​ for (const auto entry : qAsConst(parseResult.entries)) {
176​ if (entry->paramValues.isEmpty()) {
177​ continue;
178​ }
179​
180​ cppPreamble += QStringLiteral("const char* const ") + cfg.className + QStringLiteral("::") + enumName(entry->param);
181​ cppPreamble += cfg.globalEnums
182​ ? QStringLiteral("ToString[] = { \"") + entry->paramValues.join(QStringLiteral("\", \"")) + QStringLiteral("\" };\n")
183​ : QStringLiteral("::enumToString[] = { \"") + entry->paramValues.join(QStringLiteral("\", \"")) + QStringLiteral("\" };\n");
184​ }
185​
186​ if (!cppPreamble.isEmpty()) {
187​ stream << cppPreamble << endl;
188​ }
189​}
190​
191​void KConfigSourceGenerator::createConstructorParameterList()
192​{
193​ if (parseResult.cfgFileNameArg) {
194​ if (! cfg.forceStringFilename) {
195​ stream << " KSharedConfig::Ptr config";
196​ } else {
197​ stream << " const QString& config";
198​ }
199​ stream << (parseResult.parameters.isEmpty() ? "" : ",");
200​ }
201​
202​ for (QList<Param>::ConstIterator it = parseResult.parameters.constBegin();
203​ it != parseResult.parameters.constEnd(); ++it) {
204​ if (it != parseResult.parameters.constBegin()) {
205​ stream << ",";
206​ }
207​ stream << " " << param((*it).type) << " " << (*it).name;
208​ }
209​
210​ if (cfg.parentInConstructor) {
211​ if (parseResult.cfgFileNameArg || !parseResult.parameters.isEmpty()) {
212​ stream << ",";
213​ }
214​ stream << " QObject *parent";
215​ }
216​
217​}
218​
219​void KConfigSourceGenerator::createParentConstructorCall()
220​{
221​ stream << cfg.inherits << "(";
222​ if (!parseResult.cfgFileName.isEmpty()) {
223​ stream << " QStringLiteral( \"" << parseResult.cfgFileName << "\" ";
224​ }
225​ if (parseResult.cfgFileNameArg) {
dfaureUnsubmitted
Done

no space after '!'

dfaure: no space after '!'
226​ if (! cfg.forceStringFilename) {
227​ stream << " std::move( config ) ";
228​ } else {
229​ stream << " config ";
230​ }
231​ }
232​ if (!parseResult.cfgFileName.isEmpty()) {
233​ stream << ") ";
234​ }
235​ stream << ")" << endl;
236​}
237​
238​void KConfigSourceGenerator::createInitializerList()
239​{
240​ for (const auto &parameter : parseResult.parameters) {
241​ stream << " , mParam" << parameter.name << "(" << parameter.name << ")" << endl;
242​ }
243​
244​ if (parseResult.hasNonModifySignals && !cfg.dpointer) {
245​ stream << " , " << varName(QStringLiteral("settingsChanged"), cfg) << "(0)" << endl;
246​ }
247​}
248​
249​void KConfigSourceGenerator::createEnums(CfgEntry *entry)
250​{
251​ if (entry->type != QLatin1String("Enum")) {
252​ return;
253​ }
254​ stream << " QList<" << cfg.inherits << "::ItemEnum::Choice> values" << entry->name << ";" << endl;
255​
256​ for (const auto &choice : entry->choices.choices) {
257​ stream << " {" << endl;
258​ stream << " " << cfg.inherits << "::ItemEnum::Choice choice;" << endl;
259​ stream << " choice.name = QStringLiteral(\"" << choice.name << "\");" << endl;
260​ if (cfg.setUserTexts) {
261​ if (!choice.label.isEmpty()) {
262​ stream << " choice.label = "
263​ << translatedString(cfg, choice.label, choice.context)
264​ << ";" << endl;
265​ }
266​ if (!choice.toolTip.isEmpty()) {
267​ stream << " choice.toolTip = "
268​ << translatedString(cfg, choice.toolTip, choice.context)
269​ << ";" << endl;
270​ }
271​ if (!choice.whatsThis.isEmpty()) {
272​ stream << " choice.whatsThis = "
273​ << translatedString(cfg, choice.whatsThis, choice.context)
274​ << ";" << endl;
275​ }
276​ }
277​ stream << " values" << entry->name << ".append( choice );" << endl;
278​ stream << " }" << endl;
279​ }
280​}
281​
282​void KConfigSourceGenerator::createNormalEntry(CfgEntry *entry, const QString& key)
283​{
284​ stream << " " << itemPath(entry, cfg) << " = "
285​ << newItem(entry, key, entry->defaultValue, cfg) << endl;
286​
287​ if (!entry->min.isEmpty()) {
288​ stream << " " << itemPath(entry, cfg) << "->setMinValue(" << entry->min << ");" << endl;
289​ }
290​ if (!entry->max.isEmpty()) {
291​ stream << " " << itemPath(entry, cfg) << "->setMaxValue(" << entry->max << ");" << endl;
292​ }
293​
294​ if (cfg.setUserTexts) {
295​ stream << userTextsFunctions(entry, cfg);
296​ }
297​
298​ if (cfg.allNotifiers || cfg.notifiers.contains(entry->name)) {
299​ stream << " " << itemPath(entry, cfg) << "->setWriteFlags(KConfigBase::Notify);" << endl;
300​ }
301​
302​ stream << " addItem( " << itemPath(entry, cfg);
303​ QString quotedName = entry->name;
304​ addQuotes(quotedName);
305​ if (quotedName != key) {
306​ stream << ", QStringLiteral( \"" << entry->name << "\" )";
307​ }
308​ stream << " );" << endl;
309​}
310​
311​void KConfigSourceGenerator::createIndexedEntry(CfgEntry *entry, const QString& key)
312​{
313​ for (int i = 0; i <= entry->paramMax; i++) {
314​ QString itemVarStr(itemPath(entry, cfg) + QStringLiteral("[%1]").arg(i));
315​
ervinUnsubmitted
Done

Ditto

ervin: Ditto
316​ QString defaultStr = !entry->paramDefaultValues[i].isEmpty() ? entry->paramDefaultValues[i]
317​ : !entry->defaultValue.isEmpty() ? paramString(entry->defaultValue, entry, i)
318​ : defaultValue(entry->type);
319​
320​ stream << " " << itemVarStr << " = "
321​ << newItem(entry, paramString(key, entry, i), defaultStr, cfg, QStringLiteral("[%1]").arg(i)) << endl;
322​
323​ if (cfg.setUserTexts) {
324​ stream << userTextsFunctions(entry, cfg, itemVarStr, entry->paramName);
325​ }
326​
327​ // Make mutators for enum parameters work by adding them with $(..) replaced by the
328​ // param name. The check for isImmutable in the set* functions doesn't have the param
329​ // name available, just the corresponding enum value (int), so we need to store the
330​ // param names in a separate static list!.
331​ const bool isEnum = entry->paramType == QLatin1String("Enum");
332​ const QString arg = isEnum ? entry->paramValues[i] : QString::number(i);
333​
334​ stream << " addItem( " << itemVarStr << ", QStringLiteral( \"";
335​ stream << entry->paramName.replace(QStringLiteral("$(") + entry->param + QLatin1Char(')'), QLatin1String("%1")).arg( arg );
336​ stream << "\" ) );" << endl;
337​ }
338​}
339​
340​void KConfigSourceGenerator::handleCurrentGroupChange(CfgEntry *entry)
341​{
342​ if (entry->group == mCurrentGroup) {
343​ return;
344​ }
ervinUnsubmitted
Done

Ditto

ervin: Ditto
345​ if (!entry->group.isEmpty()) {
346​ stream << endl;
347​ }
348​ mCurrentGroup = entry->group;
349​ stream << " setCurrentGroup( " << paramString(mCurrentGroup, parseResult.parameters) << " );";
350​ stream << endl << endl;
351​}
352​void KConfigSourceGenerator::doConstructor() {
353​
354​ // Constructor
355​ stream << cfg.className << "::" << cfg.className << "(";
356​ createConstructorParameterList();
357​ stream << " )" << endl;
358​ stream << " : ";
359​ createParentConstructorCall();
360​ createInitializerList();
361​
362​ stream << "{" << endl;
363​
364​ if (cfg.parentInConstructor) {
365​ stream << " setParent(parent);" << endl;
366​ }
367​
368​ if (cfg.dpointer) {
369​ stream << " d = new " << cfg.className << "Private;" << endl;
370​ if (parseResult.hasNonModifySignals) {
371​ stream << " " << varPath(QStringLiteral("settingsChanged"), cfg) << " = 0;" << endl;
372​ }
373​ }
374​
375​ // Needed in case the singleton class is used as baseclass for
376​ // another singleton.
377​ if (cfg.singleton) {
378​ stream << " Q_ASSERT(!s_global" << cfg.className << "()->q);" << endl;
379​ stream << " s_global" << cfg.className << "()->q = this;" << endl;
380​ }
381​
382​ if (!parseResult.signalList.isEmpty()) {
383​ // this cast to base-class pointer-to-member is valid C++
384​ // https://stackoverflow.com/questions/4272909/is-it-safe-to-upcast-a-method-pointer-and-use-it-with-base-class-pointer/
385​ stream << " KConfigCompilerSignallingItem::NotifyFunction notifyFunction ="
386​ << " static_cast<KConfigCompilerSignallingItem::NotifyFunction>(&"
387​ << cfg.className << "::itemChanged);" << endl;
388​ }
389​
390​ for (auto *entry : qAsConst(parseResult.entries)) {
391​ handleCurrentGroupChange(entry);
392​
dfaureUnsubmitted
Done

newline before '{'

dfaure: newline before '{'
393​ const QString key = paramString(entry->key, parseResult.parameters);
394​ if (!entry->code.isEmpty()) {
395​ stream << entry->code << endl;
396​ }
397​ createEnums(entry);
398​
399​ if (!cfg.dpointer) {
400​ stream << itemDeclaration(entry, cfg);
401​ }
402​
403​ if (entry->param.isEmpty()) {
404​ createNormalEntry(entry, key);
405​ } else {
406​ createIndexedEntry(entry, key);
407​ }
408​ }
409​
410​ stream << "}" << endl << endl;
411​}
412​
413​void KConfigSourceGenerator::createGetterDPointerMode(CfgEntry *entry)
414​{
415​ // Accessor
416​ if (cfg.useEnumTypes && entry->type == QLatin1String("Enum")) {
417​ stream << enumType(entry, cfg.globalEnums);
418​ } else {
419​ stream << cppType(entry->paramType);
420​ }
421​ stream << " " << getFunction(entry->name, cfg.className) << "(";
422​ if (!entry->param.isEmpty()) {
423​ stream << " " << cppType(entry->paramType) << " i ";
424​ }
425​ stream << ")" << Const << endl;
426​
427​ // function body inline only if not using dpointer
428​ // for BC mode
429​ stream << "{" << endl;
430​ stream << memberAccessorBody(entry, cfg.globalEnums, cfg);
431​ stream << "}" << endl << endl;
432​}
433​
434​void KConfigSourceGenerator::createSetterDPointerMode(CfgEntry *entry)
435​{
436​ // Manipulator
437​ if (!(cfg.allMutators || cfg.mutators.contains(entry->name))) {
438​ return;
439​ }
440​
441​ stream << "void " << setFunction(entry->name, cfg.className) << "( ";
442​ if (!entry->param.isEmpty()) {
443​ stream << cppType(entry->paramType) << " i, ";
444​ }
445​
446​ if (cfg.useEnumTypes && entry->type == QLatin1String("Enum")) {
447​ stream << enumType(entry, cfg.globalEnums);
448​ } else {
449​ stream << param(entry->type);
450​ }
451​ stream << " v )" << endl;
452​
453​ // function body inline only if not using dpointer
454​ // for BC mode
455​ stream << "{" << endl;
456​ stream << memberMutatorBody(entry, cfg);
457​ stream << "}" << endl << endl;
458​}
459​
460​void KConfigSourceGenerator::createItemGetterDPointerMode(CfgEntry *entry)
461​{
462​ // Item accessor
463​ if (!cfg.itemAccessors) {
464​ return;
465​ }
466​ stream << endl;
467​ stream << cfg.inherits << "::Item" << itemType(entry->type) << " *"
468​ << getFunction(entry->name, cfg.className) << "Item(";
469​ if (!entry->param.isEmpty()) {
470​ stream << " " << cppType(entry->paramType) << " i ";
471​ }
472​ stream << ")" << endl;
473​ stream << "{" << endl;
474​ stream << itemAccessorBody(entry, cfg);
475​ stream << "}" << endl;
476​}
477​
478​void KConfigSourceGenerator::doGetterSetterDPointerMode()
479​{
480​ if (!cfg.dpointer) {
481​ return;
482​ }
483​
484​ // setters and getters go in Cpp if in dpointer mode
485​ for (auto *entry : qAsConst(parseResult.entries)) {
486​ createGetterDPointerMode(entry);
487​ createSetterDPointerMode(entry);
488​ createItemGetterDPointerMode(entry);
489​ stream << endl;
490​ }
491​}
492​
493​void KConfigSourceGenerator::createDefaultValueGetterSetter()
494​{
495​ // default value getters always go in Cpp
496​ for (auto *entry : qAsConst(parseResult.entries)) {
497​ QString n = entry->name;
498​ QString t = entry->type;
499​
500​ // Default value Accessor, as "helper" function
501​ if ((cfg.allDefaultGetters || cfg.defaultGetters.contains(n)) && !entry->defaultValue.isEmpty()) {
502​ stream << cppType(t) << " " << getDefaultFunction(n, cfg.className) << "_helper(";
503​ if (!entry->param.isEmpty()) {
504​ stream << " " << cppType(entry->paramType) << " i ";
505​ }
506​ stream << ")" << Const << endl;
507​ stream << "{" << endl;
508​ stream << memberGetDefaultBody(entry) << endl;
509​ stream << "}" << endl << endl;
510​ }
511​ }
512​}
513​
514​void KConfigSourceGenerator::createDestructor()
515​{
516​ stream << cfg.className << "::~" << cfg.className << "()" << endl;
517​ stream << "{" << endl;
518​ if (cfg.dpointer) {
519​ stream << " delete d;" << endl;
520​ }
521​ if (cfg.singleton) {
522​ stream << " s_global" << cfg.className << "()->q = nullptr;" << endl;
523​ }
524​ stream << "}" << endl << endl;
525​}
526​
527​void KConfigSourceGenerator::createNonModifyingSignalsHelper()
528​{
529​ if (!parseResult.hasNonModifySignals) {
530​ return;
531​ }
532​ stream << "bool " << cfg.className << "::" << "usrSave()" << endl;
533​ stream << "{" << endl;
534​ stream << " const bool res = " << cfg.inherits << "::usrSave();" << endl;
535​ stream << " if (!res) return false;" << endl << endl;
536​ for (const Signal &signal : qAsConst(parseResult.signalList)) {
537​ if (signal.modify) {
538​ continue;
539​ }
540​
541​ stream << " if ( " << varPath(QStringLiteral("settingsChanged"), cfg) << " & " << signalEnumName(signal.name) << " )" << endl;
542​ stream << " Q_EMIT " << signal.name << "(";
543​ QList<SignalArguments>::ConstIterator it, itEnd = signal.arguments.constEnd();
544​ for (it = signal.arguments.constBegin(); it != itEnd;) {
545​ SignalArguments argument = *it;
546​ bool cast = false;
547​ if (cfg.useEnumTypes && argument.type == QLatin1String("Enum")) {
548​ for (int i = 0, end = parseResult.entries.count(); i < end; ++i) {
549​ if (parseResult.entries.at(i)->name == argument.variableName) {
550​ stream << "static_cast<" << enumType(parseResult.entries.at(i), cfg.globalEnums) << ">(";
551​ cast = true;
552​ break;
553​ }
554​ }
555​ }
556​ stream << varPath(argument.variableName, cfg);
557​ if (cast) {
558​ stream << ")";
559​ }
560​ if (++it != itEnd) {
561​ stream << ", ";
562​ }
563​ }
564​
565​ stream << ");" << endl;
566​ }
567​
568​ stream << " " << varPath(QStringLiteral("settingsChanged"), cfg) << " = 0;" << endl;
569​ stream << " return true;" << endl;
570​ stream << "}" << endl;
571​}
572​
573​void KConfigSourceGenerator::createSignalFlagsHandler()
574​{
575​ if (parseResult.signalList.isEmpty()) {
576​ return;
577​ }
578​
579​ stream << endl;
580​ stream << "void " << cfg.className << "::" << "itemChanged(quint64 flags) {" << endl;
581​ if (parseResult.hasNonModifySignals)
582​ stream << " " << varPath(QStringLiteral("settingsChanged"), cfg) << " |= flags;" << endl;
583​
584​ if (!parseResult.signalList.isEmpty())
585​ stream << endl;
586​
587​ for (const Signal &signal : qAsConst(parseResult.signalList)) {
588​ if (signal.modify) {
589​ stream << " if ( flags & " << signalEnumName(signal.name) << " ) {" << endl;
590​ stream << " Q_EMIT " << signal.name << "();" << endl;
591​ stream << " }" << endl;
592​ }
593​ }
594​
595​ stream << "}" << endl;
596​}
597​
598​void KConfigSourceGenerator::includeMoc() {
599​ if (parseResult.signalList.count() || cfg.generateProperties) {
600​ const QString mocFileName = cfg.baseName + QStringLiteral(".moc");
601​
602​ // Add includemoc if they are signals defined.
603​ stream << endl;
604​ stream << "#include \"" << mocFileName << "\"" << endl;
605​ stream << endl;
606​ }
607​}