libutils/source/language/gettext.cpp

/****************************************************************************
 * Copyright (C) 2015 Dimok
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 ****************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include <string>
#include <vector>
#include "gettext.h"
#include "fs/CFile.hpp"
#include "utils/StringTools.h"

typedef struct _MSG {
    u32 id;
    char* msgstr;
    struct _MSG *next;
} MSG;
static MSG *baseMSG = 0;

#define HASHWORDBITS 32

/* Defines the so called `hashpjw' function by P.J. Weinberger
 [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
 1986, 1987 Bell Telephone Laboratories, Inc.]  */
static inline u32 hash_string(const char *str_param) {
    u32 hval, g;
    const char *str = str_param;

    /* Compute the hash value for the given string.  */
    hval = 0;
    while (*str != '\0') {
        hval <<= 4;
        hval += (u8) *str++;
        g = hval & ((u32) 0xf << (HASHWORDBITS - 4));
        if (g != 0) {
            hval ^= g >> (HASHWORDBITS - 8);
            hval ^= g;
        }
    }
    return hval;
}

/* Expand some escape sequences found in the argument string.  */
static char *
expand_escape(const char *str) {
    char *retval, *rp;
    const char *cp = str;

    retval = (char *) malloc(strlen(str) + 1);
    if (retval == NULL) return NULL;
    rp = retval;

    while (cp[0] != '\0' && cp[0] != '\\')
        *rp++ = *cp++;
    if (cp[0] == '\0') goto terminate;
    do {

        /* Here cp[0] == '\\'.  */
        switch (*++cp) {
        case '\"': /* " */
            *rp++ = '\"';
            ++cp;
            break;
        case 'a': /* alert */
            *rp++ = '\a';
            ++cp;
            break;
        case 'b': /* backspace */
            *rp++ = '\b';
            ++cp;
            break;
        case 'f': /* form feed */
            *rp++ = '\f';
            ++cp;
            break;
        case 'n': /* new line */
            *rp++ = '\n';
            ++cp;
            break;
        case 'r': /* carriage return */
            *rp++ = '\r';
            ++cp;
            break;
        case 't': /* horizontal tab */
            *rp++ = '\t';
            ++cp;
            break;
        case 'v': /* vertical tab */
            *rp++ = '\v';
            ++cp;
            break;
        case '\\':
            *rp = '\\';
            ++cp;
            break;
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7': {
            int ch = *cp++ - '0';

            if (*cp >= '0' && *cp <= '7') {
                ch *= 8;
                ch += *cp++ - '0';

                if (*cp >= '0' && *cp <= '7') {
                    ch *= 8;
                    ch += *cp++ - '0';
                }
            }
            *rp = ch;
        }
        break;
        default:
            *rp = '\\';
            break;
        }

        while (cp[0] != '\0' && cp[0] != '\\')
            *rp++ = *cp++;
    } while (cp[0] != '\0');

    /* Terminate string.  */
terminate:
    *rp = '\0';
    return retval;
}

static MSG *findMSG(u32 id) {
    MSG *msg;
    for (msg = baseMSG; msg; msg = msg->next) {
        if (msg->id == id) return msg;
    }
    return NULL;
}

static MSG *setMSG(const char *msgid, const char *msgstr) {
    u32 id = hash_string(msgid);
    MSG *msg = findMSG(id);
    if (!msg) {
        msg = (MSG *) malloc(sizeof(MSG));
        msg->id = id;
        msg->msgstr = NULL;
        msg->next = baseMSG;
        baseMSG = msg;
    }
    if (msg) {
        if (msgstr) {
            if (msg->msgstr) free(msg->msgstr);
            //msg->msgstr = strdup(msgstr);
            msg->msgstr = expand_escape(msgstr);
        }
        return msg;
    }
    return NULL;
}

extern "C" void gettextCleanUp(void) {
    while (baseMSG) {
        MSG *nextMsg = baseMSG->next;
        free(baseMSG->msgstr);
        free(baseMSG);
        baseMSG = nextMsg;
    }
}

extern "C" bool gettextLoadLanguage(const char* langFile) {
    char *lastID = NULL;
    gettextCleanUp();

    CFile file(langFile, CFile::ReadOnly);
    if (!file.isOpen())
        return false;

    std::string strBuffer;
    strBuffer.resize(file.size());
    file.read((u8 *) &strBuffer[0], strBuffer.size());
    file.close();

    //! remove all windows crap signs
    size_t position;
    while(1) {
        position = strBuffer.find('\r');
        if(position == std::string::npos)
            break;

        strBuffer.erase(position, 1);
    }

    std::vector<std::string> lines = StringTools::stringSplit(strBuffer, "\n");


    if(lines.empty())
        return false;

    for(unsigned int i = 0; i < lines.size(); i++) {
        std::string & line = lines[i];
        // lines starting with # are comments
        if (line[0] == '#')
            continue;
        else if (strncmp(line.c_str(), "msgid \"", 7) == 0) {
            char *msgid, *end;
            if (lastID) {
                free(lastID);
                lastID = NULL;
            }
            msgid = &line[7];
            end = strrchr(msgid, '"');
            if (end && end - msgid > 1) {
                *end = 0;
                lastID = strdup(msgid);
            }
        } else if (strncmp(line.c_str(), "msgstr \"", 8) == 0) {
            char *msgstr, *end;

            if (lastID == NULL) continue;

            msgstr = &line[8];
            end = strrchr(msgstr, '"');
            if (end && end - msgstr > 1) {
                *end = 0;
                setMSG(lastID, msgstr);
            }
            free(lastID);
            lastID = NULL;
        }

    }
    return true;
}

extern "C" const char *gettext(const char *msgid) {
    if(!msgid) return NULL;
    MSG *msg = findMSG(hash_string(msgid));
    if (msg && msg->msgstr) return msg->msgstr;
    return msgid;
}