Subversion Repositories SvarDOS

Rev

Rev 1064 | Rev 1248 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
597 mateuszvis 1
/*
2
 * Copyright (C) 2021-2022 Mateusz Viste
3
 *
4
 * usage: tlumacz en fr pl etc
5
 *
601 mateuszvis 6
 * computes an out.lng file that contains all language ressources.
597 mateuszvis 7
 *
8
 * DAT format:
9
 *
10
 * 4-bytes signature:
11
 * "SvL\x1b"
12
 *
13
 * Then "LANG BLOCKS" follow. Each LANG BLOCK is prefixed with 4 bytes:
14
 * II LL    - II is the LANG identifier ("EN", "PL", etc) and LL is the size
15
 *            of the block (65535 bytes max).
16
 *
17
 * Inside a LANG BLOCK is a set of strings:
18
 *
623 mateuszvis 19
 * II LL S  where II is the string's 16-bit identifier, LL is its length
20
 *          (1-65535) and S is the actual string. All strings are ASCIIZ (ie.
21
 *          they end with a NULL terminator).
597 mateuszvis 22
 *
23
 * The list of strings ends with a single 0-long string.
24
 */
25
 
26
 
27
#include <stdio.h>
28
#include <stdlib.h>
29
#include <string.h>
30
 
31
 
32
 
33
struct bitmap {
34
  unsigned char bits[8192];
35
};
36
 
37
static void bitmap_set(struct bitmap *b, unsigned short id) {
623 mateuszvis 38
  b->bits[id >> 3] |= 1 << (id & 7);
597 mateuszvis 39
}
40
 
41
static int bitmap_get(const struct bitmap *b, unsigned short id) {
623 mateuszvis 42
  return(b->bits[id >> 3] & (1 << (id & 7)));
597 mateuszvis 43
}
44
 
45
static void bitmap_init(struct bitmap *b) {
623 mateuszvis 46
  bzero(b, sizeof(struct bitmap));
597 mateuszvis 47
}
48
 
49
 
50
 
51
/* read a single line from fd and fills it into dst, returns line length
52
 * ending CR/LF is trimmed, as well as any trailing spaces */
53
static unsigned short readl(char *dst, size_t dstsz, FILE *fd) {
54
  unsigned short l, lastnonspace = 0;
55
 
56
  if (fgets(dst, dstsz, fd) == NULL) return(0xffff); /* EOF */
57
  /* trim at first CR or LF and return len */
58
  for (l = 0; (dst[l] != 0) && (dst[l] != '\r') && (dst[l] != '\n'); l++) {
59
    if (dst[l] != ' ') lastnonspace = l;
60
  }
61
 
62
  if (lastnonspace < l) l = lastnonspace + 1; /* rtrim */
63
  dst[l] = 0;
64
 
65
  return(l);
66
}
67
 
68
 
1114 mateusz.vi 69
/* parse a line in format "[?]1.50:somestring". fills id and returns a pointer to
597 mateuszvis 70
 * the actual string part on success, or NULL on error */
1114 mateusz.vi 71
static const char *parseline(unsigned short *id, const char *s) {
597 mateuszvis 72
  int i;
73
  int dotpos = 0, colpos = 0, gotdigits = 0;
74
 
1114 mateusz.vi 75
  /* strings prefixed by '?' are flagged as "dirty": ignore this flag here */
76
  if (*s == '?') s++;
77
 
597 mateuszvis 78
  /* I must have a . and a : in the first 9 bytes */
79
  for (i = 0;; i++) {
80
    if (s[i] == '.') {
81
      if ((dotpos != 0) || (gotdigits == 0)) break;
82
      dotpos = i;
83
      gotdigits = 0;
84
    } else if (s[i] == ':') {
85
      if (gotdigits != 0) colpos = i;
86
      break;
87
    } else if ((s[i] < '0') || (s[i] > '9')) {
88
      break;
89
    }
90
    gotdigits++;
91
  }
92
  /* did I collect everything? */
93
  if ((dotpos == 0) || (colpos == 0)) return(NULL);
94
  if (s[colpos + 1] == 0) return(NULL);
95
 
96
  *id = atoi(s);
97
  *id <<= 8;
98
  *id |= atoi(s + dotpos + 1);
99
 
100
  /* printf("parseline(): %04X = '%s'\r\n", *id, s + colpos + 1); */
101
 
102
  return(s + colpos + 1);
103
}
104
 
105
 
639 mateusz.vi 106
/* converts escape sequences like "\n" or "\t" into actual bytes, returns
107
 * the new length of the string. */
