TheCloud/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2025-09-10 12:28:48 -04:00
Code Issues Packages Projects Releases Wiki Activity

Simplify enum value alias handling. (#1523)

Browse Source 
* Simplify enum value handling.

* Simplified enum value generation
This commit is contained in:
Andreas Süßenbach 2023-03-06 08:37:40 +01:00 committed by GitHub
parent 81633480b9
commit 31554d2aca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 876 additions and 837 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

183
VulkanHppGenerator.cpp
View File

@ -792,10 +792,6 @@ void VulkanHppGenerator::checkCommandCorrectness() const
{ {
resultCodes.insert( rc.name ); resultCodes.insert( rc.name );
} }
for ( auto rc : resultIt->second.aliases )
{
resultCodes.insert( rc.first );
}
// command checks // command checks
for ( auto const & command : m_commands ) for ( auto const & command : m_commands )
@ -875,15 +871,14 @@ void VulkanHppGenerator::checkEnumCorrectness() const
assert( typeIt != m_types.end() ); assert( typeIt != m_types.end() );
checkForWarning( !typeIt->second.requiredBy.empty(), e.second.xmlLine, "enum <" + e.first + "> not required in any feature or extension" ); checkForWarning( !typeIt->second.requiredBy.empty(), e.second.xmlLine, "enum <" + e.first + "> not required in any feature or extension" );
// check that the aliasNames are known enum values or known aliases // check that the alias names are known enum values
for ( auto const & alias : e.second.aliases ) for ( auto const & value : e.second.values )
{ {
checkForError( checkForError( value.alias.empty() ||
( std::find_if( e.second.values.begin(), e.second.values.end(), [&alias]( EnumValueData const & evd ) { return evd.name == alias.second.name; } ) != ( std::find_if( e.second.values.begin(), e.second.values.end(), [&value]( auto const & evd ) { return evd.name == value.alias; } ) !=
e.second.values.end() ) || e.second.values.end() ),
( e.second.aliases.find( alias.second.name ) != e.second.aliases.end() ), value.xmlLine,
alias.second.xmlLine, "enum <" + value.name + "> uses unknown alias <" + value.alias + ">" );
"enum <" + alias.first + "> uses unknown alias <" + alias.second.name + ">" );
} }
} }
@ -905,13 +900,10 @@ void VulkanHppGenerator::checkEnumCorrectness() const
assert( enumIt->second.values.front().name == "VK_FORMAT_UNDEFINED" ); assert( enumIt->second.values.front().name == "VK_FORMAT_UNDEFINED" );
for ( auto enumValueIt = std::next( enumIt->second.values.begin() ); enumValueIt != enumIt->second.values.end(); ++enumValueIt ) for ( auto enumValueIt = std::next( enumIt->second.values.begin() ); enumValueIt != enumIt->second.values.end(); ++enumValueIt )
{ {
auto formatIt = m_formats.find( enumValueIt->name ); // check for non-alias formats only
if ( formatIt == m_formats.end() ) checkForError( !enumValueIt->alias.empty() || ( m_formats.find( enumValueIt->name ) != m_formats.end() ),
{ enumValueIt->xmlLine,
auto aliasIt = std::find_if( "missing format specification for <" + enumValueIt->name + ">" );
enumIt->second.aliases.begin(), enumIt->second.aliases.end(), [&enumValueIt]( auto const & ead ) { return ead.second.name == enumValueIt->name; } );
checkForError( aliasIt != enumIt->second.aliases.end(), enumValueIt->xmlLine, "missing format specification for <" + enumValueIt->name + ">" );
}
} }
} }
} }
@ -1105,10 +1097,11 @@ void VulkanHppGenerator::checkHandleCorrectness() const
{ {
if ( objectTypeValue.name != "VK_OBJECT_TYPE_UNKNOWN" ) if ( objectTypeValue.name != "VK_OBJECT_TYPE_UNKNOWN" )
{ {
checkForError( std::find_if( m_handles.begin(), // check for non-alias objectTypes only
checkForError( !objectTypeValue.alias.empty() || ( std::find_if( m_handles.begin(),
m_handles.end(), m_handles.end(),
[&objectTypeValue]( std::pair<std::string, HandleData> const & hd ) [&objectTypeValue]( std::pair<std::string, HandleData> const & hd )
{ return hd.second.objTypeEnum == objectTypeValue.name; } ) != m_handles.end(), { return hd.second.objTypeEnum == objectTypeValue.name; } ) != m_handles.end() ),
objectTypeValue.xmlLine, objectTypeValue.xmlLine,
"VkObjectType value <" + objectTypeValue.name + "> not specified as \"objtypeenum\" for any handle" ); "VkObjectType value <" + objectTypeValue.name + "> not specified as \"objtypeenum\" for any handle" );
} }
@ -1168,7 +1161,10 @@ void VulkanHppGenerator::checkStructCorrectness() const
} }
else else
{ {
checkForError( sTypeValues.erase( enumValue.name ) == 1, enumValue.xmlLine, "VkStructureType enum value <" + enumValue.name + "> never used" ); // check for non-alias structureTypes only
checkForError( !enumValue.alias.empty() || ( sTypeValues.erase( enumValue.name ) == 1 ),
enumValue.xmlLine,
"VkStructureType enum value <" + enumValue.name + "> never used" );
} }
} }
assert( sTypeValues.empty() ); assert( sTypeValues.empty() );
@ -2123,6 +2119,9 @@ std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskDa
bool encounteredFlag = false; bool encounteredFlag = false;
std::string previousEnter, previousLeave; std::string previousEnter, previousLeave;
for ( auto const & value : bitmaskBitsIt->second.values ) for ( auto const & value : bitmaskBitsIt->second.values )
{
// only list non-alias values in the allFlags trait
if ( value.alias.empty() )
{ {
// if the value's protect differs from the surrounding protect, generate protection code // if the value's protect differs from the surrounding protect, generate protection code
std::string enter, leave; std::string enter, leave;
@ -2131,12 +2130,13 @@ std::string VulkanHppGenerator::generateBitmask( std::map<std::string, BitmaskDa
tie( enter, leave ) = generateProtection( value.protect ); tie( enter, leave ) = generateProtection( value.protect );
} }
std::string valueName = generateEnumValueName( bitmaskBitsIt->first, value.name, true ); std::string valueName = generateEnumValueName( bitmaskBitsIt->first, value.name, true );
allFlags += allFlags += ( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " " + ( encounteredFlag ? "| " : " " ) + enumName +
( ( previousEnter != enter ) ? ( "\n" + previousLeave + enter ) : "\n" ) + " " + ( encounteredFlag ? "| " : " " ) + enumName + "::" + valueName; "::" + valueName;
encounteredFlag = true; encounteredFlag = true;
previousEnter = enter; previousEnter = enter;
previousLeave = leave; previousLeave = leave;
} }
}
if ( !previousLeave.empty() ) if ( !previousLeave.empty() )
{ {
allFlags += "\n" + previousLeave; allFlags += "\n" + previousLeave;
@ -4940,12 +4940,25 @@ std::string VulkanHppGenerator::generateEnum( std::pair<std::string, EnumData> c
bitmask = generateBitmask( bitmaskIt, surroundingProtect ); bitmask = generateBitmask( bitmaskIt, surroundingProtect );
} }
auto aliasEnumIt = findAlias( enumData.first, m_enumsAliases );
std::string enumValues, previousEnter, previousLeave; std::string enumValues, previousEnter, previousLeave;
#if !defined( NDEBUG )
std::map<std::string, std::string> valueToNameMap; std::map<std::string, std::string> valueToNameMap;
#else
std::set<std::string> valueSet;
#endif
for ( auto const & value : enumData.second.values ) for ( auto const & value : enumData.second.values )
{ {
assert( value.required ); assert( value.required );
std::string valueName = generateEnumValueName(
value.alias.empty() || ( aliasEnumIt == m_enumsAliases.end() ) ? enumData.first : aliasEnumIt->first, value.name, enumData.second.isBitmask );
#if !defined( NDEBUG )
auto valueToNameIt = valueToNameMap.find( valueName );
if ( valueToNameIt == valueToNameMap.end() )
#else
if ( valueSet.find( valueName ) == valueSet.end() )
#endif
{
// if the value's protect differs from the surrounding protect, generate protection code // if the value's protect differs from the surrounding protect, generate protection code
std::string enter, leave; std::string enter, leave;
if ( !value.protect.empty() && ( value.protect != surroundingProtect ) ) if ( !value.protect.empty() && ( value.protect != surroundingProtect ) )
@ -4956,47 +4969,53 @@ std::string VulkanHppGenerator::generateEnum( std::pair<std::string, EnumData> c
{ {
enumValues += previousLeave + enter; enumValues += previousLeave + enter;
} }
std::string valueName = generateEnumValueName( enumData.first, value.name, enumData.second.isBitmask );
enumValues += " " + valueName + " = " + value.name + ",\n"; enumValues += " " + valueName + " = " + value.name + ",\n";
assert( valueToNameMap.find( valueName ) == valueToNameMap.end() );
#if !defined( NDEBUG )
if ( value.alias.empty() )
{
valueToNameMap[valueName] = value.name; valueToNameMap[valueName] = value.name;
}
else
{
// map the aliasName to the name of the base
std::string baseName = value.name;
auto valueIt = std::find_if(
enumData.second.values.begin(), enumData.second.values.end(), [&baseName]( EnumValueData const & evd ) { return evd.name == baseName; } );
while ( !valueIt->alias.empty() )
{
baseName = valueIt->alias;
valueIt = std::find_if(
enumData.second.values.begin(), enumData.second.values.end(), [&baseName]( EnumValueData const & evd ) { return evd.name == baseName; } );
}
valueToNameMap[valueName] = baseName;
}
#else
valueSet.insert( valueName );
#endif
previousEnter = enter; previousEnter = enter;
previousLeave = leave; previousLeave = leave;
} }
enumValues += previousLeave;
auto aliasEnumIt = findAlias( enumData.first, m_enumsAliases );
for ( auto const & alias : enumData.second.aliases )
{
std::string aliasName =
generateEnumValueName( ( aliasEnumIt == m_enumsAliases.end() ) ? enumData.first : aliasEnumIt->first, alias.first, enumData.second.isBitmask );
// make sure to only list alias values that differ from all previous values
auto valueToNameIt = valueToNameMap.find( aliasName );
if ( valueToNameIt == valueToNameMap.end() )
{
enumValues += " " + aliasName + " = " + alias.first + ",\n";
// map the aliasName to the name of the base
std::string baseName = findBaseName( alias.second.name, enumData.second.aliases );
assert( std::find_if( enumData.second.values.begin(),
enumData.second.values.end(),
[&baseName]( EnumValueData const & evd ) { return evd.name == baseName; } ) != enumData.second.values.end() );
valueToNameMap[aliasName] = baseName;
}
#if !defined( NDEBUG ) #if !defined( NDEBUG )
else else
{ {
// verify, that the identical value represents the identical name // verify, that the identical value represents the identical name
std::string baseName = findBaseName( alias.second.name, enumData.second.aliases ); auto valueIt =
assert( std::find_if( enumData.second.values.begin(), std::find_if( enumData.second.values.begin(), enumData.second.values.end(), [&value]( EnumValueData const & evd ) { return evd.name == value.name; } );
enumData.second.values.end(), std::string baseName = valueIt->name;
[&baseName]( EnumValueData const & evd ) { return evd.name == baseName; } ) != enumData.second.values.end() ); while ( !valueIt->alias.empty() )
{
baseName = valueIt->alias;
valueIt = std::find_if(
enumData.second.values.begin(), enumData.second.values.end(), [&baseName]( EnumValueData const & evd ) { return evd.name == baseName; } );
}
assert( baseName == valueToNameIt->second ); assert( baseName == valueToNameIt->second );
} }
#endif #endif
} }
enumValues += previousLeave;
if ( !enumValues.empty() ) if ( !enumValues.empty() )
{ {
size_t pos = enumValues.rfind( ',' ); size_t pos = enumValues.rfind( ',' );
@ -5168,6 +5187,9 @@ std::string VulkanHppGenerator::generateEnumToString( std::pair<std::string, Enu
{ {
std::string cases, previousEnter, previousLeave; std::string cases, previousEnter, previousLeave;
for ( auto const & value : enumData.second.values ) for ( auto const & value : enumData.second.values )
{
// generate cases for non-alias enum values only
if ( value.alias.empty() )
{ {
auto [enter, leave] = generateProtection( value.protect ); auto [enter, leave] = generateProtection( value.protect );
if ( previousEnter != enter ) if ( previousEnter != enter )
@ -5184,6 +5206,7 @@ std::string VulkanHppGenerator::generateEnumToString( std::pair<std::string, Enu
previousEnter = enter; previousEnter = enter;
previousLeave = leave; previousLeave = leave;
} }
}
cases += previousLeave; cases += previousLeave;
const std::string functionBodyTemplate = const std::string functionBodyTemplate =
@ -5484,6 +5507,9 @@ ${texelsPerBlockCases}
componentPlaneIndexCases, componentsAreCompressedCases, compressionSchemeCases, packedCases, planeCompatibleCases, planeCountCases, planeHeightDivisorCases, componentPlaneIndexCases, componentsAreCompressedCases, compressionSchemeCases, packedCases, planeCompatibleCases, planeCountCases, planeHeightDivisorCases,
planeWidthDivisorCases, texelsPerBlockCases; planeWidthDivisorCases, texelsPerBlockCases;
for ( auto formatValuesIt = std::next( formatIt->second.values.begin() ); formatValuesIt != formatIt->second.values.end(); ++formatValuesIt ) for ( auto formatValuesIt = std::next( formatIt->second.values.begin() ); formatValuesIt != formatIt->second.values.end(); ++formatValuesIt )
{
// only generate a trait for non-alias formats
if ( formatValuesIt->alias.empty() )
{ {
auto traitIt = m_formats.find( formatValuesIt->name ); auto traitIt = m_formats.find( formatValuesIt->name );
assert( traitIt != m_formats.end() ); assert( traitIt != m_formats.end() );
@ -5622,7 +5648,8 @@ ${widthDivisorCases}
for ( size_t i = 0; i < traitIt->second.planes.size(); ++i ) for ( size_t i = 0; i < traitIt->second.planes.size(); ++i )
{ {
compatibleCases += " case " + std::to_string( i ) + compatibleCases += " case " + std::to_string( i ) +
": return VULKAN_HPP_NAMESPACE::Format::" + generateEnumValueName( "VkFormat", traitIt->second.planes[i].compatible, false ) + ";\n"; ": return VULKAN_HPP_NAMESPACE::Format::" + generateEnumValueName( "VkFormat", traitIt->second.planes[i].compatible, false ) +
";\n";
heightDivisorCases += " case " + std::to_string( i ) + ": return " + traitIt->second.planes[i].heightDivisor + ";\n"; heightDivisorCases += " case " + std::to_string( i ) + ": return " + traitIt->second.planes[i].heightDivisor + ";\n";
widthDivisorCases += " case " + std::to_string( i ) + ": return " + traitIt->second.planes[i].widthDivisor + ";\n"; widthDivisorCases += " case " + std::to_string( i ) + ": return " + traitIt->second.planes[i].widthDivisor + ";\n";
} }
@ -5642,6 +5669,7 @@ ${widthDivisorCases}
texelsPerBlockCases += caseString + " return " + traitIt->second.texelsPerBlock + ";\n"; texelsPerBlockCases += caseString + " return " + traitIt->second.texelsPerBlock + ";\n";
} }
}
return replaceWithMap( formatTraitsTemplate, return replaceWithMap( formatTraitsTemplate,
{ { "blockExtentCases", blockExtentCases }, { { "blockExtentCases", blockExtentCases },
@ -8232,7 +8260,8 @@ ${leave})";
auto enumIt = m_enums.find( "VkResult" ); auto enumIt = m_enums.find( "VkResult" );
for ( auto const & value : enumIt->second.values ) for ( auto const & value : enumIt->second.values )
{ {
if ( value.name.starts_with( "VK_ERROR" ) ) // Only generate exception class for non-alias results codes
if ( value.alias.empty() && value.name.starts_with( "VK_ERROR" ) )
{ {
auto [enter, leave] = generateProtection( value.protect ); auto [enter, leave] = generateProtection( value.protect );
std::string valueName = generateEnumValueName( enumIt->first, value.name, false ); std::string valueName = generateEnumValueName( enumIt->first, value.name, false );
@ -9677,7 +9706,8 @@ std::string VulkanHppGenerator::generateThrowResultException() const
std::string cases; std::string cases;
for ( auto const & value : enumIt->second.values ) for ( auto const & value : enumIt->second.values )
{ {
if ( value.name.starts_with( "VK_ERROR" ) ) // only generate throw-functions for non-alias error codes
if ( value.alias.empty() && value.name.starts_with( "VK_ERROR" ) )
{ {
auto [enter, leave] = generateProtection( value.protect ); auto [enter, leave] = generateProtection( value.protect );
std::string valueName = generateEnumValueName( enumIt->first, value.name, false ); std::string valueName = generateEnumValueName( enumIt->first, value.name, false );
@ -10814,7 +10844,7 @@ void VulkanHppGenerator::readEnumsEnum( tinyxml2::XMLElement const * element, st
if ( api.empty() || ( api == "vulkan" ) ) if ( api.empty() || ( api == "vulkan" ) )
{ {
enumIt->second.addEnumAlias( line, name, alias ); enumIt->second.addEnumAlias( line, name, alias, "", true );
} }
} }
else else
@ -11194,8 +11224,7 @@ void VulkanHppGenerator::readFormat( tinyxml2::XMLElement const * element )
checkForError( std::find_if( formatIt->second.values.begin(), checkForError( std::find_if( formatIt->second.values.begin(),
formatIt->second.values.end(), formatIt->second.values.end(),
[&name]( EnumValueData const & evd ) { return evd.name == name; } ) != formatIt->second.values.end() || [&name]( EnumValueData const & evd ) { return evd.name == name; } ) != formatIt->second.values.end(),
( formatIt->second.aliases.find( name ) != formatIt->second.aliases.end() ),
line, line,
"encountered unknown format <" + name + ">" ); "encountered unknown format <" + name + ">" );
auto [it, inserted] = m_formats.insert( std::make_pair( name, format ) ); auto [it, inserted] = m_formats.insert( std::make_pair( name, format ) );
@ -11664,7 +11693,7 @@ void VulkanHppGenerator::readRequireEnum( tinyxml2::XMLElement const * element,
assert( enumIt != m_enums.end() ); assert( enumIt != m_enums.end() );
if ( ( api.empty() || ( api == "vulkan" ) ) && supported ) if ( ( api.empty() || ( api == "vulkan" ) ) && supported )
{ {
enumIt->second.addEnumAlias( line, name, alias ); enumIt->second.addEnumAlias( line, name, alias, getProtectFromPlatform( platform ), supported );
} }
} }
} }
@ -12773,25 +12802,33 @@ std::string VulkanHppGenerator::toString( TypeCategory category )
} }
} }
void VulkanHppGenerator::EnumData::addEnumAlias( int line, std::string const & name, std::string const & aliasName ) void VulkanHppGenerator::EnumData::addEnumAlias( int line, std::string const & name, std::string const & alias, std::string const & protect, bool required )
{ {
auto aliasIt = aliases.find( name ); auto valueIt = std::find_if( values.begin(), values.end(), [&name]( EnumValueData const & evd ) { return evd.name == name; } );
checkForError( if ( valueIt != values.end() )
( aliasIt == aliases.end() ) || ( aliasIt->second.name == aliasName ), line, "enum alias <" + name + "> already listed for a different enum value" );
aliases[name] = { aliasName, line };
}
void VulkanHppGenerator::EnumData::addEnumValue(
int line, std::string const & valueName, std::string const & protect, bool singleBit, bool required )
{
auto valueIt = std::find_if( values.begin(), values.end(), [&valueName]( EnumValueData const & evd ) { return evd.name == valueName; } );
if ( valueIt == values.end() )
{ {
values.emplace_back( EnumValueData{ valueName, protect, required, singleBit, line } ); checkForError( ( valueIt->alias == alias ) && ( valueIt->protect == protect ) && ( valueIt->required == required ) && !valueIt->singleBit,
line,
"enum alias <" + name + "> already specified with different attributes" );
} }
else else
{ {
assert( ( valueIt->protect == protect ) && ( valueIt->required == required ) && ( valueIt->singleBit == singleBit ) ); values.push_back( { alias, name, protect, required, false, line } );
}
}
void VulkanHppGenerator::EnumData::addEnumValue( int line, std::string const & name, std::string const & protect, bool singleBit, bool required )
{
auto valueIt = std::find_if( values.begin(), values.end(), [&name]( EnumValueData const & evd ) { return evd.name == name; } );
if ( valueIt != values.end() )
{
checkForError( valueIt->alias.empty() && ( valueIt->protect == protect ) && ( valueIt->required == required ) && ( valueIt->singleBit == singleBit ),
line,
"enum value <" + name + "> already specified with different attributes" );
}
else
{
values.push_back( { "", name, protect, required, singleBit, line } );
} }
} }

4
VulkanHppGenerator.hpp
View File

@ -198,6 +198,7 @@ private:
struct EnumValueData struct EnumValueData
{ {
std::string alias = {};
std::string name = {}; std::string name = {};
std::string protect = {}; std::string protect = {};
bool required = false; bool required = false;
@ -207,10 +208,9 @@ private:
struct EnumData struct EnumData
{ {
void addEnumAlias( int line, std::string const & name, std::string const & alias ); void addEnumAlias( int line, std::string const & name, std::string const & alias, std::string const & protect, bool required );
void addEnumValue( int line, std::string const & valueName, std::string const & protect, bool singleBit, bool required ); void addEnumValue( int line, std::string const & valueName, std::string const & protect, bool singleBit, bool required );
std::map<std::string, AliasData> aliases = {}; // aliases for the values
std::string bitwidth = {}; std::string bitwidth = {};
bool isBitmask = false; bool isBitmask = false;
std::vector<EnumValueData> values = {}; std::vector<EnumValueData> values = {};

716
vulkan/vulkan_enums.hpp
View File

File diff suppressed because it is too large Load Diff