2019-01-09 10:55:11 +00:00
|
|
|
// Copyright(c) 2015-2019, NVIDIA CORPORATION. All rights reserved.
|
2017-12-21 11:40:48 +00:00
|
|
|
//
|
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
|
//
|
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
//
|
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include <iostream>
|
2020-04-12 19:49:12 +00:00
|
|
|
#include <map>
|
2017-12-21 11:40:48 +00:00
|
|
|
#include <set>
|
|
|
|
|
#include <tinyxml2.h>
|
2020-04-12 19:49:12 +00:00
|
|
|
#include <vector>
|
2017-12-21 11:40:48 +00:00
|
|
|
|
|
|
|
|
class VulkanHppGenerator
|
|
|
|
|
{
|
2020-04-12 19:49:12 +00:00
|
|
|
public:
|
|
|
|
|
VulkanHppGenerator( tinyxml2::XMLDocument const & document );
|
|
|
|
|
|
2021-07-06 07:13:53 +00:00
|
|
|
std::string generateBaseTypes() const;
|
|
|
|
|
std::string generateBitmasks() const;
|
|
|
|
|
std::string generateCommandDefinitions() const;
|
2021-07-09 07:01:56 +00:00
|
|
|
std::string generateDispatchLoaderDynamic() const; // uses vkGet*ProcAddress to get function pointers
|
|
|
|
|
std::string generateDispatchLoaderStatic() const; // uses exported symbols from loader
|
2021-07-06 07:13:53 +00:00
|
|
|
std::string generateEnums() const;
|
2021-11-24 11:21:38 +00:00
|
|
|
std::string generateFormatTraits() const;
|
2021-07-13 07:01:55 +00:00
|
|
|
std::string generateHandles() const;
|
2021-12-02 11:21:30 +00:00
|
|
|
std::string generateHandleHashStructures() const;
|
2021-07-06 07:13:53 +00:00
|
|
|
std::string generateIndexTypeTraits() const;
|
|
|
|
|
std::string generateRAIICommandDefinitions() const;
|
|
|
|
|
std::string generateRAIIDispatchers() const;
|
|
|
|
|
std::string generateRAIIHandles() const;
|
|
|
|
|
std::string generateResultExceptions() const;
|
2021-07-13 07:01:55 +00:00
|
|
|
std::string generateStructExtendsStructs() const;
|
2021-08-05 11:13:41 +00:00
|
|
|
std::string generateStructForwardDeclarations() const;
|
2021-12-09 09:54:26 +00:00
|
|
|
std::string generateStructHashStructures() const;
|
2021-07-13 07:01:55 +00:00
|
|
|
std::string generateStructs() const;
|
2021-07-06 07:13:53 +00:00
|
|
|
std::string generateThrowResultException() const;
|
|
|
|
|
std::string const & getTypesafeCheck() const;
|
|
|
|
|
std::string const & getVersion() const;
|
|
|
|
|
std::string const & getVulkanLicenseHeader() const;
|
|
|
|
|
void prepareRAIIHandles();
|
2020-04-12 19:49:12 +00:00
|
|
|
|
|
|
|
|
private:
|
2020-05-18 10:02:10 +00:00
|
|
|
struct TypeInfo
|
2020-04-12 19:49:12 +00:00
|
|
|
{
|
2021-10-14 06:36:04 +00:00
|
|
|
std::string compose( std::string const & nameSpace ) const;
|
2020-04-12 19:49:12 +00:00
|
|
|
|
2020-05-18 10:02:10 +00:00
|
|
|
bool operator==( TypeInfo const & rhs ) const
|
2017-12-21 11:40:48 +00:00
|
|
|
{
|
2020-04-12 19:49:12 +00:00
|
|
|
return ( prefix == rhs.prefix ) && ( type == rhs.type ) && ( postfix == rhs.postfix );
|
|
|
|
|
}
|
|
|
|
|
|
2021-08-02 10:04:37 +00:00
|
|
|
bool operator!=( TypeInfo const & rhs ) const
|
|
|
|
|
{
|
|
|
|
|
return !operator==( rhs );
|
|
|
|
|
}
|
|
|
|
|
|
2021-07-28 07:13:25 +00:00
|
|
|
bool operator<( TypeInfo const & rhs ) const
|
|
|
|
|
{
|
2022-02-28 09:11:04 +00:00
|
|
|
return ( prefix < rhs.prefix ) || ( ( prefix == rhs.prefix ) && ( ( type < rhs.type ) || ( ( type == rhs.type ) && ( postfix < rhs.postfix ) ) ) );
|
2021-07-28 07:13:25 +00:00
|
|
|
}
|
|
|
|
|
|
2020-09-15 08:23:19 +00:00
|
|
|
bool isConstPointer() const
|
|
|
|
|
{
|
|
|
|
|
return ( prefix.find( "const" ) != std::string::npos ) && ( postfix.find( '*' ) != std::string::npos );
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-02 13:00:06 +00:00
|
|
|
bool isNonConstPointer() const
|
|
|
|
|
{
|
|
|
|
|
return ( prefix.find( "const" ) == std::string::npos ) && ( postfix.find( '*' ) != std::string::npos );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool isValue() const
|
|
|
|
|
{
|
2020-09-25 21:45:55 +00:00
|
|
|
return ( ( prefix.find( '*' ) == std::string::npos ) && ( postfix.find( '*' ) == std::string::npos ) );
|
2020-09-02 13:00:06 +00:00
|
|
|
}
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
std::string prefix;
|
|
|
|
|
std::string type;
|
|
|
|
|
std::string postfix;
|
|
|
|
|
};
|
|
|
|
|
|
2021-06-30 06:56:05 +00:00
|
|
|
struct BaseTypeData
|
|
|
|
|
{
|
|
|
|
|
BaseTypeData( TypeInfo const & typeInfo_, int line ) : typeInfo( typeInfo_ ), xmlLine( line ) {}
|
|
|
|
|
|
|
|
|
|
TypeInfo typeInfo;
|
2021-07-05 07:29:12 +00:00
|
|
|
int xmlLine;
|
2021-06-30 06:56:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct BitmaskData
|
|
|
|
|
{
|
2022-02-28 09:11:04 +00:00
|
|
|
BitmaskData( std::string const & r, std::string const & t, int line ) : requirements( r ), type( t ), xmlLine( line ) {}
|
2021-06-30 06:56:05 +00:00
|
|
|
|
|
|
|
|
std::string requirements;
|
|
|
|
|
std::string type;
|
|
|
|
|
std::string alias;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct NameData
|
|
|
|
|
{
|
|
|
|
|
std::string name;
|
|
|
|
|
std::vector<std::string> arraySizes;
|
|
|
|
|
};
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
struct ParamData
|
|
|
|
|
{
|
|
|
|
|
ParamData( int line ) : optional( false ), xmlLine( line ) {}
|
|
|
|
|
|
2020-05-18 10:02:10 +00:00
|
|
|
TypeInfo type;
|
2020-04-12 19:49:12 +00:00
|
|
|
std::string name;
|
|
|
|
|
std::vector<std::string> arraySizes;
|
|
|
|
|
std::string len;
|
|
|
|
|
bool optional;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct CommandData
|
|
|
|
|
{
|
|
|
|
|
CommandData( int line ) : xmlLine( line ) {}
|
|
|
|
|
|
2021-04-28 11:35:14 +00:00
|
|
|
std::string alias;
|
|
|
|
|
std::vector<std::string> errorCodes;
|
|
|
|
|
std::string handle;
|
|
|
|
|
std::vector<ParamData> params;
|
|
|
|
|
std::string referencedIn;
|
|
|
|
|
std::string returnType;
|
|
|
|
|
std::vector<std::string> successCodes;
|
|
|
|
|
int xmlLine;
|
2020-04-12 19:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
2021-05-04 15:08:24 +00:00
|
|
|
struct EnumAliasData
|
|
|
|
|
{
|
2021-06-01 17:48:06 +00:00
|
|
|
EnumAliasData( std::string const & name_, int line ) : name( name_ ), xmlLine( line ) {}
|
2021-05-04 15:08:24 +00:00
|
|
|
|
2021-06-01 17:48:06 +00:00
|
|
|
std::string name;
|
2021-05-04 15:08:24 +00:00
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
struct EnumValueData
|
|
|
|
|
{
|
2022-02-28 09:11:04 +00:00
|
|
|
EnumValueData( int line, std::string const & name_, std::string const & protect_, std::string const & extension_, bool singleBit_ )
|
2021-06-30 07:58:58 +00:00
|
|
|
: name( name_ ), extension( extension_ ), protect( protect_ ), singleBit( singleBit_ ), xmlLine( line )
|
2022-03-09 10:20:05 +00:00
|
|
|
{
|
|
|
|
|
}
|
2020-04-12 19:49:12 +00:00
|
|
|
|
2021-06-01 17:48:06 +00:00
|
|
|
std::string name;
|
2021-01-25 15:34:32 +00:00
|
|
|
std::string extension;
|
2021-06-30 07:58:58 +00:00
|
|
|
std::string protect;
|
2020-04-12 19:49:12 +00:00
|
|
|
bool singleBit;
|
2020-07-13 09:45:47 +00:00
|
|
|
int xmlLine;
|
2020-04-12 19:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct EnumData
|
|
|
|
|
{
|
2021-10-05 16:09:05 +00:00
|
|
|
EnumData( int line, bool isBitmask_ = false ) : isBitmask( isBitmask_ ), xmlLine( line ) {}
|
2021-06-01 17:48:06 +00:00
|
|
|
void addEnumAlias( int line, std::string const & name, std::string const & alias );
|
2022-02-28 09:11:04 +00:00
|
|
|
void addEnumValue( int line, std::string const & valueName, std::string const & protect, bool bitpos, std::string const & extension );
|
2020-04-12 19:49:12 +00:00
|
|
|
|
2021-06-24 09:09:49 +00:00
|
|
|
std::string alias; // alias for this enum
|
|
|
|
|
std::map<std::string, EnumAliasData> aliases; // aliases for the values
|
2021-06-08 09:08:11 +00:00
|
|
|
std::string bitwidth;
|
2021-10-05 16:09:05 +00:00
|
|
|
bool isBitmask;
|
2021-05-04 15:08:24 +00:00
|
|
|
std::vector<EnumValueData> values;
|
|
|
|
|
int xmlLine;
|
2020-04-12 19:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
2021-07-21 15:09:21 +00:00
|
|
|
struct RequireData
|
|
|
|
|
{
|
2022-07-04 16:02:22 +00:00
|
|
|
RequireData( int line, std::string const & titles_ );
|
2021-07-21 15:09:21 +00:00
|
|
|
|
2022-07-04 16:02:22 +00:00
|
|
|
std::vector<std::string> titles;
|
2021-07-21 15:09:21 +00:00
|
|
|
std::vector<std::string> commands;
|
|
|
|
|
std::vector<std::string> types;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
2021-04-27 15:19:32 +00:00
|
|
|
struct FeatureData
|
|
|
|
|
{
|
|
|
|
|
FeatureData( std::string const & number_ ) : number( number_ ) {}
|
|
|
|
|
|
2021-06-08 06:32:46 +00:00
|
|
|
std::string number;
|
2021-07-21 15:09:21 +00:00
|
|
|
std::vector<RequireData> requireData;
|
2021-04-27 15:19:32 +00:00
|
|
|
};
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
struct ExtensionData
|
|
|
|
|
{
|
2020-05-18 10:02:10 +00:00
|
|
|
ExtensionData( int line,
|
|
|
|
|
std::string const & deprecatedBy_,
|
2021-04-27 15:19:32 +00:00
|
|
|
std::string const & number_,
|
2020-05-18 10:02:10 +00:00
|
|
|
std::string const & obsoletedBy_,
|
|
|
|
|
std::string const & platform_,
|
|
|
|
|
std::string const & promotedTo_ )
|
2022-02-28 09:11:04 +00:00
|
|
|
: deprecatedBy( deprecatedBy_ ), number( number_ ), obsoletedBy( obsoletedBy_ ), platform( platform_ ), promotedTo( promotedTo_ ), xmlLine( line )
|
2022-03-09 10:20:05 +00:00
|
|
|
{
|
|
|
|
|
}
|
2020-04-12 19:49:12 +00:00
|
|
|
|
2021-07-21 15:09:21 +00:00
|
|
|
std::string deprecatedBy;
|
|
|
|
|
std::string number;
|
|
|
|
|
std::string obsoletedBy;
|
|
|
|
|
std::string platform;
|
|
|
|
|
std::string promotedTo;
|
|
|
|
|
std::set<std::string> requiresAttribute;
|
|
|
|
|
std::vector<RequireData> requireData;
|
|
|
|
|
int xmlLine;
|
2020-04-12 19:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
2021-11-22 13:27:34 +00:00
|
|
|
struct ComponentData
|
|
|
|
|
{
|
|
|
|
|
ComponentData( int line ) : xmlLine( line ) {}
|
|
|
|
|
|
|
|
|
|
std::string bits;
|
|
|
|
|
std::string name;
|
|
|
|
|
std::string numericFormat;
|
|
|
|
|
std::string planeIndex;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct PlaneData
|
|
|
|
|
{
|
|
|
|
|
PlaneData( int line ) : xmlLine( line ) {}
|
|
|
|
|
|
|
|
|
|
std::string compatible;
|
|
|
|
|
std::string heightDivisor;
|
|
|
|
|
std::string widthDivisor;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct FormatData
|
|
|
|
|
{
|
|
|
|
|
FormatData( int line ) : xmlLine( line ) {}
|
|
|
|
|
|
|
|
|
|
std::string blockExtent;
|
|
|
|
|
std::string blockSize;
|
|
|
|
|
std::string chroma;
|
|
|
|
|
std::string classAttribute;
|
|
|
|
|
std::vector<ComponentData> components;
|
|
|
|
|
std::string compressed;
|
|
|
|
|
std::string packed;
|
|
|
|
|
std::vector<PlaneData> planes;
|
|
|
|
|
std::string spirvImageFormat;
|
|
|
|
|
std::string texelsPerBlock;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
2021-09-21 12:20:24 +00:00
|
|
|
struct FuncPointerArgumentData
|
|
|
|
|
{
|
|
|
|
|
FuncPointerArgumentData( std::string const & t, int line ) : type( t ), xmlLine( line ) {}
|
|
|
|
|
|
|
|
|
|
std::string type;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
struct FuncPointerData
|
|
|
|
|
{
|
|
|
|
|
FuncPointerData( std::string const & r, int line ) : requirements( r ), xmlLine( line ) {}
|
|
|
|
|
|
2021-09-21 12:20:24 +00:00
|
|
|
std::vector<FuncPointerArgumentData> arguments;
|
|
|
|
|
std::string requirements;
|
|
|
|
|
int xmlLine;
|
2020-04-12 19:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct HandleData
|
|
|
|
|
{
|
2022-04-15 09:24:30 +00:00
|
|
|
HandleData( std::string const & p, std::string const & objType, bool isDispatchable, int line )
|
|
|
|
|
: objTypeEnum( objType ), parent( p ), isDispatchable( isDispatchable ), xmlLine( line )
|
|
|
|
|
{
|
|
|
|
|
}
|
2020-04-12 19:49:12 +00:00
|
|
|
|
2021-04-12 10:38:04 +00:00
|
|
|
std::string alias;
|
|
|
|
|
std::set<std::string> childrenHandles;
|
|
|
|
|
std::set<std::string> commands;
|
|
|
|
|
std::string deleteCommand;
|
|
|
|
|
std::string deletePool;
|
|
|
|
|
std::string objTypeEnum;
|
|
|
|
|
std::string parent;
|
|
|
|
|
std::set<std::string> secondLevelCommands;
|
2022-04-15 09:24:30 +00:00
|
|
|
bool isDispatchable;
|
2021-04-12 10:38:04 +00:00
|
|
|
int xmlLine;
|
2021-02-17 09:49:59 +00:00
|
|
|
|
|
|
|
|
// RAII data
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator destructorIt;
|
|
|
|
|
std::vector<std::map<std::string, CommandData>::const_iterator> constructorIts;
|
2020-04-12 19:49:12 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct MemberData
|
|
|
|
|
{
|
|
|
|
|
MemberData( int line ) : xmlLine( line ) {}
|
|
|
|
|
|
2020-05-18 10:02:10 +00:00
|
|
|
TypeInfo type;
|
2020-04-12 19:49:12 +00:00
|
|
|
std::string name;
|
|
|
|
|
std::vector<std::string> arraySizes;
|
|
|
|
|
std::string bitCount;
|
2020-07-01 12:43:37 +00:00
|
|
|
std::vector<std::string> len;
|
2020-07-08 08:58:37 +00:00
|
|
|
bool noAutoValidity = false;
|
2020-12-10 10:11:13 +00:00
|
|
|
std::vector<bool> optional;
|
2020-06-15 06:03:17 +00:00
|
|
|
std::string selection;
|
|
|
|
|
std::string selector;
|
2021-07-26 15:59:25 +00:00
|
|
|
std::string value;
|
2020-04-12 19:49:12 +00:00
|
|
|
std::string usedConstant;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
2020-05-18 10:02:10 +00:00
|
|
|
struct PlatformData
|
|
|
|
|
{
|
|
|
|
|
PlatformData( std::string const & protect_ ) : protect( protect_ ) {}
|
|
|
|
|
|
|
|
|
|
std::string protect;
|
|
|
|
|
};
|
|
|
|
|
|
2021-06-22 08:15:24 +00:00
|
|
|
struct StructureAliasData
|
|
|
|
|
{
|
|
|
|
|
StructureAliasData( std::string const & alias_, int line ) : alias( alias_ ), xmlLine( line ) {}
|
|
|
|
|
|
|
|
|
|
std::string alias;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
struct StructureData
|
|
|
|
|
{
|
2020-06-15 06:03:17 +00:00
|
|
|
StructureData( std::vector<std::string> const & extends, int line ) : structExtends( extends ), xmlLine( line ) {}
|
2020-04-12 19:49:12 +00:00
|
|
|
|
2020-12-10 16:23:44 +00:00
|
|
|
bool allowDuplicate = false;
|
|
|
|
|
bool isUnion = false;
|
|
|
|
|
bool returnedOnly = false;
|
|
|
|
|
bool mutualExclusiveLens = false;
|
2020-04-12 19:49:12 +00:00
|
|
|
std::vector<MemberData> members;
|
|
|
|
|
std::vector<std::string> structExtends;
|
|
|
|
|
std::string subStruct;
|
|
|
|
|
int xmlLine;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum class TypeCategory
|
|
|
|
|
{
|
|
|
|
|
Bitmask,
|
|
|
|
|
BaseType,
|
|
|
|
|
Define,
|
|
|
|
|
Enum,
|
|
|
|
|
FuncPointer,
|
|
|
|
|
Handle,
|
|
|
|
|
Requires,
|
|
|
|
|
Struct,
|
|
|
|
|
Union,
|
|
|
|
|
Unknown
|
|
|
|
|
};
|
|
|
|
|
|
2020-05-18 10:02:10 +00:00
|
|
|
struct TypeData
|
|
|
|
|
{
|
2022-02-28 09:11:04 +00:00
|
|
|
TypeData( TypeCategory category_, std::string const & referencedIn_ = "" ) : category( category_ ), referencedIn( referencedIn_ ) {}
|
2020-05-18 10:02:10 +00:00
|
|
|
|
2021-04-27 07:06:55 +00:00
|
|
|
TypeCategory category;
|
|
|
|
|
std::string referencedIn;
|
2020-05-18 10:02:10 +00:00
|
|
|
};
|
|
|
|
|
|
2020-04-12 19:49:12 +00:00
|
|
|
private:
|
2021-07-13 07:01:55 +00:00
|
|
|
void addCommand( std::string const & name, CommandData & commandData );
|
2021-07-21 15:09:21 +00:00
|
|
|
void addMissingFlagBits( std::vector<RequireData> & requireData, std::string const & referencedIn );
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string addTitleAndProtection( std::string const & title, std::string const & strIf, std::string const & strElse = {} ) const;
|
|
|
|
|
bool allVectorSizesSupported( std::vector<ParamData> const & params, std::map<size_t, size_t> const & vectorParams ) const;
|
2021-07-21 15:09:21 +00:00
|
|
|
void appendDispatchLoaderDynamicCommands( std::vector<RequireData> const & requireData,
|
2021-07-13 07:01:55 +00:00
|
|
|
std::set<std::string> & listedCommands,
|
|
|
|
|
std::string const & title,
|
|
|
|
|
std::string & commandMembers,
|
|
|
|
|
std::string & initialCommandAssignments,
|
|
|
|
|
std::string & instanceCommandAssignments,
|
|
|
|
|
std::string & deviceCommandAssignments ) const;
|
2021-07-21 16:15:31 +00:00
|
|
|
void appendRAIIDispatcherCommands( std::vector<RequireData> const & requireData,
|
|
|
|
|
std::set<std::string> & listedCommands,
|
|
|
|
|
std::string const & title,
|
|
|
|
|
std::string & contextInitializers,
|
|
|
|
|
std::string & contextMembers,
|
|
|
|
|
std::string & deviceAssignments,
|
|
|
|
|
std::string & deviceMembers,
|
|
|
|
|
std::string & instanceAssignments,
|
|
|
|
|
std::string & instanceMembers ) const;
|
2021-08-02 10:04:37 +00:00
|
|
|
void checkBitmaskCorrectness() const;
|
|
|
|
|
void checkCommandCorrectness() const;
|
2021-08-04 21:43:49 +00:00
|
|
|
void checkCorrectness() const;
|
2021-08-02 10:04:37 +00:00
|
|
|
void checkEnumCorrectness() const;
|
2021-07-30 09:25:48 +00:00
|
|
|
void checkEnumCorrectness( std::vector<RequireData> const & requireData ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
bool checkEquivalentSingularConstructor( std::vector<std::map<std::string, CommandData>::const_iterator> const & constructorIts,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::vector<ParamData>::const_iterator lenIt ) const;
|
|
|
|
|
void checkExtensionCorrectness() const;
|
|
|
|
|
void checkFuncPointerCorrectness() const;
|
|
|
|
|
void checkHandleCorrectness() const;
|
|
|
|
|
void checkStructCorrectness() const;
|
|
|
|
|
void checkStructMemberCorrectness( std::string const & structureName, std::vector<MemberData> const & members, std::set<std::string> & sTypeValues ) const;
|
2022-07-04 09:37:22 +00:00
|
|
|
void checkValidStructs( int line, std::map<std::string, std::string> const & attributes ) const;
|
2022-05-04 06:37:09 +00:00
|
|
|
std::string combineDataTypes( std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
bool singular,
|
|
|
|
|
bool enumerating,
|
2022-06-14 08:53:50 +00:00
|
|
|
std::vector<std::string> const & dataTypes,
|
2022-06-15 09:48:06 +00:00
|
|
|
bool unique,
|
2022-06-14 08:53:50 +00:00
|
|
|
bool raii ) const;
|
2022-05-04 06:37:09 +00:00
|
|
|
bool containsArray( std::string const & type ) const;
|
2022-06-13 08:47:13 +00:00
|
|
|
bool containsFuncPointer( std::string const & type ) const;
|
2022-05-04 06:37:09 +00:00
|
|
|
bool containsFloatingPoints( std::vector<MemberData> const & members ) const;
|
|
|
|
|
bool containsUnion( std::string const & type ) const;
|
|
|
|
|
std::vector<size_t> determineConstPointerParams( std::vector<ParamData> const & params ) const;
|
|
|
|
|
std::vector<std::string> determineDataTypes( std::vector<VulkanHppGenerator::ParamData> const & params,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
2022-06-27 08:03:03 +00:00
|
|
|
std::set<size_t> const & templatedParams,
|
|
|
|
|
bool raii ) const;
|
2022-05-04 06:37:09 +00:00
|
|
|
size_t determineDefaultStartIndex( std::vector<ParamData> const & params, std::set<size_t> const & skippedParams ) const;
|
2022-05-18 07:12:00 +00:00
|
|
|
bool determineEnumeration( std::map<size_t, size_t> const & vectorParams, std::vector<size_t> const & returnParams ) const;
|
|
|
|
|
size_t determineInitialSkipCount( std::string const & command ) const;
|
|
|
|
|
std::vector<size_t> determineReturnParams( std::vector<ParamData> const & params ) const;
|
2021-02-17 09:49:59 +00:00
|
|
|
std::vector<std::map<std::string, CommandData>::const_iterator>
|
2022-02-28 09:11:04 +00:00
|
|
|
determineRAIIHandleConstructors( std::string const & handleType, std::map<std::string, CommandData>::const_iterator destructorIt ) const;
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator determineRAIIHandleDestructor( std::string const & handleType ) const;
|
|
|
|
|
std::set<size_t> determineSkippedParams( std::vector<ParamData> const & params,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
std::vector<size_t> const & returnParam,
|
|
|
|
|
bool singular ) const;
|
|
|
|
|
std::string determineSubStruct( std::pair<std::string, StructureData> const & structure ) const;
|
|
|
|
|
std::map<size_t, size_t> determineVectorParams( std::vector<ParamData> const & params ) const;
|
|
|
|
|
std::set<size_t> determineVoidPointerParams( std::vector<ParamData> const & params ) const;
|
|
|
|
|
void distributeSecondLevelCommands( std::set<std::string> const & specialFunctions );
|
|
|
|
|
std::string findBaseName( std::string aliasName, std::map<std::string, EnumAliasData> const & aliases ) const;
|
|
|
|
|
std::vector<MemberData>::const_iterator findStructMemberIt( std::string const & name, std::vector<MemberData> const & memberData ) const;
|
|
|
|
|
std::vector<MemberData>::const_iterator findStructMemberItByType( std::string const & type, std::vector<MemberData> const & memberData ) const;
|
2022-05-04 06:37:09 +00:00
|
|
|
std::pair<std::string, std::string> generateAllocatorTemplates( std::vector<size_t> const & returnParams,
|
2022-04-06 08:33:08 +00:00
|
|
|
std::vector<std::string> const & returnDataTypes,
|
2022-03-29 07:53:04 +00:00
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
bool definition,
|
2022-04-26 08:39:07 +00:00
|
|
|
bool singular,
|
2022-04-27 08:37:11 +00:00
|
|
|
bool unique,
|
|
|
|
|
bool chained ) const;
|
2022-04-28 09:53:52 +00:00
|
|
|
std::string generateArgumentListEnhanced( std::vector<ParamData> const & params,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::set<size_t> const & skippedParams,
|
|
|
|
|
std::set<size_t> const & singularParams,
|
|
|
|
|
std::set<size_t> const & templatedParams,
|
|
|
|
|
bool definition,
|
|
|
|
|
bool withAllocators,
|
|
|
|
|
bool structureChain,
|
|
|
|
|
bool withDispatcher ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateArgumentListStandard( std::vector<ParamData> const & params, std::set<size_t> const & skippedParams ) const;
|
2022-04-28 09:53:52 +00:00
|
|
|
std::string generateArgumentTemplates( std::vector<ParamData> const & params,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::set<size_t> const & templatedParams,
|
2022-06-07 16:02:52 +00:00
|
|
|
bool chained,
|
2022-06-28 11:33:36 +00:00
|
|
|
bool raii ) const;
|
2021-06-24 09:09:49 +00:00
|
|
|
std::string generateBitmask( std::map<std::string, BitmaskData>::const_iterator bitmaskIt ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateBitmasks( std::vector<RequireData> const & requireData, std::set<std::string> & listedBitmasks, std::string const & title ) const;
|
2021-10-20 14:55:30 +00:00
|
|
|
std::string generateCallArgumentsEnhanced( CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool nonConstPointerAsNullptr,
|
|
|
|
|
std::set<size_t> const & singularParams,
|
2022-01-10 10:50:11 +00:00
|
|
|
std::set<size_t> const & templatedParams,
|
2021-10-20 14:55:30 +00:00
|
|
|
bool raiiHandleMemberFunction ) const;
|
2021-10-14 06:36:04 +00:00
|
|
|
std::string generateCallArgumentsRAIIFactory( std::vector<ParamData> const & params,
|
|
|
|
|
size_t initialSkipCount,
|
2022-01-11 08:45:35 +00:00
|
|
|
std::set<size_t> const & skippedParams,
|
2021-10-14 06:36:04 +00:00
|
|
|
std::set<size_t> const & singularParams ) const;
|
2021-07-21 16:15:31 +00:00
|
|
|
std::string generateCallArgumentsStandard( std::string const & handle, std::vector<ParamData> const & params ) const;
|
2021-08-05 11:13:41 +00:00
|
|
|
std::string generateCallArgumentEnhanced( std::vector<ParamData> const & params,
|
|
|
|
|
size_t paramIndex,
|
|
|
|
|
bool nonConstPointerAsNullptr,
|
|
|
|
|
std::set<size_t> const & singularParams,
|
2022-01-10 10:50:11 +00:00
|
|
|
std::set<size_t> const & templatedParams,
|
2021-08-05 11:13:41 +00:00
|
|
|
bool raiiHandleMemberFunction ) const;
|
|
|
|
|
std::string generateCallArgumentEnhancedConstPointer( ParamData const & param,
|
|
|
|
|
size_t paramIndex,
|
2022-01-10 10:50:11 +00:00
|
|
|
std::set<size_t> const & singularParams,
|
|
|
|
|
std::set<size_t> const & templatedParams ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateCallArgumentEnhancedNonConstPointer(
|
|
|
|
|
ParamData const & param, size_t paramIndex, bool nonConstPointerAsNullptr, std::set<size_t> const & singularParams, bool raiiHandleMemberFunction ) const;
|
|
|
|
|
std::string generateCallArgumentEnhancedValue( std::vector<ParamData> const & params, size_t paramIndex, std::set<size_t> const & singularParams ) const;
|
2022-04-19 09:26:27 +00:00
|
|
|
std::string generateCallSequence( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::set<size_t> const & singularParams,
|
2022-04-27 08:37:11 +00:00
|
|
|
std::set<size_t> const & templatedParams,
|
2022-05-18 07:12:00 +00:00
|
|
|
bool chained,
|
|
|
|
|
bool raii ) const;
|
2022-04-27 08:37:11 +00:00
|
|
|
std::string generateChainTemplates( std::vector<size_t> const & returnParams, bool chained ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateCommand( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string
|
|
|
|
|
generateCommandDefinitions( std::vector<RequireData> const & requireData, std::set<std::string> & listedCommands, std::string const & title ) const;
|
2021-06-24 09:09:49 +00:00
|
|
|
std::string generateCommandDefinitions( std::string const & command, std::string const & handle ) const;
|
2022-04-19 09:26:27 +00:00
|
|
|
std::string generateCommandEnhanced( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
bool singular,
|
|
|
|
|
bool withAllocator,
|
|
|
|
|
bool chained,
|
|
|
|
|
bool unique ) const;
|
2021-07-07 06:30:14 +00:00
|
|
|
std::string generateCommandName( std::string const & vulkanCommandName,
|
|
|
|
|
std::vector<ParamData> const & params,
|
|
|
|
|
size_t initialSkipCount,
|
2022-04-07 13:38:51 +00:00
|
|
|
std::set<std::string> const & tags,
|
|
|
|
|
bool singular,
|
|
|
|
|
bool unique ) const;
|
2021-09-21 11:37:15 +00:00
|
|
|
std::string
|
2022-02-28 09:11:04 +00:00
|
|
|
generateCommandResultMultiSuccessNoErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
2022-03-28 07:58:37 +00:00
|
|
|
std::string generateCommandResultMultiSuccessNoErrors0Return( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateCommandResultMultiSuccessNoErrors2Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, std::vector<size_t> const & returnParams ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string
|
|
|
|
|
generateCommandResultMultiSuccessWithErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string generateCommandResultMultiSuccessWithErrors1Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandResultMultiSuccessWithErrors2Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, std::vector<size_t> const & returnParamIndices ) const;
|
|
|
|
|
std::string generateCommandResultMultiSuccessWithErrors3Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, std::vector<size_t> const & returnParamIndices ) const;
|
2021-09-21 11:37:15 +00:00
|
|
|
std::string
|
2022-02-28 09:11:04 +00:00
|
|
|
generateCommandResultSingleSuccessNoErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
2021-09-08 08:15:49 +00:00
|
|
|
std::string
|
2022-02-28 09:11:04 +00:00
|
|
|
generateCommandResultSingleSuccessWithErrors( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnChain(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnHandle(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnHandle1Vector( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::pair<size_t, size_t> const & vectorParamIndex ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnHandle2Vector( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnValue(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnValue2Vectors( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors1ReturnVoid(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandResultSingleSuccessWithErrors2Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, std::vector<size_t> const & returnParamIndices ) const;
|
|
|
|
|
std::string
|
|
|
|
|
generateCommandResultWithErrors0Return( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
2021-09-08 08:15:49 +00:00
|
|
|
std::string generateCommandSetStandard( std::string const & standard ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateCommandSetStandardEnhanced( bool definition, std::string const & standard, std::string const & enhanced ) const;
|
2021-09-08 08:15:49 +00:00
|
|
|
std::string generateCommandSetStandardEnhancedChained( bool definition,
|
|
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedChained ) const;
|
2022-02-07 08:53:27 +00:00
|
|
|
std::string generateCommandSetStandardEnhancedSingular( bool definition,
|
|
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedSingular ) const;
|
2021-09-08 08:15:49 +00:00
|
|
|
std::string generateCommandSetStandardEnhancedUnique( bool definition,
|
|
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedUnique ) const;
|
|
|
|
|
std::string generateCommandSetStandardEnhancedWithAllocator( bool definition,
|
|
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedWithAllocator ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateCommandSetStandardEnhancedWithAllocatorChained( bool definition,
|
2022-01-03 14:33:51 +00:00
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedWithAllocator,
|
|
|
|
|
std::string const & enhancedChained,
|
|
|
|
|
std::string const & enhancedChainedWithAllocator ) const;
|
2021-10-06 07:47:13 +00:00
|
|
|
std::string generateCommandSetStandardEnhancedWithAllocatorSingular( bool definition,
|
|
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedWithAllocator,
|
|
|
|
|
std::string const & enhancedSingular ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateCommandSetStandardEnhancedWithAllocatorSingularUnique( bool definition,
|
|
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedWithAllocator,
|
|
|
|
|
std::string const & enhancedSingular,
|
|
|
|
|
std::string const & enhancedUnique,
|
|
|
|
|
std::string const & enhancedUniqueWithAllocator,
|
|
|
|
|
std::string const & enhancedUniqueSingular ) const;
|
|
|
|
|
std::string generateCommandSetStandardEnhancedWithAllocatorUnique( bool definition,
|
2021-09-08 08:15:49 +00:00
|
|
|
std::string const & standard,
|
|
|
|
|
std::string const & enhanced,
|
|
|
|
|
std::string const & enhancedWithAllocator,
|
|
|
|
|
std::string const & enhancedUnique,
|
|
|
|
|
std::string const & enhancedUniqueWithAllocator ) const;
|
|
|
|
|
std::string generateCommandSetStandardOrEnhanced( std::string const & standard, std::string const & enhanced ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateCommandStandard( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string generateCommandValue( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string generateCommandVoid0Return( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string
|
|
|
|
|
generateCommandVoid1Return( std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, size_t returnParam ) const;
|
|
|
|
|
std::string generateCommandVoid2Return(
|
|
|
|
|
std::string const & name, CommandData const & commandData, size_t initialSkipCount, bool definition, std::vector<size_t> const & returnParamIndices ) const;
|
2021-11-12 01:59:37 +00:00
|
|
|
std::string generateConstexprString( std::string const & structName ) const;
|
2022-03-24 09:52:24 +00:00
|
|
|
std::string generateDataDeclarations( CommandData const & commandData,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
2022-03-29 07:53:04 +00:00
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
2022-04-06 08:33:08 +00:00
|
|
|
std::set<size_t> const & templatedParams,
|
2022-03-29 07:53:04 +00:00
|
|
|
bool singular,
|
|
|
|
|
bool withAllocator,
|
2022-03-24 09:52:24 +00:00
|
|
|
bool chained,
|
2022-04-26 08:39:07 +00:00
|
|
|
bool unique,
|
2022-06-22 07:21:34 +00:00
|
|
|
bool raii,
|
2022-03-24 09:52:24 +00:00
|
|
|
std::vector<std::string> const & dataTypes,
|
2022-04-28 09:53:52 +00:00
|
|
|
std::string const & dataType,
|
2022-03-24 09:52:24 +00:00
|
|
|
std::string const & returnType,
|
|
|
|
|
std::string const & returnVariable ) const;
|
2022-04-26 08:39:07 +00:00
|
|
|
std::string generateDataPreparation( CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::set<size_t> const & templatedParams,
|
|
|
|
|
bool singular,
|
|
|
|
|
bool withAllocator,
|
2022-04-27 08:37:11 +00:00
|
|
|
bool unique,
|
2022-04-28 09:53:52 +00:00
|
|
|
bool chained,
|
|
|
|
|
bool enumerating ) const;
|
2022-04-06 08:33:08 +00:00
|
|
|
std::string generateDataSizeChecks( CommandData const & commandData,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
std::vector<std::string> const & returnParamTypes,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::set<size_t> const & templatedParams,
|
|
|
|
|
bool singular ) const;
|
2021-07-13 07:01:55 +00:00
|
|
|
std::string generateDestroyCommand( std::string const & name, CommandData const & commandData ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string
|
|
|
|
|
generateDispatchLoaderDynamicCommandAssignment( std::string const & commandName, CommandData const & commandData, std::string const & firstArg ) const;
|
2021-07-21 15:09:21 +00:00
|
|
|
std::string generateDispatchLoaderStaticCommands( std::vector<RequireData> const & requireData,
|
2021-07-08 15:30:53 +00:00
|
|
|
std::set<std::string> & listedCommands,
|
2021-07-09 07:01:56 +00:00
|
|
|
std::string const & title ) const;
|
2021-07-13 07:01:55 +00:00
|
|
|
std::string generateEnum( std::pair<std::string, EnumData> const & enumData ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateEnums( std::vector<RequireData> const & requireData, std::set<std::string> & listedEnums, std::string const & title ) const;
|
2021-07-13 07:01:55 +00:00
|
|
|
std::string generateEnumInitializer( TypeInfo const & type,
|
|
|
|
|
std::vector<std::string> const & arraySizes,
|
|
|
|
|
std::vector<EnumValueData> const & values,
|
|
|
|
|
bool bitmask ) const;
|
|
|
|
|
std::string generateEnumToString( std::pair<std::string, EnumData> const & enumData ) const;
|
2021-07-26 15:59:25 +00:00
|
|
|
std::string generateFailureCheck( std::vector<std::string> const & successCodes ) const;
|
|
|
|
|
std::string generateFunctionPointerCheck( std::string const & function, std::string const & referencedIn ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateHandle( std::pair<std::string, HandleData> const & handle, std::set<std::string> & listedHandles ) const;
|
2021-09-14 08:01:02 +00:00
|
|
|
std::string generateHandleCommandDeclarations( std::set<std::string> const & commands ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateHandleDependencies( std::pair<std::string, HandleData> const & handle, std::set<std::string> & listedHandles ) const;
|
2021-09-14 08:01:02 +00:00
|
|
|
std::string generateHandleEmpty( HandleData const & handleData ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateHandleHashStructures( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
2020-12-10 16:23:44 +00:00
|
|
|
std::string
|
2022-04-07 13:38:51 +00:00
|
|
|
generateLenInitializer( std::vector<MemberData>::const_iterator mit,
|
|
|
|
|
std::map<std::vector<MemberData>::const_iterator, std::vector<std::vector<MemberData>::const_iterator>>::const_iterator litit,
|
|
|
|
|
bool mutualExclusiveLens ) const;
|
|
|
|
|
std::string generateName( TypeInfo const & typeInfo ) const;
|
|
|
|
|
std::string generateObjectDeleter( std::string const & commandName, CommandData const & commandData, size_t initialSkipCount, size_t returnParam ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::pair<std::string, std::string> generateProtection( std::string const & referencedIn, std::string const & protect ) const;
|
2020-05-18 10:02:10 +00:00
|
|
|
std::pair<std::string, std::string> generateProtection( std::string const & type, bool isAliased ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string
|
|
|
|
|
generateRAIICommandDefinitions( std::vector<RequireData> const & requireData, std::set<std::string> & listedCommands, std::string const & title ) const;
|
|
|
|
|
std::string generateRAIIHandle( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::set<std::string> & listedHandles,
|
|
|
|
|
std::set<std::string> const & specialFunctions ) const;
|
2021-10-25 09:22:02 +00:00
|
|
|
std::string generateRAIIHandleCommand( std::string const & command, size_t initialSkipCount, bool definition ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleCommandDeclarations( std::pair<std::string, HandleData> const & handle, std::set<std::string> const & specialFunctions ) const;
|
2022-05-17 08:15:04 +00:00
|
|
|
std::string generateRAIIHandleCommandEnhanced( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
2022-05-18 07:12:00 +00:00
|
|
|
std::vector<size_t> const & returnParams,
|
2022-05-17 08:15:04 +00:00
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
2022-06-07 16:02:52 +00:00
|
|
|
bool definition,
|
2022-06-20 10:26:30 +00:00
|
|
|
bool chained,
|
|
|
|
|
bool singular ) const;
|
2021-10-14 06:36:04 +00:00
|
|
|
std::string generateRAIIHandleCommandFactory( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
2022-05-18 07:12:00 +00:00
|
|
|
std::vector<size_t> const & returnParams,
|
2022-05-11 08:00:53 +00:00
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
bool definition,
|
|
|
|
|
bool singular ) const;
|
2021-10-14 06:36:04 +00:00
|
|
|
std::string generateRAIIHandleCommandFactoryArgumentList( std::vector<ParamData> const & params,
|
2022-01-11 08:45:35 +00:00
|
|
|
std::set<size_t> const & skippedParams,
|
2021-10-14 06:36:04 +00:00
|
|
|
bool definition,
|
|
|
|
|
bool singular ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleCommandResult( std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessNoErrors( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition ) const;
|
2022-03-28 07:58:37 +00:00
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessNoErrors2Return( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
std::vector<size_t> const & returnParams ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessNoErrors2Return1VectorEnumerate( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
std::vector<size_t> const & returnParamIndices,
|
|
|
|
|
bool definition ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessWithErrors( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessWithErrors1Return( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
size_t returnParam ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessWithErrors1ReturnVoidSingular( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
std::vector<size_t> const & returnParamIndices,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessWithErrors2Return( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
std::vector<size_t> const & returnParamIndices ) const;
|
2022-03-23 09:00:40 +00:00
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessWithErrors2ReturnValues( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
bool definition ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleCommandResultMultiSuccessWithErrors3Return( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
std::vector<size_t> const & returnParamIndices ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessNoErrors( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1Return( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
size_t returnParam ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueSingular( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnValueVector( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors1ReturnVoidSingular( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors2Return( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
bool definition,
|
|
|
|
|
std::vector<size_t> const & returnParamIndices ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandValue( std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
|
|
|
|
|
std::string generateRAIIHandleCommandVoid( std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
|
2022-05-18 07:12:00 +00:00
|
|
|
std::string generateRAIIHandleCommandVoid1ReturnVoidVectorSingular( std::map<std::string, CommandData>::const_iterator commandIt,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
bool definition ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::pair<std::string, std::string> generateRAIIHandleConstructor( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
|
|
|
|
std::pair<std::string, std::string> generateRAIIHandleConstructor1Return2Vector( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices ) const;
|
|
|
|
|
std::pair<std::string, std::string> generateRAIIHandleConstructors( std::pair<std::string, HandleData> const & handle ) const;
|
|
|
|
|
std::string generateRAIIHandleConstructorArgument( ParamData const & param, bool definition, bool singular, bool takesOwnership ) const;
|
|
|
|
|
std::string generateRAIIHandleConstructorArguments( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
|
|
|
|
|
bool singular,
|
|
|
|
|
bool takesOwnership ) const;
|
|
|
|
|
std::string generateRAIIHandleConstructorCallArguments( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, VulkanHppGenerator::CommandData>::const_iterator constructorIt,
|
|
|
|
|
bool nonConstPointerAsNullptr,
|
|
|
|
|
std::set<size_t> const & singularParams,
|
|
|
|
|
bool allocatorIsMemberVariable ) const;
|
2021-09-06 12:38:17 +00:00
|
|
|
std::string generateRAIIHandleConstructorEnumerate( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::vector<ParamData>::const_iterator handleParamIt,
|
|
|
|
|
std::vector<ParamData>::const_iterator lenParamIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleConstructorInitializationList( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator destructorIt,
|
|
|
|
|
bool takesOwnership ) const;
|
|
|
|
|
std::string generateRAIIHandleConstructorParamName( std::string const & type, std::map<std::string, CommandData>::const_iterator destructorIt ) const;
|
|
|
|
|
std::pair<std::string, std::string> generateRAIIHandleConstructorResult( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
|
|
|
|
std::string generateRAIIHandleConstructorResultSingleSuccessWithErrors1Return0Vector( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
2021-07-26 15:59:25 +00:00
|
|
|
std::string generateRAIIHandleConstructorTakeOwnership( std::pair<std::string, HandleData> const & handle ) const;
|
2021-09-06 12:38:17 +00:00
|
|
|
std::string generateRAIIHandleConstructorVector( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::vector<ParamData>::const_iterator handleParamIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleConstructorVectorSingular( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::vector<ParamData>::const_iterator handleParamIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
|
|
|
|
std::pair<std::string, std::string> generateRAIIHandleConstructorVoid( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
|
|
|
|
std::string generateRAIIHandleConstructorVoid1Return0Vector( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt,
|
|
|
|
|
std::string const & enter,
|
|
|
|
|
std::string const & leave ) const;
|
|
|
|
|
std::string generateRAIIHandleContext( std::pair<std::string, HandleData> const & handle, std::set<std::string> const & specialFunctions ) const;
|
|
|
|
|
std::string generateRAIIHandleDestructorCallArguments( std::string const & handleType,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator destructorIt ) const;
|
2022-02-15 09:50:52 +00:00
|
|
|
std::tuple<std::string, std::string, std::string, std::string, std::string, std::string>
|
|
|
|
|
generateRAIIHandleDetails( std::pair<std::string, HandleData> const & handle ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateRAIIHandleForwardDeclarations( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
|
|
|
|
std::string generateRAIIHandleSingularConstructorArguments( std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::map<std::string, CommandData>::const_iterator constructorIt ) const;
|
2021-07-26 15:59:25 +00:00
|
|
|
std::string generateRAIIHandleVectorSizeCheck( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, std::vector<size_t>> const & countToVectorMap,
|
|
|
|
|
std::set<size_t> const & skippedParams ) const;
|
2022-03-24 09:52:24 +00:00
|
|
|
std::string generateResultAssignment( CommandData const & commandData ) const;
|
2022-04-28 09:53:52 +00:00
|
|
|
std::string generateResultCheck(
|
|
|
|
|
CommandData const & commandData, std::string const & className, std::string const & classSeparator, std::string commandName, bool enumerating ) const;
|
2022-04-07 13:38:51 +00:00
|
|
|
std::string generateReturnStatement( std::string const & commandName,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
std::string const & returnVariable,
|
|
|
|
|
std::string const & returnType,
|
|
|
|
|
std::string const & dataType,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
size_t returnParam,
|
2022-04-28 09:53:52 +00:00
|
|
|
bool unique,
|
2022-05-25 18:21:21 +00:00
|
|
|
bool enumerating,
|
|
|
|
|
bool raii ) const;
|
2022-05-18 07:12:00 +00:00
|
|
|
std::string generateReturnType(
|
2022-05-25 18:21:21 +00:00
|
|
|
CommandData const & commandData, std::vector<size_t> const & returnParams, bool unique, bool chained, bool raii, std::string const & dataType ) const;
|
2022-04-19 09:26:27 +00:00
|
|
|
std::string generateReturnVariable( CommandData const & commandData,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
bool chained,
|
|
|
|
|
bool singular ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string
|
|
|
|
|
generateSizeCheck( std::vector<std::vector<MemberData>::const_iterator> const & arrayIts, std::string const & structName, bool mutualExclusiveLens ) const;
|
|
|
|
|
std::string generateStruct( std::pair<std::string, StructureData> const & structure, std::set<std::string> & listedStructs ) const;
|
2021-09-28 06:56:30 +00:00
|
|
|
std::string generateStructAssignmentOperators( std::pair<std::string, StructureData> const & structure ) const;
|
2022-01-03 11:35:24 +00:00
|
|
|
std::string generateStructCompareOperators( std::pair<std::string, StructureData> const & structure ) const;
|
2021-09-28 06:56:30 +00:00
|
|
|
std::string generateStructConstructors( std::pair<std::string, StructureData> const & structData ) const;
|
|
|
|
|
std::string generateStructConstructorsEnhanced( std::pair<std::string, StructureData> const & structData ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateStructConstructorArgument( bool listedArgument, MemberData const & memberData, bool withDefault ) const;
|
|
|
|
|
std::string generateStructHashStructure( std::pair<std::string, StructureData> const & structure, std::set<std::string> & listedStructs ) const;
|
2021-12-02 11:21:30 +00:00
|
|
|
std::string generateStructHashSum( std::string const & structName, std::vector<MemberData> const & members ) const;
|
2021-09-28 06:56:30 +00:00
|
|
|
std::string generateStructure( std::pair<std::string, StructureData> const & structure ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string
|
|
|
|
|
generateStructExtendsStructs( std::vector<RequireData> const & requireData, std::set<std::string> & listedStructs, std::string const & title ) const;
|
|
|
|
|
std::string generateStructForwardDeclarations( std::vector<RequireData> const & requireData, std::string const & title ) const;
|
|
|
|
|
std::tuple<std::string, std::string, std::string, std::string> generateStructMembers( std::pair<std::string, StructureData> const & structData ) const;
|
|
|
|
|
std::string generateStructSetter( std::string const & structureName, std::vector<MemberData> const & memberData, size_t index ) const;
|
|
|
|
|
std::string generateStructSubConstructor( std::pair<std::string, StructureData> const & structData ) const;
|
|
|
|
|
std::string generateSuccessCheck( std::vector<std::string> const & successCodes ) const;
|
2022-04-28 09:53:52 +00:00
|
|
|
std::string generateSuccessCodeList( std::vector<std::string> const & successCodes, bool enumerating ) const;
|
|
|
|
|
std::string generateTypenameCheck( std::vector<size_t> const & returnParams,
|
2022-03-29 07:53:04 +00:00
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
bool definition,
|
2022-04-28 09:53:52 +00:00
|
|
|
std::vector<std::string> const & dataTypes,
|
2022-03-29 07:53:04 +00:00
|
|
|
bool singular,
|
2022-04-26 08:39:07 +00:00
|
|
|
bool withAllocator,
|
2022-04-27 08:37:11 +00:00
|
|
|
bool unique,
|
|
|
|
|
bool chained ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
std::string generateUnion( std::pair<std::string, StructureData> const & structure ) const;
|
|
|
|
|
std::string generateUniqueTypes( std::string const & parentType, std::set<std::string> const & childrenTypes ) const;
|
|
|
|
|
std::string generateVectorSizeCheck( std::string const & name,
|
|
|
|
|
CommandData const & commandData,
|
|
|
|
|
size_t initialSkipCount,
|
|
|
|
|
std::map<size_t, std::vector<size_t>> const & countToVectorMap,
|
2022-03-15 09:00:04 +00:00
|
|
|
std::set<size_t> const & skippedParams,
|
|
|
|
|
bool onlyThrows ) const;
|
2021-10-20 14:55:30 +00:00
|
|
|
std::pair<std::string, std::string> getParentTypeAndName( std::pair<std::string, HandleData> const & handle ) const;
|
|
|
|
|
std::string getPlatform( std::string const & title ) const;
|
2020-10-07 20:44:44 +00:00
|
|
|
std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const;
|
2022-04-06 08:33:08 +00:00
|
|
|
std::string getVectorSize( std::vector<ParamData> const & params,
|
|
|
|
|
std::map<size_t, size_t> const & vectorParamIndices,
|
|
|
|
|
size_t returnParam,
|
|
|
|
|
std::string const & returnParamType,
|
|
|
|
|
std::set<size_t> const & templatedParams ) const;
|
|
|
|
|
bool hasParentHandle( std::string const & handle, std::string const & parent ) const;
|
|
|
|
|
bool isDeviceCommand( CommandData const & commandData ) const;
|
|
|
|
|
bool isHandleType( std::string const & type ) const;
|
|
|
|
|
bool isLenByStructMember( std::string const & name, std::vector<ParamData> const & params ) const;
|
|
|
|
|
bool isLenByStructMember( std::string const & name, ParamData const & param ) const;
|
|
|
|
|
bool isMultiSuccessCodeConstructor( std::vector<std::map<std::string, CommandData>::const_iterator> const & constructorIts ) const;
|
|
|
|
|
bool isParam( std::string const & name, std::vector<ParamData> const & params ) const;
|
|
|
|
|
bool isStructMember( std::string const & name, std::vector<MemberData> const & memberData ) const;
|
|
|
|
|
bool isStructureChainAnchor( std::string const & type ) const;
|
2022-03-14 13:54:56 +00:00
|
|
|
std::pair<bool, std::map<size_t, std::vector<size_t>>> needsVectorSizeCheck( std::vector<ParamData> const & params,
|
2022-03-29 07:53:04 +00:00
|
|
|
std::map<size_t, size_t> const & vectorParams,
|
|
|
|
|
std::vector<size_t> const & returnParams,
|
2022-03-09 08:25:17 +00:00
|
|
|
std::set<size_t> const & singularParams ) const;
|
2022-02-28 09:11:04 +00:00
|
|
|
void readCommands( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readCommandsCommand( tinyxml2::XMLElement const * element );
|
|
|
|
|
ParamData readCommandsCommandParam( tinyxml2::XMLElement const * element, std::vector<ParamData> const & params );
|
2021-09-28 06:56:30 +00:00
|
|
|
std::pair<std::string, std::string> readCommandsCommandProto( tinyxml2::XMLElement const * element );
|
2020-04-12 19:49:12 +00:00
|
|
|
std::string readComment( tinyxml2::XMLElement const * element );
|
2021-09-28 06:56:30 +00:00
|
|
|
void readEnums( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readEnumsConstant( tinyxml2::XMLElement const * element );
|
2022-02-28 09:11:04 +00:00
|
|
|
void readEnumsEnum( tinyxml2::XMLElement const * element, std::map<std::string, EnumData>::iterator enumIt );
|
|
|
|
|
void readExtensions( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readExtensionsExtension( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readExtensionsExtensionDisabledRequire( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readExtensionsExtensionDisabledRequireCommand( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readExtensionsExtensionDisabledRequireType( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readExtensionsExtensionRequire( tinyxml2::XMLElement const * element, std::map<std::string, ExtensionData>::iterator extensionIt );
|
|
|
|
|
void readExtensionsExtensionRequireCommand( tinyxml2::XMLElement const * element, std::string const & extensionName, RequireData & requireData );
|
|
|
|
|
void readExtensionsExtensionRequireType( tinyxml2::XMLElement const * element, std::string const & extensionName, RequireData & requireData );
|
2020-04-12 19:49:12 +00:00
|
|
|
void readFeature( tinyxml2::XMLElement const * element );
|
2022-02-28 09:11:04 +00:00
|
|
|
void readFeatureRequire( tinyxml2::XMLElement const * element, std::map<std::string, FeatureData>::iterator featureIt );
|
|
|
|
|
void readFeatureRequireCommand( tinyxml2::XMLElement const * element, std::map<std::string, FeatureData>::iterator featureIt, RequireData & requireData );
|
|
|
|
|
void readFeatureRequireType( tinyxml2::XMLElement const * element, std::map<std::string, FeatureData>::iterator featureIt, RequireData & requireData );
|
2021-11-22 13:27:34 +00:00
|
|
|
void readFormats( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readFormatsFormat( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readFormatsFormatComponent( tinyxml2::XMLElement const * element, FormatData & formatData );
|
|
|
|
|
void readFormatsFormatPlane( tinyxml2::XMLElement const * element, FormatData & formatData );
|
|
|
|
|
void readFormatsFormatSPIRVImageFormat( tinyxml2::XMLElement const * element, FormatData & formatData );
|
2020-05-18 10:02:10 +00:00
|
|
|
std::pair<NameData, TypeInfo> readNameAndType( tinyxml2::XMLElement const * elements );
|
2020-04-12 19:49:12 +00:00
|
|
|
void readPlatforms( tinyxml2::XMLElement const * element );
|
2021-09-28 06:56:30 +00:00
|
|
|
void readPlatformsPlatform( tinyxml2::XMLElement const * element );
|
2020-04-12 19:49:12 +00:00
|
|
|
void readRegistry( tinyxml2::XMLElement const * element );
|
2022-02-28 09:11:04 +00:00
|
|
|
void readRequireEnum( tinyxml2::XMLElement const * element, std::string const & extensionName );
|
|
|
|
|
void readSPIRVCapabilities( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readSPIRVCapabilitiesSPIRVCapability( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readSPIRVCapabilitiesSPIRVCapabilityEnable( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readSPIRVCapabilitiesSPIRVCapabilityEnableExtension( int xmlLine, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readSPIRVCapabilitiesSPIRVCapabilityEnableProperty( int xmlLine, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readSPIRVCapabilitiesSPIRVCapabilityEnableStruct( int xmlLine, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readSPIRVCapabilitiesSPIRVCapabilityEnableVersion( int xmlLine, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readSPIRVExtensions( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readSPIRVExtensionsExtension( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readSPIRVExtensionsExtensionEnable( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readTags( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readTagsTag( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readTypes( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readTypesType( tinyxml2::XMLElement const * element );
|
|
|
|
|
void readTypesTypeBasetype( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeBitmask( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeDefine( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeEnum( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeFuncpointer( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeHandle( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeInclude( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeRequires( tinyxml2::XMLElement const * element, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeStruct( tinyxml2::XMLElement const * element, bool isUnion, std::map<std::string, std::string> const & attributes );
|
|
|
|
|
void readTypesTypeStructMember( tinyxml2::XMLElement const * element, std::vector<MemberData> & members, bool isUnion );
|
2021-10-04 10:10:04 +00:00
|
|
|
void readTypesTypeStructMemberEnum( tinyxml2::XMLElement const * element, MemberData & memberData );
|
2022-02-28 09:11:04 +00:00
|
|
|
void readTypesTypeStructMemberName( tinyxml2::XMLElement const * element, MemberData & memberData, std::vector<MemberData> const & members );
|
2021-10-04 10:10:04 +00:00
|
|
|
void readTypesTypeStructMemberType( tinyxml2::XMLElement const * element, MemberData & memberData );
|
2021-07-21 16:15:31 +00:00
|
|
|
TypeInfo readTypeInfo( tinyxml2::XMLElement const * element ) const;
|
|
|
|
|
void registerDeleter( std::string const & name, std::pair<std::string, CommandData> const & commandData );
|
|
|
|
|
void rescheduleRAIIHandle( std::string & str,
|
|
|
|
|
std::pair<std::string, HandleData> const & handle,
|
|
|
|
|
std::set<std::string> & listedHandles,
|
|
|
|
|
std::set<std::string> const & specialFunctions ) const;
|
2021-07-21 15:09:21 +00:00
|
|
|
std::vector<std::string> selectCommandsByHandle( std::vector<RequireData> const & requireData,
|
|
|
|
|
std::set<std::string> const & handleCommands,
|
|
|
|
|
std::set<std::string> & listedCommands ) const;
|
|
|
|
|
void setVulkanLicenseHeader( int line, std::string const & comment );
|
2021-10-20 14:55:30 +00:00
|
|
|
bool skipLeadingGrandParent( std::pair<std::string, HandleData> const & handle ) const;
|
2021-07-21 16:15:31 +00:00
|
|
|
std::string toString( TypeCategory category );
|
2017-12-21 11:40:48 +00:00
|
|
|
|
2020-04-21 12:26:32 +00:00
|
|
|
private:
|
2022-02-28 09:11:04 +00:00
|
|
|
std::map<std::string, BaseTypeData> m_baseTypes;
|
|
|
|
|
std::map<std::string, BitmaskData> m_bitmasks;
|
|
|
|
|
std::map<std::string, CommandData> m_commands;
|
|
|
|
|
std::map<std::string, std::string> m_constants;
|
|
|
|
|
std::set<std::string> m_defines;
|
|
|
|
|
std::map<std::string, EnumData> m_enums;
|
|
|
|
|
std::set<std::string> m_extendedStructs; // structs which are referenced by the structextends tag
|
|
|
|
|
std::map<std::string, ExtensionData> m_extensions;
|
2021-04-29 08:23:41 +00:00
|
|
|
std::map<int, std::map<std::string, ExtensionData>::const_iterator> m_extensionsByNumber;
|
|
|
|
|
std::map<std::string, FeatureData> m_features;
|
2021-11-22 13:27:34 +00:00
|
|
|
std::map<std::string, FormatData> m_formats;
|
2021-04-29 08:23:41 +00:00
|
|
|
std::map<std::string, FuncPointerData> m_funcPointers;
|
|
|
|
|
std::map<std::string, HandleData> m_handles;
|
|
|
|
|
std::set<std::string> m_includes;
|
|
|
|
|
std::map<std::string, PlatformData> m_platforms;
|
2021-07-06 07:13:53 +00:00
|
|
|
std::set<std::string> m_RAIISpecialFunctions;
|
2021-04-29 08:23:41 +00:00
|
|
|
std::map<std::string, StructureData> m_structures;
|
2021-08-04 21:43:49 +00:00
|
|
|
std::map<std::string, StructureAliasData> m_structureAliases;
|
|
|
|
|
std::map<std::string, std::set<std::string>> m_structureAliasesInverse;
|
2021-04-29 08:23:41 +00:00
|
|
|
std::set<std::string> m_tags;
|
|
|
|
|
std::map<std::string, TypeData> m_types;
|
|
|
|
|
std::string m_typesafeCheck;
|
|
|
|
|
std::string m_version;
|
|
|
|
|
std::string m_vulkanLicenseHeader;
|
2019-01-09 10:55:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const size_t INVALID_INDEX = (size_t)~0;
|
