1436 lines
49 KiB
C++
1436 lines
49 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
// This is real evil but allows the code to inspect arbitrary class variables.
|
|
#define private public
|
|
#define protected public
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../Game_local.h"
|
|
|
|
#ifdef ID_DEBUG_MEMORY
|
|
#include "GameTypeInfo.h" // Make sure this is up to date!
|
|
#else
|
|
#include "NoGameTypeInfo.h"
|
|
#endif
|
|
|
|
// disabled because it's adds about 64MB to state dumps and takes a really long time
|
|
//#define DUMP_GAMELOCAL
|
|
|
|
|
|
typedef void (*WriteVariableType_t)( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize );
|
|
|
|
|
|
class idTypeInfoTools {
|
|
public:
|
|
static const classTypeInfo_t * FindClassInfo( const char *typeName );
|
|
static const enumTypeInfo_t * FindEnumInfo( const char *typeName );
|
|
static bool IsSubclassOf( const char *typeName, const char *superType );
|
|
static void PrintType( const void *typePtr, const char *typeName );
|
|
static void WriteTypeToFile( idFile *fp, const void *typePtr, const char *typeName );
|
|
static void InitTypeVariables( const void *typePtr, const char *typeName, int value );
|
|
static void WriteGameState( const char *fileName );
|
|
static void CompareGameState( const char *fileName );
|
|
|
|
private:
|
|
static idFile * fp;
|
|
static int initValue;
|
|
static WriteVariableType_t Write;
|
|
static idLexer * src;
|
|
static bool typeError;
|
|
|
|
static const char * OutputString( const char *string );
|
|
static bool ParseTemplateArguments( idLexer &src, idStr &arguments );
|
|
static void PrintVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize );
|
|
static void WriteVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize );
|
|
static void WriteGameStateVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize );
|
|
static void InitVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize );
|
|
static void VerifyVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize );
|
|
static int WriteVariable_r( const void *varPtr, const char *varName, const char *varType, const char *scope, const char *prefix, const int pointerDepth );
|
|
static void WriteClass_r( const void *classPtr, const char *className, const char *classType, const char *scope, const char *prefix, const int pointerDepth );
|
|
};
|
|
|
|
idFile * idTypeInfoTools::fp = NULL;
|
|
int idTypeInfoTools::initValue = 0;
|
|
WriteVariableType_t idTypeInfoTools::Write = NULL;
|
|
idLexer * idTypeInfoTools::src = NULL;
|
|
bool idTypeInfoTools::typeError = false;
|
|
|
|
|
|
/*
|
|
================
|
|
GetTypeVariableName
|
|
================
|
|
*/
|
|
const char *GetTypeVariableName( const char *typeName, int offset ) {
|
|
static char varName[1024];
|
|
int i;
|
|
|
|
for ( i = 0; classTypeInfo[i].typeName != NULL; i++ ) {
|
|
if ( idStr::Cmp( typeName, classTypeInfo[i].typeName ) == 0 ) {
|
|
if ( classTypeInfo[i].variables[0].name != NULL && offset >= classTypeInfo[i].variables[0].offset ) {
|
|
break;
|
|
}
|
|
typeName = classTypeInfo[i].superType;
|
|
if ( *typeName == '\0' ) {
|
|
return "<unknown>";
|
|
}
|
|
i = -1;
|
|
}
|
|
}
|
|
|
|
const classTypeInfo_t &classInfo = classTypeInfo[i];
|
|
|
|
for ( i = 0; classInfo.variables[i].name != NULL; i++ ) {
|
|
if ( offset <= classInfo.variables[i].offset ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( i == 0 ) {
|
|
idStr::snPrintf( varName, sizeof( varName ), "%s::<unknown>", classInfo.typeName );
|
|
} else {
|
|
idStr::snPrintf( varName, sizeof( varName ), "%s::%s", classInfo.typeName, classInfo.variables[i-1].name );
|
|
}
|
|
return varName;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::FindClassInfo
|
|
================
|
|
*/
|
|
const classTypeInfo_t *idTypeInfoTools::FindClassInfo( const char *typeName ) {
|
|
int i;
|
|
|
|
for ( i = 0; classTypeInfo[i].typeName != NULL; i++ ) {
|
|
if ( idStr::Cmp( typeName, classTypeInfo[i].typeName ) == 0 ) {
|
|
return &classTypeInfo[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::FindEnumInfo
|
|
================
|
|
*/
|
|
const enumTypeInfo_t *idTypeInfoTools::FindEnumInfo( const char *typeName ) {
|
|
int i;
|
|
|
|
for ( i = 0; enumTypeInfo[i].typeName != NULL; i++ ) {
|
|
if ( idStr::Cmp( typeName, enumTypeInfo[i].typeName ) == 0 ) {
|
|
return &enumTypeInfo[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::IsSubclassOf
|
|
================
|
|
*/
|
|
bool idTypeInfoTools::IsSubclassOf( const char *typeName, const char *superType ) {
|
|
int i;
|
|
|
|
while( *typeName != '\0' ) {
|
|
if ( idStr::Cmp( typeName, superType ) == 0 ) {
|
|
return true;
|
|
}
|
|
for ( i = 0; classTypeInfo[i].typeName != NULL; i++ ) {
|
|
if ( idStr::Cmp( typeName, classTypeInfo[i].typeName ) == 0 ) {
|
|
typeName = classTypeInfo[i].superType;
|
|
break;
|
|
}
|
|
}
|
|
if ( classTypeInfo[i].typeName == NULL ) {
|
|
common->Warning( "super class %s not found", typeName );
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::OutputString
|
|
================
|
|
*/
|
|
const char *idTypeInfoTools::OutputString( const char *string ) {
|
|
static int index = 0;
|
|
static char buffers[4][16384];
|
|
char *out;
|
|
int i, c;
|
|
|
|
out = buffers[index];
|
|
index = ( index + 1 ) & 3;
|
|
|
|
if ( string == NULL ) {
|
|
return NULL;
|
|
}
|
|
|
|
for ( i = 0; i < sizeof( buffers[0] ) - 2; i++ ) {
|
|
c = *string++;
|
|
switch( c ) {
|
|
case '\0': out[i] = '\0'; return out;
|
|
case '\\': out[i++] = '\\'; out[i] = '\\'; break;
|
|
case '\n': out[i++] = '\\'; out[i] = 'n'; break;
|
|
case '\r': out[i++] = '\\'; out[i] = 'r'; break;
|
|
case '\t': out[i++] = '\\'; out[i] = 't'; break;
|
|
case '\v': out[i++] = '\\'; out[i] = 'v'; break;
|
|
default: out[i] = c; break;
|
|
}
|
|
}
|
|
out[i] = '\0';
|
|
return out;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::ParseTemplateArguments
|
|
================
|
|
*/
|
|
bool idTypeInfoTools::ParseTemplateArguments( idLexer &src, idStr &arguments ) {
|
|
int indent;
|
|
idToken token;
|
|
|
|
arguments = "";
|
|
|
|
if ( !src.ExpectTokenString( "<" ) ) {
|
|
return false;
|
|
}
|
|
|
|
indent = 1;
|
|
while( indent ) {
|
|
if ( !src.ReadToken( &token ) ) {
|
|
break;
|
|
}
|
|
if ( token == "<" ) {
|
|
indent++;
|
|
} else if ( token == ">" ) {
|
|
indent--;
|
|
} else {
|
|
if ( arguments.Length() ) {
|
|
arguments += " ";
|
|
}
|
|
arguments += token;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::PrintType
|
|
================
|
|
*/
|
|
void idTypeInfoTools::PrintType( const void *typePtr, const char *typeName ) {
|
|
idTypeInfoTools::fp = NULL;
|
|
idTypeInfoTools::initValue = 0;
|
|
idTypeInfoTools::Write = PrintVariable;
|
|
WriteClass_r( typePtr, "", typeName, "", "", 0 );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::WriteTypeToFile
|
|
================
|
|
*/
|
|
void idTypeInfoTools::WriteTypeToFile( idFile *fp, const void *typePtr, const char *typeName ) {
|
|
idTypeInfoTools::fp = fp;
|
|
idTypeInfoTools::initValue = 0;
|
|
idTypeInfoTools::Write = WriteVariable;
|
|
WriteClass_r( typePtr, "", typeName, "", "", 0 );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::InitTypeVariables
|
|
================
|
|
*/
|
|
void idTypeInfoTools::InitTypeVariables( const void *typePtr, const char *typeName, int value ) {
|
|
idTypeInfoTools::fp = NULL;
|
|
idTypeInfoTools::initValue = value;
|
|
idTypeInfoTools::Write = InitVariable;
|
|
WriteClass_r( typePtr, "", typeName, "", "", 0 );
|
|
}
|
|
|
|
/*
|
|
================
|
|
IsAllowedToChangedFromSaveGames
|
|
================
|
|
*/
|
|
bool IsAllowedToChangedFromSaveGames( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value ) {
|
|
if ( idStr::Icmp( scope, "idAnimator" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "forceUpdate" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "lastTransformTime" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "AFPoseTime" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "frameBounds" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idClipModel" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "touchCount" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idEntity" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "numPVSAreas" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "renderView" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idBrittleFracture" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "changed" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idPhysics_AF" ) == 0 ) {
|
|
return true;
|
|
} else if ( idStr::Icmp( scope, "renderEntity_t" ) == 0 ) {
|
|
// These get fixed up when UpdateVisuals is called
|
|
if ( idStr::Icmp( varName, "origin" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "axis" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "bounds" ) == 0 ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( idStr::Icmpn( prefix, "idAFEntity_Base::af.idAF::physicsObj.idPhysics_AF", 49) == 0 ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
IsRenderHandleVariable
|
|
================
|
|
*/
|
|
bool IsRenderHandleVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value ) {
|
|
if ( idStr::Icmp( scope, "idClipModel" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "renderModelHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idFXLocalAction" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "lightDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "modelDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idEntity" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "modelDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idLight" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "lightDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idAFEntity_Gibbable" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "skeletonModelDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idAFEntity_SteamPipe" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "steamModelHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idItem" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "itemShellHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idExplodingBarrel" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "particleModelDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "lightDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idProjectile" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "lightDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idBFGProjectile" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "secondModelDefHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idSmokeParticles" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "renderEntityHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
} else if ( idStr::Icmp( scope, "idWeapon" ) == 0 ) {
|
|
if ( idStr::Icmp( varName, "muzzleFlashHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "worldMuzzleFlashHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "guiLightHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
if ( idStr::Icmp( varName, "nozzleGlowHandle" ) == 0 ) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::PrintVariable
|
|
================
|
|
*/
|
|
void idTypeInfoTools::PrintVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize ) {
|
|
common->Printf( "%s%s::%s%s = \"%s\"\n", prefix, scope, varName, postfix, value );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::WriteVariable
|
|
================
|
|
*/
|
|
void idTypeInfoTools::WriteVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize ) {
|
|
|
|
for ( int i = idStr::FindChar( value, '#', 0 ); i >= 0; i = idStr::FindChar( value, '#', i+1 ) ) {
|
|
if ( idStr::Icmpn( value+i+1, "INF", 3 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "IND", 3 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "NAN", 3 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "QNAN", 4 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "SNAN", 4 ) == 0 ) {
|
|
common->Warning( "%s%s::%s%s = \"%s\"", prefix, scope, varName, postfix, value );
|
|
break;
|
|
}
|
|
}
|
|
fp->WriteFloatString( "%s%s::%s%s = \"%s\"\n", prefix, scope, varName, postfix, value );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::WriteGameStateVariable
|
|
================
|
|
*/
|
|
void idTypeInfoTools::WriteGameStateVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize ) {
|
|
|
|
for ( int i = idStr::FindChar( value, '#', 0 ); i >= 0; i = idStr::FindChar( value, '#', i+1 ) ) {
|
|
if ( idStr::Icmpn( value+i+1, "INF", 3 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "IND", 3 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "NAN", 3 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "QNAN", 4 ) == 0 ||
|
|
idStr::Icmpn( value+i+1, "SNAN", 4 ) == 0 ) {
|
|
common->Warning( "%s%s::%s%s = \"%s\"", prefix, scope, varName, postfix, value );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( IsRenderHandleVariable( varName, varType, scope, prefix, postfix, value ) ) {
|
|
return;
|
|
}
|
|
|
|
if ( IsAllowedToChangedFromSaveGames( varName, varType, scope, prefix, postfix, value ) ) {
|
|
return;
|
|
}
|
|
|
|
fp->WriteFloatString( "%s%s::%s%s = \"%s\"\n", prefix, scope, varName, postfix, value );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::InitVariable
|
|
================
|
|
*/
|
|
void idTypeInfoTools::InitVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize ) {
|
|
if ( varPtr != NULL && varSize > 0 ) {
|
|
// NOTE: skip renderer handles
|
|
if ( IsRenderHandleVariable( varName, varType, scope, prefix, postfix, value ) ) {
|
|
return;
|
|
}
|
|
memset( const_cast<void*>(varPtr), initValue, varSize );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::VerifyVariable
|
|
================
|
|
*/
|
|
void idTypeInfoTools::VerifyVariable( const char *varName, const char *varType, const char *scope, const char *prefix, const char *postfix, const char *value, const void *varPtr, int varSize ) {
|
|
idToken token;
|
|
|
|
if ( typeError ) {
|
|
return;
|
|
}
|
|
|
|
src->SkipUntilString( "=" );
|
|
src->ExpectTokenType( TT_STRING, 0, &token );
|
|
if ( token.Cmp( value ) != 0 ) {
|
|
|
|
// NOTE: skip several things
|
|
|
|
if ( IsRenderHandleVariable( varName, varType, scope, prefix, postfix, value ) ) {
|
|
return;
|
|
}
|
|
|
|
if ( IsAllowedToChangedFromSaveGames( varName, varType, scope, prefix, postfix, value ) ) {
|
|
return;
|
|
}
|
|
|
|
src->Warning( "state diff for %s%s::%s%s\n%s\n%s", prefix, scope, varName, postfix, token.c_str(), value );
|
|
typeError = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::WriteVariable_r
|
|
================
|
|
*/
|
|
int idTypeInfoTools::WriteVariable_r( const void *varPtr, const char *varName, const char *varType, const char *scope, const char *prefix, const int pointerDepth ) {
|
|
int i, isPointer, typeSize;
|
|
idLexer typeSrc;
|
|
idToken token;
|
|
idStr typeString, templateArgs;
|
|
|
|
isPointer = 0;
|
|
typeSize = -1;
|
|
|
|
// create a type string without 'const', 'mutable', 'class', 'struct', 'union'
|
|
typeSrc.LoadMemory( varType, idStr::Length( varType ), varName );
|
|
while( typeSrc.ReadToken( &token ) ) {
|
|
if ( token != "const" && token != "mutable" && token != "class" && token != "struct" && token != "union" ) {
|
|
typeString += token + " ";
|
|
}
|
|
}
|
|
typeString.StripTrailing( ' ' );
|
|
typeSrc.FreeSource();
|
|
|
|
// if this is an array
|
|
if ( typeString[typeString.Length() - 1] == ']' ) {
|
|
for ( i = typeString.Length(); i > 0 && typeString[i - 1] != '['; i-- ) {
|
|
}
|
|
int num = atoi( &typeString[i] );
|
|
idStr listVarType = typeString;
|
|
listVarType.CapLength( i - 1 );
|
|
typeSize = 0;
|
|
for ( i = 0; i < num; i++ ) {
|
|
idStr listVarName = va( "%s[%d]", varName, i );
|
|
int size = WriteVariable_r( varPtr, listVarName, listVarType, scope, prefix, pointerDepth );
|
|
typeSize += size;
|
|
if ( size == -1 ) {
|
|
break;
|
|
}
|
|
varPtr = (void *)( ( (byte *) varPtr ) + size );
|
|
}
|
|
return typeSize;
|
|
}
|
|
|
|
// if this is a pointer
|
|
isPointer = 0;
|
|
for ( i = typeString.Length(); i > 0 && typeString[i - 1] == '*'; i -= 2 ) {
|
|
// flibit: 64 bit fix, changed long to int
|
|
if ( varPtr == (void *)0xcdcdcdcd || ( varPtr != NULL && *((unsigned int *)varPtr) == 0xcdcdcdcd ) ) {
|
|
// flibit end
|
|
common->Warning( "%s%s::%s%s references uninitialized memory", prefix, scope, varName, "" );
|
|
return typeSize;
|
|
}
|
|
if ( varPtr != NULL ) {
|
|
varPtr = *((void **)varPtr);
|
|
}
|
|
isPointer++;
|
|
}
|
|
|
|
if ( varPtr == NULL ) {
|
|
Write( varName, varType, scope, prefix, "", "<NULL>", varPtr, 0 );
|
|
return sizeof( void * );
|
|
}
|
|
|
|
typeSrc.LoadMemory( typeString, typeString.Length(), varName );
|
|
|
|
if ( !typeSrc.ReadToken( &token ) ) {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), varPtr, 0 );
|
|
return -1;
|
|
}
|
|
|
|
// get full type
|
|
while( typeSrc.CheckTokenString( "::" ) ) {
|
|
idToken newToken;
|
|
typeSrc.ExpectTokenType( TT_NAME, 0, &newToken );
|
|
token += "::" + newToken;
|
|
}
|
|
|
|
if ( token == "signed" ) {
|
|
|
|
if ( !typeSrc.ReadToken( &token ) ) {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), varPtr, 0 );
|
|
return -1;
|
|
}
|
|
if ( token == "char" ) {
|
|
|
|
typeSize = sizeof( signed char );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((signed char *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "short" ) {
|
|
|
|
typeSize = sizeof( signed short );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((signed short *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "int" ) {
|
|
|
|
typeSize = sizeof( signed int );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((signed int *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "long" ) {
|
|
|
|
typeSize = sizeof( signed long );
|
|
Write( varName, varType, scope, prefix, "", va( "%ld", *((signed long *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else {
|
|
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), varPtr, 0 );
|
|
return -1;
|
|
}
|
|
|
|
} else if ( token == "unsigned" ) {
|
|
|
|
if ( !typeSrc.ReadToken( &token ) ) {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), varPtr, 0 );
|
|
return -1;
|
|
}
|
|
if ( token == "char" ) {
|
|
|
|
typeSize = sizeof( unsigned char );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((unsigned char *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "short" ) {
|
|
|
|
typeSize = sizeof( unsigned short );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((unsigned short *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "int" ) {
|
|
|
|
typeSize = sizeof( unsigned int );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((unsigned int *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "long" ) {
|
|
|
|
typeSize = sizeof( unsigned long );
|
|
Write( varName, varType, scope, prefix, "", va( "%lu", *((unsigned long *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else {
|
|
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), varPtr, 0 );
|
|
return -1;
|
|
}
|
|
|
|
} else if ( token == "byte" ) {
|
|
|
|
typeSize = sizeof( byte );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((byte *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "word" ) {
|
|
|
|
typeSize = sizeof( word );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((word *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "dword" ) {
|
|
|
|
typeSize = sizeof( dword );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((dword *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "bool" ) {
|
|
|
|
typeSize = sizeof( bool );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((bool *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "char" ) {
|
|
|
|
typeSize = sizeof( char );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((char *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "short" ) {
|
|
|
|
typeSize = sizeof( short );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((short *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "int" ) {
|
|
|
|
typeSize = sizeof( int );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((int *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "long" ) {
|
|
|
|
typeSize = sizeof( long );
|
|
Write( varName, varType, scope, prefix, "", va( "%ld", *((long *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "float" ) {
|
|
|
|
typeSize = sizeof( float );
|
|
Write( varName, varType, scope, prefix, "", idStr( *((float *)varPtr) ).c_str(), varPtr, typeSize );
|
|
|
|
} else if ( token == "double" ) {
|
|
|
|
typeSize = sizeof( double );
|
|
Write( varName, varType, scope, prefix, "", idStr( (float)*((double *)varPtr) ).c_str(), varPtr, typeSize );
|
|
|
|
} else if ( token == "idVec2" ) {
|
|
|
|
typeSize = sizeof( idVec2 );
|
|
Write( varName, varType, scope, prefix, "", ((idVec2 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idVec3" ) {
|
|
|
|
typeSize = sizeof( idVec3 );
|
|
Write( varName, varType, scope, prefix, "", ((idVec3 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idVec4" ) {
|
|
|
|
typeSize = sizeof( idVec4 );
|
|
Write( varName, varType, scope, prefix, "", ((idVec4 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idVec5" ) {
|
|
|
|
typeSize = sizeof( idVec5 );
|
|
Write( varName, varType, scope, prefix, "", ((idVec5 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idVec6" ) {
|
|
|
|
typeSize = sizeof( idVec6 );
|
|
Write( varName, varType, scope, prefix, "", ((idVec6 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idVecX" ) {
|
|
|
|
const idVecX *vec = ((idVecX *)varPtr);
|
|
if ( vec->ToFloatPtr() != NULL ) {
|
|
Write( varName, varType, scope, prefix, "", vec->ToString( 8 ), vec->ToFloatPtr(), vec->GetSize() * sizeof( float ) );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", "<NULL>", varPtr, 0 );
|
|
}
|
|
typeSize = sizeof( idVecX );
|
|
|
|
} else if ( token == "idMat2" ) {
|
|
|
|
typeSize = sizeof( idMat2 );
|
|
Write( varName, varType, scope, prefix, "", ((idMat2 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idMat3" ) {
|
|
|
|
typeSize = sizeof( idMat3 );
|
|
Write( varName, varType, scope, prefix, "", ((idMat3 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idMat4" ) {
|
|
|
|
typeSize = sizeof( idMat4 );
|
|
Write( varName, varType, scope, prefix, "", ((idMat4 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idMat5" ) {
|
|
|
|
typeSize = sizeof( idMat5 );
|
|
Write( varName, varType, scope, prefix, "", ((idMat5 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idMat6" ) {
|
|
|
|
typeSize = sizeof( idMat6 );
|
|
Write( varName, varType, scope, prefix, "", ((idMat6 *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idMatX" ) {
|
|
|
|
typeSize = sizeof( idMatX );
|
|
const idMatX *mat = ((idMatX *)varPtr);
|
|
if ( mat->ToFloatPtr() != NULL ) {
|
|
Write( varName, varType, scope, prefix, "", mat->ToString( 8 ), mat->ToFloatPtr(), mat->GetNumColumns() * mat->GetNumRows() * sizeof( float ) );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", "<NULL>", NULL, 0 );
|
|
}
|
|
|
|
} else if ( token == "idAngles" ) {
|
|
|
|
typeSize = sizeof( idAngles );
|
|
Write( varName, varType, scope, prefix, "", ((idAngles *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idQuat" ) {
|
|
|
|
typeSize = sizeof( idQuat );
|
|
Write( varName, varType, scope, prefix, "", ((idQuat *)varPtr)->ToString( 8 ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idBounds" ) {
|
|
|
|
typeSize = sizeof( idBounds );
|
|
const idBounds *bounds = ((idBounds *)varPtr);
|
|
if ( bounds->IsCleared() ) {
|
|
Write( varName, varType, scope, prefix, "", "<cleared>", varPtr, typeSize );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "(%s)-(%s)", (*bounds)[0].ToString( 8 ), (*bounds)[1].ToString( 8 ) ), varPtr, typeSize );
|
|
}
|
|
|
|
} else if ( token == "idList" ) {
|
|
|
|
idList<int> *list = ((idList<int> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".num", va( "%d", list->Num() ), NULL, 0 );
|
|
// NOTE: we don't care about the amount of memory allocated
|
|
//Write( varName, varType, scope, prefix, ".size", va( "%d", list->Size() ), NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".granularity", va( "%d", list->GetGranularity() ), NULL, 0 );
|
|
|
|
if ( list->Num() && ParseTemplateArguments( typeSrc, templateArgs ) ) {
|
|
void *listVarPtr = list->Ptr();
|
|
for ( i = 0; i < list->Num(); i++ ) {
|
|
idStr listVarName = va( "%s[%d]", varName, i );
|
|
int size = WriteVariable_r( listVarPtr, listVarName, templateArgs, scope, prefix, pointerDepth );
|
|
if ( size == -1 ) {
|
|
break;
|
|
}
|
|
listVarPtr = (void *)( ( (byte *) listVarPtr ) + size );
|
|
}
|
|
}
|
|
|
|
typeSize = sizeof( idList<int> );
|
|
|
|
} else if ( token == "idStaticList" ) {
|
|
|
|
idStaticList<int, 1> *list = ((idStaticList<int, 1> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".num", va( "%d", list->Num() ), NULL, 0 );
|
|
|
|
int totalSize = 0;
|
|
if ( list->Num() && ParseTemplateArguments( typeSrc, templateArgs ) ) {
|
|
void *listVarPtr = list->Ptr();
|
|
for ( i = 0; i < list->Num(); i++ ) {
|
|
idStr listVarName = va( "%s[%d]", varName, i );
|
|
int size = WriteVariable_r( listVarPtr, listVarName, templateArgs, scope, prefix, pointerDepth );
|
|
if ( size == -1 ) {
|
|
break;
|
|
}
|
|
totalSize += size;
|
|
listVarPtr = (void *)( ( (byte *) listVarPtr ) + size );
|
|
}
|
|
}
|
|
|
|
typeSize = sizeof( int ) + totalSize;
|
|
|
|
} else if ( token == "idLinkList" ) {
|
|
|
|
// FIXME: implement
|
|
typeSize = sizeof( idLinkList<idEntity> );
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), NULL, 0 );
|
|
|
|
} else if ( token == "idStr" ) {
|
|
|
|
typeSize = sizeof( idStr );
|
|
|
|
const idStr *str = ((idStr *)varPtr);
|
|
Write( varName, varType, scope, prefix, "", OutputString( str->c_str() ), str->c_str(), str->Length() );
|
|
|
|
} else if ( token == "idStrList" ) {
|
|
|
|
typeSize = sizeof( idStrList );
|
|
|
|
const idStrList *list = ((idStrList *)varPtr);
|
|
if ( list->Num() ) {
|
|
for ( i = 0; i < list->Num(); i++ ) {
|
|
Write( varName, varType, scope, prefix, va("[%d]", i ), OutputString( (*list)[i].c_str() ), (*list)[i].c_str(), (*list)[i].Length() );
|
|
}
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", "<empty>", NULL, 0 );
|
|
}
|
|
|
|
} else if ( token == "idDict" ) {
|
|
|
|
typeSize = sizeof( idDict );
|
|
|
|
const idDict *dict = ((idDict *)varPtr);
|
|
if ( dict->GetNumKeyVals() ) {
|
|
for ( i = 0; i < dict->GetNumKeyVals(); i++ ) {
|
|
const idKeyValue *kv = dict->GetKeyVal( i );
|
|
Write( varName, varType, scope, prefix, va("[%d]", i ), va( "\'%s\' \'%s\'", OutputString( kv->GetKey().c_str() ), OutputString( kv->GetValue().c_str() ) ), NULL, 0 );
|
|
}
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", "<empty>", NULL, 0 );
|
|
}
|
|
|
|
} else if ( token == "idExtrapolate" ) {
|
|
|
|
const idExtrapolate<float> *interpolate = ((idExtrapolate<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".extrapolationType", idStr( interpolate->GetExtrapolationType() ).c_str(), &interpolate->extrapolationType, sizeof( interpolate->extrapolationType ) );
|
|
Write( varName, varType, scope, prefix, ".startTime", idStr( interpolate->GetStartTime() ).c_str(), &interpolate->startTime, sizeof( interpolate->startTime ) );
|
|
Write( varName, varType, scope, prefix, ".duration", idStr( interpolate->GetDuration() ).c_str(), &interpolate->duration, sizeof( interpolate->duration ) );
|
|
|
|
if ( ParseTemplateArguments( typeSrc, templateArgs ) ) {
|
|
if ( templateArgs == "int" ) {
|
|
const idExtrapolate<int> *interpolate = ((idExtrapolate<int> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".baseSpeed", idStr( interpolate->GetBaseSpeed() ).c_str(), &interpolate->baseSpeed, sizeof( interpolate->baseSpeed ) );
|
|
Write( varName, varType, scope, prefix, ".speed", idStr( interpolate->GetSpeed() ).c_str(), &interpolate->speed, sizeof( interpolate->speed ) );
|
|
typeSize = sizeof( idExtrapolate<int> );
|
|
} else if ( templateArgs == "float" ) {
|
|
const idExtrapolate<float> *interpolate = ((idExtrapolate<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".baseSpeed", idStr( interpolate->GetBaseSpeed() ).c_str(), &interpolate->baseSpeed, sizeof( interpolate->baseSpeed ) );
|
|
Write( varName, varType, scope, prefix, ".speed", idStr( interpolate->GetSpeed() ).c_str(), &interpolate->speed, sizeof( interpolate->speed ) );
|
|
typeSize = sizeof( idExtrapolate<float> );
|
|
} else if ( templateArgs == "idVec3" ) {
|
|
const idExtrapolate<idVec3> *interpolate = ((idExtrapolate<idVec3> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", interpolate->GetStartValue().ToString( 8 ), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".baseSpeed", interpolate->GetBaseSpeed().ToString( 8 ), &interpolate->baseSpeed, sizeof( interpolate->baseSpeed ) );
|
|
Write( varName, varType, scope, prefix, ".speed", interpolate->GetSpeed().ToString( 8 ), &interpolate->speed, sizeof( interpolate->speed ) );
|
|
typeSize = sizeof( idExtrapolate<idVec3> );
|
|
} else if ( templateArgs == "idAngles" ) {
|
|
const idExtrapolate<idAngles> *interpolate = ((idExtrapolate<idAngles> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", interpolate->GetStartValue().ToString( 8 ), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".baseSpeed", interpolate->GetBaseSpeed().ToString( 8 ), &interpolate->baseSpeed, sizeof( interpolate->baseSpeed ) );
|
|
Write( varName, varType, scope, prefix, ".speed", interpolate->GetSpeed().ToString( 8 ), &interpolate->speed, sizeof( interpolate->speed ) );
|
|
typeSize = sizeof( idExtrapolate<idAngles> );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown template argument type '%s' for idExtrapolate>", templateArgs.c_str() ), NULL, 0 );
|
|
}
|
|
}
|
|
|
|
} else if ( token == "idInterpolate" ) {
|
|
|
|
const idInterpolate<float> *interpolate = ((idInterpolate<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startTime", idStr( interpolate->GetStartTime() ).c_str(), &interpolate->startTime, sizeof( interpolate->startTime ) );
|
|
Write( varName, varType, scope, prefix, ".duration", idStr( interpolate->GetDuration() ).c_str(), &interpolate->duration, sizeof( interpolate->duration ) );
|
|
|
|
if ( ParseTemplateArguments( typeSrc, templateArgs ) ) {
|
|
if ( templateArgs == "int" ) {
|
|
const idInterpolate<int> *interpolate = ((idInterpolate<int> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".endValue", idStr( interpolate->GetEndValue() ).c_str(), &interpolate->endValue, sizeof( interpolate->endValue ) );
|
|
typeSize = sizeof( idInterpolate<int> );
|
|
} else if ( templateArgs == "float" ) {
|
|
const idInterpolate<float> *interpolate = ((idInterpolate<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".endValue", idStr( interpolate->GetEndValue() ).c_str(), &interpolate->endValue, sizeof( interpolate->endValue ) );
|
|
typeSize = sizeof( idInterpolate<float> );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown template argument type '%s' for idInterpolate>", templateArgs.c_str() ), NULL, 0 );
|
|
}
|
|
}
|
|
|
|
} else if ( token == "idInterpolateAccelDecelLinear" ) {
|
|
|
|
const idInterpolateAccelDecelLinear<float> *interpolate = ((idInterpolateAccelDecelLinear<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startTime", idStr( interpolate->GetStartTime() ).c_str(), &interpolate->startTime, sizeof( interpolate->startTime ) );
|
|
Write( varName, varType, scope, prefix, ".accelTime", idStr( interpolate->GetAcceleration() ).c_str(), &interpolate->accelTime, sizeof( interpolate->accelTime ) );
|
|
Write( varName, varType, scope, prefix, ".linearTime", idStr( interpolate->linearTime ).c_str(), &interpolate->linearTime, sizeof( interpolate->linearTime ) );
|
|
Write( varName, varType, scope, prefix, ".decelTime", idStr( interpolate->GetDeceleration() ).c_str(), &interpolate->decelTime, sizeof( interpolate->decelTime ) );
|
|
|
|
if ( ParseTemplateArguments( typeSrc, templateArgs ) ) {
|
|
if ( templateArgs == "int" ) {
|
|
const idInterpolateAccelDecelLinear<int> *interpolate = ((idInterpolateAccelDecelLinear<int> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".endValue", idStr( interpolate->GetEndValue() ).c_str(), &interpolate->endValue, sizeof( interpolate->endValue ) );
|
|
typeSize = sizeof( idInterpolateAccelDecelLinear<int> );
|
|
} else if ( templateArgs == "float" ) {
|
|
const idInterpolateAccelDecelLinear<float> *interpolate = ((idInterpolateAccelDecelLinear<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".endValue", idStr( interpolate->GetEndValue() ).c_str(), &interpolate->endValue, sizeof( interpolate->endValue ) );
|
|
typeSize = sizeof( idInterpolateAccelDecelLinear<float> );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown template argument type '%s' for idInterpolateAccelDecelLinear>", templateArgs.c_str() ), NULL, 0 );
|
|
}
|
|
}
|
|
|
|
} else if ( token == "idInterpolateAccelDecelSine" ) {
|
|
|
|
const idInterpolateAccelDecelSine<float> *interpolate = ((idInterpolateAccelDecelSine<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startTime", idStr( interpolate->GetStartTime() ).c_str(), &interpolate->startTime, sizeof( interpolate->startTime ) );
|
|
Write( varName, varType, scope, prefix, ".accelTime", idStr( interpolate->GetAcceleration() ).c_str(), &interpolate->accelTime, sizeof( interpolate->accelTime ) );
|
|
Write( varName, varType, scope, prefix, ".linearTime", idStr( interpolate->linearTime ).c_str(), &interpolate->linearTime, sizeof( interpolate->linearTime ) );
|
|
Write( varName, varType, scope, prefix, ".decelTime", idStr( interpolate->GetDeceleration() ).c_str(), &interpolate->decelTime, sizeof( interpolate->decelTime ) );
|
|
|
|
if ( ParseTemplateArguments( typeSrc, templateArgs ) ) {
|
|
if ( templateArgs == "int" ) {
|
|
const idInterpolateAccelDecelSine<int> *interpolate = ((idInterpolateAccelDecelSine<int> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".endValue", idStr( interpolate->GetEndValue() ).c_str(), &interpolate->endValue, sizeof( interpolate->endValue ) );
|
|
typeSize = sizeof( idInterpolateAccelDecelSine<int> );
|
|
} else if ( templateArgs == "float" ) {
|
|
const idInterpolateAccelDecelSine<float> *interpolate = ((idInterpolateAccelDecelSine<float> *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".startValue", idStr( interpolate->GetStartValue() ).c_str(), &interpolate->startValue, sizeof( interpolate->startValue ) );
|
|
Write( varName, varType, scope, prefix, ".endValue", idStr( interpolate->GetEndValue() ).c_str(), &interpolate->endValue, sizeof( interpolate->endValue ) );
|
|
typeSize = sizeof( idInterpolateAccelDecelSine<float> );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown template argument type '%s' for idInterpolateAccelDecelSine>", templateArgs.c_str() ), NULL, 0 );
|
|
}
|
|
}
|
|
|
|
} else if ( token == "idUserInterface" ) {
|
|
|
|
typeSize = sizeof( idUserInterface );
|
|
const idUserInterface *gui = ((idUserInterface *)varPtr);
|
|
Write( varName, varType, scope, prefix, "", gui->Name(), varPtr, sizeof( varPtr ) );
|
|
|
|
} else if ( token == "idRenderModel" ) {
|
|
|
|
typeSize = sizeof( idRenderModel );
|
|
const idRenderModel *model = ((idRenderModel *)varPtr);
|
|
Write( varName, varType, scope, prefix, "", model->Name(), varPtr, sizeof( varPtr ) );
|
|
|
|
} else if ( token == "qhandle_t" ) {
|
|
|
|
typeSize = sizeof( int );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((int *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "cmHandle_t" ) {
|
|
|
|
typeSize = sizeof( int );
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((int *)varPtr) ), varPtr, typeSize );
|
|
|
|
} else if ( token == "idEntityPtr" ) {
|
|
|
|
typeSize = sizeof( idEntityPtr<idEntity> );
|
|
|
|
const idEntityPtr<idEntity> *entPtr = ((idEntityPtr<idEntity> *)varPtr);
|
|
if ( entPtr->GetEntity() ) {
|
|
idEntity *entity = entPtr->GetEntity();
|
|
Write( varName, varType, scope, prefix, ".", va( "entity %d: \'%s\'", entity->entityNumber, entity->name.c_str() ), varPtr, typeSize );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", "<NULL>", varPtr, typeSize );
|
|
}
|
|
|
|
} else if ( token == "idEntity::entityFlags_s" ) {
|
|
|
|
const idEntity::entityFlags_s *flags = ((idEntity::entityFlags_s *)varPtr);
|
|
Write( varName, varType, scope, prefix, ".notarget", flags->notarget ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".noknockback", flags->noknockback ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".takedamage", flags->takedamage ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".hidden", flags->hidden ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".bindOrientated", flags->bindOrientated ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".solidForTeam", flags->solidForTeam ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".forcePhysicsUpdate", flags->forcePhysicsUpdate ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".selected", flags->selected ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".neverDormant", flags->neverDormant ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".isDormant", flags->isDormant ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".hasAwakened", flags->hasAwakened ? "true" : "false", NULL, 0 );
|
|
Write( varName, varType, scope, prefix, ".networkSync", flags->networkSync ? "true" : "false", NULL, 0 );
|
|
typeSize = sizeof( idEntity::entityFlags_s );
|
|
|
|
} else if ( token == "idScriptBool" ) {
|
|
|
|
typeSize = sizeof( idScriptBool );
|
|
|
|
const idScriptBool *scriptBool = ((idScriptBool *)varPtr);
|
|
if ( scriptBool->IsLinked() ) {
|
|
Write( varName, varType, scope, prefix, "", ( *scriptBool != 0 ) ? "true" : "false", varPtr, typeSize );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", "<not linked>", varPtr, typeSize );
|
|
}
|
|
|
|
} else {
|
|
|
|
const classTypeInfo_t *classTypeInfo = FindClassInfo( scope + ( "::" + token ) );
|
|
if ( classTypeInfo == NULL ) {
|
|
classTypeInfo = FindClassInfo( token );
|
|
}
|
|
if ( classTypeInfo != NULL ) {
|
|
|
|
typeSize = classTypeInfo->size;
|
|
|
|
if ( !isPointer ) {
|
|
|
|
char newPrefix[1024];
|
|
idStr::snPrintf( newPrefix, sizeof( newPrefix ), "%s%s::%s.", prefix, scope, varName );
|
|
WriteClass_r( varPtr, "", token, token, newPrefix, pointerDepth );
|
|
|
|
} else if ( token == "idAnim" ) {
|
|
|
|
const idAnim *anim = ((idAnim*)varPtr);
|
|
Write( varName, varType, scope, prefix, "", anim->Name(), NULL, 0 );
|
|
|
|
} else if ( token == "idPhysics" ) {
|
|
|
|
const idPhysics *physics = ((idPhysics*)varPtr);
|
|
Write( varName, varType, scope, prefix, "", physics->GetType()->classname, NULL, 0 );
|
|
|
|
} else if ( IsSubclassOf( token, "idEntity" ) ) {
|
|
|
|
const idEntity *entity = ((idEntity*)varPtr);
|
|
Write( varName, varType, scope, prefix, "", va( "entity %d: \'%s\'", entity->entityNumber, entity->name.c_str() ), NULL, 0 );
|
|
|
|
} else if ( IsSubclassOf( token, "idDecl" ) ) {
|
|
|
|
const idDecl *decl = ((idDecl *)varPtr);
|
|
Write( varName, varType, scope, prefix, "", decl->GetName(), NULL, 0 );
|
|
|
|
} else if ( pointerDepth == 0 && (
|
|
token == "idAFBody" ||
|
|
token == "idAFTree" ||
|
|
token == "idClipModel" ||
|
|
IsSubclassOf( token, "idAFConstraint" )
|
|
) ) {
|
|
|
|
char newPrefix[1024];
|
|
idStr::snPrintf( newPrefix, sizeof( newPrefix ), "%s%s::%s->", prefix, scope, varName );
|
|
WriteClass_r( varPtr, "", token, token, newPrefix, pointerDepth + 1 );
|
|
|
|
} else {
|
|
|
|
Write( varName, varType, scope, prefix, "", va( "<pointer type '%s' not listed>", varType ), NULL, 0 );
|
|
return -1;
|
|
}
|
|
} else {
|
|
const enumTypeInfo_t *enumTypeInfo = FindEnumInfo( scope + ( "::" + token ) );
|
|
if ( enumTypeInfo == NULL ) {
|
|
enumTypeInfo = FindEnumInfo( token );
|
|
}
|
|
if ( enumTypeInfo != NULL ) {
|
|
|
|
typeSize = sizeof( int ); // NOTE: assuming sizeof( enum ) is sizeof( int )
|
|
|
|
for ( i = 0; enumTypeInfo->values[i].name != NULL; i++ ) {
|
|
if ( *((int *)varPtr) == enumTypeInfo->values[i].value ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( enumTypeInfo->values[i].name != NULL ) {
|
|
Write( varName, varType, scope, prefix, "", enumTypeInfo->values[i].name, NULL, 0 );
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "%d", *((int *)varPtr) ), NULL, 0 );
|
|
}
|
|
|
|
} else {
|
|
Write( varName, varType, scope, prefix, "", va( "<unknown type '%s'>", varType ), NULL, 0 );
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
i = 0;
|
|
do {
|
|
// flibit: 64 bit fix, changed long to int
|
|
if ( *((unsigned int *)varPtr) == 0xcdcdcdcd ) {
|
|
// flibit end
|
|
common->Warning( "%s%s::%s%s uses uninitialized memory", prefix, scope, varName, "" );
|
|
break;
|
|
}
|
|
} while( ++i < typeSize );
|
|
|
|
if ( isPointer ) {
|
|
return sizeof( void * );
|
|
}
|
|
return typeSize;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::WriteClass_r
|
|
================
|
|
*/
|
|
void idTypeInfoTools::WriteClass_r( const void *classPtr, const char *className, const char *classType, const char *scope, const char *prefix, const int pointerDepth ) {
|
|
int i;
|
|
|
|
const classTypeInfo_t *classInfo = FindClassInfo( classType );
|
|
if ( !classInfo ) {
|
|
return;
|
|
}
|
|
if ( *classInfo->superType != '\0' ) {
|
|
WriteClass_r( classPtr, className, classInfo->superType, scope, prefix, pointerDepth );
|
|
}
|
|
|
|
for ( i = 0; classInfo->variables[i].name != NULL; i++ ) {
|
|
const classVariableInfo_t &classVar = classInfo->variables[i];
|
|
|
|
void *varPtr = (void *) (((byte *)classPtr) + classVar.offset);
|
|
|
|
WriteVariable_r( varPtr, classVar.name, classVar.type, classType, prefix, pointerDepth );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::WriteGameState
|
|
================
|
|
*/
|
|
void idTypeInfoTools::WriteGameState( const char *fileName ) {
|
|
int i, num;
|
|
idFile *file;
|
|
|
|
file = fileSystem->OpenFileWrite( fileName );
|
|
if ( !file ) {
|
|
common->Warning( "couldn't open %s", fileName );
|
|
return;
|
|
}
|
|
|
|
fp = file;
|
|
Write = WriteGameStateVariable; //WriteVariable;
|
|
|
|
#ifdef DUMP_GAMELOCAL
|
|
|
|
file->WriteFloatString( "\ngameLocal {\n" );
|
|
WriteClass_r( (void *)&gameLocal, "", "idGameLocal", "idGameLocal", "", 0 );
|
|
file->WriteFloatString( "}\n" );
|
|
|
|
#endif
|
|
|
|
for ( num = i = 0; i < gameLocal.num_entities; i++ ) {
|
|
idEntity *ent = gameLocal.entities[i];
|
|
if ( ent == NULL ) {
|
|
continue;
|
|
}
|
|
file->WriteFloatString( "\nentity %d %s {\n", i, ent->GetType()->classname );
|
|
WriteClass_r( (void *)ent, "", ent->GetType()->classname, ent->GetType()->classname, "", 0 );
|
|
file->WriteFloatString( "}\n" );
|
|
num++;
|
|
}
|
|
|
|
fileSystem->CloseFile( file );
|
|
|
|
common->Printf( "%d entities written\n", num );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idTypeInfoTools::CompareGameState
|
|
================
|
|
*/
|
|
void idTypeInfoTools::CompareGameState( const char *fileName ) {
|
|
int entityNum;
|
|
idToken token;
|
|
|
|
src = new idLexer();
|
|
src->SetFlags( LEXFL_NOSTRINGESCAPECHARS );
|
|
|
|
if ( !src->LoadFile( fileName ) ) {
|
|
common->Warning( "couldn't load %s", fileName );
|
|
delete src;
|
|
src = NULL;
|
|
return;
|
|
}
|
|
|
|
fp = NULL;
|
|
Write = VerifyVariable;
|
|
|
|
#ifdef DUMP_GAMELOCAL
|
|
|
|
if ( !src->ExpectTokenString( "gameLocal" ) || !src->ExpectTokenString( "{" ) ) {
|
|
delete src;
|
|
src = NULL;
|
|
return;
|
|
}
|
|
|
|
WriteClass_r( (void *)&gameLocal, "", "idGameLocal", "idGameLocal", "", 0 );
|
|
|
|
if ( !src->ExpectTokenString( "}" ) ) {
|
|
delete src;
|
|
src = NULL;
|
|
return;
|
|
}
|
|
|
|
#endif
|
|
|
|
while( src->ReadToken( &token ) ) {
|
|
if ( token != "entity" ) {
|
|
break;
|
|
}
|
|
if ( !src->ExpectTokenType( TT_NUMBER, TT_INTEGER, &token ) ) {
|
|
break;
|
|
}
|
|
|
|
entityNum = token.GetIntValue();
|
|
|
|
if ( entityNum < 0 || entityNum >= gameLocal.num_entities ) {
|
|
src->Warning( "entity number %d out of range", entityNum );
|
|
break;
|
|
}
|
|
|
|
typeError = false;
|
|
|
|
idEntity *ent = gameLocal.entities[entityNum];
|
|
if ( !ent ) {
|
|
src->Warning( "entity %d is not spawned", entityNum );
|
|
src->SkipBracedSection( true );
|
|
continue;
|
|
}
|
|
|
|
if ( !src->ExpectTokenType( TT_NAME, 0, &token ) ) {
|
|
break;
|
|
}
|
|
|
|
if ( token.Cmp( ent->GetType()->classname ) != 0 ) {
|
|
src->Warning( "entity %d has wrong type", entityNum );
|
|
src->SkipBracedSection( true );
|
|
continue;
|
|
}
|
|
|
|
if ( !src->ExpectTokenString( "{" ) ) {
|
|
src->Warning( "entity %d missing leading {", entityNum );
|
|
break;
|
|
}
|
|
|
|
WriteClass_r( (void *)ent, "", ent->GetType()->classname, ent->GetType()->classname, "", 0 );
|
|
|
|
if ( !src->SkipBracedSection( false ) ) {
|
|
src->Warning( "entity %d missing trailing }", entityNum );
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete src;
|
|
src = NULL;
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteGameState_f
|
|
================
|
|
*/
|
|
void WriteGameState_f( const idCmdArgs &args ) {
|
|
idStr fileName;
|
|
|
|
if ( args.Argc() > 1 ) {
|
|
fileName = args.Argv(1);
|
|
} else {
|
|
fileName = "GameState.txt";
|
|
}
|
|
fileName.SetFileExtension( "gameState.txt" );
|
|
|
|
idTypeInfoTools::WriteGameState( fileName );
|
|
}
|
|
|
|
/*
|
|
================
|
|
CompareGameState_f
|
|
================
|
|
*/
|
|
void CompareGameState_f( const idCmdArgs &args ) {
|
|
idStr fileName;
|
|
|
|
if ( args.Argc() > 1 ) {
|
|
fileName = args.Argv(1);
|
|
} else {
|
|
fileName = "GameState.txt";
|
|
}
|
|
fileName.SetFileExtension( "gameState.txt" );
|
|
|
|
idTypeInfoTools::CompareGameState( fileName );
|
|
}
|
|
|
|
/*
|
|
================
|
|
TestSaveGame_f
|
|
================
|
|
*/
|
|
void TestSaveGame_f( const idCmdArgs &args ) {
|
|
idStr name;
|
|
|
|
if ( args.Argc() <= 1 ) {
|
|
gameLocal.Printf( "testSaveGame <mapName>\n" );
|
|
return;
|
|
}
|
|
|
|
name = args.Argv( 1 );
|
|
|
|
try {
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "map %s", name.c_str() ) );
|
|
name.Replace( "\\", "_" );
|
|
name.Replace( "/", "_" );
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "saveGame test_%s", name.c_str() ) );
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "loadGame test_%s", name.c_str() ) );
|
|
}
|
|
catch( idException & ) {
|
|
// an ERR_DROP was thrown
|
|
}
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, "quit" );
|
|
}
|
|
|
|
/*
|
|
================
|
|
WriteTypeToFile
|
|
================
|
|
*/
|
|
void WriteTypeToFile( idFile *fp, const void *typePtr, const char *typeName ) {
|
|
idTypeInfoTools::WriteTypeToFile( fp, typePtr, typeName );
|
|
}
|
|
|
|
/*
|
|
================
|
|
PrintType
|
|
================
|
|
*/
|
|
void PrintType( const void *typePtr, const char *typeName ) {
|
|
idTypeInfoTools::PrintType( typePtr, typeName );
|
|
}
|
|
|
|
/*
|
|
================
|
|
InitTypeVariables
|
|
================
|
|
*/
|
|
void InitTypeVariables( const void *typePtr, const char *typeName, int value ) {
|
|
idTypeInfoTools::InitTypeVariables( typePtr, typeName, value );
|
|
}
|
|
|
|
/*
|
|
================
|
|
ListTypeInfo_f
|
|
================
|
|
*/
|
|
int SortTypeInfoByName( const int *a, const int *b ) {
|
|
return idStr::Icmp( classTypeInfo[*a].typeName, classTypeInfo[*b].typeName );
|
|
}
|
|
|
|
int SortTypeInfoBySize( const int *a, const int *b ) {
|
|
if ( classTypeInfo[*a].size < classTypeInfo[*b].size ) {
|
|
return -1;
|
|
}
|
|
if ( classTypeInfo[*a].size > classTypeInfo[*b].size ) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void ListTypeInfo_f( const idCmdArgs &args ) {
|
|
int i, j;
|
|
idList<int> index;
|
|
|
|
common->Printf( "%-32s : %-32s size (B)\n", "type name", "super type name" );
|
|
for ( i = 0; classTypeInfo[i].typeName != NULL; i++ ) {
|
|
index.Append( i );
|
|
}
|
|
|
|
if ( args.Argc() > 1 && idStr::Icmp( args.Argv( 1 ), "size" ) == 0 ) {
|
|
index.Sort( SortTypeInfoBySize );
|
|
} else {
|
|
index.Sort( SortTypeInfoByName );
|
|
}
|
|
|
|
for ( i = 0; classTypeInfo[i].typeName != NULL; i++ ) {
|
|
j = index[i];
|
|
common->Printf( "%-32s : %-32s %d\n", classTypeInfo[j].typeName, classTypeInfo[j].superType, classTypeInfo[j].size );
|
|
}
|
|
}
|