108
static unsigned short unesc_string(char *linebuff) {
109
  unsigned short i;
110
  for (i = 0; linebuff[i] != 0; i++) {
111
    if (linebuff[i] != '\\') continue;
112
    strcpy(linebuff + i, linebuff + i + 1);
113
    if (linebuff[i] == 0) break;
114
    switch (linebuff[i]) {
115
      case 'n':
116
        linebuff[i] = '\n';
117
        break;
118
      case 'r':
119
        linebuff[i] = '\r';
120
        break;
121
      case 't':
122
        linebuff[i] = '\t';
123
        break;
124
    }
125
  }
126
  return(i);
127
}
128
 
129
 
1061 mateusz.vi 130
/* opens a CATS-style file and compiles it into a ressources lang block
131
 * returns 0 on error, or the size of the generated data block otherwise */
597 mateuszvis 132
static unsigned short gen_langstrings(unsigned char *buff, const char *langid, struct bitmap *b, const struct bitmap *refb, const unsigned char *refblock) {
133
  unsigned short len = 0, linelen;
134
  FILE *fd;
135
  char fname[] = "XX.TXT";
623 mateuszvis 136
  static char linebuf[8192];
1114 mateusz.vi 137
  const char *ptr;
597 mateuszvis 138
  unsigned short id, linecount;
139
 
140
  bitmap_init(b);
141
 
142
  memcpy(fname + strlen(fname) - 6, langid, 2);
143
 
144
  fd = fopen(fname, "rb");
145
  if (fd == NULL) {
146
    printf("ERROR: FAILED TO OPEN '%s'\r\n", fname);
147
    return(0);
148
  }
149
 
150
  for (linecount = 1;; linecount++) {
151
 
152
    linelen = readl(linebuf, sizeof(linebuf), fd);
153
    if (linelen == 0xffff) break; /* EOF */
154
    if ((linelen == 0) || (linebuf[0] == '#')) continue;
155
 
639 mateusz.vi 156
    /* convert escaped chars to actual bytes (\n -> newline, etc) */
157
    linelen = unesc_string(linebuf);
158
 
597 mateuszvis 159
    /* read id and get ptr to actual string ("1.15:string") */
160
    ptr = parseline(&id, linebuf);
161
    if (ptr == NULL) {
623 mateuszvis 162
      printf("ERROR: line #%u of %s is malformed (linelen = %u):\r\n", linecount, fname, linelen);
163
      puts(linebuf);
597 mateuszvis 164
      len = 0;
165
      break;
166
    }
167
 
1114 mateusz.vi 168
    /* warn about dirty lines */
169
    if (linebuf[0] == '?') {
170
      printf("WARNING: %s[#%u] string id %u.%u is flagged as 'dirty'\r\n", fname, linecount, id >> 8, id & 0xff);
171
    }
172
 
623 mateuszvis 173
    /* write string into block (II LL S) */
597 mateuszvis 174
    memcpy(buff + len, &id, 2);
175
    len += 2;
623 mateuszvis 176
    {
177
      unsigned short slen = strlen(ptr) + 1;
178
      memcpy(buff + len, &slen, 2);
179
      len += 2;
180
      memcpy(buff + len, ptr, slen);
181
      len += slen;
182
    }
597 mateuszvis 183
 
184
    /* if reference bitmap provided: check that the id is valid */
185
    if ((refb != NULL) && (bitmap_get(refb, id) == 0)) {
186
      printf("WARNING: %s[#%u] has an invalid id (%u.%u not present in ref lang)\r\n", fname, linecount, id >> 8, id & 0xff);
187
    }
188
 
189
    /* make sure this id is not already present */
190
    if (bitmap_get(b, id) == 0) {
191
      /* set bit in bitmap to remember I have this string */
192
      bitmap_set(b, id);
193
    } else {
194
      printf("WARNING: %s[#%u] has a duplicated id (%u.%u)\r\n", fname, linecount, id >> 8, id & 0xff);
195
    }
196
  }
197
 
198
  fclose(fd);
199
 
200
  /* if refblock provided, pull missing strings from it */
201
  if (refblock != NULL) {
202
    for (;;) {
623 mateuszvis 203
      unsigned short slen;
204
      id = ((unsigned short *)refblock)[0];
205
      slen = ((unsigned short *)refblock)[1];
206
      if ((id == 0) && (slen == 0)) break;
597 mateuszvis 207
      if (bitmap_get(b, id) == 0) {
208
        printf("WARNING: %s is missing string %u.%u (pulled from ref lang)\r\n", fname, id >> 8, id & 0xff);
209
        /* copy missing string from refblock */
623 mateuszvis 210
        memcpy(buff + len, refblock, slen + 4);
211
        len += slen + 4;
597 mateuszvis 212
      }
623 mateuszvis 213
      refblock += slen + 4;
597 mateuszvis 214
    }
215
  }
216
 
217
  /* write the block terminator (0-long string) */
218
  buff[len++] = 0; /* id */
219
  buff[len++] = 0; /* id */
220
  buff[len++] = 0; /* len */
623 mateuszvis 221
  buff[len++] = 0; /* len */
222
  buff[len++] = 0; /* empty string */
597 mateuszvis 223
 
224
  return(len);
225
}
226
 
