gettext.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <ctype.h>
#include <locale.h>
#include <stdlib.h>
#include "physfs.h"
 
#include "naev.h"
#include "gettext.h"
 
#include "array.h"
#include "env.h"
#include "log.h"
#include "msgcat.h"
#include "ndata.h"
 
typedef struct translation {
   char *language;              
   msgcat_t *chain;             
   char **chain_lang;           
   struct translation *next;    
} translation_t;
 
static char *gettext_systemLanguage = NULL;             
static translation_t *gettext_translations = NULL;      
static translation_t *gettext_activeTranslation = NULL; 
static uint32_t gettext_nstrings = 0;                   
static void gettext_readStats (void);
static const char* gettext_matchLanguage( const char* lang, size_t lang_len, char*const* available );
 
void gettext_init (void)
{
   const char *env_vars[] = {"LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"};
 
   setlocale( LC_ALL, "" );
   /* If we don't disable LC_NUMERIC, lots of stuff blows up because 1,000 can be interpreted as
    * 1.0 in certain languages. */
   setlocale( LC_NUMERIC, "C" ); /* Disable numeric locale part. */
 
   free( gettext_systemLanguage );
   for (size_t i=0; i < sizeof(env_vars)/sizeof(env_vars[0]); i++) {
      const char *language = getenv( env_vars[i] );
      if (language != NULL && *language != 0) {
         gettext_systemLanguage = strdup( language );
         return; /* The first env var with language settings wins. */
      }
   }
   gettext_systemLanguage = strdup( "" );
}
 
void gettext_exit (void)
{
   free( gettext_systemLanguage );
   gettext_systemLanguage = NULL;
   while (gettext_translations != NULL) {
      for (int i = 0; i < array_size(gettext_translations->chain_lang); i++)
         free( gettext_translations->chain_lang[i] );
      array_free( gettext_translations->chain_lang );
      for (int i = 0; i < array_size(gettext_translations->chain); i++)
         free( (void*) gettext_translations->chain[i].map );
      array_free( gettext_translations->chain );
      free( gettext_translations->language );
      gettext_activeTranslation = gettext_translations->next;
      free( gettext_translations );
      gettext_translations = gettext_activeTranslation;
   }
}
 
const char* gettext_getLanguage (void)
{
   if (array_size( gettext_activeTranslation->chain_lang ))
      return gettext_activeTranslation->chain_lang[0];
   else
      return "en";
}
 
void gettext_setLanguage( const char* lang )
{
   translation_t *newtrans;
   char root[256], **paths, **available_langs;
 
   if (lang == NULL)
      lang = gettext_systemLanguage;
   if (gettext_activeTranslation != NULL && !strcmp( lang, gettext_activeTranslation->language ))
      return;
 
   /* Search for the selected language in the loaded translations. */
   for (translation_t *ptrans = gettext_translations; ptrans != NULL; ptrans = ptrans->next)
      if (!strcmp( lang, ptrans->language )) {
         gettext_activeTranslation = ptrans;
         return;
      }
 
   /* Load a new translation chain from ndata, and activate it. */
   newtrans = calloc( 1, sizeof( translation_t ) );
   newtrans->language = strdup( lang );
   newtrans->chain = array_create( msgcat_t );
   newtrans->chain_lang = array_create( char* );
   newtrans->next = gettext_translations;
   gettext_translations = newtrans;
 
   available_langs = PHYSFS_enumerateFiles( GETTEXT_PATH );
 
   /* @TODO This code orders the translations alphabetically by file path.
    * That doesn't make sense, but this is a new use case and it's unclear
    * how we should determine precedence in case multiple .mo files exist. */
   while (lang != NULL && *lang != 0) {
      size_t map_size, lang_part_len;
      const char *lang_part = lang, *lang_match;
      lang = strchr(lang, ':');
      if (lang == NULL)
         lang_part_len = strlen(lang_part);
      else {
         lang_part_len = (size_t)(lang-lang_part);
         lang++;
      }
      lang_match = gettext_matchLanguage( lang_part, lang_part_len, available_langs );
      if (lang_match == NULL)
         continue;
      snprintf( root, sizeof(root), GETTEXT_PATH"%s", lang_match );
      paths = ndata_listRecursive( root );
      for (int i=0; i<array_size(paths); i++) {
         const char *map = ndata_read( paths[i], &map_size );
         if (map != NULL) {
            msgcat_init( &array_grow( &newtrans->chain ), map, map_size );
            array_push_back( &newtrans->chain_lang, strdup( lang_match ) );
            DEBUG( _("Adding translations from %s"), paths[i] );
         }
         free( paths[i] );
      }
      array_free( paths );
   }
   PHYSFS_freeList( available_langs );
   gettext_activeTranslation = newtrans;
}
 
