source: trunk/tools/qtconcurrent/generaterun/main.cpp

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 21.1 KB
RevLine 
[2]1/****************************************************************************
2**
[846]3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
[561]4** All rights reserved.
5** Contact: Nokia Corporation (qt-info@nokia.com)
[2]6**
7** This file is part of the tools applications of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
[561]24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
[2]27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
[561]36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
[2]38** $QT_END_LICENSE$
39**
40****************************************************************************/
41#include <QApplication>
42#include <QDebug>
43#include <QFile>
44
45#include "codegenerator.h"
46using namespace CodeGenerator;
47
48const Item argument = "arg" + Counter();
49const Item argumentRef = "&arg" + Counter();
50const Item argumentType = "Arg" + Counter();
51const Item constArgumentType = "const Arg" + Counter();
52const Item parameterType = "Param" + Counter();
53
54Group argumentTypes(argumentType); // expands to ",Arg1, Arg2, ..."
55Group argumentTypesNoPrefix(argumentType); // expands to "Arg1, Arg2, ..."
56Group arguments(argument); // expands to ",arg1, arg2, ..."
57Group argumentsNoPrefix(argument); // expands to "arg1, arg2, ..."
58Group parameterTypes(parameterType); // expands to ",Param1, Param2, ..."
59Group parameterTypesNoPrefix(parameterType); // expands to "Param1, Param2, ..."
60Group typenameTypes("typename " + parameterType + ", typename " + argumentType); // expands to " ,typename Param1, typename Arg1, ..."
61Group types(parameterType + ", " + argumentType); // expands to ", Param1, Arg1, ..."
62Group functionParameters(constArgumentType + " " + argumentRef);
63Group typenameArgumentTypes("typename " + argumentType);
64
65Group initializers(argument + "(" + argument + ")");
66Group classData(argumentType +" " + argument + ";");
67Group arglist(argument);
68Group typeList(argumentTypes);
69
70void init()
71{
72 argumentTypes.setPrefix(", ");
73 arguments.setPrefix(", ");
74 parameterTypes.setPrefix(", ");
75 typenameTypes.setPrefix(", ");
76 types.setPrefix(", ");
77 functionParameters.setPrefix(", ");
78 typenameArgumentTypes.setPrefix(", ");
79
80 initializers.setPrefix(", ");
81 classData.setSeparator(" ");
82 classData.setPrefix(" ");
83 arglist.setPrefix(", ");
84 typeList.setPrefix(", ");
85}
86
87
88Item Line(Item item)
89{
90 return item + "\n";
91}
92
93Item generateRunFunctions(int repeats)
94{
95 Item functionPointerType = "T (*)(" + parameterTypesNoPrefix + ")";
96
97 Item functionPointerParameter = "T (*functionPointer)(" + parameterTypesNoPrefix + ")";
98
99
100
101 // plain functions
102 Repeater functions = Line ("template <typename T" + typenameTypes + ">") +
103 Line ("QFuture<T> run(" + functionPointerParameter + functionParameters + ")") +
104 Line("{") +
105 Line(" return (new QT_TYPENAME SelectStoredFunctorCall" + Counter() + "<T, " +
106 functionPointerType + argumentTypes + ">::type(functionPointer" + arguments + "))->start();") +
107 Line("}");
108 functions.setRepeatCount(repeats);
109
110 // function objects by value
111 Repeater functionObjects = Line ("template <typename FunctionObject" + typenameArgumentTypes + ">") +
112 Line ("QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject" + functionParameters + ")") +
113 Line("{") +
114 Line(" return (new QT_TYPENAME SelectStoredFunctorCall" + Counter() +
115 "<QT_TYPENAME FunctionObject::result_type, FunctionObject" +
116 argumentTypes + ">::type(functionObject" + arguments + "))->start();") +
117 Line("}");
118 functionObjects.setRepeatCount(repeats);
119
120 // function objects by pointer
121 Repeater functionObjectsPointer = Line ("template <typename FunctionObject" + typenameArgumentTypes + ">") +
122 Line ("QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject" + functionParameters + ")") +
123 Line("{") +
124 Line(" return (new QT_TYPENAME SelectStoredFunctorPointerCall" + Counter() +
125 "<QT_TYPENAME FunctionObject::result_type, FunctionObject" +
126 argumentTypes + ">::type(functionObject" + arguments + "))->start();") +
127 Line("}");
128 functionObjectsPointer.setRepeatCount(repeats);
129
130 // member functions by value
131 Repeater memberFunction = Line ("template <typename T, typename Class" + typenameTypes + ">") +
132 Line ("QFuture<T> run(const Class &object, T (Class::*fn)(" + parameterTypesNoPrefix + ")" + functionParameters + ")") +
133 Line("{") +
134 Line(" return (new QT_TYPENAME SelectStoredMemberFunctionCall" + Counter() +
135 "<T, Class" +
136 types + ">::type(fn, object" + arguments + "))->start();") +
137 Line("}");
138 memberFunction.setRepeatCount(repeats);
139
140 // const member functions by value
141 Repeater constMemberFunction = Line ("template <typename T, typename Class" + typenameTypes + ">") +
142 Line ("QFuture<T> run(const Class &object, T (Class::*fn)(" + parameterTypesNoPrefix + ") const" + functionParameters + ")") +
143 Line("{") +
144 Line(" return (new QT_TYPENAME SelectStoredConstMemberFunctionCall" + Counter() +
145 "<T, Class" +
146 types + ">::type(fn, object" + arguments + "))->start();") +
147 Line("}");
148 constMemberFunction.setRepeatCount(repeats);
149
150 // member functions by class pointer
151 Repeater memberFunctionPointer = Line ("template <typename T, typename Class" + typenameTypes + ">") +
152 Line ("QFuture<T> run(Class *object, T (Class::*fn)(" + parameterTypesNoPrefix + ")" + functionParameters + ")") +
153 Line("{") +
154 Line(" return (new QT_TYPENAME SelectStoredMemberFunctionPointerCall" + Counter() +
155 "<T, Class" +
156 types + ">::type(fn, object" + arguments + "))->start();") +
157 Line("}");
158 memberFunctionPointer.setRepeatCount(repeats);
159
160 // const member functions by class pointer
161 Repeater constMemberFunctionPointer = Line ("template <typename T, typename Class" + typenameTypes + ">") +
162 Line ("QFuture<T> run(const Class *object, T (Class::*fn)(" + parameterTypesNoPrefix + ") const" + functionParameters + ")") +
163 Line("{") +
164 Line(" return (new QT_TYPENAME SelectStoredConstMemberFunctionPointerCall" + Counter() +
165 "<T, Class" +
166 types + ">::type(fn, object" + arguments + "))->start();") +
167 Line("}");
168 constMemberFunctionPointer.setRepeatCount(repeats);
169
170
171 Item interfaceFunctionPointerType = "void (*)(QFutureInterface<T> &" + argumentTypes + ")";
172 Item interfaceFunctionPointerParameter = "void (*functionPointer)(QFutureInterface<T> &" + argumentTypes + ")";
173/*
174 // QFutureInterface functions
175 Repeater interfaceFunctions = Line ("template <typename T" + typenameTypes + ">") +
176 Line ("QFuture<T> run(" + interfaceFunctionPointerParameter + functionParameters + ")") +
177 Line("{") +
178 Line(" return (new StoredInterfaceFunctionCall" + Counter() + "<T, " +
179 interfaceFunctionPointerType + typenameArgumentTypes + ">(functionPointer" + arguments + "))->start();") +
180 Line("}");
181 functions.setRepeatCount(repeats);
182 interfaceFunctions.setRepeatCount(repeats);
183
184 // member functions by class pointer
185 Repeater interfaceMemberFunction = Line ("template <typename Class, typename T" + typenameTypes + ">") +
186 Line ("QFuture<T> run(void (Class::*fn)(QFutureInterface<T> &), Class *object" + functionParameters + ")") +
187 Line("{") +
188 Line(" return (new StoredInterfaceMemberFunctionCall" + Counter() +
189 "<T, void (Class::*)(QFutureInterface<T> &), Class" +
190 typenameArgumentTypes + ">(fn, object" + arguments + "))->start();") +
191 Line("}");
192 memberFunctionPointer.setRepeatCount(repeats);
193*/
194 return functions + Line("") + functionObjects + Line("") + functionObjectsPointer + Line("")
195 + memberFunction + Line("") + constMemberFunction + Line("")
196 + memberFunctionPointer + Line("") + constMemberFunctionPointer + Line("")
197 /* + interfaceFunctions + Line("") + interfaceMemberFunction + Line("")*/
198 ;
199}
200
201
202Item functions(Item className, Item functorType, Item callLine)
203{
204 return
205 Line("template <typename T, typename FunctionPointer" + typenameArgumentTypes + ">") +
206 Line("struct " + className + Counter() +": public RunFunctionTask<T>") +
207 Line("{") +
208 Line(" inline " + className + Counter() + "(" + functorType + " function" + functionParameters +")") +
209 Line(" : function(function)" + initializers + " {}") +
210 Line(" void runFunctor() {" + callLine + argumentsNoPrefix + "); }") +
211 Line(" " + functorType + " function;") +
212 Line( classData) +
213 Line("};") +
214 Line("");
215}
216
217Item functionSelector(Item classNameBase)
218{
219 return
220 Line("template <typename T, typename FunctionPointer" + typenameArgumentTypes + ">") +
221 Line("struct Select" + classNameBase + Counter()) +
222 Line("{") +
223 Line(" typedef typename SelectSpecialization<T>::template") +
224 Line(" Type<" + classNameBase + Counter() + " <T, FunctionPointer" + argumentTypes + ">,") +
225 Line(" Void" + classNameBase + Counter() + "<T, FunctionPointer" + argumentTypes + "> >::type type;") +
226 Line("};");
227}
228
229Item memberFunctions(Item className, Item constFunction, Item objectArgument, Item objectMember, Item callLine)
230{
231 return
232 Line("template <typename T, typename Class" + typenameTypes + ">") +
233 Line("class " + className + Counter() + " : public RunFunctionTask<T>") +
234 Line("{") +
235 Line("public:")+
236 Line(" " + className + Counter() + "(T (Class::*fn)(" + parameterTypesNoPrefix + ") " + constFunction + ", " + objectArgument + functionParameters + ")") +
237 Line(" : fn(fn), object(object)" + initializers + "{ }" ) +
238 Line("")+
239 Line(" void runFunctor()")+
240 Line(" {")+
241 Line(" " + callLine + argumentsNoPrefix + ");")+
242 Line(" }")+
243 Line("private:")+
244 Line(" T (Class::*fn)(" + parameterTypesNoPrefix + ")" + constFunction + ";")+
245 Line(" " + objectMember + ";") +
246 Line( classData) +
247 Line("};");
248}
249
250Item memberFunctionSelector(Item classNameBase)
251{
252 return
253 Line("template <typename T, typename Class" + typenameTypes + ">") +
254 Line("struct Select" + classNameBase + Counter()) +
255 Line("{") +
256 Line(" typedef typename SelectSpecialization<T>::template") +
257 Line(" Type<" + classNameBase + Counter() + " <T, Class" + types + ">,") +
258 Line(" Void" + classNameBase + Counter() + "<T, Class" + types + "> >::type type;") +
259 Line("};");
260}
261
262Item generateSFCs(int repeats)
263{
264
265 Item functionPointerTypedef = "typedef void (*FunctionPointer)(" + argumentTypesNoPrefix + ");";
266
267 Repeater dataStructures =
268
269 // Function objects by value
270 functions(Item("StoredFunctorCall"), Item("FunctionPointer"), Item(" this->result = function(")) +
271 functions(Item("VoidStoredFunctorCall"), Item("FunctionPointer"), Item(" function(")) +
272 functionSelector(Item("StoredFunctorCall")) +
273
274 // Function objects by pointer
275 functions(Item("StoredFunctorPointerCall"), Item("FunctionPointer *"), Item(" this->result =(*function)(")) +
276 functions(Item("VoidStoredFunctorPointerCall"), Item("FunctionPointer *"), Item("(*function)(")) +
277 functionSelector(Item("StoredFunctorPointerCall")) +
278
279 // Member functions by value
280 memberFunctions(Item("StoredMemberFunctionCall"), Item(""), Item("const Class &object"), Item("Class object"), Item("this->result = (object.*fn)(")) +
281 memberFunctions(Item("VoidStoredMemberFunctionCall"), Item(""), Item("const Class &object"), Item("Class object"), Item("(object.*fn)(")) +
282 memberFunctionSelector(Item("StoredMemberFunctionCall")) +
283
284 // Const Member functions by value
285 memberFunctions(Item("StoredConstMemberFunctionCall"), Item("const"), Item("const Class &object"), Item("const Class object"), Item("this->result = (object.*fn)(")) +
286 memberFunctions(Item("VoidStoredConstMemberFunctionCall"), Item("const"), Item("const Class &object"), Item("const Class object"), Item("(object.*fn)(")) +
287 memberFunctionSelector(Item("StoredConstMemberFunctionCall")) +
288
289 // Member functions by pointer
290 memberFunctions(Item("StoredMemberFunctionPointerCall"), Item(""), Item("Class *object"), Item("Class *object"), Item("this->result = (object->*fn)(")) +
291 memberFunctions(Item("VoidStoredMemberFunctionPointerCall"), Item(""), Item("Class *object"), Item("Class *object"), Item("(object->*fn)(")) +
292 memberFunctionSelector(Item("StoredMemberFunctionPointerCall")) +
293
294 // const member functions by pointer
295 memberFunctions(Item("StoredConstMemberFunctionPointerCall"), Item("const"), Item("Class const *object"), Item("Class const *object"), Item("this->result = (object->*fn)(")) +
296 memberFunctions(Item("VoidStoredConstMemberFunctionPointerCall"), Item("const"), Item("Class const *object"), Item("Class const *object"), Item("(object->*fn)(")) +
297 memberFunctionSelector(Item("StoredConstMemberFunctionPointerCall"));
298
299 dataStructures.setRepeatCount(repeats);
300 return dataStructures;
301}
302
303void writeFile(QString fileName, QByteArray contents)
304{
305 QFile runFile(fileName);
306 if (runFile.open(QIODevice::WriteOnly) == false) {
307 qDebug() << "Write to" << fileName << "failed";
308 return;
309 }
310
311 runFile.write(contents);
312 runFile.close();
313 qDebug() << "Write to" << fileName << "Ok";
314}
315
316Item dollarQuote(Item item)
317{
318 return Item("$") + item + Item("$");
319}
320
321int main()
322{
323 const int repeats = 6;
324 init();
325 Item run = (
326 Line("/****************************************************************************") +
327 Line("**") +
[846]328 Line("** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).") +
[561]329 Line("** Contact: Nokia Corporation (qt-info@nokia.com)") +
[2]330 Line("**") +
[561]331 Line("** This file is part of the Qt Toolkit.") +
[2]332 Line("**") +
333 Line("****************************************************************************/") +
334 Line("") +
335 Line("// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/") +
336 Line("#ifndef QTCONCURRENT_RUN_H") +
337 Line("#define QTCONCURRENT_RUN_H") +
338 Line("") +
339 Line("#ifndef QT_NO_CONCURRENT") +
340 Line("") +
341 Line("#include <QtCore/qtconcurrentrunbase.h>") +
342 Line("#include <QtCore/qtconcurrentstoredfunctioncall.h>") +
343 Line("") +
344 Line("QT_BEGIN_HEADER") +
345 Line("QT_BEGIN_NAMESPACE") +
346 Line("") +
347 Line("QT_MODULE(Core)") +
348 Line("") +
349 Line("#ifdef qdoc") +
350 Line("") +
351 Line("namespace QtConcurrent {") +
352 Line("") +
353 Line(" template <typename T>") +
354 Line(" QFuture<T> run(Function function, ...);") +
355 Line("") +
356 Line("} // namespace QtConcurrent") +
357 Line("") +
358 Line("#else") +
359 Line("") +
360 Line("namespace QtConcurrent {") +
361 Line("") +
362 generateRunFunctions(repeats) +
363 Line("} //namespace QtConcurrent") +
364 Line("") +
365 Line("#endif // qdoc") +
366 Line("") +
367 Line("QT_END_NAMESPACE") +
368 Line("QT_END_HEADER") +
369 Line("") +
370 Line("#endif")
371 );
372
373 writeFile("../../../src/corelib/concurrent/qtconcurrentrun.h", run.generate());
374
375 Item storedFunctionCall = (
376 Line("/****************************************************************************") +
377 Line("**") +
[846]378 Line("** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).") +
[561]379 Line("** Contact: Nokia Corporation (qt-info@nokia.com)") +
[2]380 Line("**") +
[561]381 Line("** This file is part of the Qt Toolkit.") +
[2]382 Line("**") +
383 Line("****************************************************************************/") +
384 Line("") +
385 Line("// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/") +
386 Line("#ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H") +
387 Line("#define QTCONCURRENT_STOREDFUNCTIONCALL_H") +
388 Line("") +
389 Line("#include <QtCore/qglobal.h>") +
390 Line("") +
391 Line("#ifndef QT_NO_CONCURRENT") +
392 Line("#include <QtCore/qtconcurrentrunbase.h>") +
393 Line("") +
394 Line("QT_BEGIN_HEADER") +
395 Line("QT_BEGIN_NAMESPACE") +
396 Line("") +
397 Line("QT_MODULE(Core)") +
398 Line("") +
399 Line("#ifndef qdoc") +
400 Line("") +
401 Line("namespace QtConcurrent {") +
402 generateSFCs(repeats) +
403 Line("} //namespace QtConcurrent") +
404 Line("") +
405 Line("#endif // qdoc") +
406 Line("") +
407 Line("QT_END_NAMESPACE") +
408 Line("QT_END_HEADER") +
409 Line("") +
410 Line("#endif // QT_NO_CONCURRENT") +
411 Line("") +
412 Line("#endif")
413 );
414
415 writeFile("../../../src/corelib/concurrent/qtconcurrentstoredfunctioncall.h", storedFunctionCall.generate());
416}
417
418
Note: See TracBrowser for help on using the repository browser.