lang.c-Dateireferenz

#include "stdlib.h"
#include "stddef.h"
#include "string.h"
#include "lang.h"
#include "fileutil.h"

Include-Abhängigkeitsdiagramm für lang.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	MAX_LANGID   0x1000

Funktionen
void	lang_init (int num)
static char *	placelstr (int size)
static void	lang_add_string (int num, const char *str)
int	lang_parse_from_mem (char *buf, int size)
char *	load_builtin_lang_strings (int cnt, short *array)
void	lang_map_preparsed_from_mem (char *gui_lang_default, int num)
void	lang_load_from_file (const char *filename)
char *	lang_str (int str)
unsigned int	lang_strhash31 (int langid)

Variablen
static char *	preparsed_lang_default_start =0
static short *	strings = NULL
static int	count = 0
static char *	langbuf = NULL
static int	langbuflen = 0
static int	lbpointer

Makro-Dokumentation

#define MAX_LANGID   0x1000

Definiert in Zeile 11 der Datei lang.c.

Dokumentation der Funktionen

static void lang_add_string ( int  num, const char *  str  )

static

Definiert in Zeile 61 der Datei lang.c.

                                                      {
    int f=0;
    char *p;

    if (strings && num<count) {

       p = placelstr(strlen(str)+1);
       if (p) {
           strings[num] = -(1 + p - langbuf); // lang string offsets are encoded as negative
           for (; *str; ++str) {
                if (f) {
                    if (*str == '"' || *str == '\\') *(p-1)=*str;
                    else if (*str == 'n') *(p-1)='\n';
                    else *p++=*str;
                    f = 0;
                } else {
                    *p++=*str;
                    if (*str == '\\') {
                        f = 1;
                    }
                }
           }
           *p=0;
       }
    }
}

void lang_init

(

int

num)

Definiert in Zeile 32 der Datei lang.c.

                        {

    if (strings) {
        free(strings);
        count = 0;
    }

    ++num;
    strings = malloc(num*sizeof(short));
    if (strings) {
        memset(strings, 0, num*sizeof(short));
        count = num;
    }

}

void lang_load_from_file

(

const char *

filename)

Definiert in Zeile 201 der Datei lang.c.

                                               {
    process_file(filename, lang_parse_from_mem, 1);
}

void lang_map_preparsed_from_mem	(	char *	gui_lang_default,
		int	num
	)

Definiert in Zeile 190 der Datei lang.c.

{

    preparsed_lang_default_start = gui_lang_default;
    lang_init( num );
    // preparsed_lang_default_end =  // variable not currently needed
    load_builtin_lang_strings(num, strings);

}

int lang_parse_from_mem	(	char *	buf,
		int	size
	)

Definiert in Zeile 91 der Datei lang.c.

                                             {
    char *p, *s, *e, *b;
    int i, langbufneed;
    char** pstrtmp;

    if  ( size <= 0 )
      return 0;

    langbufneed = 0;
    lbpointer = 0;
    // allocate temporary array for storing pointers to found strings
    pstrtmp = malloc(count*sizeof(char*));
    if (!pstrtmp) {
        return 0;
    }
    // needs to be zeroed
    memset(pstrtmp, 0, count*sizeof(char*));

    // initialize _final_ offset array with built-in strings
    char* load_builtin_lang_strings(int, short*);
    load_builtin_lang_strings(count-1, strings);

    e = buf-1;
    while(e) {
        p = e+1;
        while (*p && (*p=='\r' || *p=='\n')) ++p; //skip empty lines
        i = strtol(p, &e, 0/*autodetect base oct-dec-hex*/);    // convert "*p" to long "i" and return pointer beyond to e
        if (e!=p) {
            p = e;
            e = strpbrk(p, "\r\n");        //break string with zero on \r|\n
            if (e) *e=0;

            while (*p && *p!='\"') ++p;    // cut string from "" if it exists
            if (*p) ++p;
            s = p;
            while (*p && (*p!='\"' || *(p-1)=='\\')) ++p;
            *p=0;

            // store string address and add its length to total
            if ((i > 0) && (i<count)) {
                // ignore string IDs that have zero length built-in string
                // rationale: built-in strings are always complete (have English fallback),
                // except for IDs that are disabled for the port
                //
                // lang_str() only returns built-in strings at this point
                b = lang_str(i);
                if (b && b[0]!=0) {
                    langbufneed += strlen(s) + 1;
                    pstrtmp[i] = s;
                }
            }
        } else { //skip invalid line
            e = strpbrk(p, "\r\n");
            if (e) *e=0;
        }
    }

    if ((langbufneed>langbuflen)||(!langbuf)) { // existing buffer is too small or not allocated
        if (langbuf) {
            free(langbuf);
        }
        langbuf = malloc(langbufneed);
        if (langbuf) {
            langbuflen = langbufneed;
        }
        else {
            langbuflen = 0;
        }
    }
    // zeroing is not required (holes between strings will contain junk, but that doesn't hurt)
    // memset(langbuf, 0, langbuflen);

    for (i=1; i<count; i++) {
        if (pstrtmp[i]) {   // add string if it exists
            lang_add_string(i, pstrtmp[i]);
        }
    }

    free(pstrtmp);
    return 1;
}

char* lang_str

(

int

str)

Definiert in Zeile 207 der Datei lang.c.

                        {
    if (str && str<MAX_LANGID) {
        if (strings && str<count && strings[str]) {
            if (strings[str]>0) {
                // string from builtin resource
                return preparsed_lang_default_start + strings[str] - 1;
            }
            else if (langbuf) {
                // string from loaded lang file
                return langbuf - strings[str] - 1;
            }
        }
    } else { // not ID, just char*
        return (char*)str;
    }
    return "";
}

unsigned int lang_strhash31

(

int

langid)

Definiert in Zeile 227 der Datei lang.c.

{
    if ( langid<MAX_LANGID ) 
        return langid;

    unsigned char* str = (unsigned char*)langid;
    unsigned hash=0;
    for ( ; *str; str++ )
        hash = *str ^ (hash<<6) ^ (hash>>25);
    if ( hash<MAX_LANGID )
        hash |= (1<<31);
    return hash;
}

char* load_builtin_lang_strings	(	int	cnt,
		short *	array
	)

Definiert in Zeile 175 der Datei lang.c.

                                                       {
    int i;
    char *p = preparsed_lang_default_start;

    for ( i = 1; i<=cnt; i++ )
    {
        array[i] = 1 + p - preparsed_lang_default_start;
        while (*p) p++;
        p++;
    }
    return p;
}

static char* placelstr ( int  size)

static

Definiert in Zeile 50 der Datei lang.c.

                                 {
    char *ret = langbuf + lbpointer;
    lbpointer += size;
    if (lbpointer <= langbuflen) {
        return ret;
    }
    return 0;
}

Variablen-Dokumentation

int count = 0

static

Definiert in Zeile 26 der Datei lang.c.

char* langbuf = NULL

static

Definiert in Zeile 27 der Datei lang.c.

int langbuflen = 0

static

Definiert in Zeile 28 der Datei lang.c.

int lbpointer

static

Definiert in Zeile 29 der Datei lang.c.

char* preparsed_lang_default_start =0

static

Definiert in Zeile 7 der Datei lang.c.

short* strings = NULL

static

Definiert in Zeile 25 der Datei lang.c.