ioquake
/
gtkradiant
mirror of https://github.com/TTimo/GtkRadiant.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gtkradiant/plugins/eclassfgd/plugin.cpp

1142 lines
32 KiB
C++
Raw Normal View History

more eol-style git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant/branches/ZeroRadiant@185 8a3a26a2-13c4-0310-b231-cf6edde360e5
2007-11-04 03:51:54 +00:00
/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
This file is part of GtkRadiant.
GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
//#define FGD_VERBOSE // define this for extra info in the log.
#include "plugin.h"
/*! \file plugin.cpp
\brief .fgd entity description format
FGD loading code by Dominic Clifton - Hydra (Hydra@Hydras-World.com)
Overview
========
This module loads .fgd files, fgd files are split into classes:
base classes
point classes (aka fixed size entities)
solid classes (aka brush entity)
This program first scans each file, building up a list structures
in memory that contain the information for all the classes found
in the file.
Then the program looks at each of the non-base classes in the list
and build the eclass_t structure from each one.
Classes can request information in other classes.
Solid/Base and Point/Base classes can have the same names as other
classes but there can be only one of each solid/point/base class with
the same name,
e.g.:
this is NOT allowed:
@solidclass = "a"
@solidclass = "a"
this is NOT allowed:
@pointclass = "a"
@solidclass = "a"
this IS allowed:
@solidclass = "a"
@baseclass = "a"
Version History
===============
v0.1 - 13/March/2002
- Initial version.
v0.2 - 16/March/2002
- sets e->skinpath when it finds an iconsprite(<filename>) token.
v0.3 - 21/March/2002
- Core now supports > 8 spawnflags, changes reflected here too.
- FIXED: mins/maxs were backwards when only w,h,d were in the FGD
(as opposed to the actual mins/maxs being in the .def file)
- Made sure all PointClass entities were fixed size entities
and gave them a default bounding box size if a size() setting
was not in the FGD file.
- Removed the string check for classes requesting another class
with the same name, adjusted Find_Class() so that it can search
for baseclasses only, this fixes the problem with PointClass "light"
requesting the BaseClass "light".
v0.4 - 25/March/2002
- bleh, It turns out that non-baseclasses can request non-baseclasses
so now I've changed Find_Class() so that it can ignore a specific class
(i.e. the one that's asking for others, so that classes can't request
themselves but they can request other classes of any kind with the
same name).
- made all spawnflag comments appear in one place, rather than being scattered
all over the comments if a requested class also had some spawnflags
v0.5 - 6/April/2002
- not using skinpath for sprites anymore, apprently we can code a model
module to display sprites and model files.
- model() tags are now supported.
ToDo
====
* add support for setting the eclass_t's modelpath.
(not useful for CS, but very useful for HL).
* need to implement usage for e->skinpath in the core.
* cleanup some areas now that GetTokenExtra() is available
(some parts were written prior to it's creation).
* Import the comments between each BaseClass's main [ ] set.
(unfortunatly they're // cstyle comments, which GetToken skips over)
But still ignore comments OUTSIDE the main [ ] set.
*/
_QERScripLibTable g_ScripLibTable;
_EClassManagerTable g_EClassManagerTable;
_QERFuncTable_1 g_FuncTable;
_QERFileSystemTable g_FileSystemTable;
// forward declare
void Eclass_ScanFile (char *filename);
const char* EClass_GetExtension()
{
return "fgd";
}
CSynapseServer* g_pSynapseServer = NULL;
CSynapseClientFGD g_SynapseClient;
#if __GNUC__ >= 4
#pragma GCC visibility push(default)
#endif
extern "C" CSynapseClient* SYNAPSE_DLL_EXPORT Synapse_EnumerateInterfaces( const char *version, CSynapseServer *pServer ) {
#if __GNUC__ >= 4
#pragma GCC visibility pop
#endif
if (strcmp(version, SYNAPSE_VERSION))
{
Syn_Printf("ERROR: synapse API version mismatch: should be '" SYNAPSE_VERSION "', got '%s'\n", version);
return NULL;
}
g_pSynapseServer = pServer;
g_pSynapseServer->IncRef();
Set_Syn_Printf(g_pSynapseServer->Get_Syn_Printf());
g_SynapseClient.AddAPI(ECLASS_MAJOR, "fgd", sizeof(_EClassTable));
g_SynapseClient.AddAPI(SCRIPLIB_MAJOR, NULL, sizeof(g_ScripLibTable), SYN_REQUIRE, &g_ScripLibTable);
g_SynapseClient.AddAPI(RADIANT_MAJOR, NULL, sizeof(g_FuncTable), SYN_REQUIRE, &g_FuncTable);
g_SynapseClient.AddAPI(ECLASSMANAGER_MAJOR, NULL, sizeof(g_EClassManagerTable), SYN_REQUIRE, &g_EClassManagerTable);
// Needs a 'default' option for this minor because we certainly don't load anything from wad files :)
g_SynapseClient.AddAPI(VFS_MAJOR, "wad", sizeof(g_FileSystemTable), SYN_REQUIRE, &g_FileSystemTable);
return &g_SynapseClient;
}
bool CSynapseClientFGD::RequestAPI(APIDescriptor_t *pAPI)
{
if (!strcmp(pAPI->major_name, ECLASS_MAJOR))
{
_EClassTable* pTable= static_cast<_EClassTable*>(pAPI->mpTable);
pTable->m_pfnGetExtension = &EClass_GetExtension;
pTable->m_pfnScanFile = &Eclass_ScanFile;
return true;
}
Syn_Printf("ERROR: RequestAPI( '%s' ) not found in '%s'\n", pAPI->major_name, GetInfo());
return false;
}
#include "version.h"
const char* CSynapseClientFGD::GetInfo()
{
return ".fgd eclass module built " __DATE__ " " RADIANT_VERSION;
}
// ------------------------------------------------------------------------------------------------
#define CLASS_NOCLASS 0
#define CLASS_BASECLASS 1
#define CLASS_POINTCLASS 2
#define CLASS_SOLIDCLASS 3
char *classnames[] = {"NOT DEFINED","BaseClass","PointClass","SolidClass"};
#define OPTION_NOOPTION 0
#define OPTION_STRING 1
#define OPTION_CHOICES 2
#define OPTION_INTEGER 3
#define OPTION_FLAGS 4
char *optionnames[] = {"NOT DEFINED","String","Choices","Integer","Flags"};
typedef struct choice_s {
int value;
char *name;
} choice_t;
typedef struct option_s {
int optiontype;
char *optioninfo;
char *epairname;
char *optiondefault;
GSList *choices; // list of choices_t
} option_t;
typedef struct class_s {
int classtype; // see CLASS_* above.
char *classname;
GSList *l_baselist; // when building the eclass_t, other class_s's with these names are required.
char *description;
GSList *l_optionlist; // when building the eclass_t, other class_s's with these names are required.
bool gotsize; // if set then boundingbox is valid.
vec3_t boundingbox[2]; // mins, maxs
bool gotcolor; // if set then color is valid.
vec3_t color; // R,G,B, loaded as 0-255
char *model; // relative path + filename to a model (.spr/.mdl) file, or NULL
} class_t;
/*
===========================================================
utility functions
===========================================================
*/
char *strlower (char *start)
{
char *in;
in = start;
while (*in)
{
*in = tolower(*in);
in++;
}
return start;
}
char *addstr(char *dest,char *source)
{
if (dest)
{
char *ptr;
int len = strlen(dest);
ptr = (char *) malloc (len + strlen(source) + 1);
strcpy(ptr,dest);
strcpy(ptr+len,source);
free(dest);
dest = ptr;
}
else
{
dest = strdup(source);
}
return(dest);
}
int getindex(unsigned int a)
{
unsigned int count = 0;
unsigned int b = 0;
for (;b != a;count++)
{
b = (1<<count);
if (count > a)
return -1;
}
return (count);
}
void ClearGSList (GSList* lst)
{
GSList *p = lst;
while (p)
{
free (p->data);
p = g_slist_remove (p, p->data);
}
}
/*!
free a choice_t structure and it's contents
*/
void Free_Choice(choice_t *p)
{
if (p->name) free(p->name);
free (p);
}
/*
===========================================================
Main functions
===========================================================
*/
/*!
free an option_t structure and it's contents
*/
void Free_Option(option_t *p)
{
if (p->epairname) free(p->epairname);
if (p->optiondefault) free(p->optiondefault);
if (p->optioninfo) free(p->optioninfo);
GSList *l = p->choices;
while (l)
{
Free_Choice ((choice_t *)l->data);
l = g_slist_remove (l, l->data);
}
free (p);
}
/*!
free a class_t structure and it's contents
*/
void Free_Class(class_t *p)
{
GSList *l = p->l_optionlist;
while (l)
{
Free_Option ((option_t *)l->data);
l = g_slist_remove (l, l->data);
}
if (p->classname) free(p->classname);
free (p);
}
/*!
find a class in the list
*/
class_t *Find_Class(GSList *l,char *classname, class_t *ignore)
{
for (GSList *clst = l; clst != NULL; clst = clst->next)
{
class_t *c = (class_t *)clst->data;
if (c == ignore)
continue;
// NOTE: to speed up we could make all the classnames lower-case when they're initialised.
if (!stricmp(c->classname,classname))
{
return c;
}
}
return NULL;
}
/*!
Import as much as possible from a class_t into an eclass_t
Note: this is somewhat recursive, as a class can require a class that requires a class and so on..
*/
void EClass_ImportFromClass(eclass_t *e, GSList *l_classes, class_t *bc)
{
char color[128];
// We allocate 16k here, but only the memory actually used is kept allocated.
// this is just used for building the final comments string.
// Note: if the FGD file contains comments that are >16k (per entity) then
// radiant will crash upon loading such a file as the eclass_t will become
// corrupted.
// FIXME: we could add some length checking when building "newcomments", but
// that'd slow it down a bit.
char newcomments[16384] = "";
//Note: we override the values already in e.
//and we do it in such a way that the items that appear last in the l_baselist
//represent the final values.
if (bc->description)
{
sprintf(newcomments,"%s\n",bc->description);
e->comments = addstr(e->comments,newcomments);
newcomments[0] = 0; // so we don't add them twice.
}
// import from other classes if required.
if (bc->l_baselist)
{
// this class requires other base classes.
for (GSList *bclst = bc->l_baselist; bclst != NULL; bclst = bclst->next)
{
char *requestedclass = (char *)bclst->data;
// class_t *rbc = Find_Class(l_classes, requestedclass, true);
class_t *rbc = Find_Class(l_classes, requestedclass, bc);
// make sure we don't request ourself!
if (rbc == bc)
{
Sys_Printf ("WARNING: baseclass '%s' tried to request itself!\n", bclst->data);
}
else
{
if (!rbc)
{
Sys_Printf ("WARNING: could not find the requested baseclass '%s' when building '%s'\n", requestedclass,bc->classname);
}
else
{
// call ourself!
EClass_ImportFromClass(e, l_classes, rbc);
}
}
}
}
// SIZE
if (bc->gotsize)
{
e->fixedsize = true;
memcpy(e->mins,bc->boundingbox[0],sizeof( vec3_t ));
memcpy(e->maxs,bc->boundingbox[1],sizeof( vec3_t ));
}
/*
// Hydra: apparently, this would be bad.
if (bc->sprite)
{
// Hydra - NOTE: e->skinpath is not currently used by the editor but the code
// to set it is used by both this eclass_t loader and the .DEF eclass_t loader.
// TODO: implement using e->skinpath.
if (e->skinpath)
free (e->skinpath);
e->skinpath = strdup(bc->sprite);
}
*/
// MODEL
if (bc->model)
{
if (e->modelpath)
free (e->modelpath);
e->modelpath = strdup(bc->model);
}
// COLOR
if (bc->gotcolor)
{
memcpy(e->color,bc->color,sizeof( vec3_t ));
sprintf (color, "(%f %f %f)", e->color[0], e->color[1], e->color[2]);
e->texdef.SetName(color);
}
// SPAWNFLAGS and COMMENTS
if (bc->l_optionlist)
{
for (GSList *optlst = bc->l_optionlist; optlst != NULL; optlst = optlst->next)
{
option_t *opt = (option_t*) optlst->data;
if (opt->optiontype != OPTION_FLAGS)
{
// add some info to the comments.
if (opt->optioninfo)
{
sprintf(newcomments+strlen(newcomments),"%s '%s' %s%s\n",
opt->epairname,
opt->optioninfo ? opt->optioninfo : "",
opt->optiondefault ? ", Default: " : "",
opt->optiondefault ? opt->optiondefault : "");
}
else
{
sprintf(newcomments+strlen(newcomments),"%s %s%s\n",
opt->epairname,
opt->optiondefault ? ", Default: " : "",
opt->optiondefault ? opt->optiondefault : "");
}
}
GSList *choicelst;
switch(opt->optiontype)
{
case OPTION_FLAGS :
// grab the flags.
for (choicelst = opt->choices; choicelst != NULL; choicelst = choicelst->next)
{
choice_t *choice = (choice_t*) choicelst->data;
int index = getindex(choice->value);
index--;
if (index < MAX_FLAGS)
{
strcpy(e->flagnames[index],choice->name);
}
else
{
Sys_Printf ("WARNING: baseclass '%s' has a spawnflag out of range, ignored!\n", bc->classname);
}
}
break;
case OPTION_CHOICES :
strcat(newcomments," Choices:\n");
for (choicelst = opt->choices; choicelst != NULL; choicelst = choicelst->next)
{
choice_t *choice = (choice_t*) choicelst->data;
sprintf(newcomments+strlen(newcomments)," %5d - %s\n",choice->value,choice->name);
}
break;
}
}
}
// name
if (e->name) free(e->name);
e->name = strdup(bc->classname);
// fixed size initialisation
if (bc->classtype == CLASS_POINTCLASS)
{
e->fixedsize = true;
// some point classes dont seem to have size()'s in the fgd, so set up a default here..
if ((e->mins[0] == 0) && (e->mins[1] == 0) && (e->mins[2] == 0) &&
(e->maxs[0] == 0) && (e->maxs[1] == 0) && (e->maxs[2] == 0))
{
e->mins[0] = -8;
e->mins[1] = -8;
e->mins[2] = -8;
e->maxs[0] = 8;
e->maxs[1] = 8;
e->maxs[2] = 8;
}
if (e->texdef.GetName() == NULL)
{
// no color specified for this entity in the fgd file
// set one now
// Note: if this eclass_t is not fully built, then this may be
// overridden with the correct color.
e->color[0] = 1;
e->color[1] = 0.5; // how about a nice bright pink, mmm, nice! :)
e->color[2] = 1;
sprintf (color, "(%f %f %f)", e->color[0], e->color[1], e->color[2]);
e->texdef.SetName(color);
}
}
// COMMENTS
if (newcomments[0])
{
e->comments = addstr(e->comments,newcomments);
}
}
/*!
create the eclass_t structures and add to the global list.
*/
void Create_EClasses(GSList *l_classes)
{
int count = 0;
// loop through the loaded structures finding all the non BaseClasses
for (GSList *clst = l_classes; clst != NULL; clst = clst->next)
{
class_t *c = (class_t *)clst->data;
if (c->classtype == CLASS_BASECLASS) // not looking for these.
continue;
eclass_t *e = (eclass_t *) malloc( sizeof( eclass_s ));
memset(e,0,sizeof( eclass_s ));
EClass_ImportFromClass(e, l_classes, c );
// radiant will crash if this is null, and it still could be at this point.
if (!e->comments)
{
e->comments=strdup("No description available, check documentation\n");
}
// dump the spawnflags to the end of the comments.
int i;
bool havespawnflags;
havespawnflags = false;
for (i = 0 ; i < MAX_FLAGS ; i++)
{
if (*e->flagnames[i]) havespawnflags = true;
}
if (havespawnflags)
{
char spawnline[80];
e->comments = addstr(e->comments,"Spawnflags\n");
for (i = 0 ; i < MAX_FLAGS ; i++)
{
if (*e->flagnames[i])
{
sprintf(spawnline," %d - %s\n", 1<<i, e->flagnames[i]);
e->comments = addstr(e->comments,spawnline);
}
}
}
Eclass_InsertAlphabetized (e);
count ++;
// Hydra: ttimo, I don't think this code is required...
// single ?
*Get_Eclass_E() = e;
Set_Eclass_Found(true);
if ( Get_Parsing_Single() )
break;
}
Sys_Printf ("FGD Loaded %d entities.\n", count);
}
void Eclass_ScanFile (char *filename)
{
int size;
char *data;
char temp[1024];
GSList *l_classes = NULL;
char token_debug[1024]; //++Hydra FIXME: cleanup this.
bool done = false;
int len,classtype;
char *token = Token();
QE_ConvertDOSToUnixName( temp, filename );
size = vfsLoadFullPathFile (filename, (void**)&data);
if (size <= 0)
{
Sys_FPrintf (SYS_ERR, "Eclass_ScanFile: %s not found\n", filename);
return;
}
Sys_Printf ("ScanFile: %s\n", temp);
// start parsing the file
StartTokenParsing(data);
// build a list of base classes first
while (!done)
{
// find an @ sign.
do
{
if (!GetToken(true))
{
done = true;
break;
}
} while (token[0] != '@');
strcpy(temp,token+1); // skip the @
classtype = CLASS_NOCLASS;
if (!stricmp(temp,"BaseClass")) classtype = CLASS_BASECLASS;
if (!stricmp(temp,"PointClass")) classtype = CLASS_POINTCLASS;
if (!stricmp(temp,"SolidClass")) classtype = CLASS_SOLIDCLASS;
if (classtype)
{
class_t *newclass = (class_t *) malloc( sizeof(class_s) );
memset( newclass, 0, sizeof(class_s) );
newclass->classtype = classtype;
while (1)
{
GetTokenExtra(false,"(",false); // option or =
strcpy(token_debug,token);
if (!strcmp(token,"="))
{
UnGetToken();
break;
}
else
{
strlower(token);
if (!strcmp(token,"base"))
{
GetTokenExtra(false,"(",true); // (
if (!strcmp(token,"("))
{
while (GetTokenExtra(false,",)",false)) // option) or option,
{
newclass->l_baselist = g_slist_append (newclass->l_baselist, strdup(token));
GetTokenExtra(false,",)",true); // , or )
if (!strcmp(token,")"))
break;
}
}
}
else if (!strcmp(token,"size"))
{
// parse (w h d) or (x y z, x y z)
GetTokenExtra(false,"(",true); // (
if (!strcmp(token,"("))
{
int sizedone = false;
float w,h,d;
GetToken(false);
w = atof(token);
GetToken(false);
h = atof(token);
GetToken(false); // number) or number ,
strcpy(temp,token);
len = strlen(temp);
if (temp[len-1] == ')') sizedone = true;
temp[len-1] = 0;
d = atof(temp);
if (sizedone)
{
// only one set of cordinates supplied, change the W,H,D to mins/maxs
newclass->boundingbox[0][0] = 0 - (w / 2);
newclass->boundingbox[1][0] = w / 2;
newclass->boundingbox[0][1] = 0 - (h / 2);
newclass->boundingbox[1][1] = h / 2;
newclass->boundingbox[0][2] = 0 - (d / 2);
newclass->boundingbox[1][2] = d / 2;
newclass->gotsize = true;
}
else
{
newclass->boundingbox[0][0] = w;
newclass->boundingbox[0][1] = h;
newclass->boundingbox[0][2] = d;
GetToken(false);
newclass->boundingbox[1][0] = atof(token);
GetToken(false);
newclass->boundingbox[1][1] = atof(token);
/*
GetToken(false); // "number)" or "number )"
strcpy(temp,token);
len = strlen(temp);
if (temp[len-1] == ')')
temp[len-1] = 0;
else
GetToken(false); // )
newclass->boundingbox[1][2] = atof(temp);
*/
GetTokenExtra(false,")",false); // number
newclass->boundingbox[1][2] = atof(token);
newclass->gotsize = true;
GetTokenExtra(false,")",true); // )
}
}
}
else if (!strcmp(token,"color"))
{
GetTokenExtra(false,"(",true); // (
if (!strcmp(token,"("))
{
// get the color values (0-255) and normalize them if required.
GetToken(false);
newclass->color[0] = atof(token);
if (newclass->color[0] > 1)
newclass->color[0]/=255;
GetToken(false);
newclass->color[1] = atof(token);
if (newclass->color[1] > 1)
newclass->color[1]/=255;
GetToken(false);
strcpy(temp,token);
len = strlen(temp);
if (temp[len-1] == ')') temp[len-1] = 0;
newclass->color[2] = atof(temp);
if (newclass->color[2] > 1)
newclass->color[2]/=255;
newclass->gotcolor = true;
}
}
else if (!strcmp(token,"iconsprite"))
{
GetTokenExtra(false,"(",true); // (
if (!strcmp(token,"("))
{
GetTokenExtra(false,")",false); // filename)
// the model plugins will handle sprites too.
// newclass->sprite = strdup(token);
newclass->model = strdup(token);
GetTokenExtra(false,")",true); // )
}
}
else if (!strcmp(token,"model"))
{
GetTokenExtra(false,"(",true); // (
if (!strcmp(token,"("))
{
GetTokenExtra(false,")",false); // filename)
newclass->model = strdup(token);
GetTokenExtra(false,")",true); // )
}
}
else
{
// Unsupported
GetToken(false); // skip it.
}
}
}
GetToken(false); // =
strcpy(token_debug,token);
if (!strcmp(token,"="))
{
GetToken(false);
newclass->classname = strdup(token);
}
// Get the description
if (newclass->classtype != CLASS_BASECLASS)
{
GetToken(false);
if (!strcmp(token,":"))
{
GetToken(false);
newclass->description = strdup(token);
} else UnGetToken(); // no description
}
// now build the option list.
GetToken(true); // [ or []
if (strcmp(token,"[]")) // got some options ?
{
if (!strcmp(token,"["))
{
// yup
bool optioncomplete = false;
option_t *newoption;
while (1)
{
GetToken(true);
if (!strcmp(token,"]"))
break; // no more options
// parse the data and build the option_t
strcpy(temp,token);
len = strlen(temp);
char *ptr = strchr(temp,'(');
if (!ptr)
break;
newoption = (option_t *) malloc ( sizeof( option_s ));
memset( newoption, 0, sizeof( option_s ));
*ptr++ = 0;
newoption->epairname = strdup(temp);
len = strlen(ptr);
if (ptr[len-1] != ')')
break;
ptr[len-1] = 0;
strlower(ptr);
if (!strcmp(ptr,"integer"))
{
newoption->optiontype = OPTION_INTEGER;
}
else if (!strcmp(ptr,"choices"))
{
newoption->optiontype = OPTION_CHOICES;
}
else if (!strcmp(ptr,"flags"))
{
newoption->optiontype = OPTION_FLAGS;
}
else // string
{
newoption->optiontype = OPTION_STRING;
}
switch (newoption->optiontype)
{
case OPTION_STRING :
case OPTION_INTEGER :
if (!TokenAvailable())
{
optioncomplete = true;
break;
}
GetToken(false); // :
strcpy(token_debug,token);
if ((token[0] == ':') && (strlen(token) > 1))
{
newoption->optioninfo = strdup(token+1);
}
else
{
GetToken(false);
newoption->optioninfo = strdup(token);
}
if (TokenAvailable()) // default value ?
{
GetToken(false);
if (!strcmp(token,":"))
{
if (GetToken(false))
{
newoption->optiondefault = strdup(token);
optioncomplete = true;
}
}
}
else
{
optioncomplete = true;
}
break;
case OPTION_CHOICES :
GetTokenExtra(false,":",true); // : or :"something like this" (bah!)
strcpy(token_debug,token);
if ((token[0] == ':') && (strlen(token) > 1))
{
if (token[1] == '\"')
{
strcpy(temp,token+2);
while (1)
{
if (!GetToken(false))
break;
strcat(temp," ");
strcat(temp,token);
len = strlen(temp);
if (temp[len-1] == '\"')
{
temp[len-1] = 0;
break;
}
}
}
newoption->optioninfo = strdup(temp);
}
else
{
GetToken(false);
newoption->optioninfo = strdup(token);
}
GetToken(false); // : or =
strcpy(token_debug,token);
if (!strcmp(token,":"))
{
GetToken(false);
newoption->optiondefault = strdup(token);
}
else
{
UnGetToken();
}
// And Follow on...
case OPTION_FLAGS :
GetToken(false); // : or =
strcpy(token_debug,token);
if (strcmp(token,"=")) // missing ?
break;
GetToken(true); // [
strcpy(token_debug,token);
if (strcmp(token,"[")) // missing ?
break;
choice_t *newchoice;
while (1)
{
GetTokenExtra(true,":",true); // "]" or "number", or "number:"
strcpy(token_debug,token);
if (!strcmp(token,"]")) // no more ?
{
optioncomplete = true;
break;
}
strcpy(temp,token);
len = strlen(temp);
if (temp[len-1] == ':')
{
temp[len-1] = 0;
}
else
{
GetToken(false); // :
if (strcmp(token,":")) // missing ?
break;
}
if (!TokenAvailable())
break;
GetToken(false); // the name
newchoice = (choice_t *) malloc ( sizeof( choice_s ));
memset( newchoice, 0, sizeof( choice_s ));
newchoice->value = atoi(temp);
newchoice->name = strdup(token);
newoption->choices = g_slist_append(newoption->choices, newchoice);
// ignore any remaining tokens on the line
while (TokenAvailable()) GetToken(false);
// and it we found a "]" on the end of the line, put it back in the queue.
if (!strcmp(token,"]")) UnGetToken();
}
break;
}
// add option to the newclass
if (optioncomplete)
{
if (newoption)
{
// add it to the list.
newclass->l_optionlist = g_slist_append(newclass->l_optionlist, newoption);
}
}
else
{
Sys_Printf ("%WARNING: Parse error occured in '%s - %s'\n",classnames[newclass->classtype],newclass->classname);
Free_Option(newoption);
}
}
}
else
{
UnGetToken(); // shouldn't get here.
}
}
// add it to our list.
l_classes = g_slist_append (l_classes, newclass);
}
}
// finished with the file now.
g_free(data);
Sys_Printf ("FGD scan complete, building entities...\n");
// Once we get here we should have a few (!) lists in memory that we
// can extract all the information required to build a the eclass_t structures.
Create_EClasses(l_classes);
// Free everything
GSList *p = l_classes;
while (p)
{
class_t *tmpclass = (class_t *)p->data;
#ifdef FGD_VERBOSE
// DEBUG: dump the info...
Sys_Printf ("%s: %s (", classnames[tmpclass->classtype],tmpclass->classname);
for (GSList *tmp = tmpclass->l_baselist; tmp != NULL; tmp = tmp->next)
{
if (tmp != tmpclass->l_baselist)
{
Sys_Printf (", ");
}
Sys_Printf ("%s", (char *)tmp->data);
}
if (tmpclass->gotsize)
{
sprintf(temp,"(%.0f %.0f %.0f) - (%.0f %.0f %.0f)",tmpclass->boundingbox[0][0],
tmpclass->boundingbox[0][1],
tmpclass->boundingbox[0][2],
tmpclass->boundingbox[1][0],
tmpclass->boundingbox[1][1],
tmpclass->boundingbox[1][2]);
} else strcpy(temp,"No Size");
Sys_Printf (") '%s' Size: %s",tmpclass->description ? tmpclass->description : "No description",temp);
if (tmpclass->gotcolor)
{
sprintf(temp,"(%d %d %d)",tmpclass->color[0],
tmpclass->color[1],
tmpclass->color[2]);
} else strcpy(temp,"No Color");
Sys_Printf (" Color: %s Options:\n",temp);
if (!tmpclass->l_optionlist)
{
Sys_Printf (" No Options\n");
}
else
{
option_t *tmpoption;
int count;
GSList *olst;
for (olst = tmpclass->l_optionlist, count = 1; olst != NULL; olst = olst->next, count ++)
{
tmpoption = (option_t *)olst->data;
Sys_Printf (" %d, Type: %s, EPair: %s\n", count,optionnames[tmpoption->optiontype], tmpoption->epairname );
choice_t *tmpchoice;
GSList *clst;
int ccount;
for (clst = tmpoption->choices, ccount = 1; clst != NULL; clst = clst->next, ccount ++)
{
tmpchoice = (choice_t *)clst->data;
Sys_Printf (" %d, Value: %d, Name: %s\n", ccount, tmpchoice->value, tmpchoice->name);
}
}
}
#endif
// free the baselist.
ClearGSList(tmpclass->l_baselist);
Free_Class (tmpclass);
p = g_slist_remove (p, p->data);
}
}