57
|
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
|
|
42 #include "rcc.h"
|
|
43
|
|
44 #include <QtCore/QByteArray>
|
|
45 #include <QtCore/QDateTime>
|
|
46 #include <QtCore/QDebug>
|
|
47 #include <QtCore/QDir>
|
|
48 #include <QtCore/QDirIterator>
|
|
49 #include <QtCore/QFile>
|
|
50 #include <QtCore/QIODevice>
|
|
51 #include <QtCore/QLocale>
|
|
52 #include <QtCore/QStack>
|
|
53
|
|
54 #include <QtXml/QDomDocument>
|
|
55
|
|
56 QT_BEGIN_NAMESPACE
|
|
57
|
|
58 enum {
|
|
59 CONSTANT_USENAMESPACE = 1,
|
|
60 CONSTANT_COMPRESSLEVEL_DEFAULT = -1,
|
|
61 CONSTANT_COMPRESSTHRESHOLD_DEFAULT = 70
|
|
62 };
|
|
63
|
|
64
|
|
65 #define writeString(s) write(s, sizeof(s))
|
|
66
|
|
67 void RCCResourceLibrary::write(const char *str, int len)
|
|
68 {
|
|
69 --len; // trailing \0 on string literals...
|
|
70 int n = m_out.size();
|
|
71 m_out.resize(n + len);
|
|
72 memcpy(m_out.data() + n, str, len);
|
|
73 }
|
|
74
|
|
75 void RCCResourceLibrary::writeByteArray(const QByteArray &other)
|
|
76 {
|
|
77 m_out.append(other);
|
|
78 }
|
|
79
|
|
80 static inline QString msgOpenReadFailed(const QString &fname, const QString &why)
|
|
81 {
|
|
82 return QString::fromUtf8("Unable to open %1 for reading: %2\n").arg(fname).arg(why);
|
|
83 }
|
|
84
|
|
85
|
|
86 ///////////////////////////////////////////////////////////
|
|
87 //
|
|
88 // RCCFileInfo
|
|
89 //
|
|
90 ///////////////////////////////////////////////////////////
|
|
91
|
|
92 class RCCFileInfo
|
|
93 {
|
|
94 public:
|
|
95 enum Flags
|
|
96 {
|
|
97 NoFlags = 0x00,
|
|
98 Compressed = 0x01,
|
|
99 Directory = 0x02
|
|
100 };
|
|
101
|
|
102 RCCFileInfo(const QString &name = QString(), const QFileInfo &fileInfo = QFileInfo(),
|
|
103 QLocale::Language language = QLocale::C,
|
|
104 QLocale::Country country = QLocale::AnyCountry,
|
|
105 uint flags = NoFlags,
|
|
106 int compressLevel = CONSTANT_COMPRESSLEVEL_DEFAULT,
|
|
107 int compressThreshold = CONSTANT_COMPRESSTHRESHOLD_DEFAULT);
|
|
108 ~RCCFileInfo();
|
|
109
|
|
110 QString resourceName() const;
|
|
111
|
|
112 public:
|
|
113 qint64 writeDataBlob(RCCResourceLibrary &lib, qint64 offset, QString *errorMessage);
|
|
114 qint64 writeDataName(RCCResourceLibrary &, qint64 offset);
|
|
115 void writeDataInfo(RCCResourceLibrary &lib);
|
|
116
|
|
117 int m_flags;
|
|
118 QString m_name;
|
|
119 QLocale::Language m_language;
|
|
120 QLocale::Country m_country;
|
|
121 QFileInfo m_fileInfo;
|
|
122 RCCFileInfo *m_parent;
|
|
123 QHash<QString, RCCFileInfo*> m_children;
|
|
124 int m_compressLevel;
|
|
125 int m_compressThreshold;
|
|
126
|
|
127 qint64 m_nameOffset;
|
|
128 qint64 m_dataOffset;
|
|
129 qint64 m_childOffset;
|
|
130 };
|
|
131
|
|
132 RCCFileInfo::RCCFileInfo(const QString &name, const QFileInfo &fileInfo,
|
|
133 QLocale::Language language, QLocale::Country country, uint flags,
|
|
134 int compressLevel, int compressThreshold)
|
|
135 {
|
|
136 m_name = name;
|
|
137 m_fileInfo = fileInfo;
|
|
138 m_language = language;
|
|
139 m_country = country;
|
|
140 m_flags = flags;
|
|
141 m_parent = 0;
|
|
142 m_nameOffset = 0;
|
|
143 m_dataOffset = 0;
|
|
144 m_childOffset = 0;
|
|
145 m_compressLevel = compressLevel;
|
|
146 m_compressThreshold = compressThreshold;
|
|
147 }
|
|
148
|
|
149 RCCFileInfo::~RCCFileInfo()
|
|
150 {
|
|
151 qDeleteAll(m_children);
|
|
152 }
|
|
153
|
|
154 QString RCCFileInfo::resourceName() const
|
|
155 {
|
|
156 QString resource = m_name;
|
|
157 for (RCCFileInfo *p = m_parent; p; p = p->m_parent)
|
|
158 resource = resource.prepend(p->m_name + QLatin1Char('/'));
|
|
159 return QLatin1Char(':') + resource;
|
|
160 }
|
|
161
|
|
162 void RCCFileInfo::writeDataInfo(RCCResourceLibrary &lib)
|
|
163 {
|
|
164 const bool text = (lib.m_format == RCCResourceLibrary::C_Code);
|
|
165 //some info
|
|
166 if (text) {
|
|
167 if (m_language != QLocale::C) {
|
|
168 lib.writeString(" // ");
|
|
169 lib.writeByteArray(resourceName().toLocal8Bit());
|
|
170 lib.writeString(" [");
|
|
171 lib.writeByteArray(QByteArray::number(m_country));
|
|
172 lib.writeString("::");
|
|
173 lib.writeByteArray(QByteArray::number(m_language));
|
|
174 lib.writeString("[\n ");
|
|
175 } else {
|
|
176 lib.writeString(" // ");
|
|
177 lib.writeByteArray(resourceName().toLocal8Bit());
|
|
178 lib.writeString("\n ");
|
|
179 }
|
|
180 }
|
|
181
|
|
182 //pointer data
|
|
183 if (m_flags & RCCFileInfo::Directory) {
|
|
184 // name offset
|
|
185 lib.writeNumber4(m_nameOffset);
|
|
186
|
|
187 // flags
|
|
188 lib.writeNumber2(m_flags);
|
|
189
|
|
190 // child count
|
|
191 lib.writeNumber4(m_children.size());
|
|
192
|
|
193 // first child offset
|
|
194 lib.writeNumber4(m_childOffset);
|
|
195 } else {
|
|
196 // name offset
|
|
197 lib.writeNumber4(m_nameOffset);
|
|
198
|
|
199 // flags
|
|
200 lib.writeNumber2(m_flags);
|
|
201
|
|
202 // locale
|
|
203 lib.writeNumber2(m_country);
|
|
204 lib.writeNumber2(m_language);
|
|
205
|
|
206 //data offset
|
|
207 lib.writeNumber4(m_dataOffset);
|
|
208 }
|
|
209 if (text)
|
|
210 lib.writeChar('\n');
|
|
211 }
|
|
212
|
|
213 qint64 RCCFileInfo::writeDataBlob(RCCResourceLibrary &lib, qint64 offset,
|
|
214 QString *errorMessage)
|
|
215 {
|
|
216 const bool text = (lib.m_format == RCCResourceLibrary::C_Code);
|
|
217
|
|
218 //capture the offset
|
|
219 m_dataOffset = offset;
|
|
220
|
|
221 //find the data to be written
|
|
222 QFile file(m_fileInfo.absoluteFilePath());
|
|
223 if (!file.open(QFile::ReadOnly)) {
|
|
224 *errorMessage = msgOpenReadFailed(m_fileInfo.absoluteFilePath(), file.errorString());
|
|
225 return 0;
|
|
226 }
|
|
227 QByteArray data = file.readAll();
|
|
228
|
|
229 #ifndef QT_NO_COMPRESS
|
|
230 // Check if compression is useful for this file
|
|
231 if (m_compressLevel != 0 && data.size() != 0) {
|
|
232 QByteArray compressed =
|
|
233 qCompress(reinterpret_cast<uchar *>(data.data()), data.size(), m_compressLevel);
|
|
234
|
|
235 int compressRatio = int(100.0 * (data.size() - compressed.size()) / data.size());
|
|
236 if (compressRatio >= m_compressThreshold) {
|
|
237 data = compressed;
|
|
238 m_flags |= Compressed;
|
|
239 }
|
|
240 }
|
|
241 #endif // QT_NO_COMPRESS
|
|
242
|
|
243 // some info
|
|
244 if (text) {
|
|
245 lib.writeString(" // ");
|
|
246 lib.writeByteArray(m_fileInfo.absoluteFilePath().toLocal8Bit());
|
|
247 lib.writeString("\n ");
|
|
248 }
|
|
249
|
|
250 // write the length
|
|
251
|
|
252 lib.writeNumber4(data.size());
|
|
253 if (text)
|
|
254 lib.writeString("\n ");
|
|
255 offset += 4;
|
|
256
|
|
257 // write the payload
|
|
258 const char *p = data.constData();
|
|
259 if (text) {
|
|
260 for (int i = data.size(), j = 0; --i >= 0; --j) {
|
|
261 lib.writeHex(*p++);
|
|
262 if (j == 0) {
|
|
263 lib.writeString("\n ");
|
|
264 j = 16;
|
|
265 }
|
|
266 }
|
|
267 } else {
|
|
268 for (int i = data.size(); --i >= 0; )
|
|
269 lib.writeChar(*p++);
|
|
270 }
|
|
271 offset += data.size();
|
|
272
|
|
273 // done
|
|
274 if (text)
|
|
275 lib.writeString("\n ");
|
|
276 return offset;
|
|
277 }
|
|
278
|
|
279 qint64 RCCFileInfo::writeDataName(RCCResourceLibrary &lib, qint64 offset)
|
|
280 {
|
|
281 const bool text = (lib.m_format == RCCResourceLibrary::C_Code);
|
|
282
|
|
283 // capture the offset
|
|
284 m_nameOffset = offset;
|
|
285
|
|
286 // some info
|
|
287 if (text) {
|
|
288 lib.writeString(" // ");
|
|
289 lib.writeByteArray(m_name.toLocal8Bit());
|
|
290 lib.writeString("\n ");
|
|
291 }
|
|
292
|
|
293 // write the length
|
|
294 lib.writeNumber2(m_name.length());
|
|
295 if (text)
|
|
296 lib.writeString("\n ");
|
|
297 offset += 2;
|
|
298
|
|
299 // write the hash
|
|
300 lib.writeNumber4(qHash(m_name));
|
|
301 if (text)
|
|
302 lib.writeString("\n ");
|
|
303 offset += 4;
|
|
304
|
|
305 // write the m_name
|
|
306 const QChar *unicode = m_name.unicode();
|
|
307 for (int i = 0; i < m_name.length(); ++i) {
|
|
308 lib.writeNumber2(unicode[i].unicode());
|
|
309 if (text && i % 16 == 0)
|
|
310 lib.writeString("\n ");
|
|
311 }
|
|
312 offset += m_name.length()*2;
|
|
313
|
|
314 // done
|
|
315 if (text)
|
|
316 lib.writeString("\n ");
|
|
317 return offset;
|
|
318 }
|
|
319
|
|
320
|
|
321 ///////////////////////////////////////////////////////////
|
|
322 //
|
|
323 // RCCResourceLibrary
|
|
324 //
|
|
325 ///////////////////////////////////////////////////////////
|
|
326
|
|
327 RCCResourceLibrary::Strings::Strings() :
|
|
328 TAG_RCC(QLatin1String("RCC")),
|
|
329 TAG_RESOURCE(QLatin1String("qresource")),
|
|
330 TAG_FILE(QLatin1String("file")),
|
|
331 ATTRIBUTE_LANG(QLatin1String("lang")),
|
|
332 ATTRIBUTE_PREFIX(QLatin1String("prefix")),
|
|
333 ATTRIBUTE_ALIAS(QLatin1String("alias")),
|
|
334 ATTRIBUTE_THRESHOLD(QLatin1String("threshold")),
|
|
335 ATTRIBUTE_COMPRESS(QLatin1String("compress"))
|
|
336 {
|
|
337 }
|
|
338
|
|
339 RCCResourceLibrary::RCCResourceLibrary()
|
|
340 : m_root(0),
|
|
341 m_format(C_Code),
|
|
342 m_verbose(false),
|
|
343 m_compressLevel(CONSTANT_COMPRESSLEVEL_DEFAULT),
|
|
344 m_compressThreshold(CONSTANT_COMPRESSTHRESHOLD_DEFAULT),
|
|
345 m_treeOffset(0),
|
|
346 m_namesOffset(0),
|
|
347 m_dataOffset(0),
|
|
348 m_useNameSpace(CONSTANT_USENAMESPACE),
|
|
349 m_errorDevice(0)
|
|
350 {
|
|
351 m_out.reserve(30 * 1000 * 1000);
|
|
352 }
|
|
353
|
|
354 RCCResourceLibrary::~RCCResourceLibrary()
|
|
355 {
|
|
356 delete m_root;
|
|
357 }
|
|
358
|
|
359 bool RCCResourceLibrary::interpretResourceFile(QIODevice *inputDevice,
|
|
360 const QString &fname, QString currentPath, bool ignoreErrors)
|
|
361 {
|
|
362 Q_ASSERT(m_errorDevice);
|
|
363 const QChar slash = QLatin1Char('/');
|
|
364 if (!currentPath.isEmpty() && !currentPath.endsWith(slash))
|
|
365 currentPath += slash;
|
|
366
|
|
367 QDomDocument document;
|
|
368 {
|
|
369 QString errorMsg;
|
|
370 int errorLine = 0;
|
|
371 int errorColumn = 0;
|
|
372 if (!document.setContent(inputDevice, &errorMsg, &errorLine, &errorColumn)) {
|
|
373 if (ignoreErrors)
|
|
374 return true;
|
|
375 const QString msg = QString::fromUtf8("RCC Parse Error: '%1' Line: %2 Column: %3 [%4]\n").arg(fname).arg(errorLine).arg(errorColumn).arg(errorMsg);
|
|
376 m_errorDevice->write(msg.toUtf8());
|
|
377 return false;
|
|
378 }
|
|
379 }
|
|
380
|
|
381 QDomElement domRoot = document.firstChildElement(m_strings.TAG_RCC).toElement();
|
|
382 if (!domRoot.isNull() && domRoot.tagName() == m_strings.TAG_RCC) {
|
|
383 for (QDomNode node = domRoot.firstChild(); !node.isNull(); node = node.nextSibling()) {
|
|
384 if (!node.isElement())
|
|
385 continue;
|
|
386
|
|
387 QDomElement child = node.toElement();
|
|
388 if (!child.isNull() && child.tagName() == m_strings.TAG_RESOURCE) {
|
|
389 QLocale::Language language = QLocale::c().language();
|
|
390 QLocale::Country country = QLocale::c().country();
|
|
391
|
|
392 if (child.hasAttribute(m_strings.ATTRIBUTE_LANG)) {
|
|
393 QString attribute = child.attribute(m_strings.ATTRIBUTE_LANG);
|
|
394 QLocale lang = QLocale(attribute);
|
|
395 language = lang.language();
|
|
396 if (2 == attribute.length()) {
|
|
397 // Language only
|
|
398 country = QLocale::AnyCountry;
|
|
399 } else {
|
|
400 country = lang.country();
|
|
401 }
|
|
402 }
|
|
403
|
|
404 QString prefix;
|
|
405 if (child.hasAttribute(m_strings.ATTRIBUTE_PREFIX))
|
|
406 prefix = child.attribute(m_strings.ATTRIBUTE_PREFIX);
|
|
407 if (!prefix.startsWith(slash))
|
|
408 prefix.prepend(slash);
|
|
409 if (!prefix.endsWith(slash))
|
|
410 prefix += slash;
|
|
411
|
|
412 for (QDomNode res = child.firstChild(); !res.isNull(); res = res.nextSibling()) {
|
|
413 if (res.isElement() && res.toElement().tagName() == m_strings.TAG_FILE) {
|
|
414
|
|
415 QString fileName(res.firstChild().toText().data());
|
|
416 if (fileName.isEmpty()) {
|
|
417 const QString msg = QString::fromUtf8("RCC: Warning: Null node in XML of '%1'\n").arg(fname);
|
|
418 m_errorDevice->write(msg.toUtf8());
|
|
419 }
|
|
420 QString alias;
|
|
421 if (res.toElement().hasAttribute(m_strings.ATTRIBUTE_ALIAS))
|
|
422 alias = res.toElement().attribute(m_strings.ATTRIBUTE_ALIAS);
|
|
423 else
|
|
424 alias = fileName;
|
|
425
|
|
426 int compressLevel = m_compressLevel;
|
|
427 if (res.toElement().hasAttribute(m_strings.ATTRIBUTE_COMPRESS))
|
|
428 compressLevel = res.toElement().attribute(m_strings.ATTRIBUTE_COMPRESS).toInt();
|
|
429 int compressThreshold = m_compressThreshold;
|
|
430 if (res.toElement().hasAttribute(m_strings.ATTRIBUTE_THRESHOLD))
|
|
431 compressThreshold = res.toElement().attribute(m_strings.ATTRIBUTE_THRESHOLD).toInt();
|
|
432
|
|
433 // Special case for -no-compress. Overrides all other settings.
|
|
434 if (m_compressLevel == -2)
|
|
435 compressLevel = 0;
|
|
436
|
|
437 alias = QDir::cleanPath(alias);
|
|
438 while (alias.startsWith(QLatin1String("../")))
|
|
439 alias.remove(0, 3);
|
|
440 alias = QDir::cleanPath(m_resourceRoot) + prefix + alias;
|
|
441
|
|
442 QString absFileName = fileName;
|
|
443 if (QDir::isRelativePath(absFileName))
|
|
444 absFileName.prepend(currentPath);
|
|
445 QFileInfo file(absFileName);
|
|
446 if (!file.exists()) {
|
|
447 m_failedResources.push_back(absFileName);
|
|
448 const QString msg = QString::fromUtf8("RCC: Error in '%1': Cannot find file '%2'\n").arg(fname).arg(fileName);
|
|
449 m_errorDevice->write(msg.toUtf8());
|
|
450 if (ignoreErrors)
|
|
451 continue;
|
|
452 else
|
|
453 return false;
|
|
454 } else if (file.isFile()) {
|
|
455 const bool arc = addFile(alias, RCCFileInfo(alias.section(slash, -1), file, language, country,
|
|
456 RCCFileInfo::NoFlags, compressLevel, compressThreshold));
|
|
457 if (!arc)
|
|
458 m_failedResources.push_back(absFileName);
|
|
459 } else {
|
|
460 QDir dir;
|
|
461 if (file.isDir()) {
|
|
462 dir.setPath(file.filePath());
|
|
463 } else {
|
|
464 dir.setPath(file.path());
|
|
465 dir.setNameFilters(QStringList(file.fileName()));
|
|
466 if (alias.endsWith(file.fileName()))
|
|
467 alias = alias.left(alias.length()-file.fileName().length());
|
|
468 }
|
|
469 if (!alias.endsWith(slash))
|
|
470 alias += slash;
|
|
471 QDirIterator it(dir, QDirIterator::FollowSymlinks|QDirIterator::Subdirectories);
|
|
472 while (it.hasNext()) {
|
|
473 it.next();
|
|
474 QFileInfo child(it.fileInfo());
|
|
475 if (child.fileName() != QLatin1String(".") && child.fileName() != QLatin1String("..")) {
|
|
476 const bool arc = addFile(alias + child.fileName(),
|
|
477 RCCFileInfo(child.fileName(), child, language, country,
|
|
478 RCCFileInfo::NoFlags, compressLevel, compressThreshold));
|
|
479 if (!arc)
|
|
480 m_failedResources.push_back(child.fileName());
|
|
481 }
|
|
482 }
|
|
483 }
|
|
484 }
|
|
485 }
|
|
486 }
|
|
487 }
|
|
488 }
|
|
489 if (m_root == 0) {
|
|
490 const QString msg = QString::fromUtf8("RCC: Warning: No resources in '%1'.\n").arg(fname);
|
|
491 m_errorDevice->write(msg.toUtf8());
|
|
492 if (!ignoreErrors && m_format == Binary) {
|
|
493 // create dummy entry, otherwise loading qith QResource will crash
|
|
494 m_root = new RCCFileInfo(QString(), QFileInfo(),
|
|
495 QLocale::C, QLocale::AnyCountry, RCCFileInfo::Directory);
|
|
496 }
|
|
497 }
|
|
498
|
|
499 return true;
|
|
500 }
|
|
501
|
|
502 bool RCCResourceLibrary::addFile(const QString &alias, const RCCFileInfo &file)
|
|
503 {
|
|
504 Q_ASSERT(m_errorDevice);
|
|
505 if (file.m_fileInfo.size() > 0xffffffff) {
|
|
506 const QString msg = QString::fromUtf8("File too big: %1\n").arg(file.m_fileInfo.absoluteFilePath());
|
|
507 m_errorDevice->write(msg.toUtf8());
|
|
508 return false;
|
|
509 }
|
|
510 if (!m_root)
|
|
511 m_root = new RCCFileInfo(QString(), QFileInfo(), QLocale::C, QLocale::AnyCountry, RCCFileInfo::Directory);
|
|
512
|
|
513 RCCFileInfo *parent = m_root;
|
|
514 const QStringList nodes = alias.split(QLatin1Char('/'));
|
|
515 for (int i = 1; i < nodes.size()-1; ++i) {
|
|
516 const QString node = nodes.at(i);
|
|
517 if (node.isEmpty())
|
|
518 continue;
|
|
519 if (!parent->m_children.contains(node)) {
|
|
520 RCCFileInfo *s = new RCCFileInfo(node, QFileInfo(), QLocale::C, QLocale::AnyCountry, RCCFileInfo::Directory);
|
|
521 s->m_parent = parent;
|
|
522 parent->m_children.insert(node, s);
|
|
523 parent = s;
|
|
524 } else {
|
|
525 parent = parent->m_children[node];
|
|
526 }
|
|
527 }
|
|
528
|
|
529 const QString filename = nodes.at(nodes.size()-1);
|
|
530 RCCFileInfo *s = new RCCFileInfo(file);
|
|
531 s->m_parent = parent;
|
|
532 parent->m_children.insertMulti(filename, s);
|
|
533 return true;
|
|
534 }
|
|
535
|
|
536 void RCCResourceLibrary::reset()
|
|
537 {
|
|
538 if (m_root) {
|
|
539 delete m_root;
|
|
540 m_root = 0;
|
|
541 }
|
|
542 m_errorDevice = 0;
|
|
543 m_failedResources.clear();
|
|
544 }
|
|
545
|
|
546
|
|
547 bool RCCResourceLibrary::readFiles(bool ignoreErrors, QIODevice &errorDevice)
|
|
548 {
|
|
549 reset();
|
|
550 m_errorDevice = &errorDevice;
|
|
551 //read in data
|
|
552 if (m_verbose) {
|
|
553 const QString msg = QString::fromUtf8("Processing %1 files [%2]\n")
|
|
554 .arg(m_fileNames.size()).arg(static_cast<int>(ignoreErrors));
|
|
555 m_errorDevice->write(msg.toUtf8());
|
|
556 }
|
|
557 for (int i = 0; i < m_fileNames.size(); ++i) {
|
|
558 QFile fileIn;
|
|
559 QString fname = m_fileNames.at(i);
|
|
560 QString pwd;
|
|
561 if (fname == QLatin1String("-")) {
|
|
562 fname = QLatin1String("(stdin)");
|
|
563 pwd = QDir::currentPath();
|
|
564 fileIn.setFileName(fname);
|
|
565 if (!fileIn.open(stdin, QIODevice::ReadOnly)) {
|
|
566 m_errorDevice->write(msgOpenReadFailed(fname, fileIn.errorString()).toUtf8());
|
|
567 return false;
|
|
568 }
|
|
569 } else {
|
|
570 pwd = QFileInfo(fname).path();
|
|
571 fileIn.setFileName(fname);
|
|
572 if (!fileIn.open(QIODevice::ReadOnly)) {
|
|
573 m_errorDevice->write(msgOpenReadFailed(fname, fileIn.errorString()).toUtf8());
|
|
574 return false;
|
|
575 }
|
|
576 }
|
|
577 if (m_verbose) {
|
|
578 const QString msg = QString::fromUtf8("Interpreting %1\n").arg(fname);
|
|
579 m_errorDevice->write(msg.toUtf8());
|
|
580 }
|
|
581
|
|
582 if (!interpretResourceFile(&fileIn, fname, pwd, ignoreErrors))
|
|
583 return false;
|
|
584 }
|
|
585 return true;
|
|
586 }
|
|
587
|
|
588 QStringList RCCResourceLibrary::dataFiles() const
|
|
589 {
|
|
590 QStringList ret;
|
|
591 QStack<RCCFileInfo*> pending;
|
|
592
|
|
593 if (!m_root)
|
|
594 return ret;
|
|
595 pending.push(m_root);
|
|
596 while (!pending.isEmpty()) {
|
|
597 RCCFileInfo *file = pending.pop();
|
|
598 for (QHash<QString, RCCFileInfo*>::iterator it = file->m_children.begin();
|
|
599 it != file->m_children.end(); ++it) {
|
|
600 RCCFileInfo *child = it.value();
|
|
601 if (child->m_flags & RCCFileInfo::Directory)
|
|
602 pending.push(child);
|
|
603 ret.append(child->m_fileInfo.filePath());
|
|
604 }
|
|
605 }
|
|
606 return ret;
|
|
607 }
|
|
608
|
|
609 // Determine map of resource identifier (':/newPrefix/images/p1.png') to file via recursion
|
|
610 static void resourceDataFileMapRecursion(const RCCFileInfo *m_root, const QString &path, RCCResourceLibrary::ResourceDataFileMap &m)
|
|
611 {
|
|
612 typedef QHash<QString, RCCFileInfo*>::const_iterator ChildConstIterator;
|
|
613 const QChar slash = QLatin1Char('/');
|
|
614 const ChildConstIterator cend = m_root->m_children.constEnd();
|
|
615 for (ChildConstIterator it = m_root->m_children.constBegin(); it != cend; ++it) {
|
|
616 const RCCFileInfo *child = it.value();
|
|
617 QString childName = path;
|
|
618 childName += slash;
|
|
619 childName += child->m_name;
|
|
620 if (child->m_flags & RCCFileInfo::Directory) {
|
|
621 resourceDataFileMapRecursion(child, childName, m);
|
|
622 } else {
|
|
623 m.insert(childName, child->m_fileInfo.filePath());
|
|
624 }
|
|
625 }
|
|
626 }
|
|
627
|
|
628 RCCResourceLibrary::ResourceDataFileMap RCCResourceLibrary::resourceDataFileMap() const
|
|
629 {
|
|
630 ResourceDataFileMap rc;
|
|
631 if (m_root)
|
|
632 resourceDataFileMapRecursion(m_root, QString(QLatin1Char(':')), rc);
|
|
633 return rc;
|
|
634 }
|
|
635
|
|
636 bool RCCResourceLibrary::output(QIODevice &outDevice, QIODevice &errorDevice)
|
|
637 {
|
|
638 m_errorDevice = &errorDevice;
|
|
639 //write out
|
|
640 if (m_verbose)
|
|
641 m_errorDevice->write("Outputting code\n");
|
|
642 if (!writeHeader()) {
|
|
643 m_errorDevice->write("Could not write header\n");
|
|
644 return false;
|
|
645 }
|
|
646 if (m_root) {
|
|
647 if (!writeDataBlobs()) {
|
|
648 m_errorDevice->write("Could not write data blobs.\n");
|
|
649 return false;
|
|
650 }
|
|
651 if (!writeDataNames()) {
|
|
652 m_errorDevice->write("Could not write file names\n");
|
|
653 return false;
|
|
654 }
|
|
655 if (!writeDataStructure()) {
|
|
656 m_errorDevice->write("Could not write data tree\n");
|
|
657 return false;
|
|
658 }
|
|
659 }
|
|
660 if (!writeInitializer()) {
|
|
661 m_errorDevice->write("Could not write footer\n");
|
|
662 return false;
|
|
663 }
|
|
664 outDevice.write(m_out, m_out.size());
|
|
665 return true;
|
|
666 }
|
|
667
|
|
668 void RCCResourceLibrary::writeHex(quint8 tmp)
|
|
669 {
|
|
670 const char * const digits = "0123456789abcdef";
|
|
671 writeChar('0');
|
|
672 writeChar('x');
|
|
673 if (tmp < 16) {
|
|
674 writeChar(digits[tmp]);
|
|
675 } else {
|
|
676 writeChar(digits[tmp >> 4]);
|
|
677 writeChar(digits[tmp & 0xf]);
|
|
678 }
|
|
679 writeChar(',');
|
|
680 }
|
|
681
|
|
682 void RCCResourceLibrary::writeNumber2(quint16 number)
|
|
683 {
|
|
684 if (m_format == RCCResourceLibrary::Binary) {
|
|
685 writeChar(number >> 8);
|
|
686 writeChar(number);
|
|
687 } else {
|
|
688 writeHex(number >> 8);
|
|
689 writeHex(number);
|
|
690 }
|
|
691 }
|
|
692
|
|
693 void RCCResourceLibrary::writeNumber4(quint32 number)
|
|
694 {
|
|
695 if (m_format == RCCResourceLibrary::Binary) {
|
|
696 writeChar(number >> 24);
|
|
697 writeChar(number >> 16);
|
|
698 writeChar(number >> 8);
|
|
699 writeChar(number);
|
|
700 } else {
|
|
701 writeHex(number >> 24);
|
|
702 writeHex(number >> 16);
|
|
703 writeHex(number >> 8);
|
|
704 writeHex(number);
|
|
705 }
|
|
706 }
|
|
707
|
|
708 bool RCCResourceLibrary::writeHeader()
|
|
709 {
|
|
710 if (m_format == C_Code) {
|
|
711 writeString("/****************************************************************************\n");
|
|
712 writeString("** Resource object code\n");
|
|
713 writeString("**\n");
|
|
714 writeString("** Created: ");
|
|
715 writeByteArray(QDateTime::currentDateTime().toString().toLatin1());
|
|
716 writeString("\n** by: The Resource Compiler for Qt version ");
|
|
717 writeByteArray(QT_VERSION_STR);
|
|
718 writeString("\n**\n");
|
|
719 writeString("** WARNING! All changes made in this file will be lost!\n");
|
|
720 writeString( "*****************************************************************************/\n\n");
|
|
721 } else if (m_format == Binary) {
|
|
722 writeString("qres");
|
|
723 writeNumber4(0);
|
|
724 writeNumber4(0);
|
|
725 writeNumber4(0);
|
|
726 writeNumber4(0);
|
|
727 }
|
|
728 return true;
|
|
729 }
|
|
730
|
|
731 bool RCCResourceLibrary::writeDataBlobs()
|
|
732 {
|
|
733 Q_ASSERT(m_errorDevice);
|
|
734 if (m_format == C_Code)
|
|
735 writeString("static const ubyte[] qt_resource_data = [\n");
|
|
736 else if (m_format == Binary)
|
|
737 m_dataOffset = m_out.size();
|
|
738 QStack<RCCFileInfo*> pending;
|
|
739
|
|
740 if (!m_root)
|
|
741 return false;
|
|
742
|
|
743 pending.push(m_root);
|
|
744 qint64 offset = 0;
|
|
745 QString errorMessage;
|
|
746 while (!pending.isEmpty()) {
|
|
747 RCCFileInfo *file = pending.pop();
|
|
748 for (QHash<QString, RCCFileInfo*>::iterator it = file->m_children.begin();
|
|
749 it != file->m_children.end(); ++it) {
|
|
750 RCCFileInfo *child = it.value();
|
|
751 if (child->m_flags & RCCFileInfo::Directory)
|
|
752 pending.push(child);
|
|
753 else {
|
|
754 offset = child->writeDataBlob(*this, offset, &errorMessage);
|
|
755 if (offset == 0)
|
|
756 m_errorDevice->write(errorMessage.toUtf8());
|
|
757 }
|
|
758 }
|
|
759 }
|
|
760 if (m_format == C_Code)
|
|
761 writeString("\n];\n\n");
|
|
762 return true;
|
|
763 }
|
|
764
|
|
765 bool RCCResourceLibrary::writeDataNames()
|
|
766 {
|
|
767 if (m_format == C_Code)
|
|
768 writeString("static const ubyte[] qt_resource_name = [\n");
|
|
769 else if (m_format == Binary)
|
|
770 m_namesOffset = m_out.size();
|
|
771
|
|
772 QHash<QString, int> names;
|
|
773 QStack<RCCFileInfo*> pending;
|
|
774
|
|
775 if (!m_root)
|
|
776 return false;
|
|
777
|
|
778 pending.push(m_root);
|
|
779 qint64 offset = 0;
|
|
780 while (!pending.isEmpty()) {
|
|
781 RCCFileInfo *file = pending.pop();
|
|
782 for (QHash<QString, RCCFileInfo*>::iterator it = file->m_children.begin();
|
|
783 it != file->m_children.end(); ++it) {
|
|
784 RCCFileInfo *child = it.value();
|
|
785 if (child->m_flags & RCCFileInfo::Directory)
|
|
786 pending.push(child);
|
|
787 if (names.contains(child->m_name)) {
|
|
788 child->m_nameOffset = names.value(child->m_name);
|
|
789 } else {
|
|
790 names.insert(child->m_name, offset);
|
|
791 offset = child->writeDataName(*this, offset);
|
|
792 }
|
|
793 }
|
|
794 }
|
|
795 if (m_format == C_Code)
|
|
796 writeString("\n];\n\n");
|
|
797 return true;
|
|
798 }
|
|
799
|
|
800 static bool qt_rcc_compare_hash(const RCCFileInfo *left, const RCCFileInfo *right)
|
|
801 {
|
|
802 return qHash(left->m_name) < qHash(right->m_name);
|
|
803 }
|
|
804
|
|
805 bool RCCResourceLibrary::writeDataStructure()
|
|
806 {
|
|
807 if (m_format == C_Code)
|
|
808 writeString("static const ubyte[] qt_resource_struct = [\n");
|
|
809 else if (m_format == Binary)
|
|
810 m_treeOffset = m_out.size();
|
|
811 QStack<RCCFileInfo*> pending;
|
|
812
|
|
813 if (!m_root)
|
|
814 return false;
|
|
815
|
|
816 //calculate the child offsets (flat)
|
|
817 pending.push(m_root);
|
|
818 int offset = 1;
|
|
819 while (!pending.isEmpty()) {
|
|
820 RCCFileInfo *file = pending.pop();
|
|
821 file->m_childOffset = offset;
|
|
822
|
|
823 //sort by hash value for binary lookup
|
|
824 QList<RCCFileInfo*> m_children = file->m_children.values();
|
|
825 qSort(m_children.begin(), m_children.end(), qt_rcc_compare_hash);
|
|
826
|
|
827 //write out the actual data now
|
|
828 for (int i = 0; i < m_children.size(); ++i) {
|
|
829 RCCFileInfo *child = m_children.at(i);
|
|
830 ++offset;
|
|
831 if (child->m_flags & RCCFileInfo::Directory)
|
|
832 pending.push(child);
|
|
833 }
|
|
834 }
|
|
835
|
|
836 //write out the structure (ie iterate again!)
|
|
837 pending.push(m_root);
|
|
838 m_root->writeDataInfo(*this);
|
|
839 while (!pending.isEmpty()) {
|
|
840 RCCFileInfo *file = pending.pop();
|
|
841
|
|
842 //sort by hash value for binary lookup
|
|
843 QList<RCCFileInfo*> m_children = file->m_children.values();
|
|
844 qSort(m_children.begin(), m_children.end(), qt_rcc_compare_hash);
|
|
845
|
|
846 //write out the actual data now
|
|
847 for (int i = 0; i < m_children.size(); ++i) {
|
|
848 RCCFileInfo *child = m_children.at(i);
|
|
849 child->writeDataInfo(*this);
|
|
850 if (child->m_flags & RCCFileInfo::Directory)
|
|
851 pending.push(child);
|
|
852 }
|
|
853 }
|
|
854 if (m_format == C_Code)
|
|
855 writeString("\n];\n\n");
|
|
856
|
|
857 return true;
|
|
858 }
|
|
859
|
|
860 void RCCResourceLibrary::writeMangleNamespaceFunction(const QByteArray &name)
|
|
861 {
|
|
862 if (m_useNameSpace) {
|
|
863 // qtd writeString("QT_MANGLE_NAMESPACE(");
|
|
864 writeByteArray(name);
|
|
865 // qtd writeChar(')');
|
|
866 } else {
|
|
867 writeByteArray(name);
|
|
868 }
|
|
869 }
|
|
870
|
|
871 void RCCResourceLibrary::writeAddNamespaceFunction(const QByteArray &name)
|
|
872 {
|
|
873 if (m_useNameSpace) {
|
|
874 writeString("QT_PREPEND_NAMESPACE(");
|
|
875 writeByteArray(name);
|
|
876 writeChar(')');
|
|
877 } else {
|
|
878 writeByteArray(name);
|
|
879 }
|
|
880 }
|
|
881
|
|
882 bool RCCResourceLibrary::writeInitializer()
|
|
883 {
|
|
884 if (m_format == C_Code) {
|
|
885 //write("\nQT_BEGIN_NAMESPACE\n");
|
|
886 QString initName = m_initName;
|
|
887 if (!initName.isEmpty()) {
|
|
888 initName.prepend(QLatin1Char('_'));
|
|
889 initName.replace(QRegExp(QLatin1String("[^a-zA-Z0-9_]")), QLatin1String("_"));
|
|
890 }
|
|
891
|
|
892 //init
|
|
893 if (m_useNameSpace)
|
|
894 writeString("// QT_BEGIN_NAMESPACE\n\n");
|
|
895 if (m_root) {
|
|
896 writeString("extern(C) bool qtd_register_resource_data(int version_, ubyte *tree, ubyte *name, ubyte *data);\n\n");
|
|
897 writeString("extern(C) bool qtd_unregister_resource_data(int version_, ubyte *tree, ubyte *name, ubyte *data);\n\n");
|
|
898 }
|
|
899 if (m_useNameSpace)
|
|
900 writeString("// QT_END_NAMESPACE\n\n\n");
|
|
901 QString initResources = QLatin1String("qtd_init_resources");
|
|
902 initResources += initName;
|
|
903 writeString("extern(C) int ");
|
|
904 writeMangleNamespaceFunction(initResources.toLatin1());
|
|
905 writeString("()\n{\n");
|
|
906
|
|
907 if (m_root) {
|
|
908 writeString(" ");
|
|
909 writeString("qtd_register_resource_data(0x01, qt_resource_struct.ptr, "
|
|
910 "qt_resource_name.ptr, qt_resource_data.ptr);\n");
|
|
911 }
|
|
912 writeString(" return 1;\n");
|
|
913 writeString("}\n\n");
|
|
914
|
|
915 //cleanup
|
|
916 QString cleanResources = QLatin1String("qtd_cleanup_resources");
|
|
917 cleanResources += initName;
|
|
918 writeString("extern(C) int ");
|
|
919 writeMangleNamespaceFunction(cleanResources.toLatin1());
|
|
920 writeString("()\n{\n");
|
|
921 if (m_root) {
|
|
922 writeString(" ");
|
|
923 writeString("qtd_unregister_resource_data(0x01, qt_resource_struct.ptr, "
|
|
924 "qt_resource_name.ptr, qt_resource_data.ptr);\n");
|
|
925 }
|
|
926 writeString(" return 1;\n");
|
|
927 writeString("}\n\n");
|
|
928 } else if (m_format == Binary) {
|
|
929 int i = 4;
|
|
930 char *p = m_out.data();
|
|
931 p[i++] = 0; // 0x01
|
|
932 p[i++] = 0;
|
|
933 p[i++] = 0;
|
|
934 p[i++] = 1;
|
|
935
|
|
936 p[i++] = (m_treeOffset >> 24) & 0xff;
|
|
937 p[i++] = (m_treeOffset >> 16) & 0xff;
|
|
938 p[i++] = (m_treeOffset >> 8) & 0xff;
|
|
939 p[i++] = (m_treeOffset >> 0) & 0xff;
|
|
940
|
|
941 p[i++] = (m_dataOffset >> 24) & 0xff;
|
|
942 p[i++] = (m_dataOffset >> 16) & 0xff;
|
|
943 p[i++] = (m_dataOffset >> 8) & 0xff;
|
|
944 p[i++] = (m_dataOffset >> 0) & 0xff;
|
|
945
|
|
946 p[i++] = (m_namesOffset >> 24) & 0xff;
|
|
947 p[i++] = (m_namesOffset >> 16) & 0xff;
|
|
948 p[i++] = (m_namesOffset >> 8) & 0xff;
|
|
949 p[i++] = (m_namesOffset >> 0) & 0xff;
|
|
950 }
|
|
951 return true;
|
|
952 }
|
|
953
|
|
954 QT_END_NAMESPACE
|