Skip to content

W
wine-cw
Commit c74f6d9d authored by Mikołaj Zalewski's avatar Mikołaj Zalewski Committed by Alexandre Julliard
Browse files
Options

wrc: Change the format of the output of "wrc --verify-translation".

parent fbd25173
Show whitespace changes
Inline Side-by-side
Showing with 204 additions and 225 deletions
tools/wrc/translation.c
View file @ c74f6d9d
......@@ -18,11 +18,14 @@
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "dumpres.h"
#include "utils.h"
#include "wrc.h"
#define MASTER_LANGUAGE LANG_ENGLISH
#define MASTER_SUBLANGUAGE SUBLANG_ENGLISH_US
#define NB_LANG 0x94
enum lang_type_e {
......@@ -31,80 +34,65 @@ enum lang_type_e {
lang_type_normal
};
static int present_resources[res_usr+1];
static char *res_names[res_usr+1];
static int nb_resources[res_usr+1][lang_type_normal+1];
static resource_t **list_resources[res_usr+1][lang_type_normal+1];
static int get_language_id(resource_t *resource) {
static language_t get_language(resource_t *resource) {
switch(resource->type) {
case res_acc:
return resource->res.acc->lvc.language->id;
return *resource->res.acc->lvc.language;
case res_bmp:
return resource->res.bmp->data->lvc.language->id;
return *resource->res.bmp->data->lvc.language;
case res_cur:
return resource->res.cur->lvc.language->id;
return *resource->res.cur->lvc.language;
case res_curg:
return resource->res.curg->lvc.language->id;
return *resource->res.curg->lvc.language;
case res_dlg:
return resource->res.dlg->lvc.language->id;
return *resource->res.dlg->lvc.language;
case res_dlgex:
return resource->res.dlgex->lvc.language->id;
return *resource->res.dlgex->lvc.language;
case res_fnt:
return resource->res.fnt->data->lvc.language->id;
return *resource->res.fnt->data->lvc.language;
case res_fntdir:
return resource->res.fnd->data->lvc.language->id;
return *resource->res.fnd->data->lvc.language;
case res_ico:
return resource->res.ico->lvc.language->id;
return *resource->res.ico->lvc.language;
case res_icog:
return resource->res.icog->lvc.language->id;
return *resource->res.icog->lvc.language;
case res_men:
return resource->res.men->lvc.language->id;
return *resource->res.men->lvc.language;
case res_menex:
return resource->res.menex->lvc.language->id;
return *resource->res.menex->lvc.language;
case res_rdt:
return resource->res.rdt->data->lvc.language->id;
return *resource->res.rdt->data->lvc.language;
case res_stt:
return resource->res.stt->lvc.language->id;
return *resource->res.stt->lvc.language;
case res_usr:
return resource->res.usr->data->lvc.language->id;
return *resource->res.usr->data->lvc.language;
case res_msg:
return resource->res.msg->data->lvc.language->id;
return *resource->res.msg->data->lvc.language;
case res_ver:
return resource->res.ver->lvc.language->id;
return *resource->res.ver->lvc.language;
case res_dlginit:
return resource->res.dlgi->data->lvc.language->id;
return *resource->res.dlgi->data->lvc.language;
case res_toolbar:
return resource->res.tbt->lvc.language->id;
return *resource->res.tbt->lvc.language;
case res_anicur:
case res_aniico:
return resource->res.ani->data->lvc.language->id;
return *resource->res.ani->data->lvc.language;
case res_html:
return resource->res.html->data->lvc.language->id;
return *resource->res.html->data->lvc.language;
default:
/* Not supposed to reach here */
fprintf(stderr, "Not supposed to reach here (get_language_id())\n");
abort();
return -1;
}
}
static void add_resource(resource_t *resource) {
enum lang_type_e lang_type;
enum res_e res_type = resource->type;
int lid = get_language_id(resource);
if(lid == MASTER_LANGUAGE) {
lang_type = lang_type_master;
} else if(lid == LANG_NEUTRAL) {
lang_type = lang_type_neutral;
} else {
lang_type = lang_type_normal;
}
nb_resources[res_type][lang_type]++;
list_resources[res_type][lang_type] = realloc(list_resources[res_type][lang_type], nb_resources[res_type][lang_type]*sizeof(resource_t *));
list_resources[res_type][lang_type][nb_resources[res_type][lang_type]-1] = resource;
static int get_language_id(resource_t *resource) {
return get_language(resource).id;
}
static int compare_lang(language_t lang1, language_t lang2)
{
return memcmp(&lang1, &lang2, sizeof(language_t));
}
#if 0
......@@ -951,27 +939,113 @@ static int compare(resource_t *resource1, resource_t *resource2) {
}
}
void verify_translations(resource_t *top) {
enum lang_type_e lang_type;
enum res_e res_type;
int **presence;
int i, j;
char *nameid;
char **problems;
int nb_problems, last_problem;
int complete, needs_work, partial;
resource_t *next = top;
for(res_type = res_0; res_type <= res_usr; res_type++) {
present_resources[res_type] = 0;
for(lang_type = lang_type_master; lang_type <= lang_type_normal; lang_type++) {
nb_resources[res_type][lang_type] = 0;
list_resources[res_type][lang_type] = NULL;
static void dump_stringtable(resource_t *res)
{
stringtable_t *stt = res->res.stt;
int j;
printf("DUMP ");
assert((stt->idbase%16) == 0);
assert(stt->nentries == 16);
for (j = 0; j < stt->nentries; j++)
{
stt_entry_t *entry = &stt->entries[j];
language_t *lang = stt->lvc.language;
string_t *newstr;
WCHAR *wstr;
int k;
if (entry->str)
{
newstr = convert_string(entry->str, str_unicode, get_language_codepage(lang->id, lang->sub));
printf("%02x%02x", newstr->size & 0xff, (newstr->size >> 8) & 0xff);
wstr = newstr->str.wstr;
for (k = 0; k < newstr->size; k++)
printf("%02x%02x", wstr[k] & 0xff, wstr[k] >> 8);
free_string(newstr);
}
else
printf("0000");
}
putchar('\n');
}
static void dump(resource_t *res)
{
switch (res->type)
{
case res_stt:
dump_stringtable(res);
return;
default:
break;
}
}
typedef struct resource_lang_node
{
language_t lang;
resource_t *res;
struct resource_lang_node *next;
} resource_lang_node_t;
typedef struct resource_id_node
{
name_id_t *id;
resource_lang_node_t *langs;
struct resource_id_node *next;
} resource_id_node_t;
struct
{
int enabled;
struct resource_id_node *ids;
} verify_tab[res_usr+1];
static void add_resource(resource_t *res)
{
resource_id_node_t *idnode;
resource_lang_node_t *langnode;
if (!verify_tab[res->type].enabled)
{
fprintf(stderr, "ERR: Report this: unknown resource type parsed %08x\n", res->type);
return;
}
for (idnode = verify_tab[res->type].ids; idnode; idnode = idnode->next)
if (compare_name_id(idnode->id, res->name) == 0)
break;
if (idnode == NULL)
{
idnode = xmalloc(sizeof(resource_id_node_t));
idnode->id = res->name;
idnode->langs = NULL;
idnode->next = verify_tab[res->type].ids;
verify_tab[res->type].ids = idnode;
}
for (langnode = idnode->langs; langnode; langnode = langnode->next)
if (compare_lang(langnode->lang, get_language(res)) == 0)
{
fprintf(stderr, "ERR: resource %s [type %x] language %03x:%02x duplicated!\n",
get_nameid_str(res->name), res->type, langnode->lang.id, langnode->lang.sub);
return;
}
while(next) {
switch(next->type) {
langnode = xmalloc(sizeof(resource_lang_node_t));
langnode->res = res;
langnode->lang = get_language(res);
langnode->next = idnode->langs;
idnode->langs = langnode;
}
static void setup_tabs()
{
int i;
for (i = 0; i <= res_usr; i++)
switch(i) {
case res_acc:
case res_bmp:
case res_cur:
......@@ -994,181 +1068,86 @@ void verify_translations(resource_t *top) {
case res_anicur:
case res_aniico:
case res_html:
add_resource(next);
verify_tab[i].enabled = 1;
break;
default:
fprintf(stderr, "Report this: unknown resource type parsed %08x\n", next->type);
}
next = next->next;
}
present_resources[res_acc] = 1;
res_names[res_acc] = strdup("accelerator");
present_resources[res_bmp] = 1;
res_names[res_bmp] = strdup("bitmap");
present_resources[res_cur] = 1;
res_names[res_cur] = strdup("cursor");
present_resources[res_curg] = 1;
res_names[res_curg] = strdup("cursor_group");
present_resources[res_dlg] = 1;
res_names[res_dlg] = strdup("dialog");
present_resources[res_dlgex] = 1;
res_names[res_dlgex] = strdup("dialogex");
present_resources[res_fnt] = 1;
res_names[res_fnt] = strdup("font");
present_resources[res_fntdir] = 1;
res_names[res_fntdir] = strdup("fontdir");
present_resources[res_ico] = 1;
res_names[res_ico] = strdup("icon");
present_resources[res_icog] = 1;
res_names[res_icog] = strdup("icon_group");
present_resources[res_men] = 1;
res_names[res_men] = strdup("menu");
present_resources[res_menex] = 1;
res_names[res_menex] = strdup("menuex");
present_resources[res_rdt] = 1;
res_names[res_rdt] = strdup("rcdata");
present_resources[res_stt] = 1;
res_names[res_stt] = strdup("stringtable");
present_resources[res_usr] = 1;
res_names[res_usr] = strdup("user");
present_resources[res_msg] = 1;
res_names[res_msg] = strdup("messagetable");
present_resources[res_ver] = 1;
res_names[res_ver] = strdup("versioninfo");
present_resources[res_dlginit] = 1;
res_names[res_dlginit] = strdup("dlginit");
present_resources[res_toolbar] = 1;
res_names[res_toolbar] = strdup("toolbar");
present_resources[res_anicur] = 1;
res_names[res_anicur] = strdup("ani_cursor");
present_resources[res_aniico] = 1;
res_names[res_aniico] = strdup("ani_icon");
present_resources[res_html] = 1;
res_names[res_html] = strdup("html");
for(res_type = res_0; res_type <= res_usr; res_type++) {
if(!present_resources[res_type]) {
continue;
}
if(nb_resources[res_type][lang_type_normal] > 0) {
if(nb_resources[res_type][lang_type_master] && nb_resources[res_type][lang_type_neutral]) {
fprintf(stderr, "Type %s:\n", res_names[res_type]);
fprintf(stderr, "There are both a NEUTRAL and a MASTER version for %s, along with additional localized versions. The NEUTRAL versions will not be checked against other versions.\n", res_names[res_type]);
} else if(nb_resources[res_type][lang_type_neutral]) {
fprintf(stderr, "Type %s:\n", res_names[res_type]);
fprintf(stderr, "There are no MASTER version, but there are some NEUTRAL versions for %s, so will use those instead of MASTER for comparison.\n", res_names[res_type]);
list_resources[res_type][lang_type_master] = list_resources[res_type][lang_type_neutral];
nb_resources[res_type][lang_type_master] = nb_resources[res_type][lang_type_neutral];
} else if(!nb_resources[res_type][lang_type_master]) {
fprintf(stderr, "Type %s:\n", res_names[res_type]);
fprintf(stderr, "There are no NEUTRAL nor MASTER versions for %s, but there are some other localized versions. No comparison will be done at all.\n", res_names[res_type]);
}
} else {
if(nb_resources[res_type][lang_type_master] && nb_resources[res_type][lang_type_neutral]) {
fprintf(stderr, "Type %s:\n", res_names[res_type]);
fprintf(stderr, "There are both a NEUTRAL and a MASTER versions for %s, but no other localized version. No comparison will be done at all.\n", res_names[res_type]);
} else if(nb_resources[res_type][lang_type_master]) {
fprintf(stderr, "Type %s:\n", res_names[res_type]);
fprintf(stderr, "There are only MASTER versions for %s. No comparison will be done at all.\n", res_names[res_type]);
} else if(nb_resources[res_type][lang_type_neutral]) {
/* fprintf(stderr, "There are only NEUTRAL versions for %s. No comparison will be done at all.\n", res_names[res_type]); */
} else {
/* fprintf(stderr, "There are no versions at all for %s. No comparison will be done at all.\n", res_names[res_type]); */
}
}
}
presence = malloc(nb_resources[res_type][lang_type_master]*sizeof(int *));
for(i = 0; i < nb_resources[res_type][lang_type_master]; i++) {
presence[i] = calloc(NB_LANG, sizeof(int));
presence[i][MASTER_LANGUAGE] = -1;
}
static const char *get_typename_for_int(int type) {
resource_t res;
res.type = type;
return get_typename(&res);
}
for(i = 0; i < nb_resources[res_type][lang_type_normal]; i++) {
for(j = 0; j < nb_resources[res_type][lang_type_master]; j++) {
nameid = strdup(get_nameid_str(list_resources[res_type][lang_type_normal][i]->name));
if(!strcmp(nameid, get_nameid_str(list_resources[res_type][lang_type_master][j]->name))) {
if(compare(list_resources[res_type][lang_type_normal][i], list_resources[res_type][lang_type_master][j])) {
presence[j][get_language_id(list_resources[res_type][lang_type_normal][i])] = 2;
/* fprintf(stderr, "Differences in type %s, ID %s, for language %s\n", res_names[res_type], nameid, get_language_name(get_language_id(list_resources[res_type][lang_type_normal][i]))); */
} else {
presence[j][get_language_id(list_resources[res_type][lang_type_normal][i])] = 1;
}
}
free(nameid);
}
static resource_t *find_main(int type, name_id_t *id, resource_lang_node_t *langnode)
{
resource_t *neutral = NULL, *en = NULL, *en_US = NULL;
for (; langnode; langnode = langnode->next)
{
if (langnode->lang.id == LANG_NEUTRAL && langnode->lang.sub == SUBLANG_NEUTRAL)
neutral = langnode->res;
if (langnode->lang.id == MASTER_LANGUAGE && langnode->lang.sub == SUBLANG_NEUTRAL)
en = langnode->res;
if (langnode->lang.id == MASTER_LANGUAGE && langnode->lang.sub == MASTER_SUBLANGUAGE)
en_US = langnode->res;
}
problems = malloc(sizeof(char *));
problems[0] = strdup("");
nb_problems = 0;
last_problem = -1;
for(i = 0; i < NB_LANG; i++) {
complete = 1;
needs_work = 0;
partial = 0;
for(j = 0; j < nb_resources[res_type][lang_type_master]; j++) {
if(presence[j][i]) {
partial = 1;
if(presence[j][i] == 2) {
needs_work = 1;
problems = realloc(problems, (++nb_problems+1)*sizeof(char *));
problems[nb_problems] = malloc(strlen(get_nameid_str(list_resources[res_type][lang_type_master][j]->name)) + 9);
sprintf(problems[nb_problems], "DIFF %s %02x", get_nameid_str(list_resources[res_type][lang_type_master][j]->name), i);
if(last_problem == i) {
problems[nb_problems-1] = realloc(problems[nb_problems-1], strlen(problems[nb_problems-1]) + 3);
strcat(problems[nb_problems-1], " \\");
} else {
last_problem = i;
}
if (neutral != NULL && (en != NULL || en_US != NULL))
{
fprintf(stderr, "INFO: Resource %04x/%s has both NEUTRAL and MASTER language translarion\n",
type, get_nameid_str(id));
}
} else {
complete = 0;
problems = realloc(problems, (++nb_problems+1)*sizeof(char *));
problems[nb_problems] = malloc(strlen(get_nameid_str(list_resources[res_type][lang_type_master][j]->name)) + 8);
sprintf(problems[nb_problems], "ABS %s %02x", get_nameid_str(list_resources[res_type][lang_type_master][j]->name), i);
if(last_problem == i) {
problems[nb_problems-1] = realloc(problems[nb_problems-1], strlen(problems[nb_problems-1]) + 3);
strcat(problems[nb_problems-1], " \\");
} else {
last_problem = i;
if (en_US != NULL) return en_US;
if (en != NULL) return en;
return neutral;
}
void verify_translations(resource_t *top) {
resource_t *curr = top;
resource_id_node_t *idnode;
resource_lang_node_t *langnode;
int type;
setup_tabs();
while (curr)
{
add_resource(curr);
curr = curr->next;
}
for (type = 0; type <= res_usr; type++)
{
printf("TYPE NEXT [%s]\n", get_typename_for_int(type));
for (idnode = verify_tab[type].ids; idnode; idnode = idnode->next)
{
resource_t *mainres;
printf("RESOURCE [%s]\n", get_nameid_str(idnode->id));
mainres = find_main(type, idnode->id, idnode->langs);
if (!mainres)
{
fprintf(stderr, "ERR: resource %04x/%s has translation(s) but not available in NEUTRAL or MASTER language\n",
type, get_nameid_str(idnode->id));
for (langnode = idnode->langs; langnode; langnode = langnode->next)
printf("EXTRA %03x:%02x\n", langnode->lang.id, langnode->lang.sub);
continue;
}
if (get_language_id(mainres) == LANG_NEUTRAL && idnode->langs->next == NULL) {
printf("NOTRANSL\n");
continue;
}
if(complete && partial && !needs_work) {
/* Support is complete, no need to do anything */
/* fprintf(stderr, "Support for language %s is complete for %s.\n", get_language_name(i), res_names[res_type]); */
printf(".");
} else if(complete && partial && needs_work) {
/* Support is incomplete (differing resources), needs work */
/* fprintf(stderr, "Support for language %s is incomplete (differing resources) for %s.\n", get_language_name(i), res_names[res_type]); */
printf("x");
} else if(!complete && partial && !needs_work) {
/* Support is incomplete (missing resources), needs work */
/* fprintf(stderr, "Support for language %s is incomplete (missing resources) for %s.\n", get_language_name(i), res_names[res_type]); */
printf("-");
} else if(!complete && partial && needs_work) {
/* Support is incomplete (missing and differing resources), needs work */
/* fprintf(stderr, "Support for language %s is incomplete (missing and differing resources) for %s.\n", get_language_name(i), res_names[res_type]); */
printf("+");
} else if(!complete && !partial) {
/* Support is totally absent, might be interesting to do */
/* fprintf(stderr, "Support for language %s is absent for %s.\n", get_language_name(i), res_names[res_type]); */
printf(" ");
} else {
/* Support is not relevant, no need to do anything */
/* fprintf(stderr, "Support for language %s is not relevant for %s.\n", get_language_name(i), res_names[res_type]); */
printf("n");
for (langnode = idnode->langs; langnode; langnode = langnode->next)
{
printf("EXIST %03x:%02x\n", langnode->lang.id, langnode->lang.sub);
dump(langnode->res);
if (compare(langnode->res, mainres))
{
printf("DIFF %03x:%02x\n", langnode->lang.id, langnode->lang.sub);
}
}
printf("\n");
for(i = 1; i <= nb_problems; i++) {
printf("%s\n", problems[i]);
free(problems[i]);
}
free(problems[0]);
free(problems);
for(i = 0; i < nb_resources[res_type][lang_type_master]; i++)
free(presence[i]);
free(presence);
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment