|
1
|
1 /****************************************************************************
|
|
|
2 **
|
|
|
3 ** Copyright (C) 1992-2008 Nokia. All rights reserved.
|
|
|
4 **
|
|
|
5 ** This file is part of Qt Jambi.
|
|
|
6 **
|
|
|
7 ** * Commercial Usage
|
|
|
8 * Licensees holding valid Qt Commercial licenses may use this file in
|
|
|
9 * accordance with the Qt Commercial License Agreement provided with the
|
|
|
10 * Software or, alternatively, in accordance with the terms contained in
|
|
|
11 * a written agreement between you and Nokia.
|
|
|
12 *
|
|
|
13 *
|
|
|
14 * GNU General Public License Usage
|
|
|
15 * Alternatively, this file may be used under the terms of the GNU
|
|
|
16 * General Public License versions 2.0 or 3.0 as published by the Free
|
|
|
17 * Software Foundation and appearing in the file LICENSE.GPL included in
|
|
|
18 * the packaging of this file. Please review the following information
|
|
|
19 * to ensure GNU General Public Licensing requirements will be met:
|
|
|
20 * http://www.fsf.org/licensing/licenses/info/GPLv2.html and
|
|
|
21 * http://www.gnu.org/copyleft/gpl.html. In addition, as a special
|
|
|
22 * exception, Nokia gives you certain additional rights. These rights
|
|
|
23 * are described in the Nokia Qt GPL Exception version 1.2, included in
|
|
|
24 * the file GPL_EXCEPTION.txt in this package.
|
|
|
25 *
|
|
|
26 * Qt for Windows(R) Licensees
|
|
|
27 * As a special exception, Nokia, as the sole copyright holder for Qt
|
|
|
28 * Designer, grants users of the Qt/Eclipse Integration plug-in the
|
|
|
29 * right for the Qt/Eclipse Integration to link to functionality
|
|
|
30 * provided by Qt Designer and its related libraries.
|
|
|
31 *
|
|
|
32 *
|
|
|
33 * If you are unsure which license is appropriate for your use, please
|
|
|
34 * contact the sales department at qt-sales@nokia.com.
|
|
|
35
|
|
|
36 **
|
|
|
37 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
|
|
|
38 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
39 **
|
|
|
40 ****************************************************************************/
|
|
|
41
|
|
|
42 #include "containergenerator.h"
|
|
|
43 #include "cppimplgenerator.h"
|
|
|
44 #include "fileout.h"
|
|
|
45
|
|
|
46 static Indentor INDENT;
|
|
|
47
|
|
|
48 ContainerGenerator::ContainerGenerator():
|
|
|
49 DGenerator()
|
|
|
50
|
|
|
51 {
|
|
|
52 setFilenameStub("ArrayOps");
|
|
|
53 excludedTypes.clear();
|
|
|
54
|
|
|
55 // qtd2
|
|
|
56 excludedTypes << "QFuture";
|
|
|
57 }
|
|
|
58
|
|
|
59 QString ContainerGenerator::subDirectoryForPackage(const QString &package, OutputDirectoryType type) const
|
|
|
60 {
|
|
|
61 switch (type) {
|
|
|
62 case CppDirectory:
|
|
|
63 return "cpp/" + QString(package).replace(".", "_") + "/";
|
|
|
64 case DDirectory:
|
|
|
65 return QString(package).replace(".", "/");
|
|
|
66 case HDirectory:
|
|
|
67 return "include/";
|
|
|
68 default:
|
|
|
69 return QString(); // kill nonsense warnings
|
|
|
70 }
|
|
|
71 }
|
|
|
72
|
|
|
73 void ContainerGenerator::write(QTextStream &, const AbstractMetaClass *)
|
|
|
74 {
|
|
|
75 // not used
|
|
|
76 }
|
|
|
77
|
|
|
78 void ContainerGenerator::addTypeEntry(const TypeEntry* te)
|
|
|
79 {
|
|
|
80 if (!excludedTypes.contains(te->name()))
|
|
|
81 containerTypes << te;
|
|
|
82 }
|
|
|
83
|
|
|
84 void ContainerGenerator::processType(AbstractMetaType *d_type)
|
|
|
85 {
|
|
|
86 if (d_type->isContainer()) {
|
|
|
87 QList<AbstractMetaType *> args = d_type->instantiations();
|
|
|
88
|
|
|
89 if (args.size() == 1) // QVector or QList
|
|
|
90 if (args.at(0)->typeEntry()->isComplex()
|
|
|
91 && !args.at(0)->isContainer()
|
|
|
92 && !args.at(0)->isTargetLangString())
|
|
|
93 addTypeEntry(args.at(0)->typeEntry()); // qMakePair(args.at(0)->typeEntry(), m_class);
|
|
|
94 }
|
|
|
95 }
|
|
|
96
|
|
|
97 void ContainerGenerator::processFunction(const AbstractMetaFunction *d_function)
|
|
|
98 {
|
|
|
99 if (notWrappedYet(d_function)) // qtd2
|
|
|
100 return;
|
|
|
101
|
|
|
102 if (d_function->type()) {
|
|
|
103 AbstractMetaType *d_type = d_function->type();
|
|
|
104 if (d_type->isContainer()) {
|
|
|
105 processType(d_type);
|
|
|
106 }
|
|
|
107 }
|
|
|
108
|
|
|
109 AbstractMetaArgumentList arguments = d_function->arguments();
|
|
|
110 for (int i=0; i<arguments.count(); ++i) {
|
|
|
111 const AbstractMetaArgument *arg = arguments.at(i);
|
|
|
112 processType(arg->type());
|
|
|
113 }
|
|
|
114 }
|
|
|
115
|
|
|
116 void ContainerGenerator::buildTypeList()
|
|
|
117 {
|
|
|
118 foreach (AbstractMetaClass *d_class, classes()) {
|
|
|
119 m_class = d_class;
|
|
|
120 AbstractMetaFunctionList d_funcs = d_class->functionsInTargetLang();
|
|
|
121 for (int i=0; i<d_funcs.size(); ++i) {
|
|
|
122 AbstractMetaFunction *function = d_funcs.at(i);
|
|
|
123
|
|
|
124 // If a method in an interface class is modified to be private, this should
|
|
|
125 // not be present in the interface at all, only in the implementation.
|
|
|
126 if (d_class->isInterface()) {
|
|
|
127 uint includedAttributes = 0;
|
|
|
128 uint excludedAttributes = 0;
|
|
|
129 retrieveModifications(function, d_class, &excludedAttributes, &includedAttributes);
|
|
|
130 if (includedAttributes & AbstractMetaAttributes::Private)
|
|
|
131 continue;
|
|
|
132 }
|
|
|
133
|
|
|
134 processFunction(function);
|
|
|
135 }
|
|
|
136 AbstractMetaFieldList fields = d_class->fields();
|
|
|
137 foreach (const AbstractMetaField *field, fields) {
|
|
|
138 if (field->wasPublic() || (field->wasProtected() && !d_class->isFinal())) {
|
|
|
139 processFunction(field->setter());
|
|
|
140 processFunction(field->getter());
|
|
|
141 }
|
|
|
142 }
|
|
|
143
|
|
|
144 }
|
|
|
145 }
|
|
|
146
|
|
|
147 void ContainerGenerator::generate()
|
|
|
148 {
|
|
|
149 buildTypeList();
|
|
|
150
|
|
|
151 writeFile(cppFilename(), CppDirectory, &ContainerGenerator::writeCppContent); // cpp file
|
|
|
152 writeFile("ArrayOps_%1.h", HDirectory, &ContainerGenerator::writeHeaderContent); // header file
|
|
|
153 writeFile(dFilename(), DDirectory, &ContainerGenerator::writeDContent); // d file
|
|
|
154 }
|
|
|
155
|
|
|
156 void ContainerGenerator::writeFile(const QString& fileName, OutputDirectoryType dirType, WriteOut writeOut)
|
|
|
157 {
|
|
|
158 AbstractMetaClassList classList = classes();
|
|
|
159 QHash<QString, FileOut *> fileHash;
|
|
|
160
|
|
|
161 // Seems continue is not supported by our foreach loop, so
|
|
|
162 foreach (AbstractMetaClass *cls, classList) {
|
|
|
163
|
|
|
164 FileOut *f = fileHash.value(cls->package(), 0);
|
|
|
165 if (f == 0) {
|
|
|
166 f = new FileOut(outputDirectory() + "/" + subDirectoryForPackage(cls->package(), dirType) + "/" +
|
|
|
167 fileName.arg(cls->package().replace(".", "_")));
|
|
|
168 writeNotice(f->stream);
|
|
|
169
|
|
|
170 (this->*writeOut)(f->stream, cls);
|
|
|
171
|
|
|
172 fileHash.insert(cls->package(), f);
|
|
|
173
|
|
|
174 // QString pro_file_name = cls->package().replace(".", "_") + "/" + cls->package().replace(".", "_") + ".pri";
|
|
|
175 // priGenerator->addSource(pro_file_name, cppFilename());
|
|
|
176 }
|
|
|
177 }
|
|
|
178
|
|
|
179 foreach (QString package, fileHash.keys()) {
|
|
|
180 FileOut *f = fileHash.value(package, 0);
|
|
|
181 if (f != 0) {
|
|
|
182 if( f->done() )
|
|
|
183 ++m_num_generated_written;
|
|
|
184 ++m_num_generated;
|
|
|
185
|
|
|
186 delete f;
|
|
|
187 }
|
|
|
188 }
|
|
|
189 }
|
|
|
190
|
|
|
191 void ContainerGenerator::writeCppContent(QTextStream &s, AbstractMetaClass *cls)
|
|
|
192 {
|
|
|
193 QString package = cls->package().replace(".", "_");
|
|
|
194
|
|
|
195 s << "// stuff for passing D function pointers" << endl << endl
|
|
|
196 << "#ifdef CPP_SHARED" << endl << endl
|
|
|
197 << "#include \"ArrayOps_" << package << ".h\"" << endl << endl;
|
|
|
198
|
|
|
199 foreach (const TypeEntry *te, containerTypes) {
|
|
|
200 if (te->javaPackage() == cls->package()) {
|
|
|
201 const ComplexTypeEntry *centry = static_cast<const ComplexTypeEntry *>(te);
|
|
|
202 QString cls_name = centry->name();
|
|
|
203
|
|
|
204 setFuncNames(cls_name);
|
|
|
205 s << "QTD_EXPORT_VAR(" << all_name << ")" << endl
|
|
|
206 << "QTD_EXPORT_VAR(" << ass_name << ")" << endl
|
|
|
207 << "QTD_EXPORT_VAR(" << get_name << ")" << endl << endl;
|
|
|
208 }
|
|
|
209 }
|
|
|
210
|
|
|
211 s << endl
|
|
|
212 << "extern \"C\" DLL_PUBLIC void qtd_" << cls->package().replace(".", "_") << "_ArrayOps_initCallBacks(pfunc_abstr *callbacks)" << endl
|
|
|
213 << "{" << endl;
|
|
|
214
|
|
|
215 int num_funcs = 0;
|
|
|
216 foreach (const TypeEntry *te, containerTypes) {
|
|
|
217 if (te->javaPackage() == cls->package()) {
|
|
|
218 const ComplexTypeEntry *centry = static_cast<const ComplexTypeEntry *>(te);
|
|
|
219 QString cls_name = centry->name();
|
|
|
220
|
|
|
221 setFuncNames(cls_name);
|
|
|
222 s << " QTD_EXPORT_VAR_SET(" << all_name << ", callbacks[" << num_funcs + 0 << "]);" << endl
|
|
|
223 << " QTD_EXPORT_VAR_SET(" << ass_name << ", callbacks[" << num_funcs + 1 << "]);" << endl
|
|
|
224 << " QTD_EXPORT_VAR_SET(" << get_name << ", callbacks[" << num_funcs + 2 << "]);" << endl << endl;
|
|
|
225
|
|
|
226 num_funcs += NUM_ARRAY_FUNCS;
|
|
|
227 }
|
|
|
228 }
|
|
|
229 s << "}" << endl
|
|
|
230 << "#endif" << endl;
|
|
|
231 }
|
|
|
232
|
|
|
233 void ContainerGenerator::writeHeaderContent(QTextStream &s, AbstractMetaClass *cls)
|
|
|
234 {
|
|
35
|
235 QString file_upper = "ArrayOps_" + QString(cls->package()).replace(".", "_") + "_h";
|
|
|
236 file_upper = file_upper.toUpper();
|
|
|
237 s << "#ifndef " << file_upper << endl
|
|
|
238 << "#define " << file_upper << endl << endl
|
|
|
239 << "#include <cstring>" << endl
|
|
1
|
240 << "#include \"qtd_core.h\"" << endl << endl;
|
|
|
241
|
|
|
242 foreach (const TypeEntry *te, containerTypes) {
|
|
|
243 if (te->javaPackage() == cls->package()) {
|
|
|
244 const ComplexTypeEntry *typeEntry = static_cast<const ComplexTypeEntry *>(te);
|
|
|
245 s << "// " << typeEntry->name() << endl; // " in " << it.second->name() << endl;
|
|
|
246
|
|
|
247 Indentation indent(INDENT);
|
|
|
248 writeHeaderArrayFunctions(s, typeEntry);
|
|
|
249 }
|
|
|
250 }
|
|
35
|
251
|
|
|
252 s << "#endif // " << file_upper << endl;
|
|
1
|
253 }
|
|
|
254
|
|
|
255 void ContainerGenerator::setFuncNames(const QString& cls_name)
|
|
|
256 {
|
|
|
257 all_name = QString("qtd_allocate_%1_array").arg(cls_name);
|
|
|
258 ass_name = QString("qtd_assign_%1_array_element").arg(cls_name);
|
|
|
259 get_name = QString("qtd_get_%1_from_array").arg(cls_name);
|
|
|
260 }
|
|
|
261
|
|
|
262 void ContainerGenerator::writeHeaderArrayFunctions(QTextStream &s, const ComplexTypeEntry *centry)
|
|
|
263 {
|
|
|
264 QString cls_name = centry->name();
|
|
|
265 bool d_export = true;
|
|
|
266 QString d_type, cpp_type, cpp_type_assign;
|
|
|
267
|
|
|
268 if (centry->name() == "QModelIndex") {
|
|
|
269 cpp_type = "QModelIndexAccessor*";
|
|
|
270 } else if (centry->isStructInD()) {
|
|
|
271 cpp_type = centry->qualifiedCppName() + "*";
|
|
|
272 } else if (centry->isObject() || centry->isQObject() || centry->isValue() || centry->isInterface() || centry->isVariant()) {
|
|
|
273 cpp_type = "void*";
|
|
|
274 }
|
|
|
275
|
|
|
276 setFuncNames(cls_name);
|
|
|
277
|
|
|
278 s << "QTD_EXPORT(void, " << all_name << ", (void* arr, size_t len))" << endl
|
|
|
279 << "QTD_EXPORT(void, " << ass_name << ", (void* arr, size_t pos, " << cpp_type << " elem))" << endl
|
|
|
280 << "QTD_EXPORT(void, " << get_name << ", (void* arr, size_t pos, " << cpp_type << " elem))" << endl;
|
|
|
281
|
|
|
282 s << "#ifdef CPP_SHARED" << endl
|
|
|
283 << "#define " << all_name << " qtd_get_" << all_name << "()" << endl
|
|
|
284 << "#define " << ass_name << " qtd_get_" << ass_name << "()" << endl
|
|
|
285 << "#define " << get_name << " qtd_get_" << get_name << "()" << endl
|
|
|
286 << "#endif" << endl;
|
|
|
287
|
|
|
288 s << endl;
|
|
|
289 }
|
|
|
290
|
|
|
291 void ContainerGenerator::writeDContent(QTextStream &s, AbstractMetaClass *cls)
|
|
|
292 {
|
|
|
293 s << "module " << cls->package() << ".ArrayOps;" << endl << endl;
|
|
|
294
|
|
|
295 int num_funcs = 0;
|
|
|
296 foreach (const TypeEntry *te, containerTypes) {
|
|
|
297 if (te->javaPackage() == cls->package()) {
|
|
|
298 const ComplexTypeEntry *typeEntry = static_cast<const ComplexTypeEntry *>(te);
|
|
|
299 s << "// " << typeEntry->name() << endl;
|
|
|
300 writeImportString(s, typeEntry);
|
|
|
301 s << endl;
|
|
|
302
|
|
|
303 Indentation indent(INDENT);
|
|
|
304
|
|
|
305 writeArrayFunctions(s, typeEntry);
|
|
|
306 s << endl;
|
|
|
307 num_funcs += NUM_ARRAY_FUNCS;
|
|
|
308 }
|
|
|
309 }
|
|
|
310 if (num_funcs == 0)
|
|
|
311 return;
|
|
|
312
|
|
|
313 s << "version (Windows) {" << endl
|
|
|
314 << " private extern (C) void qtd_" << cls->package().replace(".", "_") << "_ArrayOps_initCallBacks(void* callbacks);" << endl << endl
|
|
|
315 << " static this() {" << endl
|
|
|
316 << " void*[" << num_funcs << "] callbacks; " << endl << endl;
|
|
|
317
|
|
|
318 num_funcs = 0;
|
|
|
319 foreach (const TypeEntry *te, containerTypes) {
|
|
|
320 if (te->javaPackage() == cls->package()) {
|
|
|
321 const ComplexTypeEntry *centry = static_cast<const ComplexTypeEntry *>(te);
|
|
|
322
|
|
|
323 QString cls_name = centry->name();
|
|
|
324 setFuncNames(cls_name);
|
|
|
325
|
|
|
326 s << " callbacks[" << num_funcs + 0 << "] = &" << all_name << ";" << endl
|
|
|
327 << " callbacks[" << num_funcs + 1 << "] = &" << ass_name << ";" << endl
|
|
|
328 << " callbacks[" << num_funcs + 2 << "] = &" << get_name << ";" << endl;
|
|
|
329
|
|
|
330 s << endl;
|
|
|
331 num_funcs += NUM_ARRAY_FUNCS;
|
|
|
332 }
|
|
|
333 }
|
|
|
334 s << " qtd_" << cls->package().replace(".", "_") << "_ArrayOps_initCallBacks(callbacks.ptr);" << endl
|
|
|
335 << " }" << endl
|
|
|
336 << "}" << endl;
|
|
|
337 }
|
|
|
338
|
|
|
339 void ContainerGenerator::writeNotice(QTextStream &s)
|
|
|
340 {
|
|
|
341 s << "/****************************************************************************" << endl
|
|
|
342 << "**" << endl
|
|
|
343 << "** This is a generated file, please don't touch." << endl
|
|
|
344 << "**" << endl
|
|
|
345 << "****************************************************************************/" << endl << endl;
|
|
|
346 }
|
|
|
347
|
|
|
348 void ContainerGenerator::writeArrayFunctions(QTextStream &s, const ComplexTypeEntry *centry)
|
|
|
349 {
|
|
|
350 QString cls_name = centry->name();
|
|
|
351 QString type_name = cls_name;
|
|
|
352
|
|
|
353 bool d_export = true;
|
|
|
354 QString d_type, cpp_type, cpp_assign_type, convert, nativeId;
|
|
|
355
|
|
|
356 convert = "qtd_" + cls_name + "_cpp_to_d(elem)";
|
|
|
357 nativeId = "";
|
|
|
358
|
|
|
359 if (centry->name() == "QModelIndex") {
|
|
|
360 cpp_type = "QModelIndexAccessor*";
|
|
|
361 cpp_assign_type = cpp_type;
|
|
|
362 d_type = cpp_type;
|
|
|
363 convert = "*elem";
|
|
|
364 } else if (centry->isStructInD()) {
|
|
|
365 cpp_type = centry->qualifiedCppName() + "*";
|
|
|
366 cpp_assign_type = cpp_type;
|
|
|
367 d_type = cpp_type;
|
|
|
368 convert = "*elem";
|
|
|
369 } else if (centry->isObject() || centry->isQObject() || centry->isValue() || centry->isInterface() || centry->isVariant()) {
|
|
|
370 cpp_type = "void*";
|
|
|
371 cpp_assign_type = cpp_type + "*";
|
|
|
372 d_type = cls_name;
|
|
110
|
373 if (centry->designatedInterface())
|
|
|
374 d_type = centry->designatedInterface()->name();
|
|
1
|
375 nativeId = ".nativeId";
|
|
|
376 }
|
|
|
377
|
|
|
378 if (centry->designatedInterface()) {
|
|
|
379 type_name = centry->designatedInterface()->name();
|
|
|
380 nativeId = ".__ptr_" + type_name;
|
|
|
381 }
|
|
|
382
|
|
|
383 s << "private extern(C) void qtd_allocate_" << cls_name << "_array(" << type_name << "[]* arr, size_t len)" << endl
|
|
|
384 << "{" << endl
|
|
|
385 << INDENT << "*arr = new " << type_name << "[len];" << endl
|
|
|
386 << "}" << endl << endl;
|
|
|
387
|
|
|
388 s << "private extern(C) void qtd_assign_" << cls_name << "_array_element(" << type_name << "[]* arr, size_t pos, " << cpp_type << " elem)" << endl
|
|
|
389 << "{" << endl
|
|
|
390 << INDENT << "(*arr)[pos] = " << convert << ";" << endl
|
|
|
391 << "}" << endl << endl
|
|
|
392
|
|
|
393 << "private extern(C) void qtd_get_" << cls_name << "_from_array(" << type_name << "* arr, size_t pos, " << cpp_assign_type << " elem)" << endl
|
|
|
394 << "{" << endl
|
|
|
395 << INDENT << "*elem = arr[pos]" << nativeId << ";" << endl
|
|
|
396 << "}" << endl << endl
|
|
|
397
|
|
|
398 << "package " << d_type << " qtd_" << cls_name << "_cpp_to_d(" << cpp_type << " __qt_return_value)" << endl
|
|
|
399 << "{" << endl;
|
|
|
400
|
|
|
401 marshallFromCppToD(s, centry);
|
|
|
402
|
|
|
403 s << "}" << endl;
|
|
|
404 }
|
