void ED_ParseGlobals (char *data)
{
char keyname[64];
for(;;)
{
// parse key
data = COM_Parse (data);
if (com_token[0] == '}')
break;
if (!data)
Sys_Error ("ED_ParseEntity: EOF without closing brace");
strcpy(keyname, com_token);
// parse value
data = COM_Parse (data);
if (!data)
Sys_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
Sys_Error ("ED_ParseEntity: closing brace without data");
Con_Printf ("'%s' is not a global\n", keyname);
#if 0
if(!ED_ParseEpair((void*)pr_globals,com_token))
Host_Error ("ED_ParseGlobals: parse error");
#else
#endif
}
}
/*
=============
ED_ParseGlobals
=============
*/
void ED_ParseGlobals (char *data)
{
char keyname[64];
ddef_t *key;
while (1)
{
// parse key
data = COM_Parse (data);
if (com_token[0] == '}')
break;
if (!data)
SV_Error ("ED_ParseEntity: EOF without closing brace");
strlcpy (keyname, com_token, sizeof(keyname));
// parse value
data = COM_Parse (data);
if (!data)
SV_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
SV_Error ("ED_ParseEntity: closing brace without data");
key = ED_FindGlobal (keyname);
if (!key)
{
Con_Printf ("%s is not a global\n", keyname);
continue;
}
if (!ED_ParseEpair ((void *)pr_globals, key, com_token))
SV_Error ("ED_ParseGlobals: parse error");
}
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
Used for initial level load and for savegames.
====================
*/
char *ED_ParseEdict (char *data, edict_t *ent)
{
ddef_t *key;
qbool anglehack;
qbool init;
char keyname[256];
init = false;
// clear it
if (ent != sv.edicts) // hack
memset (&ent->v, 0, progs->entityfields * 4);
// go through all the dictionary pairs
while (1)
{
// parse key
data = COM_Parse (data);
if (com_token[0] == '}')
break;
if (!data)
SV_Error ("ED_ParseEntity: EOF without closing brace");
// anglehack is to allow QuakeEd to write single scalar angles
// and allow them to be turned into vectors. (FIXME...)
if (!strcmp(com_token, "angle"))
{
strlcpy (com_token, "angles", MAX_COM_TOKEN);
anglehack = true;
}
else
anglehack = false;
// FIXME: change light to _light to get rid of this hack
if (!strcmp(com_token, "light"))
strlcpy (com_token, "light_lev", MAX_COM_TOKEN); // hack for single light def
strlcpy (keyname, com_token, sizeof(keyname));
// parse value
data = COM_Parse (data);
if (!data)
SV_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
SV_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;
key = ED_FindField (keyname);
if (!key)
{
Con_Printf ("%s is not a field\n", keyname);
continue;
}
if (anglehack)
{
char temp[32];
strlcpy (temp, com_token, sizeof(temp));
snprintf (com_token, MAX_COM_TOKEN, "0 %s 0", temp);
}
if (!ED_ParseEpair ((void *)&ent->v, key, com_token))
SV_Error ("ED_ParseEdict: parse error");
}
if (!init)
ent->e->free = true;
return data;
}
/*
====================
ED_ParseEdict
Parses an edict out of the given string, returning the new position
ed should be a properly initialized empty edict.
Used for initial level load and for savegames.
====================
*/
const char *ED_ParseEdict (const char *data, edict_t *ent)
{
ddef_t *key;
char keyname[256];
qboolean anglehack, init;
int n;
init = false;
// clear it
if (ent != sv.edicts) // hack
memset (&ent->v, 0, progs->entityfields * 4);
// go through all the dictionary pairs
while (1)
{
// parse key
data = COM_Parse (data);
if (com_token[0] == '}')
break;
if (!data)
Host_Error ("ED_ParseEntity: EOF without closing brace");
// anglehack is to allow QuakeEd to write single scalar angles
// and allow them to be turned into vectors. (FIXME...)
if (!strcmp(com_token, "angle"))
{
strcpy (com_token, "angles");
anglehack = true;
}
else
anglehack = false;
// FIXME: change light to _light to get rid of this hack
if (!strcmp(com_token, "light"))
strcpy (com_token, "light_lev"); // hack for single light def
strcpy (keyname, com_token);
// another hack to fix keynames with trailing spaces
n = strlen(keyname);
while (n && keyname[n-1] == ' ')
{
keyname[n-1] = 0;
n--;
}
// parse value
data = COM_Parse (data);
if (!data)
Host_Error ("ED_ParseEntity: EOF without closing brace");
if (com_token[0] == '}')
Host_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;
//johnfitz -- hack to support .alpha even when progs.dat doesn't know about it
if (!strcmp(keyname, "alpha"))
ent->alpha = ENTALPHA_ENCODE(atof(com_token));
//johnfitz
key = ED_FindField (keyname);
if (!key)
{
//johnfitz -- HACK -- suppress error becuase fog/sky/alpha fields might not be mentioned in defs.qc
if (strncmp(keyname, "sky", 3) && strcmp(keyname, "fog") && strcmp(keyname, "alpha"))
Con_DPrintf ("\"%s\" is not a field\n", keyname); //johnfitz -- was Con_Printf
continue;
}
if (anglehack)
{
char temp[32];
strcpy (temp, com_token);
sprintf (com_token, "0 %s 0", temp);
}
if (!ED_ParseEpair ((void *)&ent->v, key, com_token))
Host_Error ("ED_ParseEdict: parse error");
}
if (!init)
ent->free = true;
return data;
}
