Skip to content

Commit 4bcd12c

Browse files
inbelicinbelic
committed
clang-formatting
1 parent 002e60c commit 4bcd12c

File tree

2 files changed

+54
-38
lines changed

2 files changed

+54
-38
lines changed

‎clang/include/clang/Parse/ParseHLSLRootSignature.h

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -66,15 +66,16 @@ class RootSignatureParser {
6666

6767
/// Parses as many optional parameters as possible in any order
6868
bool ParseOptionalParams(
69-
llvm::SmallDenseMap<TokenKind, llvm::hlsl::rootsig::ParamType> &RefMap, TokenKind Context);
69+
llvm::SmallDenseMap<TokenKind, llvm::hlsl::rootsig::ParamType> &RefMap,
70+
TokenKind Context);
7071

7172
/// Use NumericLiteralParser to convert CurToken.NumSpelling into a unsigned
7273
/// 32-bit integer
7374
bool HandleUIntLiteral(uint32_t &X);
7475
bool ParseRegister(llvm::hlsl::rootsig::Register *Reg, TokenKind Context);
7576
bool ParseUInt(uint32_t *X, TokenKind Context);
76-
bool
77-
ParseDescriptorRangeOffset(llvm::hlsl::rootsig::DescriptorRangeOffset *X, TokenKind Context);
77+
bool ParseDescriptorRangeOffset(llvm::hlsl::rootsig::DescriptorRangeOffset *X,
78+
TokenKind Context);
7879

7980
/// Method for parsing any type of the ENUM defined token kinds (from
8081
/// HLSLRootSignatureTokenKinds.def)
@@ -90,7 +91,8 @@ class RootSignatureParser {
9091

9192
/// Helper methods that define the mappings and invoke ParseEnum for
9293
/// different enum types
93-
bool ParseShaderVisibility(llvm::hlsl::rootsig::ShaderVisibility *Enum, TokenKind Context);
94+
bool ParseShaderVisibility(llvm::hlsl::rootsig::ShaderVisibility *Enum,
95+
TokenKind Context);
9496

9597
/// A wrapper method around ParseEnum that will parse an 'or' chain of
9698
/// enums, with AllowZero = true
@@ -101,7 +103,8 @@ class RootSignatureParser {
101103
/// Helper methods that define the mappings and invoke ParseFlags for
102104
/// different enum types
103105
bool
104-
ParseDescriptorRangeFlags(llvm::hlsl::rootsig::DescriptorRangeFlags *Enum, TokenKind Context);
106+
ParseDescriptorRangeFlags(llvm::hlsl::rootsig::DescriptorRangeFlags *Enum,
107+
TokenKind Context);
105108

106109
/// Invoke the Lexer to consume a token and update CurToken with the result
107110
void ConsumeNextToken() { CurToken = Lexer.ConsumeToken(); }

‎clang/lib/Parse/ParseHLSLRootSignature.cpp

Lines changed: 46 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -53,15 +53,18 @@ bool RootSignatureParser::Parse() {
5353
while (!ParseRootElement()) {
5454
if (Lexer.EndOfBuffer())
5555
return false;
56-
if (ConsumeExpectedToken(TokenKind::pu_comma, diag::err_expected_either, TokenKind::end_of_stream))
56+
if (ConsumeExpectedToken(TokenKind::pu_comma, diag::err_expected_either,
57+
TokenKind::end_of_stream))
5758
return true;
5859
}
5960

6061
return true;
6162
}
6263

6364
bool RootSignatureParser::ParseRootElement() {
64-
if (ConsumeExpectedToken(TokenKind::kw_DescriptorTable, diag::err_hlsl_expected_param, /*Context=*/TokenKind::kw_RootSignature))
65+
if (ConsumeExpectedToken(TokenKind::kw_DescriptorTable,
66+
diag::err_hlsl_expected_param,
67+
/*Context=*/TokenKind::kw_RootSignature))
6568
return true;
6669

6770
// Dispatch onto the correct parse method
@@ -77,7 +80,8 @@ bool RootSignatureParser::ParseRootElement() {
7780
bool RootSignatureParser::ParseDescriptorTable() {
7881
DescriptorTable Table;
7982

80-
if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after, CurToken.Kind))
83+
if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
84+
CurToken.Kind))
8185
return true;
8286

8387
// Empty case:
@@ -108,7 +112,8 @@ bool RootSignatureParser::ParseDescriptorTable() {
108112
Table.NumClauses++;
109113
} while (TryConsumeExpectedToken(TokenKind::pu_comma));
110114

111-
if (ConsumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after, CurToken.Kind))
115+
if (ConsumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after,
116+
CurToken.Kind))
112117
return true;
113118

