findfile.c

Go to the documentation of this file.

/*
 * Copyright 2008 Daniel Silverstone <dsilvers@netsurf-browser.org>
 *
 * This file is part of NetSurf, http://www.netsurf-browser.org/
 *
 * NetSurf 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; version 2 of the License.
 *
 * NetSurf 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "utils/filepath.h"
#include "utils/log.h"
 
#include "framebuffer/findfile.h"
 
char **respaths; /** resource search path vector */
 
#define MAX_LANGV_SIZE 32
 
/**
 * goes through the environment in appropriate order to find configured language
 *
 * \return language to use or "C" if nothing appropriate is set
 */
static const char *get_language_env(void)
{
        const char *envstr;
 
        envstr = getenv("LANGUAGE");
        if ((envstr != NULL) && (envstr[0] != 0)) {
                return envstr;
        }
 
        envstr = getenv("LC_ALL");
        if ((envstr != NULL) && (envstr[0] != 0)) {
                return envstr;
        }
 
        envstr = getenv("LC_MESSAGES");
        if ((envstr != NULL) && (envstr[0] != 0)) {
                return envstr;
        }
 
        envstr = getenv("LANG");
        if ((envstr != NULL) && (envstr[0] != 0)) {
                return envstr;
        }
 
        return "C";
}
 
/**
 * build a string vector of language names
 */
static char **get_language_names(void)
{
        char **langv; /* output string vector of languages */
        int langc; /* count of languages in vector */
        const char *envlang; /* colon separated list of languages from environment */
        int lstart = 0; /* offset to start of current language */
        int lunder = 0; /* offset to underscore in current language */
        int lend = 0; /* offset to end of current language */
        char *nlang;
        
        langv = calloc(MAX_LANGV_SIZE + 2, sizeof(char *));
        if (langv == NULL) {
                return NULL;
        }
 
        envlang = get_language_env();
        
        for (langc = 0; langc < MAX_LANGV_SIZE; langc++) {
                /* work through envlang splitting on : */
                while ((envlang[lend] != 0) &&
                       (envlang[lend] != ':') &&
                       (envlang[lend] != '.')) {
                        if (envlang[lend] == '_') {
                                lunder = lend;
                        }
                        lend++;
                }
                /* place language in string vector */
                nlang = malloc(lend - lstart + 1);
                memcpy(nlang, envlang + lstart, lend - lstart);
                nlang[lend - lstart] = 0;
                langv[langc] = nlang;
 
                /* add language without specialisation to vector */
                if (lunder != lstart) {
                        nlang = malloc(lunder - lstart + 1);
                        memcpy(nlang, envlang + lstart, lunder - lstart);
                        nlang[lunder - lstart] = 0;
                        langv[++langc] = nlang;
                }
 
                /* if we stopped at the dot, move to the colon delimiter */
                while ((envlang[lend] != 0) &&
                       (envlang[lend] != ':')) {
                        lend++;
                }
                if (envlang[lend] == 0) {
                        /* reached end of environment language list */
                        break;
                }
                lend++;
                lstart = lunder = lend;
        }
        return langv;
}
 
/**
 * Create an array of valid paths to search for resources.
 *
 * The idea is that all the complex path computation to find resources
 * is performed here, once, rather than every time a resource is
 * searched for.
 */
char **
fb_init_resource_path(const char *resource_path)
{
        char **pathv; /* resource path string vector */
        char **respath; /* resource paths vector */
        char **langv;
 
        pathv = filepath_path_to_strvec(resource_path);
 
        langv = get_language_names();
 
        respath = filepath_generate(pathv, (const char * const *)langv);
 
        filepath_free_strvec(langv);
 
        filepath_free_strvec(pathv);
 
        return respath;
}
 
 
 
/*
 * Local Variables:
 * c-basic-offset: 8
 * End:
 */