ubergames/gtkradiant
0
0
Fork 0
mirror of https://github.com/UberGames/GtkRadiant.git synced 2024-11-10 14:41:54 +00:00
Code Issues Projects Releases Packages Wiki Activity
gtkradiant/plugins/eclassfgd/plugin.cpp
Timothee TTimo Besset 830125fad0 uncrustify! now the code is only ugly on the *inside*
2012-03-17 15:01:54 -05:00

1112 lines
29 KiB
C++
Raw Blame History

/*
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 );
}
}
Reference in a new issue View git blame Copy permalink