source: trunk/tools/linguist/shared/po.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: 34.9 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 Qt Linguist 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
42#include "translator.h"
43
44#include <QtCore/QDebug>
45#include <QtCore/QIODevice>
46#include <QtCore/QHash>
47#include <QtCore/QString>
[846]48#include <QtCore/QTextCodec>
[2]49#include <QtCore/QTextStream>
50
51#include <ctype.h>
52
53// Uncomment if you wish to hard wrap long lines in .po files. Note that this
54// affects only msg strings, not comments.
55//#define HARD_WRAP_LONG_WORDS
56
57QT_BEGIN_NAMESPACE
58
59static const int MAX_LEN = 79;
60
61static QString poEscapedString(const QString &prefix, const QString &keyword,
62 bool noWrap, const QString &ba)
63{
64 QStringList lines;
65 int off = 0;
66 QString res;
67 while (off < ba.length()) {
68 ushort c = ba[off++].unicode();
69 switch (c) {
70 case '\n':
71 res += QLatin1String("\\n");
72 lines.append(res);
73 res.clear();
74 break;
75 case '\r':
76 res += QLatin1String("\\r");
77 break;
78 case '\t':
79 res += QLatin1String("\\t");
80 break;
81 case '\v':
82 res += QLatin1String("\\v");
83 break;
84 case '\a':
85 res += QLatin1String("\\a");
86 break;
87 case '\b':
88 res += QLatin1String("\\b");
89 break;
90 case '\f':
91 res += QLatin1String("\\f");
92 break;
93 case '"':
94 res += QLatin1String("\\\"");
95 break;
96 case '\\':
97 res += QLatin1String("\\\\");
98 break;
99 default:
100 if (c < 32) {
101 res += QLatin1String("\\x");
102 res += QString::number(c, 16);
103 if (off < ba.length() && isxdigit(ba[off].unicode()))
104 res += QLatin1String("\"\"");
105 } else {
106 res += QChar(c);
107 }
108 break;
109 }
110 }
111 if (!res.isEmpty())
112 lines.append(res);
113 if (!lines.isEmpty()) {
114 if (!noWrap) {
115 if (lines.count() != 1 ||
116 lines.first().length() > MAX_LEN - keyword.length() - prefix.length() - 3)
117 {
118 QStringList olines = lines;
119 lines = QStringList(QString());
120 const int maxlen = MAX_LEN - prefix.length() - 2;
121 foreach (const QString &line, olines) {
122 int off = 0;
123 while (off + maxlen < line.length()) {
124 int idx = line.lastIndexOf(QLatin1Char(' '), off + maxlen - 1) + 1;
125 if (idx == off) {
126#ifdef HARD_WRAP_LONG_WORDS
127 // This doesn't seem too nice, but who knows ...
128 idx = off + maxlen;
129#else
130 idx = line.indexOf(QLatin1Char(' '), off + maxlen) + 1;
131 if (!idx)
132 break;
133#endif
134 }
135 lines.append(line.mid(off, idx - off));
136 off = idx;
137 }
138 lines.append(line.mid(off));
139 }
140 }
141 } else if (lines.count() > 1) {
142 lines.prepend(QString());
143 }
144 }
145 return prefix + keyword + QLatin1String(" \"") +
146 lines.join(QLatin1String("\"\n") + prefix + QLatin1Char('"')) +
147 QLatin1String("\"\n");
148}
149
150static QString poEscapedLines(const QString &prefix, bool addSpace, const QStringList &lines)
151{
152 QString out;
153 foreach (const QString &line, lines) {
154 out += prefix;
155 if (addSpace && !line.isEmpty())
156 out += QLatin1Char(' ' );
157 out += line;
158 out += QLatin1Char('\n');
159 }
160 return out;
161}
162
163static QString poEscapedLines(const QString &prefix, bool addSpace, const QString &in0)
164{
165 QString in = in0;
166 if (in.endsWith(QLatin1Char('\n')))
167 in.chop(1);
168 return poEscapedLines(prefix, addSpace, in.split(QLatin1Char('\n')));
169}
170
171static QString poWrappedEscapedLines(const QString &prefix, bool addSpace, const QString &line)
172{
173 const int maxlen = MAX_LEN - prefix.length();
174 QStringList lines;
175 int off = 0;
176 while (off + maxlen < line.length()) {
177 int idx = line.lastIndexOf(QLatin1Char(' '), off + maxlen - 1);
178 if (idx < off) {
179#if 0 //def HARD_WRAP_LONG_WORDS
180 // This cannot work without messing up semantics, so do not even try.
181#else
182 idx = line.indexOf(QLatin1Char(' '), off + maxlen);
183 if (idx < 0)
184 break;
185#endif
186 }
187 lines.append(line.mid(off, idx - off));
188 off = idx + 1;
189 }
190 lines.append(line.mid(off));
191 return poEscapedLines(prefix, addSpace, lines);
192}
193
194struct PoItem
195{
196public:
197 PoItem()
198 : isPlural(false), isFuzzy(false)
199 {}
200
201
202public:
[846]203 QByteArray id;
204 QByteArray context;
205 QByteArray tscomment;
206 QByteArray oldTscomment;
207 QByteArray lineNumber;
208 QByteArray fileName;
209 QByteArray references;
210 QByteArray translatorComments;
211 QByteArray automaticComments;
212 QByteArray msgId;
213 QByteArray oldMsgId;
214 QList<QByteArray> msgStr;
[2]215 bool isPlural;
216 bool isFuzzy;
217 QHash<QString, QString> extra;
218};
219
220
[846]221static bool isTranslationLine(const QByteArray &line)
[2]222{
[846]223 return line.startsWith("#~ msgstr") || line.startsWith("msgstr");
[2]224}
225
[846]226static QByteArray slurpEscapedString(const QList<QByteArray> &lines, int &l,
227 int offset, const QByteArray &prefix, ConversionData &cd)
[2]228{
[846]229 QByteArray msg;
[2]230 int stoff;
231
232 for (; l < lines.size(); ++l) {
[846]233 const QByteArray &line = lines.at(l);
[2]234 if (line.isEmpty() || !line.startsWith(prefix))
235 break;
[846]236 while (isspace(line[offset])) // No length check, as string has no trailing spaces.
[2]237 offset++;
[846]238 if (line[offset] != '"')
[2]239 break;
240 offset++;
241 forever {
242 if (offset == line.length())
243 goto premature_eol;
[846]244 uchar c = line[offset++];
[2]245 if (c == '"') {
246 if (offset == line.length())
247 break;
[846]248 while (isspace(line[offset]))
[2]249 offset++;
[846]250 if (line[offset++] != '"') {
[2]251 cd.appendError(QString::fromLatin1(
252 "PO parsing error: extra characters on line %1.")
253 .arg(l + 1));
254 break;
255 }
256 continue;
257 }
258 if (c == '\\') {
259 if (offset == line.length())
260 goto premature_eol;
[846]261 c = line[offset++];
[2]262 switch (c) {
263 case 'r':
[846]264 msg += '\r'; // Maybe just throw it away?
[2]265 break;
266 case 'n':
[846]267 msg += '\n';
[2]268 break;
269 case 't':
[846]270 msg += '\t';
[2]271 break;
272 case 'v':
[846]273 msg += '\v';
[2]274 break;
275 case 'a':
[846]276 msg += '\a';
[2]277 break;
278 case 'b':
[846]279 msg += '\b';
[2]280 break;
281 case 'f':
[846]282 msg += '\f';
[2]283 break;
284 case '"':
[846]285 msg += '"';
[2]286 break;
287 case '\\':
[846]288 msg += '\\';
[2]289 break;
290 case '0':
291 case '1':
292 case '2':
293 case '3':
294 case '4':
295 case '5':
296 case '6':
297 case '7':
298 stoff = offset - 1;
[846]299 while ((c = line[offset]) >= '0' && c <= '7')
[2]300 if (++offset == line.length())
301 goto premature_eol;
[846]302 msg += line.mid(stoff, offset - stoff).toUInt(0, 8);
[2]303 break;
304 case 'x':
305 stoff = offset;
[846]306 while (isxdigit(line[offset]))
[2]307 if (++offset == line.length())
308 goto premature_eol;
[846]309 msg += line.mid(stoff, offset - stoff).toUInt(0, 16);
[2]310 break;
311 default:
312 cd.appendError(QString::fromLatin1(
313 "PO parsing error: invalid escape '\\%1' (line %2).")
[846]314 .arg(QChar((uint)c)).arg(l + 1));
315 msg += '\\';
316 msg += c;
[2]317 break;
318 }
319 } else {
[846]320 msg += c;
[2]321 }
322 }
323 offset = prefix.size();
324 }
325 --l;
326 return msg;
327
328premature_eol:
329 cd.appendError(QString::fromLatin1(
330 "PO parsing error: premature end of line %1.").arg(l + 1));
[846]331 return QByteArray();
[2]332}
333
[846]334static void slurpComment(QByteArray &msg, const QList<QByteArray> &lines, int & l)
[2]335{
[846]336 QByteArray prefix = lines.at(l);
[2]337 for (int i = 1; ; i++) {
[846]338 if (prefix.at(i) != ' ') {
[2]339 prefix.truncate(i);
340 break;
341 }
342 }
343 for (; l < lines.size(); ++l) {
[846]344 const QByteArray &line = lines.at(l);
[2]345 if (line.startsWith(prefix))
346 msg += line.mid(prefix.size());
[846]347 else if (line != "#")
[2]348 break;
[846]349 msg += '\n';
[2]350 }
351 --l;
352}
353
[846]354static void splitContext(QByteArray *comment, QByteArray *context)
355{
356 char *data = comment->data();
357 int len = comment->size();
358 int sep = -1, j = 0;
359
360 for (int i = 0; i < len; i++, j++) {
361 if (data[i] == '~' && i + 1 < len)
362 i++;
363 else if (data[i] == '|')
364 sep = j;
365 data[j] = data[i];
366 }
367 if (sep >= 0) {
368 QByteArray tmp = comment->mid(sep + 1, j - sep - 1);
369 comment->truncate(sep);
370 *context = *comment;
371 *comment = tmp;
372 } else {
373 comment->truncate(j);
374 }
375}
376
377static QString makePoHeader(const QString &str)
378{
379 return QLatin1String("po-header-") + str.toLower().replace(QLatin1Char('-'), QLatin1Char('_'));
380}
381
382static QByteArray QByteArrayList_join(const QList<QByteArray> &that, char sep)
383{
384 int totalLength = 0;
385 const int size = that.size();
386
387 for (int i = 0; i < size; ++i)
388 totalLength += that.at(i).size();
389
390 if (size > 0)
391 totalLength += size - 1;
392
393 QByteArray res;
394 if (totalLength == 0)
395 return res;
396 res.reserve(totalLength);
397 for (int i = 0; i < that.size(); ++i) {
398 if (i)
399 res += sep;
400 res += that.at(i);
401 }
402 return res;
403}
404
[2]405bool loadPO(Translator &translator, QIODevice &dev, ConversionData &cd)
406{
[846]407 QTextCodec *codec = QTextCodec::codecForName(
408 cd.m_codecForSource.isEmpty() ? QByteArray("UTF-8") : cd.m_codecForSource);
[2]409 bool error = false;
410
411 // format of a .po file entry:
412 // white-space
413 // # translator-comments
414 // #. automatic-comments
415 // #: reference...
416 // #, flag...
417 // #~ msgctxt, msgid*, msgstr - used for obsoleted messages
418 // #| msgctxt, msgid* previous untranslated-string - for fuzzy message
419 // msgctx string-context
420 // msgid untranslated-string
421 // -- For singular:
422 // msgstr translated-string
423 // -- For plural:
424 // msgid_plural untranslated-string-plural
425 // msgstr[0] translated-string
426 // ...
427
428 // we need line based lookahead below.
[846]429 QList<QByteArray> lines;
430 while (!dev.atEnd())
431 lines.append(dev.readLine().trimmed());
432 lines.append(QByteArray());
[2]433
[846]434 int l = 0, lastCmtLine = -1;
435 bool qtContexts = false;
[2]436 PoItem item;
437 for (; l != lines.size(); ++l) {
[846]438 QByteArray line = lines.at(l);
[2]439 if (line.isEmpty())
440 continue;
441 if (isTranslationLine(line)) {
[846]442 bool isObsolete = line.startsWith("#~ msgstr");
443 const QByteArray prefix = isObsolete ? "#~ " : "";
[2]444 while (true) {
[846]445 int idx = line.indexOf(' ', prefix.length());
446 QByteArray str = slurpEscapedString(lines, l, idx, prefix, cd);
[561]447 item.msgStr.append(str);
[2]448 if (l + 1 >= lines.size() || !isTranslationLine(lines.at(l + 1)))
449 break;
450 ++l;
451 line = lines.at(l);
452 }
453 if (item.msgId.isEmpty()) {
[846]454 QHash<QString, QByteArray> extras;
455 QList<QByteArray> hdrOrder;
456 QByteArray pluralForms;
457 foreach (const QByteArray &hdr, item.msgStr.first().split('\n')) {
458 if (hdr.isEmpty())
459 continue;
460 int idx = hdr.indexOf(':');
461 if (idx < 0) {
462 cd.appendError(QString::fromLatin1("Unexpected PO header format '%1'")
463 .arg(QString::fromLatin1(hdr)));
464 error = true;
465 break;
466 }
467 QByteArray hdrName = hdr.left(idx).trimmed();
468 QByteArray hdrValue = hdr.mid(idx + 1).trimmed();
469 hdrOrder << hdrName;
470 if (hdrName == "X-Language") {
471 translator.setLanguageCode(QString::fromLatin1(hdrValue));
472 } else if (hdrName == "X-Source-Language") {
473 translator.setSourceLanguageCode(QString::fromLatin1(hdrValue));
474 } else if (hdrName == "X-Qt-Contexts") {
475 qtContexts = (hdrValue == "true");
476 } else if (hdrName == "Plural-Forms") {
477 pluralForms = hdrValue;
478 } else if (hdrName == "MIME-Version") {
479 // just assume it is 1.0
480 } else if (hdrName == "Content-Type") {
481 if (cd.m_codecForSource.isEmpty()) {
482 if (!hdrValue.startsWith("text/plain; charset=")) {
483 cd.appendError(QString::fromLatin1("Unexpected Content-Type header '%1'")
484 .arg(QString::fromLatin1(hdrValue)));
485 error = true;
486 // This will avoid a flood of conversion errors.
487 codec = QTextCodec::codecForName("latin1");
488 } else {
489 QByteArray cod = hdrValue.mid(20);
490 QTextCodec *cdc = QTextCodec::codecForName(cod);
491 if (!cdc) {
492 cd.appendError(QString::fromLatin1("Unsupported codec '%1'")
493 .arg(QString::fromLatin1(cod)));
494 error = true;
495 // This will avoid a flood of conversion errors.
496 codec = QTextCodec::codecForName("latin1");
497 } else {
498 codec = cdc;
499 }
500 }
501 }
502 } else if (hdrName == "Content-Transfer-Encoding") {
503 if (hdrValue != "8bit") {
504 cd.appendError(QString::fromLatin1("Unexpected Content-Transfer-Encoding '%1'")
505 .arg(QString::fromLatin1(hdrValue)));
506 return false;
507 }
508 } else if (hdrName == "X-Virgin-Header") {
509 // legacy
510 } else {
511 extras[makePoHeader(QString::fromLatin1(hdrName))] = hdrValue;
512 }
[2]513 }
[846]514 if (!pluralForms.isEmpty()) {
515 if (translator.languageCode().isEmpty()) {
516 extras[makePoHeader(QLatin1String("Plural-Forms"))] = pluralForms;
517 } else {
518 // FIXME: have fun with making a consistency check ...
519 }
[2]520 }
[846]521 // Eliminate the field if only headers we added are present in standard order.
522 // Keep in sync with savePO
523 static const char * const dfltHdrs[] = {
524 "MIME-Version", "Content-Type", "Content-Transfer-Encoding",
525 "Plural-Forms", "X-Language", "X-Source-Language", "X-Qt-Contexts"
526 };
527 uint cdh = 0;
528 for (int cho = 0; cho < hdrOrder.length(); cho++) {
529 for (;; cdh++) {
530 if (cdh == sizeof(dfltHdrs)/sizeof(dfltHdrs[0])) {
531 extras[QLatin1String("po-headers")] =
532 QByteArrayList_join(hdrOrder, ',');
533 goto doneho;
534 }
535 if (hdrOrder.at(cho) == dfltHdrs[cdh]) {
536 cdh++;
537 break;
538 }
539 }
[2]540 }
[846]541 doneho:
542 if (lastCmtLine != -1)
543 extras[QLatin1String("po-header_comment")] =
544 QByteArrayList_join(lines.mid(0, lastCmtLine + 1), '\n');
545 for (QHash<QString, QByteArray>::ConstIterator it = extras.constBegin(),
546 end = extras.constEnd();
547 it != end; ++it)
548 translator.setExtra(it.key(), codec->toUnicode(it.value()));
549 item = PoItem();
550 continue;
[2]551 }
552 // build translator message
553 TranslatorMessage msg;
[846]554 msg.setContext(codec->toUnicode(item.context));
[2]555 if (!item.references.isEmpty()) {
[846]556 QString xrefs;
[2]557 foreach (const QString &ref,
[846]558 codec->toUnicode(item.references).split(
559 QRegExp(QLatin1String("\\s")), QString::SkipEmptyParts)) {
560 int pos = ref.indexOf(QLatin1Char(':'));
561 int lpos = ref.lastIndexOf(QLatin1Char(':'));
562 if (pos != -1 && pos == lpos) {
563 bool ok;
564 int lno = ref.mid(pos + 1).toInt(&ok);
565 if (ok) {
566 msg.addReference(ref.left(pos), lno);
567 continue;
568 }
569 }
570 if (!xrefs.isEmpty())
571 xrefs += QLatin1Char(' ');
572 xrefs += ref;
[2]573 }
[846]574 if (!xrefs.isEmpty())
575 item.extra[QLatin1String("po-references")] = xrefs;
[2]576 }
[846]577 msg.setId(codec->toUnicode(item.id));
578 msg.setSourceText(codec->toUnicode(item.msgId));
579 msg.setOldSourceText(codec->toUnicode(item.oldMsgId));
580 msg.setComment(codec->toUnicode(item.tscomment));
581 msg.setOldComment(codec->toUnicode(item.oldTscomment));
582 msg.setExtraComment(codec->toUnicode(item.automaticComments));
583 msg.setTranslatorComment(codec->toUnicode(item.translatorComments));
[2]584 msg.setPlural(item.isPlural || item.msgStr.size() > 1);
[846]585 QStringList translations;
586 foreach (const QByteArray &bstr, item.msgStr) {
587 QString str = codec->toUnicode(bstr);
588 str.replace(QChar(Translator::TextVariantSeparator),
589 QChar(Translator::BinaryVariantSeparator));
590 translations << str;
591 }
592 msg.setTranslations(translations);
[2]593 if (isObsolete)
594 msg.setType(TranslatorMessage::Obsolete);
[846]595 else if (item.isFuzzy || (!msg.sourceText().isEmpty() && !msg.isTranslated()))
[2]596 msg.setType(TranslatorMessage::Unfinished);
597 else
598 msg.setType(TranslatorMessage::Finished);
599 msg.setExtras(item.extra);
600
601 //qDebug() << "WRITE: " << context;
602 //qDebug() << "SOURCE: " << msg.sourceText();
603 //qDebug() << flags << msg.m_extra;
604 translator.append(msg);
605 item = PoItem();
[846]606 } else if (line.startsWith('#')) {
607 switch (line.size() < 2 ? 0 : line.at(1)) {
[2]608 case ':':
609 item.references += line.mid(3);
[846]610 item.references += '\n';
[2]611 break;
612 case ',': {
613 QStringList flags =
[846]614 QString::fromLatin1(line.mid(2)).split(
615 QRegExp(QLatin1String("[, ]")), QString::SkipEmptyParts);
[2]616 if (flags.removeOne(QLatin1String("fuzzy")))
617 item.isFuzzy = true;
[846]618 flags.removeOne(QLatin1String("qt-format"));
[2]619 TranslatorMessage::ExtraData::const_iterator it =
620 item.extra.find(QLatin1String("po-flags"));
621 if (it != item.extra.end())
622 flags.prepend(*it);
623 if (!flags.isEmpty())
624 item.extra[QLatin1String("po-flags")] = flags.join(QLatin1String(", "));
625 break;
626 }
627 case 0:
[846]628 item.translatorComments += '\n';
[2]629 break;
630 case ' ':
631 slurpComment(item.translatorComments, lines, l);
632 break;
633 case '.':
[846]634 if (line.startsWith("#. ts-context ")) { // legacy
[2]635 item.context = line.mid(14);
[846]636 } else if (line.startsWith("#. ts-id ")) {
[2]637 item.id = line.mid(9);
638 } else {
639 item.automaticComments += line.mid(3);
[846]640 item.automaticComments += '\n';
[2]641 }
642 break;
643 case '|':
[846]644 if (line.startsWith("#| msgid ")) {
645 item.oldMsgId = slurpEscapedString(lines, l, 9, "#| ", cd);
646 } else if (line.startsWith("#| msgid_plural ")) {
647 QByteArray extra = slurpEscapedString(lines, l, 16, "#| ", cd);
[2]648 if (extra != item.oldMsgId)
[846]649 item.extra[QLatin1String("po-old_msgid_plural")] =
650 codec->toUnicode(extra);
651 } else if (line.startsWith("#| msgctxt ")) {
652 item.oldTscomment = slurpEscapedString(lines, l, 11, "#| ", cd);
653 if (qtContexts)
654 splitContext(&item.oldTscomment, &item.context);
[2]655 } else {
[846]656 cd.appendError(QString(QLatin1String("PO-format parse error in line %1: '%2'"))
657 .arg(l + 1).arg(codec->toUnicode(lines[l])));
[2]658 error = true;
659 }
660 break;
661 case '~':
[846]662 if (line.startsWith("#~ msgid ")) {
663 item.msgId = slurpEscapedString(lines, l, 9, "#~ ", cd);
664 } else if (line.startsWith("#~ msgid_plural ")) {
665 QByteArray extra = slurpEscapedString(lines, l, 16, "#~ ", cd);
[2]666 if (extra != item.msgId)
[846]667 item.extra[QLatin1String("po-msgid_plural")] =
668 codec->toUnicode(extra);
[2]669 item.isPlural = true;
[846]670 } else if (line.startsWith("#~ msgctxt ")) {
671 item.tscomment = slurpEscapedString(lines, l, 11, "#~ ", cd);
672 if (qtContexts)
673 splitContext(&item.tscomment, &item.context);
[2]674 } else {
[846]675 cd.appendError(QString(QLatin1String("PO-format parse error in line %1: '%2'"))
676 .arg(l + 1).arg(codec->toUnicode(lines[l])));
[2]677 error = true;
678 }
679 break;
680 default:
[846]681 cd.appendError(QString(QLatin1String("PO-format parse error in line %1: '%2'"))
682 .arg(l + 1).arg(codec->toUnicode(lines[l])));
[2]683 error = true;
684 break;
685 }
[846]686 lastCmtLine = l;
687 } else if (line.startsWith("msgctxt ")) {
688 item.tscomment = slurpEscapedString(lines, l, 8, QByteArray(), cd);
689 if (qtContexts)
690 splitContext(&item.tscomment, &item.context);
691 } else if (line.startsWith("msgid ")) {
692 item.msgId = slurpEscapedString(lines, l, 6, QByteArray(), cd);
693 } else if (line.startsWith("msgid_plural ")) {
694 QByteArray extra = slurpEscapedString(lines, l, 13, QByteArray(), cd);
[2]695 if (extra != item.msgId)
[846]696 item.extra[QLatin1String("po-msgid_plural")] = codec->toUnicode(extra);
[2]697 item.isPlural = true;
698 } else {
[846]699 cd.appendError(QString(QLatin1String("PO-format error in line %1: '%2'"))
700 .arg(l + 1).arg(codec->toUnicode(lines[l])));
[2]701 error = true;
702 }
703 }
704 return !error && cd.errors().isEmpty();
705}
706
[846]707static void addPoHeader(Translator::ExtraData &headers, QStringList &hdrOrder,
708 const char *name, const QString &value)
709{
710 QString qName = QLatin1String(name);
711 if (!hdrOrder.contains(qName))
712 hdrOrder << qName;
713 headers[makePoHeader(qName)] = value;
714}
715
716static QString escapeComment(const QString &in, bool escape)
717{
718 QString out = in;
719 if (escape) {
720 out.replace(QLatin1Char('~'), QLatin1String("~~"));
721 out.replace(QLatin1Char('|'), QLatin1String("~|"));
722 }
723 return out;
724}
725
[2]726bool savePO(const Translator &translator, QIODevice &dev, ConversionData &cd)
727{
[846]728 QString str_format = QLatin1String("-format");
729
[2]730 bool ok = true;
731 QTextStream out(&dev);
[561]732 out.setCodec(cd.m_outputCodec.isEmpty() ? QByteArray("UTF-8") : cd.m_outputCodec);
[2]733
[846]734 bool qtContexts = false;
735 foreach (const TranslatorMessage &msg, translator.messages())
736 if (!msg.context().isEmpty()) {
737 qtContexts = true;
738 break;
739 }
740
741 QString cmt = translator.extra(QLatin1String("po-header_comment"));
742 if (!cmt.isEmpty())
743 out << cmt << '\n';
744 out << "msgid \"\"\n";
745 Translator::ExtraData headers = translator.extras();
746 QStringList hdrOrder = translator.extra(QLatin1String("po-headers")).split(
747 QLatin1Char(','), QString::SkipEmptyParts);
748 // Keep in sync with loadPO
749 addPoHeader(headers, hdrOrder, "MIME-Version", QLatin1String("1.0"));
750 addPoHeader(headers, hdrOrder, "Content-Type",
751 QLatin1String("text/plain; charset=" + out.codec()->name()));
752 addPoHeader(headers, hdrOrder, "Content-Transfer-Encoding", QLatin1String("8bit"));
753 if (!translator.languageCode().isEmpty()) {
754 QLocale::Language l;
755 QLocale::Country c;
756 Translator::languageAndCountry(translator.languageCode(), &l, &c);
757 const char *gettextRules;
758 if (getNumerusInfo(l, c, 0, 0, &gettextRules))
759 addPoHeader(headers, hdrOrder, "Plural-Forms", QLatin1String(gettextRules));
760 addPoHeader(headers, hdrOrder, "X-Language", translator.languageCode());
[2]761 }
[846]762 if (!translator.sourceLanguageCode().isEmpty())
763 addPoHeader(headers, hdrOrder, "X-Source-Language", translator.sourceLanguageCode());
764 if (qtContexts)
765 addPoHeader(headers, hdrOrder, "X-Qt-Contexts", QLatin1String("true"));
766 QString hdrStr;
767 foreach (const QString &hdr, hdrOrder) {
768 hdrStr += hdr;
769 hdrStr += QLatin1String(": ");
770 hdrStr += headers.value(makePoHeader(hdr));
771 hdrStr += QLatin1Char('\n');
772 }
773 out << poEscapedString(QString(), QString::fromLatin1("msgstr"), true, hdrStr);
774
[2]775 foreach (const TranslatorMessage &msg, translator.messages()) {
[846]776 out << endl;
[2]777
778 if (!msg.translatorComment().isEmpty())
779 out << poEscapedLines(QLatin1String("#"), true, msg.translatorComment());
780
781 if (!msg.extraComment().isEmpty())
782 out << poEscapedLines(QLatin1String("#."), true, msg.extraComment());
783
784 if (!msg.id().isEmpty())
785 out << QLatin1String("#. ts-id ") << msg.id() << '\n';
786
[846]787 QString xrefs = msg.extra(QLatin1String("po-references"));
788 if (!msg.fileName().isEmpty() || !xrefs.isEmpty()) {
[2]789 QStringList refs;
790 foreach (const TranslatorMessage::Reference &ref, msg.allReferences())
791 refs.append(QString(QLatin1String("%2:%1"))
792 .arg(ref.lineNumber()).arg(ref.fileName()));
[846]793 if (!xrefs.isEmpty())
794 refs << xrefs;
[2]795 out << poWrappedEscapedLines(QLatin1String("#:"), true, refs.join(QLatin1String(" ")));
796 }
797
798 bool noWrap = false;
[846]799 bool skipFormat = false;
[2]800 QStringList flags;
[846]801 if (msg.type() == TranslatorMessage::Unfinished && msg.isTranslated())
[2]802 flags.append(QLatin1String("fuzzy"));
803 TranslatorMessage::ExtraData::const_iterator itr =
804 msg.extras().find(QLatin1String("po-flags"));
805 if (itr != msg.extras().end()) {
[846]806 QStringList atoms = itr->split(QLatin1String(", "));
807 foreach (const QString &atom, atoms)
808 if (atom.endsWith(str_format)) {
809 skipFormat = true;
810 break;
811 }
812 if (atoms.contains(QLatin1String("no-wrap")))
[2]813 noWrap = true;
814 flags.append(*itr);
815 }
[846]816 if (!skipFormat) {
817 QString source = msg.sourceText();
818 // This is fuzzy logic, as we don't know whether the string is
819 // actually used with QString::arg().
820 for (int off = 0; (off = source.indexOf(QLatin1Char('%'), off)) >= 0; ) {
821 if (++off >= source.length())
822 break;
823 if (source.at(off) == QLatin1Char('n') || source.at(off).isDigit()) {
824 flags.append(QLatin1String("qt-format"));
825 break;
826 }
827 }
828 }
[2]829 if (!flags.isEmpty())
830 out << "#, " << flags.join(QLatin1String(", ")) << '\n';
831
832 QString prefix = QLatin1String("#| ");
833 if (!msg.oldComment().isEmpty())
[846]834 out << poEscapedString(prefix, QLatin1String("msgctxt"), noWrap,
835 escapeComment(msg.oldComment(), qtContexts));
[2]836 if (!msg.oldSourceText().isEmpty())
837 out << poEscapedString(prefix, QLatin1String("msgid"), noWrap, msg.oldSourceText());
838 QString plural = msg.extra(QLatin1String("po-old_msgid_plural"));
839 if (!plural.isEmpty())
840 out << poEscapedString(prefix, QLatin1String("msgid_plural"), noWrap, plural);
841 prefix = QLatin1String((msg.type() == TranslatorMessage::Obsolete) ? "#~ " : "");
[846]842 if (!msg.context().isEmpty())
843 out << poEscapedString(prefix, QLatin1String("msgctxt"), noWrap,
844 escapeComment(msg.context(), true) + QLatin1Char('|')
845 + escapeComment(msg.comment(), true));
846 else if (!msg.comment().isEmpty())
847 out << poEscapedString(prefix, QLatin1String("msgctxt"), noWrap,
848 escapeComment(msg.comment(), qtContexts));
[2]849 out << poEscapedString(prefix, QLatin1String("msgid"), noWrap, msg.sourceText());
850 if (!msg.isPlural()) {
851 QString transl = msg.translation();
[846]852 transl.replace(QChar(Translator::BinaryVariantSeparator),
853 QChar(Translator::TextVariantSeparator));
[2]854 out << poEscapedString(prefix, QLatin1String("msgstr"), noWrap, transl);
855 } else {
856 QString plural = msg.extra(QLatin1String("po-msgid_plural"));
857 if (plural.isEmpty())
858 plural = msg.sourceText();
859 out << poEscapedString(prefix, QLatin1String("msgid_plural"), noWrap, plural);
[561]860 const QStringList &translations = msg.translations();
[2]861 for (int i = 0; i != translations.size(); ++i) {
[561]862 QString str = translations.at(i);
863 str.replace(QChar(Translator::BinaryVariantSeparator),
864 QChar(Translator::TextVariantSeparator));
[2]865 out << poEscapedString(prefix, QString::fromLatin1("msgstr[%1]").arg(i), noWrap,
[561]866 str);
[2]867 }
868 }
869 }
870 return ok;
871}
872
[846]873static bool savePOT(const Translator &translator, QIODevice &dev, ConversionData &cd)
874{
875 Translator ttor = translator;
876 ttor.dropTranslations();
877 return savePO(ttor, dev, cd);
878}
879
[2]880int initPO()
881{
882 Translator::FileFormat format;
883 format.extension = QLatin1String("po");
884 format.description = QObject::tr("GNU Gettext localization files");
885 format.loader = &loadPO;
886 format.saver = &savePO;
887 format.fileType = Translator::FileFormat::TranslationSource;
888 format.priority = 1;
889 Translator::registerFileFormat(format);
[846]890 format.extension = QLatin1String("pot");
891 format.description = QObject::tr("GNU Gettext localization template files");
892 format.loader = &loadPO;
893 format.saver = &savePOT;
894 format.fileType = Translator::FileFormat::TranslationSource;
895 format.priority = -1;
896 Translator::registerFileFormat(format);
[2]897 return 1;
898}
899
900Q_CONSTRUCTOR_FUNCTION(initPO)
901
902QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.