bilingual program in console application in C

Question

I have been trying to implement a way to make my program bilingual : the user could chose if the program should display French or English (in my case). I have made lots of researches and googling but I still cannot find a good example on how to do that :/

I read about gettext, but since this is for a school's project we are not allowed to use external libraries (and I must admit I have nooo idea how to make it work even though I tried !)

Someone also suggested to me the use of arrays one for each language, I could definitely make this work but I find the solution super ugly.

Another way I thought of is to have to different files, with sentences on each line and I would be able to retrieve the right line for the right language when I need to. I think I could make this work but it also doesn't seem like the most elegant solution.

At last, a friend said I could use DLL for that. I have looked up into that and it indeed seems to be one of the best ways I could find... the problem is that most resources I could find on that matter were coded for C# and C++ and I still have no idea how I would do to implement in C :/ I can grasp the idea behind it, but have no idea how to handle it in C (at all ! I do not know how to create the DLL, call it, retrieve the right stuff from it or anything >_<)

Could someone point me to some useful resources that I could use, or write a piece of code to explain the way things work or should be done ? It would be seriously awesome !

Thanks a lot in advance !

(Btw, I use visual studio 2012 and code in C) ^^

Answer 1

If you can't use a third party lib then write your own one! No need for a dll.

The basic idea is the have a file for each locale witch contains a mapping (key=value) for text resources.

The name of the file could be something like

resources_<locale>.txt

where <locale> could be something like en, fr, de etc.

When your program stars it reads first the resource file for specified locale.

Preferably you will have to store each key/value pair in a simple struct.

Your read function reads all key/value pair into a hash table witch offers a very good access speed. An alternative would be to sort the array containing the key/value pairs by key and then use binary search on lookup (not the best option, but far better than iterating over all entries each time).

Then you'll have to write a function get_text witch takes as argument the key of the text resource to be looked up an return the corresponding text in as read for the specified locale. You have to handle keys witch have no mapping, the simplest way would be to return key back.

Here is some sample code (using qsort and bsearch):

#include<stdio.h> 
#include<stdlib.h>
#include<string.h>

#define DEFAULT_LOCALE "en"
#define NULL_ARG "[NULL]"

typedef struct localized_text {
    char* key;
    char* value;
} localized_text_t;

localized_text_t* localized_text_resources = NULL;
int counter = 0;

char* get_text(char*);
void read_localized_text_resources(char*);
char* read_line(FILE*);
void free_localized_text_resources();
int compare_keys(const void*, const void*);
void print_localized_text_resources();


int main(int argc, char** argv)  
{
    argv++;
    argc--;

    char* locale = DEFAULT_LOCALE;

    if(! *argv) {
        printf("No locale provided, default to %s\n", locale);
    } else {
        locale = *argv;
        printf("Locale provided is %s\n", locale);
    }

    read_localized_text_resources(locale);

    printf("\n%s, %s!\n", get_text("HELLO"), get_text("WORLD"));
    printf("\n%s\n", get_text("foo"));

    free_localized_text_resources();

    return 0;  
} 


char* get_text(char* key)
{
    char* text = NULL_ARG;
    if(key) {
        text = key;
        localized_text_t tmp;
        tmp.key = key;
        localized_text_t* result = bsearch(&tmp, localized_text_resources, counter, sizeof(localized_text_t), compare_keys);
        if(result) {
            text = result->value;
        }
    }    
    return text;
}

void read_localized_text_resources(char* locale)
{
    if(locale) {
        char localized_text_resources_file_name[64];
        sprintf(localized_text_resources_file_name, "resources_%s.txt", locale);
        printf("Read localized text resources from file %s\n", localized_text_resources_file_name);
        FILE* localized_text_resources_file = fopen(localized_text_resources_file_name, "r");
        if(! localized_text_resources_file) {
            perror(localized_text_resources_file_name);
            exit(1);
        }
        int size = 10;
        localized_text_resources = malloc(size * sizeof(localized_text_t));
        if(! localized_text_resources) {
            perror("Unable to allocate memory for text resources");
        }

        char* line;
        while((line = read_line(localized_text_resources_file))) {
            if(strlen(line) > 0) {
                if(counter == size) {
                    size += 10;
                    localized_text_resources = realloc(localized_text_resources, size * sizeof(localized_text_t));
                }
                localized_text_resources[counter].key = line;
                while(*line != '=') {
                    line++;
                }
                *line = '\0';
                line++;
                localized_text_resources[counter].value = line;
                counter++;
            }
        }
        qsort(localized_text_resources, counter, sizeof(localized_text_t), compare_keys);
        // print_localized_text_resources();
        printf("%d text resource(s) found in file %s\n", counter, localized_text_resources_file_name);
    }
}


char* read_line(FILE* p_file)
{
    int len = 10, i = 0, c = 0;
    char* line = NULL;

    if(p_file) {
        line = malloc(len * sizeof(char));
        c = fgetc(p_file);
        while(c != EOF) {
            if(i == len) {
                len += 10;
                line = realloc(line, len * sizeof(char));
            }
            line[i++] = c;
            c = fgetc(p_file);
            if(c == '\n' || c == '\r') {
                break;
            }
        }

        line[i] = '\0';

        while(c == '\n' || c == '\r') {
            c = fgetc(p_file);
        }
        if(c != EOF) {
            ungetc(c, p_file);
        }

        if(strlen(line) == 0 && c == EOF) {
            free(line);
            line = NULL;
        }
    }

    return line;
}


void free_localized_text_resources()
{
    if(localized_text_resources) {
        while(counter--) {
            free(localized_text_resources[counter].key);
        }
        free(localized_text_resources);
    }
}


int compare_keys(const void* e1, const void* e2)
{
    return strcmp(((localized_text_t*) e1)->key, ((localized_text_t*) e2)->key);
}


void print_localized_text_resources() 
{
    int i = 0;
    for(; i < counter; i++) {
        printf("Key=%s  value=%s\n", localized_text_resources[i].key, localized_text_resources[i].value);
    }
}

Used with the following resource files

resources_en.txt

WORLD=World
HELLO=Hello

resources_de.txt

HELLO=Hallo
WORLD=Welt

resources_fr.txt

HELLO=Hello
WORLD=Monde

run

(1) out.exe     /* default */
(2) out.exe en
(3) out.exe de
(4) out.exe fr

output

(1) Hello, World!
(2) Hello, World!
(3) Hallo, Welt!
(4) Hello, Monde!