source: branches/vendor/trolltech/qt/current/tools/qtconcurrent/generaterun/main.cpp @ 2

Last change on this file since 2 was 2, checked in by Dmitry A. Kuminov, 13 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.

File size: 21.4 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information (qt-info@nokia.com)
5**
6** This file is part of the tools applications of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file.  Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
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**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at qt-sales@nokia.com.
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("**") +
328                       Line("** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).") +
329                       Line("** Contact: Qt Software Information (qt-info@nokia.com)") +
330                       Line("**") +
331                       Line("** This file is part of the " + dollarQuote("MODULE") + " of the Qt Toolkit.") +
332                       Line("**") +
333                       Line("** " + dollarQuote("TROLLTECH_DUAL_LICENSE")) +
334                       Line("**") +
335                       Line("****************************************************************************/") +
336                       Line("") +
337                       Line("// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/") +
338                       Line("#ifndef QTCONCURRENT_RUN_H") +
339                       Line("#define QTCONCURRENT_RUN_H") +
340                       Line("") +
341                       Line("#ifndef QT_NO_CONCURRENT") +
342                       Line("") +
343                       Line("#include <QtCore/qtconcurrentrunbase.h>") +
344                       Line("#include <QtCore/qtconcurrentstoredfunctioncall.h>") +
345                       Line("") +
346                       Line("QT_BEGIN_HEADER") +
347                       Line("QT_BEGIN_NAMESPACE") +
348                       Line("") +
349                       Line("QT_MODULE(Core)") +
350                       Line("") +
351                       Line("#ifdef qdoc") +
352                       Line("") +
353                       Line("namespace QtConcurrent {") +
354                       Line("") +
355                       Line("    template <typename T>") +
356                       Line("    QFuture<T> run(Function function, ...);") +
357                       Line("") +
358                       Line("} // namespace QtConcurrent") +
359                       Line("") +
360                       Line("#else") +
361                       Line("") +
362                       Line("namespace QtConcurrent {") +
363                       Line("") +
364                       generateRunFunctions(repeats) +
365                       Line("} //namespace QtConcurrent") +
366                       Line("") +
367                       Line("#endif // qdoc") +
368                       Line("") +
369                       Line("QT_END_NAMESPACE") +
370                       Line("QT_END_HEADER") +
371                       Line("") +
372                       Line("#endif")
373                      );
374
375    writeFile("../../../src/corelib/concurrent/qtconcurrentrun.h", run.generate());
376
377    Item storedFunctionCall = (
378                                     Line("/****************************************************************************") +
379                                     Line("**") +
380                                     Line("** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).") +
381                                     Line("** Contact: Qt Software Information (qt-info@nokia.com)") +
382                                     Line("**") +
383                                     Line("** This file is part of the " + dollarQuote("MODULE") + " of the Qt Toolkit.") +
384                                     Line("**") +
385                                     Line("** " + dollarQuote("TROLLTECH_DUAL_LICENSE")) +
386                                     Line("**") +
387                                     Line("****************************************************************************/") +
388                                     Line("") +
389                                     Line("// Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/") +
390                                     Line("#ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H") +
391                                     Line("#define QTCONCURRENT_STOREDFUNCTIONCALL_H") +
392                                     Line("") +
393                                     Line("#include <QtCore/qglobal.h>") +
394                                     Line("") +
395                                     Line("#ifndef QT_NO_CONCURRENT") +
396                                     Line("#include <QtCore/qtconcurrentrunbase.h>") +
397                                     Line("") +
398                                     Line("QT_BEGIN_HEADER") +
399                                     Line("QT_BEGIN_NAMESPACE") +
400                                     Line("") +
401                                     Line("QT_MODULE(Core)") +
402                                     Line("") +
403                                     Line("#ifndef qdoc") +
404                                     Line("") +
405                                     Line("namespace QtConcurrent {") +
406                                     generateSFCs(repeats) +
407                                     Line("} //namespace QtConcurrent") +
408                                     Line("") +
409                                     Line("#endif // qdoc") +
410                                     Line("") +
411                                     Line("QT_END_NAMESPACE") +
412                                     Line("QT_END_HEADER") +
413                                     Line("") +
414                                     Line("#endif // QT_NO_CONCURRENT") +
415                                     Line("") +
416                                     Line("#endif")
417                                    );
418
419    writeFile("../../../src/corelib/concurrent/qtconcurrentstoredfunctioncall.h", storedFunctionCall.generate());
420}
421
422
Note: See TracBrowser for help on using the repository browser.