TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-04-29 16:25:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Type information for Properties in EngineXMLExport

Browse source
This commit is contained in:
Lukas Joergensen 2018-04-21 09:08:26 +02:00
parent c1a234cae6
commit fb412ff108
3 changed files with 395 additions and 363 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Engine/source/console/consoleObject.h
View file

@ -676,6 +676,8 @@ public:
prop.mFlags |= EnginePropertyGroupBegin; prop.mFlags |= EnginePropertyGroupBegin;
if (sg_tempFieldList[i].type == EndGroupFieldType) if (sg_tempFieldList[i].type == EndGroupFieldType)
prop.mFlags |= EnginePropertyGroupEnd; prop.mFlags |= EnginePropertyGroupEnd;
prop.mType = sg_tempFieldList[i].type;
props[i] = prop; props[i] = prop;
} }

6
Engine/source/console/engineTypeInfo.h
View file

@ -231,6 +231,9 @@ class EnginePropertyTable
/// Combination of EnginePropertyFlags. /// Combination of EnginePropertyFlags.
U32 mFlags; U32 mFlags;
/// Type-id of the property
U32 mType;
/// Return the name of the property. /// Return the name of the property.
const char* getName() const { return mName; } const char* getName() const { return mName; }
@ -255,6 +258,9 @@ class EnginePropertyTable
/// ///
bool hideInInspectors() const { return ( mFlags & EnginePropertyHideInInspectors ); } bool hideInInspectors() const { return ( mFlags & EnginePropertyHideInInspectors ); }
/// Return the type-id of the property.
U32 getType() const { return mType; }
}; };
protected: protected:

750
Engine/source/console/engineXMLExport.cpp
View file

