/*
* ML_Init
* Initialize map list. Check if cache file exists, if not create it
*/
void ML_Init( void )
{
if( ml_initialized )
return;
Trie_Create( MLIST_TRIE_CASING, &mlist_filenames_trie );
Trie_Create( MLIST_TRIE_CASING, &mlist_fullnames_trie );
Cmd_AddCommand( "maplist", ML_MapListCmd );
if( MLIST_CACHE_EXISTS )
ML_InitFromCache();
else
ML_InitFromMaps();
ml_initialized = true;
ml_flush = true;
}
void Dynvar_PreInit( void )
{
assert( !dynvar_initialized );
assert( !dynvar_preinitialized );
assert( !dynvar_trie );
Trie_Create( DYNVAR_TRIE_CASING, &dynvar_trie );
dynvar_preinitialized = qtrue;
}
/*
* Cvar_PreInit
*/
void Cvar_PreInit( void )
{
assert( !cvar_initialized );
assert( !cvar_preinitialized );
assert( !cvar_trie );
Trie_Create( CVAR_TRIE_CASING, &cvar_trie );
cvar_preinitialized = qtrue;
}
/*
* CL_MasterAddressCache_Init
*/
static void CL_MasterAddressCache_Init( void )
{
char *master;
const char *mlist;
serverlist_masters_head = NULL;
Trie_Create( TRIE_CASE_INSENSITIVE, &serverlist_masters_trie );
// synchronous DNS queries cause interruption of sounds, background music, etc
// so precache results of resolution queries for all master servers
mlist = Cvar_String( "masterservers" );
while( mlist )
{
master = COM_Parse( &mlist );
if( !*master )
break;
CL_ResolveMasterAddress( master, NULL );
}
}
/*
* CL_MasterAddressCache_Init
*/
static void CL_MasterAddressCache_Init( void )
{
int numMasters;
const char *ptr;
const char *master;
const char *masterservers;
Trie_Create( TRIE_CASE_INSENSITIVE, &serverlist_masters_trie );
resolverThreads = NULL;
masterservers = Cvar_String( "masterservers" );
if( !*masterservers ) {
return;
}
// count the number of master servers
numMasters = 0;
for( ptr = masterservers; ptr; ) {
master = COM_Parse( &ptr );
if( !*master ) {
break;
}
numMasters++;
}
// don't allow too many as each will spawn its own resolver thread
if( numMasters > MAX_MASTER_SERVERS )
numMasters = MAX_MASTER_SERVERS;
resolveLock = QMutex_Create();
if( resolveLock != NULL )
{
unsigned numResolverThreads;
numResolverThreads = 0;
resolverThreads = malloc( sizeof( *resolverThreads ) * (numMasters+1) );
memset( resolverThreads, 0, sizeof( *resolverThreads ) * (numMasters+1) );
for( ptr = masterservers; ptr; )
{
char *master_copy;
qthread_t *thread;
master = COM_Parse( &ptr );
if( !*master )
break;
master_copy = ( char * )malloc( strlen( master ) + 1 );
memcpy( master_copy, master, strlen( master ) + 1 );
thread = QThread_Create( CL_MasterResolverThreadEntry, ( void * )master_copy );
if( thread != NULL ) {
resolverThreads[numResolverThreads++] = thread;
continue;
}
// we shouldn't get here if all goes well with the resolving thread
free( master_copy );
}
}
}
/*
* L10n_ParsePOFile
*
* Doesn't allocate memory, writes to input buffer, which
* should NOT be freed after calling this function.
*/
static trie_t *L10n_ParsePOFile( const char *filepath, char *buffer, int length )
{
int linenum = 0;
char *start = buffer, *end = buffer + length;
char *cur, *eol;
qboolean have_msgid, have_msgstr, error;
char *msgid, *msgstr, *instr, *outstr;
size_t str_length;
trie_t *dict;
trie_error_t tr_err;
tr_err = Trie_Create( TRIE_CASE_SENSITIVE, &dict );
if( tr_err != TRIE_OK ) {
return NULL;
}
have_msgid = have_msgstr = qfalse;
instr = outstr = buffer;
msgid = msgstr = buffer;
eol = end;
for( cur = start; cur >= start && cur < end; cur = eol + 1 ) {
if( !*cur ) {
break;
}
linenum++;
// skip whitespaces
while( *cur == ' ' || *cur == '\t' ) {
cur++;
}
// find the end of line
eol = strchr( cur, '\n' );
if( eol ) {
char *prev = eol - 1;
*eol = '\0';
if( *prev == '\r' ) {
*prev = '\0';
}
}
if( *cur == '#' ) {
continue;
}
if( !*cur ) {
// empty line
continue;
}
parse_cmd:
// search for msgid "id"
if( !strncmp( cur, "msgid ", 6 ) ) {
if( have_msgstr ) {
Trie_Insert( dict, msgid, ( void * )msgstr );
have_msgid = have_msgstr = qfalse;
}
have_msgid = qtrue;
instr = cur + 6;
outstr = cur + 5;
msgid = outstr;
*msgid = '\0';
}
else if( have_msgid && !strncmp( cur, "msgstr ", 7 ) ) {
have_msgstr = qtrue;
instr = cur + 7;
outstr = cur + 6;
msgstr = outstr;
*msgstr = '\0';
}
else {
// multiline?
if( have_msgid || have_msgstr ) {
if( *cur != '"' || !strrchr( cur+1, '"') ) {
if( have_msgstr ) {
Trie_Insert( dict, msgid, ( void * )msgstr );
}
// no
have_msgid = have_msgstr = qfalse;
goto parse_cmd;
}
// yes
instr = cur;
} else {
continue;
}
}
// parse single line of C-style string
str_length = L10n_ParsePOString( instr, outstr, &error );
if( !str_length ) {
have_msgid = have_msgstr = qfalse;
if( error ) {
Com_Printf( S_COLOR_YELLOW "Error parsing line %i of %s: syntax error near '%s'\n",
linenum, filepath, instr );
}
}
else {
// shift the output buffer so that in case multiline string
// is ecountered it'll be properly appended
outstr += str_length;
}
}
if( have_msgstr ) {
Trie_Insert( dict, msgid, ( void * )msgstr );
}
return dict;
}