114119
Elements.push_back(Table);
@@ -144,7 +149,8 @@ bool RootSignatureParser::ParseDescriptorTableClause() {
144149
// Store context of clause token type we are parsing
145150
TokenKind Context = CurToken.Kind;
146151

147-
if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after, CurToken.Kind))
152+
if (ConsumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
153+
CurToken.Kind))
148154
return true;
149155

150156
// Consume mandatory Register paramater
@@ -161,7 +167,8 @@ bool RootSignatureParser::ParseDescriptorTableClause() {
161167
if (ParseOptionalParams({RefMap}, Context))
162168
return true;
163169

164-
if (ConsumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after, CurToken.Kind))
170+
if (ConsumeExpectedToken(TokenKind::pu_r_paren, diag::err_expected_after,
171+
CurToken.Kind))
165172
return true;
166173

167174
Elements.push_back(Clause);
@@ -173,22 +180,24 @@ template <class... Ts> struct ParseMethods : Ts... { using Ts::operator()...; };
173180
template <class... Ts> ParseMethods(Ts...) -> ParseMethods<Ts...>;
174181

175182
bool RootSignatureParser::ParseParam(ParamType Ref, TokenKind Context) {
176-
if (ConsumeExpectedToken(TokenKind::pu_equal, diag::err_expected_after, CurToken.Kind))
183+
if (ConsumeExpectedToken(TokenKind::pu_equal, diag::err_expected_after,
184+
CurToken.Kind))
177185
return true;
178186

179187
bool Error;
180-
std::visit(
181-
ParseMethods{
182-
[&](uint32_t *X) { Error = ParseUInt(X, Context); },
183-
[&](DescriptorRangeOffset *X) {
184-
Error = ParseDescriptorRangeOffset(X, Context);
185-
},
186-
[&](ShaderVisibility *Enum) { Error = ParseShaderVisibility(Enum, Context); },
187-
[&](DescriptorRangeFlags *Flags) {
188-
Error = ParseDescriptorRangeFlags(Flags, Context);
189-
},
190-
},
191-
Ref);
188+
std::visit(ParseMethods{
189+
[&](uint32_t *X) { Error = ParseUInt(X, Context); },
190+
[&](DescriptorRangeOffset *X) {
191+
Error = ParseDescriptorRangeOffset(X, Context);
192+
},
193+
[&](ShaderVisibility *Enum) {
194+
Error = ParseShaderVisibility(Enum, Context);
195+
},
196+
[&](DescriptorRangeFlags *Flags) {
197+
Error = ParseDescriptorRangeFlags(Flags, Context);
198+
},
199+
},
200+
Ref);
192201

193202
return Error;
194203
}
@@ -203,7 +212,8 @@ bool RootSignatureParser::ParseOptionalParams(
203212
llvm::SmallDenseSet<TokenKind> Seen;
204213

205214
while (TryConsumeExpectedToken(TokenKind::pu_comma)) {
206-
if (ConsumeExpectedToken(ParamKeywords, diag::err_hlsl_expected_param, Context))
215+
if (ConsumeExpectedToken(ParamKeywords, diag::err_hlsl_expected_param,
216+
Context))
207217
return true;
208218

209219
TokenKind ParamKind = CurToken.Kind;
@@ -247,8 +257,7 @@ bool RootSignatureParser::HandleUIntLiteral(uint32_t &X) {
247257
bool RootSignatureParser::ParseRegister(Register *Register, TokenKind Context) {
248258
if (ConsumeExpectedToken(
249259
{TokenKind::bReg, TokenKind::tReg, TokenKind::uReg, TokenKind::sReg},
250-
diag::err_hlsl_expected_param,
251-
Context))
260+
diag::err_hlsl_expected_param, Context))
252261
return true;
253262

254263
switch (CurToken.Kind) {
@@ -277,7 +286,8 @@ bool RootSignatureParser::ParseRegister(Register *Register, TokenKind Context) {
277286
bool RootSignatureParser::ParseUInt(uint32_t *X, TokenKind Context) {
278287
// Treat a postively signed integer as though it is unsigned to match DXC
279288
TryConsumeExpectedToken(TokenKind::pu_plus);
280-
if (ConsumeExpectedToken(TokenKind::int_literal, diag::err_hlsl_expected_value, Context))
289+
if (ConsumeExpectedToken(TokenKind::int_literal,
290+
diag::err_hlsl_expected_value, Context))
281291
return true;
282292

283293
if (HandleUIntLiteral(*X))
@@ -286,12 +296,11 @@ bool RootSignatureParser::ParseUInt(uint32_t *X, TokenKind Context) {
286296
return false;
287297
}
288298

289-
bool RootSignatureParser::ParseDescriptorRangeOffset(DescriptorRangeOffset *X, TokenKind Context) {
299+
bool RootSignatureParser::ParseDescriptorRangeOffset(DescriptorRangeOffset *X,
300+
TokenKind Context) {
290301
if (ConsumeExpectedToken(
291302
{TokenKind::int_literal, TokenKind::en_DescriptorRangeOffsetAppend},
292-
diag::err_hlsl_expected_value,
293-
Context
294-
))
303+
diag::err_hlsl_expected_value, Context))
295304
return true;
296305

297306
// Edge case for the offset enum -> static value
@@ -309,7 +318,8 @@ bool RootSignatureParser::ParseDescriptorRangeOffset(DescriptorRangeOffset *X, T
309318

310319
template <bool AllowZero, typename EnumType>
311320
bool RootSignatureParser::ParseEnum(
312-
llvm::SmallDenseMap<TokenKind, EnumType> &EnumMap, EnumType *Enum, TokenKind Context) {
321+
llvm::SmallDenseMap<TokenKind, EnumType> &EnumMap, EnumType *Enum,
322+
TokenKind Context) {
313323
SmallVector<TokenKind> EnumToks;
314324
if (AllowZero)
315325
EnumToks.push_back(TokenKind::int_literal); // '0' is a valid flag value
@@ -344,7 +354,8 @@ bool RootSignatureParser::ParseEnum(
344354
llvm_unreachable("Switch for an expected token was not provided");
345355
}
346356

347-
bool RootSignatureParser::ParseShaderVisibility(ShaderVisibility *Enum, TokenKind Context) {
357+
bool RootSignatureParser::ParseShaderVisibility(ShaderVisibility *Enum,
358+
TokenKind Context) {
348359
// Define the possible flag kinds
349360
llvm::SmallDenseMap<TokenKind, ShaderVisibility> EnumMap = {
350361
#define SHADER_VISIBILITY_ENUM(NAME, LIT) \
@@ -357,7 +368,8 @@ bool RootSignatureParser::ParseShaderVisibility(ShaderVisibility *Enum, TokenKin
357368

358369
template <typename FlagType>
359370
bool RootSignatureParser::ParseFlags(
360-
llvm::SmallDenseMap<TokenKind, FlagType> &FlagMap, FlagType *Flags, TokenKind Context) {
371+
llvm::SmallDenseMap<TokenKind, FlagType> &FlagMap, FlagType *Flags,
372+
TokenKind Context) {
361373
// Override the default value to 0 so that we can correctly 'or' the values
362374
*Flags = FlagType(0);
363375

@@ -372,8 +384,8 @@ bool RootSignatureParser::ParseFlags(
372384
return false;
373385
}
374386

375-
bool RootSignatureParser::ParseDescriptorRangeFlags(
376-
DescriptorRangeFlags *Flags, TokenKind Context) {
387+
bool RootSignatureParser::ParseDescriptorRangeFlags(DescriptorRangeFlags *Flags,
388+
TokenKind Context) {
377389
// Define the possible flag kinds
378390
llvm::SmallDenseMap<TokenKind, DescriptorRangeFlags> FlagMap = {
379391
#define DESCRIPTOR_RANGE_FLAG_ENUM(NAME, LIT, ON) \
@@ -425,7 +437,8 @@ bool RootSignatureParser::ConsumeExpectedToken(ArrayRef<TokenKind> AnyExpected,
425437
case diag::err_hlsl_expected_value:
426438
DB << FormatTokenKinds(AnyExpected) << FormatTokenKinds({Context});
427439
break;
428-
default: break;
440+
default:
441+
break;
429442
}
430443
return true;
431444
}

0 commit comments

Comments
 (0)