/*
* Parses an edict out of the given string,
* returning the new position ed should be
* a properly initialized empty edict.
*/
char *ED_ParseEdict(char *data, edict_t *ent)
{
qboolean init;
char keyname[256];
const char *com_token;
if (!ent) {
return NULL;
}
init = false;
memset(&st, 0, sizeof(st));
/* go through all the dictionary pairs */
while (1) {
/* parse key */
com_token = COM_Parse(&data);
if (com_token[0] == '}') {
break;
}
if (!data) {
PF_error("ED_ParseEntity: EOF without closing brace");
}
Q_strlcpy(keyname, com_token, sizeof(keyname));
/* parse value */
com_token = COM_Parse(&data);
if (!data) {
PF_error("ED_ParseEntity: EOF without closing brace");
}
if (com_token[0] == '}') {
PF_error("ED_ParseEntity: closing brace without data");
}
init = true;
/* keynames with a leading underscore are
used for utility comments, and are
immediately discarded by quake */
if (keyname[0] == '_') {
continue;
}
ED_ParseField(keyname, com_token, ent);
}
if (!init) {
memset(ent, 0, sizeof(*ent));
}
return data;
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
====================
*/
static void ED_ParseEdict(const char **data, edict_t *ent)
{
qboolean init;
char *key, *value;
init = qfalse;
memset(&st, 0, sizeof(st));
// go through all the dictionary pairs
while (1) {
// parse key
key = COM_Parse(data);
if (key[0] == '}')
break;
if (!*data)
gi.error("%s: EOF without closing brace", __func__);
// parse value
value = COM_Parse(data);
if (!*data)
gi.error("%s: EOF without closing brace", __func__);
if (value[0] == '}')
gi.error("%s: closing brace without data", __func__);
init = qtrue;
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (key[0] == '_')
continue;
if (!ED_ParseField(g_fields, key, value, (byte *)ent)) {
if (!ED_ParseField(g_temps, key, value, (byte *)&st)) {
gi.dprintf("%s: %s is not a field\n", __func__, key);
}
}
}
if (!init)
memset(ent, 0, sizeof(*ent));
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
====================
*/
char *ED_ParseEdict (char *data, edict_t *ent)
{
qboolean init;
char keyname[256];
char *com_token;
//Knightmare added
qboolean alias_loaded = false;
init = false;
memset (&st, 0, sizeof(st));
// Knightmare- look for and load an alias for this ent
alias_loaded = ED_ParseEntityAlias (data, ent);
// go through all the dictionary pairs
while (1)
{
// parse key
com_token = COM_Parse (&data);
if (com_token[0] == '}')
break;
if (!data)
gi.error ("ED_ParseEntity: EOF without closing brace");
strncpy (keyname, com_token, sizeof(keyname)-1);
// parse value
com_token = COM_Parse (&data);
if (!data)
gi.error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
gi.error ("ED_ParseEntity: closing brace without data");
init = true;
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (keyname[0] == '_')
continue;
// Knightmare- if the classname was replaced by an alias, don't load it back
if (alias_loaded && !strcmp(keyname, "classname"))
continue;
ED_ParseField (keyname, com_token, ent);
}
if (!init)
memset (ent, 0, sizeof(*ent));
return data;
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
====================
*/
char *ED_ParseEdict (char *data, edict_t *ent)
{
qboolean init;
char keyname[256];
const char *com_token;
if (!ent || !data)
{
return NULL;
}
init = false;
memset (&st, 0, sizeof(st));
// go through all the dictionary pairs
while (1)
{
// parse key
com_token = COM_Parse (&data);
if (com_token[0] == '}')
break;
if (!data)
gi.error ("ED_ParseEntity: EOF without closing brace");
strncpy (keyname, com_token, sizeof(keyname)-1);
// parse value
com_token = COM_Parse (&data);
if (!data)
gi.error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
gi.error ("ED_ParseEntity: closing brace without data");
init = true;
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (keyname[0] == '_')
continue;
ED_ParseField (keyname, com_token, ent);
}
if (!init)
memset (ent, 0, sizeof(*ent));
return data;
}
/*
* ED_ParseEdict
*
* Parses an edict out of the given string, returning the new position
* ed should be a properly initialized empty edict.
*/
static char *ED_ParseEdict( char *data, edict_t *ent )
{
bool init;
char keyname[256];
char *com_token;
init = false;
memset( &st, 0, sizeof( st ) );
level.spawning_entity = ent;
// go through all the dictionary pairs
while( 1 )
{
// parse key
com_token = COM_Parse( &data );
if( com_token[0] == '}' )
break;
if( !data )
G_Error( "ED_ParseEntity: EOF without closing brace" );
Q_strncpyz( keyname, com_token, sizeof( keyname ) );
// parse value
com_token = COM_Parse( &data );
if( !data )
G_Error( "ED_ParseEntity: EOF without closing brace" );
if( com_token[0] == '}' )
G_Error( "ED_ParseEntity: closing brace without data" );
init = true;
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if( keyname[0] == '_' )
continue;
ED_ParseField( keyname, com_token, ent );
}
if( !init )
ent->classname = NULL;
if( ent->classname && ent->helpmessage )
ent->mapmessage_index = G_RegisterHelpMessage( ent->helpmessage );
return data;
}
/**
* @brief Parses an edict out of the given string, returning the new position
* @param[in] data The string to parse from
* @param[in] ent should be a properly initialized empty edict.
*/
static const char *ED_ParseEdict (const char *data, edict_t * ent)
{
bool init;
char keyname[MAX_VAR];
init = false;
OBJZERO(st);
/* go through all the dictionary pairs */
while (1) {
/* parse key */
const char *c = Com_Parse(&data);
if (c[0] == '}')
break;
if (!data)
gi.Error("ED_ParseEntity: EOF without closing brace");
Q_strncpyz(keyname, c, sizeof(keyname));
/* parse value */
c = Com_Parse(&data);
if (!data)
gi.Error("ED_ParseEntity: EOF without closing brace");
if (c[0] == '}')
gi.Error("ED_ParseEntity: closing brace without data");
init = true;
/* keynames with a leading underscore are used for utility comments,
* and are immediately discarded by ufo */
if (keyname[0] == '_')
continue;
ED_ParseField(keyname, c, ent);
}
if (!init)
OBJZERO(*ent);
return data;
}
/*
====================
ED_ParseEntityAlias
Parses an edict, looking for its classname, and then
looks in the entity alias file for an alias, and
loads that if found.
Returns true if an alias was loaded for the given entity.
====================
*/
qboolean ED_ParseEntityAlias (char *data, edict_t *ent)
{
qboolean classname_found, alias_found, alias_loaded;
char *search_data;
char *search_token;
char entclassname[256];
char keyname[256];
int braceLevel;
classname_found = false;
alias_found = false;
alias_loaded = false;
braceLevel = 0;
if (!alias_data) // If no alias file was loaded, don't bother
return false;
search_data = data; // copy entity data postion
// go through all the dictionary pairs looking for the classname
while (1)
{ //parse keyname
search_token = COM_Parse (&search_data);
if (!search_data)
gi.error ("ED_ParseEntityAlias: end of entity data without closing brace");
if (search_token[0] == '}')
break;
if (!strcmp(search_token, "classname"))
classname_found = true;
// parse value
search_token = COM_Parse (&search_data);
if (!search_data)
gi.error ("ED_ParseEntityAlias: end of entity data without closing brace");
if (search_token[0] == '}')
gi.error ("ED_ParseEntityAlias: closing brace without entity data");
// if we've found the classname, exit loop
if (classname_found) {
strncpy (entclassname, search_token, sizeof(entclassname)-1);
break;
}
}
// then search the entalias.def file for that classname
if (classname_found)
{
search_data = alias_data; // copy alias data postion
while (search_data < (alias_data + alias_data_size))
{
search_token = COM_Parse (&search_data);
if (!search_data)
return false;
if (!search_token)
break;
// see if we're inside the braces of an alias definition
if (search_token[0] == '{') braceLevel++;
else if (search_token[0] == '}') braceLevel--;
if (braceLevel < 0) {
gi.dprintf ("ED_ParseEntityAlias: closing brace without matching opening brace\n");
return false;
}
// matching classname must be outside braces
if (!strcmp(search_token, entclassname) && (braceLevel == 0)) {
//gi.dprintf ("Alias for %s found in alias script file.\n", search_token);
alias_found = true;
break;
}
}
// then if that classname is found, load the fields from that alias
if (alias_found)
{ // get the opening curly brace
search_token = COM_Parse (&search_data);
if (!search_data) {
gi.dprintf ("ED_ParseEntityAlias: unexpected EOF\n");
return false;
}
if (search_token[0] != '{') {
gi.dprintf ("ED_ParseEntityAlias: found %s when expecting {\n", search_token);
return false;
}
// go through all the dictionary pairs
while (search_data < (alias_data + alias_data_size))
{
// parse key
search_token = COM_Parse (&search_data);
if (!search_data) {
gi.dprintf ("ED_ParseEntityAlias: EOF without closing brace\n");
return false;
}
if (search_token[0] == '}')
break;
strncpy (keyname, search_token, sizeof(keyname)-1);
// parse value
search_token = COM_Parse (&search_data);
if (!search_data) {
gi.dprintf ("ED_ParseEntityAlias: EOF without closing brace\n");
return false;
}
if (search_token[0] == '}') {
gi.dprintf ("ED_ParseEntityAlias: closing brace without data\n");
return false;
}
ED_ParseField (keyname, search_token, ent);
alias_loaded = true;
}
}
}
return alias_loaded;
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
====================
*/
char *ED_ParseEdict (char *data, edict_t *ent)
{
qboolean init;
char keyname[256];
char *com_token;
//Knightmare added
qboolean alias_loaded = false;
init = false;
memset (&st, 0, sizeof(st));
// Knightmare- look for and load an alias for this ent
alias_loaded = ED_ParseEntityAlias (data, ent);
// go through all the dictionary pairs
while (1)
{
// parse key
com_token = COM_Parse (&data);
if (com_token[0] == '}')
break;
if (!data)
gi.error ("ED_ParseEntity: EOF without closing brace");
strncpy (keyname, com_token, sizeof(keyname)-1);
// parse value
com_token = COM_Parse (&data);
if (!data)
gi.error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
gi.error ("ED_ParseEntity: closing brace without data");
init = true;
// Knightmare: check for _clientonly here
if (!strcmp(keyname, "_clientonly"))
{
int val = atoi(com_token);
// value of 2 or higher = remove, 1 = server-side bbox clip only
if (val > 1)
G_FreeEdict (ent);
else if (val == 1)
ent->svflags |= SVF_NOCLIENT;
}
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
if (keyname[0] == '_')
continue;
// Knightmare- if the classname was replaced by an alias, don't load it back
if (alias_loaded && !strcmp(keyname, "classname"))
continue;
ED_ParseField (keyname, com_token, ent);
}
if (!init)
memset (ent, 0, sizeof(*ent));
return data;
}