static const char* gettext_matchLanguage( const char* lang, size_t lang_len, char*const* available )
{
   const char *best = NULL;
 
   if (lang_len == 0)
      return NULL;
 
   /* Good enough for now: Return the greatest (thus longest) string matching up to their common length. */
   for (size_t i=0; available[i]!=NULL; i++) {
      int c = strncmp( lang, available[i], MIN( lang_len, strlen(available[i]) ) );
      if (c < 0)
         break;
      else if (c == 0)
         best = available[i];
   }
   return best;
}
 
const char* gettext_ngettext( const char* msgid, const char* msgid_plural, uint64_t n )
{
   if (gettext_activeTranslation != NULL) {
      msgcat_t *chain = gettext_activeTranslation->chain;
      for (int i=0; i<array_size(chain); i++) {
         const char *trans = msgcat_ngettext( &chain[i], msgid, msgid_plural, n );
         if (trans != NULL)
            return (char*)trans;
      }
   }
 
   return n>1 && msgid_plural!=NULL ? msgid_plural : msgid;
}
 
const char* gettext_pgettext_impl( const char* lookup, const char* msgid )
{
   const char *trans = _( lookup );
   return trans==lookup ? msgid : trans;
}
 
 
static void gettext_readStats (void)
{
   char **paths = ndata_listRecursive( GETTEXT_STATS_PATH );
 
   for (int i=0; i<array_size(paths); i++) {
      size_t size;
      char *text = ndata_read( paths[i], &size );
      if (text != NULL)
         gettext_nstrings += strtoul( text, NULL, 10 );
      free( text );
      free( paths[i] );
   }
   array_free( paths );
}
 
 
LanguageOption* gettext_languageOptions (void)
{
   LanguageOption *opts = array_create( LanguageOption );
   LanguageOption en = { .language = strdup("en"), .coverage = 1. };
   char **dirs = PHYSFS_enumerateFiles( GETTEXT_PATH );
 
   array_push_back( &opts, en );
   for (size_t i=0; dirs[i]!=NULL; i++) {
      LanguageOption *opt = &array_grow( &opts );
      opt->language = strdup( dirs[i] );
      opt->coverage = gettext_languageCoverage( dirs[i] );
   }
   PHYSFS_freeList( dirs );
 
   return opts;
}
 
 
double gettext_languageCoverage( const char* lang )
{
   uint32_t translated = 0;
   char **paths, dirpath[PATH_MAX], buf[12];
 
   /* We nail 100% of the translations we don't have to do. :) */
   if (!strcmp( lang, "en" ))
      return 1.;
 
   /* Initialize gettext_nstrings, if needed. */
   if (gettext_nstrings == 0)
      gettext_readStats();
 
   snprintf( dirpath, sizeof(dirpath), GETTEXT_PATH"%s", lang );
   paths = ndata_listRecursive( dirpath );
   for (int j=0; j<array_size(paths); j++) {
      PHYSFS_file *file;
      PHYSFS_sint64 size;
      file = PHYSFS_openRead( paths[j] );
      free( paths[j] );
      if (file == NULL)
         continue;
      size = PHYSFS_readBytes( file, buf, 12 );
      if (size < 12)
         continue;
      translated += msgcat_nstringsFromHeader( buf );
   }
   array_free( paths );
   return (double)translated / gettext_nstrings;
}
 
 
/* The function is almost the same as p_() but msgctxt and msgid can be string variables.
 */
const char* pgettext_var( const char* msgctxt, const char* msgid )
{
   char *lookup = NULL;
   const char* trans;
   asprintf( &lookup, "%s" GETTEXT_CONTEXT_GLUE "%s", msgctxt, msgid );
   trans = gettext_pgettext_impl( lookup, msgid );
   free( lookup );
   return trans;
}