Cleanup: whitespace
[blender.git] / source / blender / blentranslation / msgfmt / msgfmt.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2017 by Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Bastien Montagne
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /*
27  * Based on C++ version by Sergey Sharybin <sergey.vfx@gmail.com>.
28  * Based on Python script msgfmt.py from Python source code tree, which was written by
29  * Martin v. Löwis <loewis@informatik.hu-berlin.de>
30  *
31  * Generate binary message catalog from textual translation description.
32  *
33  * This program converts a textual Uniforum-style message catalog (.po file) into a binary GNU catalog (.mo file).
34  * This is essentially the same function as the GNU msgfmt program, however, it is a simpler implementation.
35  *
36  * Usage: msgfmt input.po output.po
37  */
38
39 #include <string.h>
40 #include <stdlib.h>
41
42 #include "BLI_utildefines.h"
43 #include "BLI_dynstr.h"
44 #include "BLI_fileops.h"
45 #include "BLI_ghash.h"
46 #include "BLI_linklist.h"
47 #include "BLI_memarena.h"
48
49 #include "MEM_guardedalloc.h"
50
51
52 /* Stupid stub necessary because some BLI files includes winstuff.h, which uses G a bit... */
53 #ifdef WIN32
54   typedef struct Global {
55         void *dummy;
56   } Global;
57
58   Global G;
59 #endif
60
61
62 /* We cannot use NULL char until ultimate step, would give nightmare to our C string processing...
63  * Using one of the UTF-8 invalid bytes (as per our BLI string_utf8.c) */
64 #define NULLSEP_STR "\xff"
65 #define NULLSEP_CHR '\xff'
66
67 typedef enum {
68         SECTION_NONE = 0,
69         SECTION_CTX  = 1,
70         SECTION_ID   = 2,
71         SECTION_STR  = 3,
72 } eSectionType;
73
74 typedef struct Message {
75         DynStr *ctxt;
76         DynStr *id;
77         DynStr *str;
78
79         bool is_fuzzy;
80 } Message;
81
82 static char *trim(char *str)
83 {
84         const size_t len = strlen(str);
85         size_t i;
86
87         if (len == 0) {
88                 return str;
89         }
90
91         for (i = 0; i < len && ELEM(str[0], ' ', '\t', '\n'); str++, i++);
92
93         char *end = &str[len - 1 - i];
94         for (i = len; i > 0 && ELEM(end[0], ' ', '\t', '\n'); end--, i--);
95         end[1] = '\0';
96
97         return str;
98 }
99
100 static char *unescape(char *str)
101 {
102         char *curr, *next;
103         for (curr = next = str; next[0] != '\0'; curr++, next++) {
104                 if (next[0] == '\\') {
105                         switch (next[1]) {
106                                 case '\0':
107                                         /* Get rid of trailing escape char... */
108                                         curr--;
109                                         break;
110                                 case '\\':
111                                         *curr = '\\';
112                                         next++;
113                                         break;
114                                 case 'n':
115                                         *curr = '\n';
116                                         next++;
117                                         break;
118                                 case 't':
119                                         *curr = '\t';
120                                         next++;
121                                         break;
122                                 default:
123                                         /* Get rid of useless escape char. */
124                                         next++;
125                                         *curr = *next;
126                         }
127                 }
128                 else if (curr != next) {
129                         *curr = *next;
130                 }
131         }
132         *curr = '\0';
133
134         if (str[0] == '"' && *(curr - 1) == '"') {
135                 *(curr - 1) = '\0';
136                 return str + 1;
137         }
138         return str;
139 }
140
141 static int qsort_str_cmp(const void *a, const void *b)
142 {
143         return strcmp(*(const char **)a, *(const char **)b);
144 }
145
146 static char **get_keys_sorted(GHash *messages, const uint32_t num_keys)
147 {
148         GHashIterator iter;
149
150         char **keys = MEM_mallocN(sizeof(*keys) * num_keys, __func__);
151         char **k = keys;
152
153         GHASH_ITER(iter, messages) {
154                 *k = BLI_ghashIterator_getKey(&iter);
155                 k++;
156         }
157
158         qsort(keys, num_keys, sizeof(*keys), qsort_str_cmp);
159
160         return keys;
161 }
162
163 BLI_INLINE size_t uint32_to_bytes(const int value, char *bytes)
164 {
165         size_t i;
166         for (i = 0; i < sizeof(value); i++) {
167                 bytes[i] = (char) ((value >> ((int)i * 8)) & 0xff);
168         }
169         return i;
170 }
171
172 BLI_INLINE size_t msg_to_bytes(char *msg, char *bytes, uint32_t size)
173 {
174         /* Note that we also perform replacing of our NULLSEP placeholder by real NULL char... */
175         size_t i;
176         for (i = 0; i < size; i++, msg++, bytes++) {
177                 *bytes = (*msg == NULLSEP_CHR) ? '\0' : *msg;
178         }
179         return i;
180 }
181
182 typedef struct Offset {
183         uint32_t key_offset, key_len, val_offset, val_len;
184 } Offset;
185
186 /* Return the generated binary output. */
187 static char *generate(GHash *messages, size_t *r_output_size) {
188         const uint32_t num_keys = BLI_ghash_size(messages);
189
190         /* Get list of sorted keys. */
191         char **keys = get_keys_sorted(messages, num_keys);
192         char **vals = MEM_mallocN(sizeof(*vals) * num_keys, __func__);
193         uint32_t tot_keys_len = 0;
194         uint32_t tot_vals_len = 0;
195
196         Offset *offsets = MEM_mallocN(sizeof(*offsets) * num_keys, __func__);
197
198         for (int i = 0; i < num_keys; i++) {
199                 Offset *off = &offsets[i];
200
201                 vals[i] = BLI_ghash_lookup(messages, keys[i]);
202
203                 /* For each string, we need size and file offset.
204                  * Each string is NULL terminated; the NULL does not count into the size. */
205                 off->key_offset = tot_keys_len;
206                 off->key_len = (uint32_t)strlen(keys[i]);
207                 tot_keys_len += off->key_len + 1;
208
209                 off->val_offset = tot_vals_len;
210                 off->val_len = (uint32_t)strlen(vals[i]);
211                 tot_vals_len += off->val_len + 1;
212         }
213
214         /* The header is 7 32-bit unsigned integers. then comes the keys index table, then the values index table. */
215         const uint32_t idx_keystart = 7 * 4;
216         const uint32_t idx_valstart = idx_keystart + 8 * num_keys;
217         /* We don't use hash tables, so the keys start right after the index tables. */
218         const uint32_t keystart = idx_valstart + 8 * num_keys;
219         /* and the values start after the keys */
220         const uint32_t valstart = keystart + tot_keys_len;
221
222         /* Final buffer representing the binary MO file. */
223         *r_output_size = valstart + tot_vals_len;
224         char *output = MEM_mallocN(*r_output_size, __func__);
225         char *h = output;
226         char *ik = output + idx_keystart;
227         char *iv = output + idx_valstart;
228         char *k = output + keystart;
229         char *v = output + valstart;
230
231         h += uint32_to_bytes(0x950412de, h);  /* Magic */
232         h += uint32_to_bytes(0x0, h);  /* Version */
233         h += uint32_to_bytes(num_keys, h);  /* Number of entries */
234         h += uint32_to_bytes(idx_keystart, h);  /* Start of key index */
235         h += uint32_to_bytes(idx_valstart, h);  /* Start of value index */
236         h += uint32_to_bytes(0, h);  /* Size of hash table */
237         h += uint32_to_bytes(0, h);  /* Offset of hash table */
238
239         BLI_assert(h == ik);
240
241         for (int i = 0; i < num_keys; i++) {
242                 Offset *off = &offsets[i];
243
244                 /* The index table first has the list of keys, then the list of values.
245                  * Each entry has first the size of the string, then the file offset. */
246                 ik += uint32_to_bytes(off->key_len, ik);
247                 ik += uint32_to_bytes(off->key_offset + keystart, ik);
248                 iv += uint32_to_bytes(off->val_len, iv);
249                 iv += uint32_to_bytes(off->val_offset + valstart, iv);
250
251                 k += msg_to_bytes(keys[i], k, off->key_len + 1);
252                 v += msg_to_bytes(vals[i], v, off->val_len + 1);
253         }
254
255         BLI_assert(ik == output + idx_valstart);
256         BLI_assert(iv == output + keystart);
257         BLI_assert(k == output + valstart);
258
259         MEM_freeN(keys);
260         MEM_freeN(vals);
261         MEM_freeN(offsets);
262
263         return output;
264 }
265
266 /* Add a non-fuzzy translation to the dictionary. */
267 static void add(GHash *messages, MemArena *memarena, const Message *msg)
268 {
269         const size_t msgctxt_len = (size_t)BLI_dynstr_get_len(msg->ctxt);
270         const size_t msgid_len = (size_t)BLI_dynstr_get_len(msg->id);
271         const size_t msgstr_len = (size_t)BLI_dynstr_get_len(msg->str);
272         const size_t msgkey_len = msgid_len  + ((msgctxt_len == 0) ? 0 : msgctxt_len + 1);
273
274         if (!msg->is_fuzzy && msgstr_len != 0) {
275                 char *msgkey = BLI_memarena_alloc(memarena, sizeof(*msgkey) * (msgkey_len + 1));
276                 char *msgstr = BLI_memarena_alloc(memarena, sizeof(*msgstr) * (msgstr_len + 1));
277
278                 if (msgctxt_len != 0) {
279                         BLI_dynstr_get_cstring_ex(msg->ctxt, msgkey);
280                         msgkey[msgctxt_len] = '\x04';  /* Context/msgid separator */
281                         BLI_dynstr_get_cstring_ex(msg->id, &msgkey[msgctxt_len + 1]);
282                 }
283                 else {
284                         BLI_dynstr_get_cstring_ex(msg->id, msgkey);
285                 }
286
287                 BLI_dynstr_get_cstring_ex(msg->str, msgstr);
288
289                 BLI_ghash_insert(messages, msgkey, msgstr);
290         }
291 }
292
293
294 static void clear(Message *msg)
295 {
296         BLI_dynstr_clear(msg->ctxt);
297         BLI_dynstr_clear(msg->id);
298         BLI_dynstr_clear(msg->str);
299         msg->is_fuzzy = false;
300 }
301
302 static int make(const char *input_file_name, const char *output_file_name)
303 {
304         GHash *messages = BLI_ghash_new(BLI_ghashutil_strhash_p_murmur, BLI_ghashutil_strcmp, __func__);
305         MemArena *msgs_memarena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
306
307         const char *msgctxt_kw = "msgctxt";
308         const char *msgid_kw = "msgid";
309         const char *msgid_plural_kw = "msgid_plural";
310         const char *msgstr_kw = "msgstr";
311         const size_t msgctxt_len = strlen(msgctxt_kw);
312         const size_t msgid_len = strlen(msgid_kw);
313         const size_t msgid_plural_len = strlen(msgid_plural_kw);
314         const size_t msgstr_len = strlen(msgstr_kw);
315
316         /* Note: For now, we assume file encoding is always utf-8. */
317
318         eSectionType section = SECTION_NONE;
319         bool is_plural = false;
320
321         Message msg = {
322             .ctxt = BLI_dynstr_new_memarena(),
323             .id = BLI_dynstr_new_memarena(),
324             .str = BLI_dynstr_new_memarena(),
325             .is_fuzzy = false,
326         };
327
328         LinkNode *input_file_lines = BLI_file_read_as_lines(input_file_name);
329         LinkNode *ifl = input_file_lines;
330
331         /* Parse the catalog. */
332         for (int lno = 1; ifl; ifl = ifl->next, lno++) {
333                 char *l = ifl->link;
334                 const bool is_comment = (l[0] == '#');
335                 /* If we get a comment line after a msgstr, this is a new entry. */
336                 if (is_comment) {
337                         if (section == SECTION_STR) {
338                                 add(messages, msgs_memarena, &msg);
339                                 clear(&msg);
340                                 section = SECTION_NONE;
341                         }
342                         /* Record a fuzzy mark. */
343                         if (l[1] == ',' && strstr(l, "fuzzy") != NULL) {
344                                 msg.is_fuzzy = true;
345                         }
346                         /* Skip comments */
347                         continue;
348                 }
349                 if (strstr(l, msgctxt_kw) == l) {
350                         if (section == SECTION_STR) {
351                                 /* New message, output previous section. */
352                                 add(messages, msgs_memarena, &msg);
353                         }
354                         if (!ELEM(section, SECTION_NONE, SECTION_STR)) {
355                                 printf("msgctxt not at start of new message on %s:%d\n", input_file_name, lno);
356                                 return EXIT_FAILURE;
357                         }
358                         section = SECTION_CTX;
359                         l = l + msgctxt_len;
360                         clear(&msg);
361                 }
362                 else if (strstr(l, msgid_plural_kw) == l) {
363                         /* This is a message with plural forms. */
364                         if (section != SECTION_ID) {
365                                 printf("msgid_plural not preceeded by msgid on %s:%d\n", input_file_name, lno);
366                                 return EXIT_FAILURE;
367                         }
368                         l = l + msgid_plural_len;
369                         BLI_dynstr_append(msg.id, NULLSEP_STR);  /* separator of singular and plural */
370                         is_plural = true;
371                 }
372                 else if (strstr(l, msgid_kw) == l) {
373                         if (section == SECTION_STR) {
374                                 add(messages, msgs_memarena, &msg);
375                         }
376                         if (section != SECTION_CTX) {
377                                 clear(&msg);
378                         }
379                         section = SECTION_ID;
380                         l = l + msgid_len;
381                         is_plural = false;
382                 }
383                 else if (strstr(l, msgstr_kw) == l) {
384                         l = l + msgstr_len;
385                         // Now we are in a msgstr section
386                         section = SECTION_STR;
387                         if (l[0] == '[') {
388                                 if (!is_plural) {
389                                         printf("plural without msgid_plural on %s:%d\n", input_file_name, lno);
390                                         return EXIT_FAILURE;
391                                 }
392                                 if ((l = strchr(l, ']')) == NULL) {
393                                         printf("Syntax error on %s:%d\n", input_file_name, lno);
394                                         return EXIT_FAILURE;
395                                 }
396                                 if (BLI_dynstr_get_len(msg.str) != 0) {
397                                         BLI_dynstr_append(msg.str, NULLSEP_STR);  /* Separator of the various plural forms. */
398                                 }
399                         }
400                         else {
401                                 if (is_plural) {
402                                         printf("indexed msgstr required for plural on %s:%d\n", input_file_name, lno);
403                                         return EXIT_FAILURE;
404                                 }
405                         }
406                 }
407                 /* Skip empty lines. */
408                 l = trim(l);
409                 if (l[0] == '\0') {
410                         if (section == SECTION_STR) {
411                                 add(messages, msgs_memarena, &msg);
412                                 clear(&msg);
413                         }
414                         section = SECTION_NONE;
415                         continue;
416                 }
417                 l = unescape(l);
418                 if (section == SECTION_CTX) {
419                         BLI_dynstr_append(msg.ctxt, l);
420                 }
421                 else if (section == SECTION_ID) {
422                         BLI_dynstr_append(msg.id, l);
423                 }
424                 else if (section == SECTION_STR) {
425                         BLI_dynstr_append(msg.str, l);
426                 }
427                 else {
428                         printf("Syntax error on %s:%d\n", input_file_name, lno);
429                         return EXIT_FAILURE;
430                 }
431         }
432         /* Add last entry */
433         if (section == SECTION_STR) {
434                 add(messages, msgs_memarena, &msg);
435         }
436
437         BLI_dynstr_free(msg.ctxt);
438         BLI_dynstr_free(msg.id);
439         BLI_dynstr_free(msg.str);
440         BLI_file_free_lines(input_file_lines);
441
442         /* Compute output */
443         size_t output_size;
444         char *output = generate(messages, &output_size);
445
446         FILE *fp = BLI_fopen(output_file_name, "wb");
447         fwrite(output, 1, output_size, fp);
448         fclose(fp);
449
450         MEM_freeN(output);
451         BLI_ghash_free(messages, NULL, NULL);
452         BLI_memarena_free(msgs_memarena);
453
454         return EXIT_SUCCESS;
455 }
456
457 int main(int argc, char **argv)
458 {
459         if (argc != 3) {
460                 printf("Usage: %s <input.po> <output.mo>\n", argv[0]);
461                 return EXIT_FAILURE;
462         }
463         const char *input_file = argv[1];
464         const char *output_file = argv[2];
465
466         return make(input_file, output_file);
467 }