MODULE evaluate_event_exists (void)
{
int event;
CleanName (token); /* Get normalised name */
for (event = 0; event < stats-> events; event++)
{
if (streq (stats-> enames [event], token))
{
*result = TRUE;
break;
}
}
}
MODULE evaluate_module_exists (void)
{
int module;
CleanName (token); /* Get normalised name */
for (module = 0; module < stats-> modules; module++)
{
if (streq (stats-> mnames [module], token))
{
*result = TRUE;
break;
}
}
}
// Adds a new attribute to this extra tree node.
FCDEAttribute* FCDENode::AddAttribute(fm::string& _name, const fchar* _value)
{
CleanName(_name);
FCDEAttribute* attribute = FindAttribute(_name.c_str());
if (attribute == NULL)
{
attribute = new FCDEAttribute();
attributes.push_back(attribute);
attribute->SetName(_name);
}
attribute->SetValue(_value);
SetNewChildFlag();
return attribute;
}
MODULE evaluate_state_exists (void)
{
int state;
CleanName (token); /* Get normalised name */
puts (token);
for (state = 0; state < stats-> states; state++)
{
puts (stats-> snames [state]);
if (streq (stats-> snames [state], token))
{
*result = TRUE;
break;
}
}
}
void FCDEntity::SetName(const fstring& _name)
{
name = CleanName(_name.c_str());
SetDirtyFlag();
}
/*
================
idTypeInfoGen::WriteTypeInfo
================
*/
void idTypeInfoGen::WriteTypeInfo( const char *fileName ) const {
int i, j;
idStr path, define;
idFile *file;
path = fileSystem->RelativePathToOSPath( fileName );
file = fileSystem->OpenExplicitFileWrite( path );
if ( !file ) {
common->Warning( "couldn't open %s", path.c_str() );
return;
}
common->Printf( "writing %s...\n", path.c_str() );
path.ExtractFileName( define );
define.Replace( ".", "_" );
define.ToUpper();
file->WriteFloatString(
"\n"
"#ifndef __%s__\n"
"#define __%s__\n"
"\n"
"/*\n"
"===================================================================================\n"
"\n"
"\tThis file has been generated with the Type Info Generator v"TYPE_INFO_GEN_VERSION" (c) 2004 id Software\n"
"\n"
"\t%d constants\n"
"\t%d enums\n"
"\t%d classes/structs/unions\n"
"\t%d templates\n"
"\t%d max inheritance level for '%s'\n"
"\n"
"===================================================================================\n"
"*/\n"
"\n", define.c_str(), define.c_str(), constants.Num(), enums.Num(), classes.Num(),
numTemplates, maxInheritance, maxInheritanceClass.c_str() );
file->WriteFloatString(
"typedef struct {\n"
"\t" "const char * name;\n"
"\t" "const char * type;\n"
"\t" "const char * value;\n"
"} constantInfo_t;\n"
"\n"
"typedef struct {\n"
"\t" "const char * name;\n"
"\t" "int value;\n"
"} enumValueInfo_t;\n"
"\n"
"typedef struct {\n"
"\t" "const char * typeName;\n"
"\t" "const enumValueInfo_t * values;\n"
"} enumTypeInfo_t;\n"
"\n"
"typedef struct {\n"
"\t" "const char * type;\n"
"\t" "const char * name;\n"
"\t" "int offset;\n"
"\t" "int size;\n"
"} classVariableInfo_t;\n"
"\n"
"typedef struct {\n"
"\t" "const char * typeName;\n"
"\t" "const char * superType;\n"
"\t" "int size;\n"
"\t" "const classVariableInfo_t * variables;\n"
"} classTypeInfo_t;\n"
"\n" );
// constants
file->WriteFloatString( "static constantInfo_t constantInfo[] = {\n" );
for ( i = 0; i < constants.Num(); i++ ) {
idConstantInfo *info = constants[i];
file->WriteFloatString( "\t{ \"%s\", \"%s\", \"%s\" },\n", info->type.c_str(), info->name.c_str(), info->value.c_str() );
}
file->WriteFloatString( "\t{ NULL, NULL, NULL }\n" );
file->WriteFloatString( "};\n\n" );
// enum values
for ( i = 0; i < enums.Num(); i++ ) {
idEnumTypeInfo *info = enums[i];
idStr typeInfoName = info->scope + info->typeName;
CleanName( typeInfoName );
file->WriteFloatString( "static enumValueInfo_t %s_typeInfo[] = {\n", typeInfoName.c_str() );
for ( j = 0; j < info->values.Num(); j++ ) {
if ( info->isTemplate ) {
file->WriteFloatString( "//" );
}
file->WriteFloatString( "\t{ \"%s\", %d },\n", info->values[j].name.c_str(), info->values[j].value );
}
file->WriteFloatString( "\t{ NULL, 0 }\n" );
file->WriteFloatString( "};\n\n" );
}
// enums
file->WriteFloatString( "static enumTypeInfo_t enumTypeInfo[] = {\n" );
for ( i = 0; i < enums.Num(); i++ ) {
idEnumTypeInfo *info = enums[i];
idStr typeName = info->scope + info->typeName;
idStr typeInfoName = typeName;
CleanName( typeInfoName );
if ( info->isTemplate ) {
file->WriteFloatString( "//" );
}
file->WriteFloatString( "\t{ \"%s\", %s_typeInfo },\n", typeName.c_str(), typeInfoName.c_str() );
}
file->WriteFloatString( "\t{ NULL, NULL }\n" );
file->WriteFloatString( "};\n\n" );
// class variables
for ( i = 0; i < classes.Num(); i++ ) {
idClassTypeInfo *info = classes[i];
idStr typeName = info->scope + info->typeName;
idStr typeInfoName = typeName;
CleanName( typeInfoName );
file->WriteFloatString( "static classVariableInfo_t %s_typeInfo[] = {\n", typeInfoName.c_str() );
for ( j = 0; j < info->variables.Num(); j++ ) {
const char *varName = info->variables[j].name.c_str();
const char *varType = info->variables[j].type.c_str();
if ( info->unnamed || info->isTemplate || info->variables[j].bits != 0 ) {
file->WriteFloatString( "//" );
}
file->WriteFloatString( "\t{ \"%s\", \"%s\", (int)(&((%s *)0)->%s), sizeof( ((%s *)0)->%s ) },\n",
varType, varName, typeName.c_str(), varName, typeName.c_str(), varName );
}
file->WriteFloatString( "\t{ NULL, 0 }\n" );
file->WriteFloatString( "};\n\n" );
}
// classes
file->WriteFloatString( "static classTypeInfo_t classTypeInfo[] = {\n" );
for ( i = 0; i < classes.Num(); i++ ) {
idClassTypeInfo *info = classes[i];
idStr typeName = info->scope + info->typeName;
idStr typeInfoName = typeName;
CleanName( typeInfoName );
if ( info->unnamed || info->isTemplate ) {
file->WriteFloatString( "//" );
}
file->WriteFloatString( "\t{ \"%s\", \"%s\", sizeof(%s), %s_typeInfo },\n",
typeName.c_str(), info->superType.c_str(), typeName.c_str(), typeInfoName.c_str() );
}
file->WriteFloatString( "\t{ NULL, NULL, 0, NULL }\n" );
file->WriteFloatString( "};\n\n" );
file->WriteFloatString( "#endif /* !__%s__ */\n", define.c_str() );
fileSystem->CloseFile( file );
}
void FCDENode::SetName(fm::string& _name)
{
name = _name;
CleanName(name);
SetDirtyFlag();
}