227
 
599 mateuszvis 228
#define MEMBLOCKSZ 65000
597 mateuszvis 229
 
230
int main(int argc, char **argv) {
231
  FILE *fd;
232
  int ecode = 0;
233
  char *buff, *refblock;
1061 mateusz.vi 234
  unsigned short refblocksz = 0;
597 mateuszvis 235
  static struct bitmap bufbitmap;
236
  static struct bitmap refbitmap;
237
  unsigned short i;
1061 mateusz.vi 238
  unsigned short biggest_langsz = 0;
597 mateuszvis 239
 
240
  if (argc < 2) {
241
    puts("usage: tlumacz en fr pl etc");
242
    return(1);
243
  }
244
 
245
  buff = malloc(MEMBLOCKSZ);
246
  refblock = malloc(MEMBLOCKSZ);
247
  if ((buff == NULL) || (refblock == NULL)) {
248
    puts("out of memory");
249
    return(1);
250
  }
251
 
601 mateuszvis 252
  fd = fopen("out.lng", "wb");
597 mateuszvis 253
  if (fd == NULL) {
254
    puts("ERR: failed to open or create SVARCOM.LNG");
255
    return(1);
256
  }
257
 
258
  /* write sig */
259
  fwrite("SvL\x1b", 1, 4, fd);
260
 
261
  /* write lang blocks */
262
  for (i = 1; i < argc; i++) {
263
    unsigned short sz;
264
    char id[3];
265
 
266
    if (strlen(argv[i]) != 2) {
267
      printf("INVALID LANG SPECIFIED: %s\r\n", argv[i]);
268
      ecode = 1;
269
      break;
270
    }
271
 
272
    id[0] = argv[i][0];
273
    id[1] = argv[i][1];
274
    id[2] = 0;
275
    if (id[0] >= 'a') id[0] -= 'a' - 'A';
276
    if (id[1] >= 'a') id[1] -= 'a' - 'A';
277
 
278
    sz = gen_langstrings(buff, id, &bufbitmap, (i != 1)?&refbitmap:NULL, (i != 1)?refblock:NULL);
279
    if (sz == 0) {
280
      printf("ERROR COMPUTING LANG '%s'\r\n", id);
281
      ecode = 1;
282
      break;
283
    } else {
284
      printf("computed %s lang block of %u bytes\r\n", id, sz);
1061 mateusz.vi 285
      if (sz > biggest_langsz) biggest_langsz = sz;
597 mateuszvis 286
    }
287
    /* write lang ID to file, followed by block size and then the actual block */
288
    if ((fwrite(id, 1, 2, fd) != 2) ||
289
        (fwrite(&sz, 1, 2, fd) != 2) ||
290
        (fwrite(buff, 1, sz, fd) != sz)) {
291
      printf("ERROR WRITING TO OUTPUT FILE\r\n");
292
      ecode = 1;
293
      break;
294
    }
1061 mateusz.vi 295
    /* remember reference data for other languages */
597 mateuszvis 296
    if (i == 1) {
1061 mateusz.vi 297
      refblocksz = sz;
597 mateuszvis 298
      memcpy(refblock, buff, MEMBLOCKSZ);
299
      memcpy(&refbitmap, &bufbitmap, sizeof(struct bitmap));
300
    }
301
  }
302
 
303
  fclose(fd);
304
 
1061 mateusz.vi 305
  /* compute the deflang.c file containing a dump of the reference block */
306
  fd = fopen("DEFLANG.C", "wb");
307
  if (fd == NULL) {
308
    puts("ERROR: FAILED TO OPEN OR CREATE DEFLANG.C");
309
    ecode = 1;
310
  } else {
311
    unsigned short allocsz = biggest_langsz + (biggest_langsz / 20);
312
    printf("biggest lang block is %u bytes -> allocating a %u bytes buffer\n", biggest_langsz, allocsz);
313
    fprintf(fd, "/* THIS FILE HAS BEEN GENERATED BY TLUMACZ (PART OF THE SVARLANG LIBRARY) */\r\n");
314
    fprintf(fd, "const unsigned short svarlang_memsz = %uu;\r\n", allocsz);
315
    fprintf(fd, "char svarlang_mem[%u] = {\r\n", allocsz);
316
    for (i = 0; i < refblocksz; i++) {
1064 mateusz.vi 317
      fprintf(fd, "%u", refblock[i]);
1061 mateusz.vi 318
      if (i + 1 < refblocksz) fprintf(fd, ",");
319
      if ((i & 15) == 15) fprintf(fd, "\r\n");
320
    }
321
    fprintf(fd, "};\r\n");
322
    fclose(fd);
323
  }
324
 
597 mateuszvis 325
  return(ecode);
326
}