@ -35,32 +35,32 @@
/// actually having to access them directly in the DLL as native entities. /// actually having to access them directly in the DLL as native entities.
static void exportScope( const EngineExportScope* scope, SimXMLDocument* xml, bool addNode = false ); static void exportScope(const EngineExportScope* scope, SimXMLDocument* xml, bool addNode = false);
static String getTypeName( const EngineTypeInfo* type ) static String getTypeName(const EngineTypeInfo* type)
{ {
if( !type ) if (!type)
{ {
static String sVoid( "void" ); static String sVoid("void");
return sVoid; return sVoid;
} }
return type->getFullyQualifiedExportName(); return type->getFullyQualifiedExportName();
} }
static const char* getDocString( const EngineExport* exportInfo ) static const char* getDocString(const EngineExport* exportInfo)
{ {
if( !exportInfo->getDocString() ) if (!exportInfo->getDocString())
return ""; return "";
return exportInfo->getDocString(); return exportInfo->getDocString();
} }
template< typename T > template< typename T >
inline T getArgValue( const EngineFunctionDefaultArguments* defaultArgs, U32 offset ) inline T getArgValue(const EngineFunctionDefaultArguments* defaultArgs, U32 offset)
{ {
return *reinterpret_cast< const T* >( defaultArgs->getArgs() + offset ); return *reinterpret_cast< const T* >(defaultArgs->getArgs() + offset);
} }
@ -71,14 +71,14 @@ static const char* sExportFilterList[] =
"Console", // Console namespace "Console", // Console namespace
}; };
static bool isExportFiltered( const EngineExport* exportInfo ) static bool isExportFiltered(const EngineExport* exportInfo)
{ {
String qualifiedName = exportInfo->getFullyQualifiedExportName(); String qualifiedName = exportInfo->getFullyQualifiedExportName();
for( U32 i = 0; i < ( sizeof( sExportFilterList ) / sizeof( sExportFilterList[ 0 ] ) ); ++ i ) for (U32 i = 0; i < (sizeof(sExportFilterList) / sizeof(sExportFilterList[0])); ++i)
if( qualifiedName.compare( sExportFilterList[ i ] ) == 0 ) if (qualifiedName.compare(sExportFilterList[i]) == 0)
return true; return true;
return false; return false;
} }
@ -90,248 +90,248 @@ static bool isExportFiltered( const EngineExport* exportInfo )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/// Helper to parse argument names out of a prototype string. /// Helper to parse argument names out of a prototype string.
static Vector< String > parseFunctionArgumentNames( const EngineFunctionInfo* function ) static Vector< String > parseFunctionArgumentNames(const EngineFunctionInfo* function)
{ {
Vector< String > argNames; Vector< String > argNames;
const char* prototype = function->getPrototypeString(); const char* prototype = function->getPrototypeString();
if( !prototype ) if (!prototype)
return argNames; return argNames;
const U32 prototypeLength = dStrlen( prototype ); const U32 prototypeLength = dStrlen(prototype);
const char* prototypeEnd = &prototype[ prototypeLength ]; const char* prototypeEnd = &prototype[prototypeLength];
const char* ptr = prototypeEnd - 1; const char* ptr = prototypeEnd - 1;
// Search for right parenthesis. // Search for right parenthesis.
while( ptr >= prototype && *ptr != ')' ) while (ptr >= prototype && *ptr != ')')
ptr --; ptr--;
if( ptr < prototype ) if (ptr < prototype)
return argNames; return argNames;
ptr --; ptr--;
while( ptr >= prototype && *ptr != '(' ) while (ptr >= prototype && *ptr != '(')
{ {
// Skip back over spaces. // Skip back over spaces.
while( ptr >= prototype && dIsspace( *ptr ) ) while (ptr >= prototype && dIsspace(*ptr))
ptr --; ptr--;
if( ptr < prototype ) if (ptr < prototype)
return argNames; return argNames;
// Parse out name. // Parse out name.
const char* end = ptr + 1; const char* end = ptr + 1;
while( ptr > prototype && dIsalnum( *ptr ) ) while (ptr > prototype && dIsalnum(*ptr))
ptr --; ptr--;
const char* start = ptr + 1; const char* start = ptr + 1;
// Skip back over spaces. // Skip back over spaces.
while( ptr >= prototype && dIsspace( *ptr ) ) while (ptr >= prototype && dIsspace(*ptr))
ptr --; ptr--;
// If we're sure we don't have just a type name without an // If we're sure we don't have just a type name without an
// argument name, copy out the argument name name. // argument name, copy out the argument name name.
if( ptr >= prototype && *ptr != ',' && *ptr != '(' && end > start ) if (ptr >= prototype && *ptr != ',' && *ptr != '(' && end > start)
argNames.push_front( String( start, end - start ) ); argNames.push_front(String(start, end - start));
else else
argNames.push_front( "" ); argNames.push_front("");
// Skip back to comma or opening parenthesis. // Skip back to comma or opening parenthesis.
U32 parenNestingCount = 0; U32 parenNestingCount = 0;
while( ptr >= prototype ) while (ptr >= prototype)
{ {
if( *ptr == ')' ) if (*ptr == ')')
parenNestingCount ++; parenNestingCount++;
else if( *ptr == '(' ) else if (*ptr == '(')
parenNestingCount --; parenNestingCount--;
else if( *ptr == ',' && parenNestingCount == 0 ) else if (*ptr == ',' && parenNestingCount == 0)
{ {
ptr --; ptr--;
break; break;
} }
else if( *ptr == '(' && parenNestingCount == 0 ) else if (*ptr == '(' && parenNestingCount == 0)
break; break;
ptr --; ptr--;
} }
} }
// Add 'this' parameter if this is a method. // Add 'this' parameter if this is a method.
if( dStrncmp( prototype, "virtual ", sizeof( "virtual " ) - 1 ) == 0 ) if (dStrncmp(prototype, "virtual ", sizeof("virtual ") - 1) == 0)
argNames.push_front( "this" ); argNames.push_front("this");
return argNames; return argNames;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static String getDefaultArgumentValue( const EngineFunctionInfo* function, const EngineTypeInfo* type, U32 offset ) static String getDefaultArgumentValue(const EngineFunctionInfo* function, const EngineTypeInfo* type, U32 offset)
{ {
String value; String value;
const EngineFunctionDefaultArguments* defaultArgs = function->getDefaultArguments(); const EngineFunctionDefaultArguments* defaultArgs = function->getDefaultArguments();
switch( type->getTypeKind() ) switch (type->getTypeKind())
{ {
case EngineTypeKindPrimitive: case EngineTypeKindPrimitive:
{ {
#define PRIMTYPE( tp ) \ #define PRIMTYPE( tp ) \
if( TYPE< tp >() == type ) \ if( TYPE< tp >() == type ) \
{ \ { \
tp val = getArgValue< tp >( defaultArgs, offset ); \ tp val = getArgValue< tp >( defaultArgs, offset ); \
value = String::ToString( val ); \ value = String::ToString( val ); \
} }
PRIMTYPE( bool ); PRIMTYPE(bool);
PRIMTYPE( S8 ); PRIMTYPE(S8);
PRIMTYPE( U8 ); PRIMTYPE(U8);
PRIMTYPE( S32 ); PRIMTYPE(S32);
PRIMTYPE( U32 ); PRIMTYPE(U32);
PRIMTYPE( F32 ); PRIMTYPE(F32);
PRIMTYPE( F64 ); PRIMTYPE(F64);
//TODO: for now we store string literals in ASCII; needs to be sorted out //TODO: for now we store string literals in ASCII; needs to be sorted out
if( TYPE< const char* >() == type ) if (TYPE< const char* >() == type)
{
const char* val = reinterpret_cast< const char* >(defaultArgs->getArgs() + offset);
value = val;
}
#undef PRIMTYPE
break;
}
case EngineTypeKindEnum:
{ {
S32 val = getArgValue< S32 >( defaultArgs, offset ); const char* val = reinterpret_cast<const char*>(defaultArgs->getArgs() + offset);
AssertFatal( type->getEnumTable(), "engineXMLExport - Enum type without table!" ); value = val;
const EngineEnumTable& table = *( type->getEnumTable() );
const U32 numValues = table.getNumValues();
for( U32 i = 0; i < numValues; ++ i )
if( table[ i ].getInt() == val )
{
value = table[ i ].getName();
break;
}
break;
} }
case EngineTypeKindBitfield: #undef PRIMTYPE
{ break;
S32 val = getArgValue< S32 >( defaultArgs, offset );
AssertFatal( type->getEnumTable(), "engineXMLExport - Bitfield type without table!" );
const EngineEnumTable& table = *( type->getEnumTable() );
const U32 numValues = table.getNumValues();
bool isFirst = true;
for( U32 i = 0; i < numValues; ++ i )
if( table[ i ].getInt() & val )
{
if( !isFirst )
value += '|';
value = table[ i ].getName();
isFirst = false;
}
break;
}
case EngineTypeKindStruct:
{
//TODO: struct type default argument values
break;
}
case EngineTypeKindClass:
case EngineTypeKindFunction:
{
// For these two kinds, we support "null" as the only valid
// default value.
const void* ptr = getArgValue< const void* >( defaultArgs, offset );
if( !ptr )
value = "null";
break;
}
default:
break;
} }
case EngineTypeKindEnum:
{
S32 val = getArgValue< S32 >(defaultArgs, offset);
AssertFatal(type->getEnumTable(), "engineXMLExport - Enum type without table!");
const EngineEnumTable& table = *(type->getEnumTable());
const U32 numValues = table.getNumValues();
for (U32 i = 0; i < numValues; ++i)
if (table[i].getInt() == val)
{
value = table[i].getName();
break;
}
break;
}
case EngineTypeKindBitfield:
{
S32 val = getArgValue< S32 >(defaultArgs, offset);
AssertFatal(type->getEnumTable(), "engineXMLExport - Bitfield type without table!");
const EngineEnumTable& table = *(type->getEnumTable());
const U32 numValues = table.getNumValues();
bool isFirst = true;
for (U32 i = 0; i < numValues; ++i)
if (table[i].getInt() & val)
{
if (!isFirst)
value += '|';
value = table[i].getName();
isFirst = false;
}
break;
}
case EngineTypeKindStruct:
{
//TODO: struct type default argument values
break;
}
case EngineTypeKindClass:
case EngineTypeKindFunction:
{
// For these two kinds, we support "null" as the only valid
// default value.
const void* ptr = getArgValue< const void* >(defaultArgs, offset);
if (!ptr)
value = "null";
break;
}
default:
break;
}
return value; return value;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void exportFunction( const EngineFunctionInfo* function, SimXMLDocument* xml ) static void exportFunction(const EngineFunctionInfo* function, SimXMLDocument* xml)
{ {
if( isExportFiltered( function ) ) if (isExportFiltered(function))
return; return;
xml->pushNewElement( "EngineFunction" );
xml->setAttribute( "name", function->getExportName() );
xml->setAttribute( "returnType", getTypeName( function->getReturnType() ) );
xml->setAttribute( "symbol", function->getBindingName() );
xml->setAttribute( "isCallback", function->isCallout() ? "1" : "0" );
xml->setAttribute( "isVariadic", function->getFunctionType()->isVariadic() ? "1" : "0" );
xml->setAttribute( "docs", getDocString( function ) );
xml->pushNewElement( "arguments" );
const U32 numArguments = function->getNumArguments();
const U32 numDefaultArguments = ( function->getDefaultArguments() ? function->getDefaultArguments()->mNumDefaultArgs : 0 );
const U32 firstDefaultArg = numArguments - numDefaultArguments;
Vector< String > argumentNames = parseFunctionArgumentNames( function );
const U32 numArgumentNames = argumentNames.size();
// Accumulated offset in function argument frame vector.
U32 argFrameOffset = 0;
for( U32 i = 0; i < numArguments; ++ i )
{
xml->pushNewElement( "EngineFunctionArgument" );
const EngineTypeInfo* type = function->getArgumentType( i );
AssertFatal( type != NULL, "exportFunction - Argument cannot have type void!" );
String argName;
if( i < numArgumentNames )
argName = argumentNames[ i ];
xml->setAttribute( "name", argName );
xml->setAttribute( "type", getTypeName( type ) );
if( i >= firstDefaultArg )
{
String defaultValue = getDefaultArgumentValue( function, type, argFrameOffset );
xml->setAttribute( "defaultValue", defaultValue );
}
xml->popElement(); xml->pushNewElement("EngineFunction");
if( type->getTypeKind() == EngineTypeKindStruct ) xml->setAttribute("name", function->getExportName());
argFrameOffset += type->getInstanceSize(); xml->setAttribute("returnType", getTypeName(function->getReturnType()));
else xml->setAttribute("symbol", function->getBindingName());
argFrameOffset += type->getValueSize(); xml->setAttribute("isCallback", function->isCallout() ? "1" : "0");
xml->setAttribute("isVariadic", function->getFunctionType()->isVariadic() ? "1" : "0");
#ifdef _PACK_BUG_WORKAROUNDS xml->setAttribute("docs", getDocString(function));
if( argFrameOffset % 4 > 0 )
argFrameOffset += 4 - ( argFrameOffset % 4 ); xml->pushNewElement("arguments");
#endif
} const U32 numArguments = function->getNumArguments();
const U32 numDefaultArguments = (function->getDefaultArguments() ? function->getDefaultArguments()->mNumDefaultArgs : 0);
const U32 firstDefaultArg = numArguments - numDefaultArguments;
Vector< String > argumentNames = parseFunctionArgumentNames(function);
const U32 numArgumentNames = argumentNames.size();
// Accumulated offset in function argument frame vector.
U32 argFrameOffset = 0;
for (U32 i = 0; i < numArguments; ++i)
{
xml->pushNewElement("EngineFunctionArgument");
const EngineTypeInfo* type = function->getArgumentType(i);
AssertFatal(type != NULL, "exportFunction - Argument cannot have type void!");
String argName;
if (i < numArgumentNames)
argName = argumentNames[i];
xml->setAttribute("name", argName);
xml->setAttribute("type", getTypeName(type));
if (i >= firstDefaultArg)
{
String defaultValue = getDefaultArgumentValue(function, type, argFrameOffset);
xml->setAttribute("defaultValue", defaultValue);
}
xml->popElement(); xml->popElement();
if (type->getTypeKind() == EngineTypeKindStruct)
argFrameOffset += type->getInstanceSize();
else
argFrameOffset += type->getValueSize();
#ifdef _PACK_BUG_WORKAROUNDS
if (argFrameOffset % 4 > 0)
argFrameOffset += 4 - (argFrameOffset % 4);
#endif
}
xml->popElement();
xml->popElement(); xml->popElement();
} }
@ -343,148 +343,172 @@ static void exportFunction( const EngineFunctionInfo* function, SimXMLDocument*
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void exportType( const EngineTypeInfo* type, SimXMLDocument* xml ) static void exportType(const EngineTypeInfo* type, SimXMLDocument* xml)
{ {
// Don't export anonymous types. // Don't export anonymous types.
if( !type->getTypeName()[ 0 ] ) if (!type->getTypeName()[0])
return; return;
if( isExportFiltered( type ) )
return;
const char* nodeName = NULL;
switch( type->getTypeKind() )
{
case EngineTypeKindPrimitive:
nodeName = "EnginePrimitiveType";
break;
case EngineTypeKindEnum:
nodeName = "EngineEnumType";
break;
case EngineTypeKindBitfield:
nodeName = "EngineBitfieldType";
break;
case EngineTypeKindStruct:
nodeName = "EngineStructType";
break;
case EngineTypeKindClass:
nodeName = "EngineClassType";
break;
default:
return;
}
xml->pushNewElement( nodeName );
xml->setAttribute( "name", type->getTypeName() ); if (isExportFiltered(type))
xml->setAttribute( "size", String::ToString( type->getInstanceSize() ) ); return;
xml->setAttribute( "isAbstract", type->isAbstract() ? "1" : "0" );
xml->setAttribute( "isInstantiable", type->isInstantiable() ? "1" : "0" ); const char* nodeName = NULL;
xml->setAttribute( "isDisposable", type->isDisposable() ? "1" : "0" ); switch (type->getTypeKind())
xml->setAttribute( "isSingleton", type->isSingleton() ? "1" : "0" ); {
xml->setAttribute( "docs", getDocString( type ) ); case EngineTypeKindPrimitive:
nodeName = "EnginePrimitiveType";
if( type->getSuperType() ) break;
xml->setAttribute( "superType", getTypeName( type->getSuperType() ) );
case EngineTypeKindEnum:
if( type->getEnumTable() ) nodeName = "EngineEnumType";
break;
case EngineTypeKindBitfield:
nodeName = "EngineBitfieldType";
break;
case EngineTypeKindStruct:
nodeName = "EngineStructType";
break;
case EngineTypeKindClass:
nodeName = "EngineClassType";
break;
default:
return;
}
xml->pushNewElement(nodeName);
xml->setAttribute("name", type->getTypeName());
xml->setAttribute("size", String::ToString(type->getInstanceSize()));
xml->setAttribute("isAbstract", type->isAbstract() ? "1" : "0");
xml->setAttribute("isInstantiable", type->isInstantiable() ? "1" : "0");
xml->setAttribute("isDisposable", type->isDisposable() ? "1" : "0");
xml->setAttribute("isSingleton", type->isSingleton() ? "1" : "0");
xml->setAttribute("docs", getDocString(type));
if (type->getSuperType())
xml->setAttribute("superType", getTypeName(type->getSuperType()));
if (type->getEnumTable())
{
xml->pushNewElement("enums");
const EngineEnumTable& table = *(type->getEnumTable());
const U32 numValues = table.getNumValues();
for (U32 i = 0; i < numValues; ++i)
{ {
xml->pushNewElement( "enums" ); xml->pushNewElement("EngineEnum");
const EngineEnumTable& table = *( type->getEnumTable() ); xml->setAttribute("name", table[i].getName());
const U32 numValues = table.getNumValues(); xml->setAttribute("value", String::ToString(table[i].getInt()));
xml->setAttribute("docs", table[i].getDocString() ? table[i].getDocString() : "");
for( U32 i = 0; i < numValues; ++ i )
{
xml->pushNewElement( "EngineEnum" );
xml->setAttribute( "name", table[ i ].getName() );
xml->setAttribute( "value", String::ToString( table[ i ].getInt() ) );
xml->setAttribute( "docs", table[ i ].getDocString() ? table[ i ].getDocString() : "" );
xml->popElement();
}
xml->popElement(); xml->popElement();
} }
else if( type->getFieldTable() )
xml->popElement();
}
else if (type->getFieldTable())
{
xml->pushNewElement("fields");
const EngineFieldTable& table = *(type->getFieldTable());
const U32 numFields = table.getNumFields();
for (U32 i = 0; i < numFields; ++i)
{ {
xml->pushNewElement( "fields" ); const EngineFieldTable::Field& field = table[i];
const EngineFieldTable& table = *( type->getFieldTable() ); xml->pushNewElement("EngineField");
const U32 numFields = table.getNumFields();
xml->setAttribute("name", field.getName());
for( U32 i = 0; i < numFields; ++ i ) xml->setAttribute("type", getTypeName(field.getType()));
{ xml->setAttribute("offset", String::ToString(field.getOffset()));
const EngineFieldTable::Field& field = table[ i ]; xml->setAttribute("indexedSize", String::ToString(field.getNumElements()));
xml->setAttribute("docs", field.getDocString() ? field.getDocString() : "");
xml->pushNewElement( "EngineField" );
xml->setAttribute( "name", field.getName() );
xml->setAttribute( "type", getTypeName( field.getType() ) );
xml->setAttribute( "offset", String::ToString( field.getOffset() ) );
xml->setAttribute( "indexedSize", String::ToString( field.getNumElements() ) );
xml->setAttribute( "docs", field.getDocString() ? field.getDocString() : "" );
xml->popElement();
}
xml->popElement(); xml->popElement();
} }
else if( type->getPropertyTable() )
xml->popElement();
}
else if (type->getPropertyTable())
{
xml->pushNewElement("properties");
const EnginePropertyTable& table = *(type->getPropertyTable());
const U32 numProperties = table.getNumProperties();
U32 groupNestingDepth = 0;
for (U32 i = 0; i < numProperties; ++i)
{ {
xml->pushNewElement( "properties" ); const EnginePropertyTable::Property& property = table[i];
const EnginePropertyTable& table = *( type->getPropertyTable() ); if (property.isGroupBegin())
const U32 numProperties = table.getNumProperties(); {
U32 groupNestingDepth = 0; groupNestingDepth++;
xml->pushNewElement("EnginePropertyGroup");
for( U32 i = 0; i < numProperties; ++ i )
xml->setAttribute("name", property.getName());
xml->setAttribute("indexedSize", String::ToString(property.getNumElements()));
xml->setAttribute("docs", property.getDocString() ? property.getDocString() : "");
xml->pushNewElement("properties");
}
else if (property.isGroupEnd())
{
groupNestingDepth--;
xml->popElement();
xml->popElement();
}
else
{
if (property.getType() == AbstractClassRep::StartArrayFieldType
|| property.getType() == AbstractClassRep::EndArrayFieldType) {
continue;
}
xml->pushNewElement("EngineProperty");
xml->setAttribute("name", property.getName());
xml->setAttribute("indexedSize", String::ToString(property.getNumElements()));
xml->setAttribute("isConstant", property.isConstant() ? "1" : "0");
xml->setAttribute("isTransient", property.isTransient() ? "1" : "0");
xml->setAttribute("isVisible", property.hideInInspectors() ? "0" : "1");
xml->setAttribute("docs", property.getDocString() ? property.getDocString() : "");
const bool isDeprecated = (property.getType() == AbstractClassRep::DeprecatedFieldType);
if (isDeprecated)
{ {
const EnginePropertyTable::Property& property = table[ i ]; xml->setAttribute("type", "deprecated");
}
if( property.isGroupBegin() ) else
{
ConsoleBaseType *cbt = ConsoleBaseType::getType(property.getType());
if (cbt != NULL)
{ {
groupNestingDepth ++; xml->setAttribute("type", cbt->getTypeClassName());
xml->pushNewElement( "EnginePropertyGroup" );
xml->setAttribute( "name", property.getName() );
xml->setAttribute( "indexedSize", String::ToString( property.getNumElements() ) );
xml->setAttribute( "docs", property.getDocString() ? property.getDocString() : "" );
xml->pushNewElement( "properties" );
}
else if( property.isGroupEnd() )
{
groupNestingDepth --;
xml->popElement();
xml->popElement();
} }
else else
{ {
xml->pushNewElement( "EngineProperty" ); xml->setAttribute("type", "unknown");
xml->setAttribute( "name", property.getName() );
xml->setAttribute( "indexedSize", String::ToString( property.getNumElements() ) );
xml->setAttribute( "isConstant", property.isConstant() ? "1" : "0" );
xml->setAttribute( "isTransient", property.isTransient() ? "1" : "0" );
xml->setAttribute( "isVisible", property.hideInInspectors() ? "0" : "1" );
xml->setAttribute( "docs", property.getDocString() ? property.getDocString() : "" );
xml->popElement();
} }
} }
AssertFatal( !groupNestingDepth, "exportType - Property group nesting mismatch!" ); xml->popElement();
xml->popElement(); }
} }
exportScope( type, xml );
AssertFatal(!groupNestingDepth, "exportType - Property group nesting mismatch!");
xml->popElement();
}
exportScope(type, xml);
xml->popElement(); xml->popElement();
} }
@ -496,63 +520,63 @@ static void exportType( const EngineTypeInfo* type, SimXMLDocument* xml )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void exportScope( const EngineExportScope* scope, SimXMLDocument* xml, bool addNode ) static void exportScope(const EngineExportScope* scope, SimXMLDocument* xml, bool addNode)
{ {
if( addNode ) if (addNode)
{ {
if( isExportFiltered( scope ) ) if (isExportFiltered(scope))
return; return;
xml->pushNewElement( "EngineExportScope" ); xml->pushNewElement("EngineExportScope");
xml->setAttribute( "name", scope->getExportName() ); xml->setAttribute("name", scope->getExportName());
xml->setAttribute( "docs", getDocString( scope ) ); xml->setAttribute("docs", getDocString(scope));
} }
// Dump all contained exports. // Dump all contained exports.
xml->pushNewElement( "exports" ); xml->pushNewElement("exports");
for( const EngineExport* exportInfo = scope->getExports(); exportInfo != NULL; exportInfo = exportInfo->getNextExport() ) for (const EngineExport* exportInfo = scope->getExports(); exportInfo != NULL; exportInfo = exportInfo->getNextExport())
{
switch (exportInfo->getExportKind())
{ {
switch( exportInfo->getExportKind() ) case EngineExportKindScope:
{ exportScope(static_cast< const EngineExportScope* >(exportInfo), xml, true);
case EngineExportKindScope: break;
exportScope( static_cast< const EngineExportScope* >( exportInfo ), xml, true );
break; case EngineExportKindFunction:
exportFunction(static_cast< const EngineFunctionInfo* >(exportInfo), xml);
case EngineExportKindFunction: break;
exportFunction( static_cast< const EngineFunctionInfo* >( exportInfo ), xml );
break; case EngineExportKindType:
exportType(static_cast< const EngineTypeInfo* >(exportInfo), xml);
case EngineExportKindType: break;
exportType( static_cast< const EngineTypeInfo* >( exportInfo ), xml );
break; default:
break;
default:
break;
}
} }
}
xml->popElement(); xml->popElement();
if( addNode ) if (addNode)
xml->popElement(); xml->popElement();
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
DefineEngineFunction( exportEngineAPIToXML, SimXMLDocument*, (),, DefineEngineFunction(exportEngineAPIToXML, SimXMLDocument*, (), ,
"Create a XML document containing a dump of the entire exported engine API.\n\n" "Create a XML document containing a dump of the entire exported engine API.\n\n"
"@return A SimXMLDocument containing a dump of the engine's export information or NULL if the operation failed.\n\n" "@return A SimXMLDocument containing a dump of the engine's export information or NULL if the operation failed.\n\n"
"@ingroup Console" ) "@ingroup Console")
{ {
SimXMLDocument* xml = new SimXMLDocument; SimXMLDocument* xml = new SimXMLDocument;
xml->registerObject(); xml->registerObject();
Sim::getRootGroup()->addObject( xml ); Sim::getRootGroup()->addObject(xml);
xml->addHeader(); xml->addHeader();
exportScope( EngineExportScope::getGlobalScope(), xml, true ); exportScope(EngineExportScope::getGlobalScope(), xml, true);
return xml; return xml;
} }