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

Move check on known enum alias value from readEnum to final checkCorrectness.

Browse Source
This commit is contained in:
asuessenbach 2021-05-04 17:08:24 +02:00
parent 0afb197f75
commit e370ab5178
2 changed files with 76 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
VulkanHppGenerator.cpp
View File

@ -14,43 +14,35 @@
#include "VulkanHppGenerator.hpp" #include "VulkanHppGenerator.hpp"
#include <algorithm>
#include <cassert> #include <cassert>
#include <exception>
#include <fstream> #include <fstream>
#include <functional>
#include <iterator>
#include <regex> #include <regex>
void appendArgumentCount( std::string & str, void appendReinterpretCast( std::string & str, bool leadingConst, std::string const & type );
size_t vectorIndex, void appendTypesafeStuff( std::string & str, std::string const & typesafeCheck );
std::string const & vectorName, void appendVersionCheck( std::string & str, std::string const & version );
size_t templateParamIndex ); bool beginsWith( std::string const & text, std::string const & prefix );
void appendReinterpretCast( std::string & str, bool leadingConst, std::string const & type ); bool endsWith( std::string const & text, std::string const & postfix );
void appendTypesafeStuff( std::string & str, std::string const & typesafeCheck ); void check( bool condition, int line, std::string const & message );
void appendVersionCheck( std::string & str, std::string const & version ); void checkAttributes( int line,
bool beginsWith( std::string const & text, std::string const & prefix ); std::map<std::string, std::string> const & attributes,
bool endsWith( std::string const & text, std::string const & postfix ); std::map<std::string, std::set<std::string>> const & required,
void check( bool condition, int line, std::string const & message ); std::map<std::string, std::set<std::string>> const & optional );
void checkAttributes( int line, void checkElements( int line,
std::map<std::string, std::string> const & attributes, std::vector<tinyxml2::XMLElement const *> const & elements,
std::map<std::string, std::set<std::string>> const & required, std::map<std::string, bool> const & required,
std::map<std::string, std::set<std::string>> const & optional ); std::set<std::string> const & optional = {} );
void checkElements( int line, std::string constructStandardArray( std::string const & type, std::vector<std::string> const & sizes );
std::vector<tinyxml2::XMLElement const *> const & elements, std::string createEnumValueName( std::string const & name,
std::map<std::string, bool> const & required, std::string const & prefix,
std::set<std::string> const & optional = {} ); std::string const & postfix,
std::string constructStandardArray( std::string const & type, std::vector<std::string> const & sizes ); bool bitmask,
std::string createEnumValueName( std::string const & name, std::string const & tag );
std::string const & prefix, std::string createSuccessCode( std::string const & code, std::set<std::string> const & tags );
std::string const & postfix, std::string determineCommandName( std::string const & vulkanCommandName,
bool bitmask, std::string const & argumentType,
std::string const & tag ); std::set<std::string> const & tags );
std::string createSuccessCode( std::string const & code, std::set<std::string> const & tags ); std::string determineNoDiscard( bool multiSuccessCodes, bool multiErrorCodes );
std::string determineCommandName( std::string const & vulkanCommandName,
std::string const & argumentType,
std::set<std::string> const & tags );
std::string determineNoDiscard( bool multiSuccessCodes, bool multiErrorCodes );
std::set<size_t> determineSingularParams( size_t returnParamIndex, std::set<size_t> determineSingularParams( size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices ); std::map<size_t, size_t> const & vectorParamIndices );
std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices ); std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices );
@ -94,24 +86,6 @@ const std::set<std::string> specialPointerTypes = {
"Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window" "Display", "IDirectFB", "wl_display", "xcb_connection_t", "_screen_window"
}; };
void appendArgumentCount( std::string & str,
size_t vectorIndex,
std::string const & vectorName,
size_t templateParamIndex )
{
// this parameter is a count parameter for a vector parameter
// the corresponding vector parameter is not the return parameter, or it's not a two-step algorithm
// for the non-singular version, the count is the size of the vector parameter
// -> use the vector parameter name without leading 'p' to get the size (in number of elements, not in bytes)
assert( vectorName[0] == 'p' );
str += startLowerCase( stripPrefix( vectorName, "p" ) ) + ".size() ";
if ( templateParamIndex == vectorIndex )
{
// if the vector parameter is templatized -> multiply by the size of that type to get the size in bytes
str += "* sizeof( T ) ";
}
}
void appendReinterpretCast( std::string & str, bool leadingConst, std::string const & type ) void appendReinterpretCast( std::string & str, bool leadingConst, std::string const & type )
{ {
str += "reinterpret_cast<"; str += "reinterpret_cast<";
@ -858,7 +832,17 @@ void VulkanHppGenerator::appendArguments( std::string & str,
[i]( std::pair<size_t, size_t> const & vpi ) { return vpi.second == i; } ); [i]( std::pair<size_t, size_t> const & vpi ) { return vpi.second == i; } );
if ( it != vectorParamIndices.end() ) if ( it != vectorParamIndices.end() )
{ {
appendArgumentCount( str, it->first, commandData.params[it->first].name, templateParamIndex ); // this parameter is a count parameter for a vector parameter
// the corresponding vector parameter is not the return parameter, or it's not a two-step algorithm
// for the non-singular version, the count is the size of the vector parameter
// -> use the vector parameter name without leading 'p' to get the size (in number of elements, not in bytes)
assert( commandData.params[it->first].name[0] == 'p' );
str += startLowerCase( stripPrefix( commandData.params[it->first].name, "p" ) ) + ".size() ";
if ( it->first == templateParamIndex )
{
// if the vector parameter is templatized -> multiply by the size of that type to get the size in bytes
str += "* sizeof( T ) ";
}
} }
else if ( beginsWith( commandData.params[i].type.type, "Vk" ) ) else if ( beginsWith( commandData.params[i].type.type, "Vk" ) )
{ {
@ -2674,26 +2658,26 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
if ( std::find_if( enumData.second.values.begin(), if ( std::find_if( enumData.second.values.begin(),
enumData.second.values.end(), enumData.second.values.end(),
[&alias]( EnumValueData const & evd ) [&alias]( EnumValueData const & evd )
{ return alias.second.second == evd.vkValue; } ) == enumData.second.values.end() ) { return alias.second.vkValue == evd.vkValue; } ) == enumData.second.values.end() )
{ {
#if !defined( NDEBUG ) #if !defined( NDEBUG )
auto enumIt = auto enumIt =
std::find_if( enumData.second.values.begin(), std::find_if( enumData.second.values.begin(),
enumData.second.values.end(), enumData.second.values.end(),
[&alias]( EnumValueData const & evd ) { return alias.second.first == evd.vulkanValue; } ); [&alias]( EnumValueData const & evd ) { return alias.second.vulkanValue == evd.vulkanValue; } );
if ( enumIt == enumData.second.values.end() ) if ( enumIt == enumData.second.values.end() )
{ {
auto aliasIt = enumData.second.aliases.find( alias.second.first ); auto aliasIt = enumData.second.aliases.find( alias.second.vulkanValue );
assert( aliasIt != enumData.second.aliases.end() ); assert( aliasIt != enumData.second.aliases.end() );
enumIt = enumIt = std::find_if( enumData.second.values.begin(),
std::find_if( enumData.second.values.begin(), enumData.second.values.end(),
enumData.second.values.end(), [&aliasIt]( EnumValueData const & evd )
[&aliasIt]( EnumValueData const & evd ) { return aliasIt->second.first == evd.vulkanValue; } ); { return aliasIt->second.vulkanValue == evd.vulkanValue; } );
} }
assert( enumIt != enumData.second.values.end() ); assert( enumIt != enumData.second.values.end() );
assert( enumIt->extension.empty() || generateProtection( enumIt->extension ).first.empty() ); assert( enumIt->extension.empty() || generateProtection( enumIt->extension ).first.empty() );
#endif #endif
enumList += "\n " + alias.second.second + " = " + alias.first + ","; enumList += "\n " + alias.second.vkValue + " = " + alias.first + ",";
} }
} }
if ( !enumList.empty() ) if ( !enumList.empty() )
@ -11129,28 +11113,19 @@ void VulkanHppGenerator::EnumData::addEnumAlias( int line,
std::string const & aliasName, std::string const & aliasName,
std::string const & vkName ) std::string const & vkName )
{ {
// check that the aliasName is either a known enum value or at least a known alias
check( ( std::find_if( values.begin(),
values.end(),
[&aliasName]( EnumValueData const & evd )
{ return evd.vulkanValue == aliasName; } ) != values.end() ) ||
( aliases.find( aliasName ) != aliases.end() ),
line,
"unknown enum alias <" + aliasName + ">" );
auto aliasIt = aliases.find( name ); auto aliasIt = aliases.find( name );
check( ( aliasIt == aliases.end() ) || ( aliasIt->second.first == aliasName ), check( ( aliasIt == aliases.end() ) || ( aliasIt->second.vulkanValue == aliasName ),
line, line,
"enum alias <" + name + "> already listed for a different enum value" ); "enum alias <" + name + "> already listed for a different enum value" );
// only list aliases that map to different vkNames // only list aliases that map to different vkNames
aliasIt = std::find_if( aliases.begin(), aliasIt = std::find_if( aliases.begin(),
aliases.end(), aliases.end(),
[&vkName]( std::pair<std::string, std::pair<std::string, std::string>> const & aliasEntry ) [&vkName]( std::pair<std::string, EnumAliasData> const & aliasEntry )
{ return vkName == aliasEntry.second.second; } ); { return vkName == aliasEntry.second.vkValue; } );
if ( aliasIt == aliases.end() ) if ( aliasIt == aliases.end() )
{ {
aliases.insert( std::make_pair( name, std::make_pair( aliasName, vkName ) ) ); aliases.insert( std::make_pair( name, EnumAliasData( aliasName, vkName, line ) ) );
} }
} }
@ -11258,6 +11233,18 @@ void VulkanHppGenerator::checkCorrectness()
warn( !typeIt->second.referencedIn.empty(), warn( !typeIt->second.referencedIn.empty(),
e.second.xmlLine, e.second.xmlLine,
"enum <" + e.first + "> not listed in any feature or extension" ); "enum <" + e.first + "> not listed in any feature or extension" );
// check that the aliasNames are known enum values or known aliases
for ( auto const & alias : e.second.aliases )
{
check( ( std::find_if( e.second.values.begin(),
e.second.values.end(),
[&alias]( EnumValueData const & evd )
{ return evd.vulkanValue == alias.second.vulkanValue; } ) != e.second.values.end() ) ||
( e.second.aliases.find( alias.second.vulkanValue ) != e.second.aliases.end() ),
alias.second.xmlLine,
"unknown enum alias <" + alias.second.vulkanValue + ">" );
}
} }
// extension checks // extension checks

21
VulkanHppGenerator.hpp
View File

@ -128,6 +128,17 @@ private:
int xmlLine; int xmlLine;
}; };
struct EnumAliasData
{
EnumAliasData( std::string const & vulkanValue_, std::string const & vkValue_, int line )
: vulkanValue( vulkanValue_ ), vkValue( vkValue_ ), xmlLine( line )
{}
std::string vulkanValue;
std::string vkValue;
int xmlLine;
};
struct EnumValueData struct EnumValueData
{ {
EnumValueData( EnumValueData(
@ -155,11 +166,11 @@ private:
std::string const & extension, std::string const & extension,
std::string const & tag ); std::string const & tag );
std::string alias; // alias for this enum std::string alias; // alias for this enum
std::map<std::string, std::pair<std::string, std::string>> aliases; // map from name to alias and vk-name std::map<std::string, EnumAliasData> aliases;
bool isBitmask = false; bool isBitmask = false;
std::vector<EnumValueData> values; std::vector<EnumValueData> values;
int xmlLine; int xmlLine;
}; };
struct FeatureData struct FeatureData