mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-07-04 12:16:10 +00:00
[wgsl-reader] Remove keywords which aren't in spec.
This CL updates the WGSL-Reader to remove the decoration keywords as they are no longer reserved in the spec. The old `::` token is removed as well as namespaces don't exist anymore. Change-Id: I1dfa16c1d7e4866f6c2f9ea7b4f93a48ff5a23d7 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/34481 Auto-Submit: dan sinclair <dsinclair@chromium.org> Reviewed-by: Ben Clayton <bclayton@google.com> Reviewed-by: Ryan Harrison <rharrison@chromium.org> Commit-Queue: dan sinclair <dsinclair@chromium.org>
This commit is contained in:
dan sinclair
Commit Bot service account
parent
15f80a706c
commit
2478ae78bb
@ -411,10 +411,6 @@ Token Lexer::try_punctuation() {
|
||||
type = Token::Type::kBang;
|
||||
pos_ += 1;
|
||||
location_.column += 1;
|
||||
} else if (matches(pos_, "::")) {
|
||||
type = Token::Type::kNamespace;
|
||||
pos_ += 2;
|
||||
location_.column += 2;
|
||||
} else if (matches(pos_, ":")) {
|
||||
type = Token::Type::kColon;
|
||||
pos_ += 1;
|
||||
@ -497,22 +493,14 @@ Token Lexer::try_punctuation() {
|
||||
Token Lexer::check_keyword(const Source& source, const std::string& str) {
|
||||
if (str == "array")
|
||||
return {Token::Type::kArray, source, "array"};
|
||||
if (str == "binding")
|
||||
return {Token::Type::kBinding, source, "binding"};
|
||||
if (str == "bitcast")
|
||||
return {Token::Type::kBitcast, source, "bitcast"};
|
||||
if (str == "block")
|
||||
return {Token::Type::kBlock, source, "block"};
|
||||
if (str == "bool")
|
||||
return {Token::Type::kBool, source, "bool"};
|
||||
if (str == "break")
|
||||
return {Token::Type::kBreak, source, "break"};
|
||||
if (str == "builtin")
|
||||
return {Token::Type::kBuiltin, source, "builtin"};
|
||||
if (str == "case")
|
||||
return {Token::Type::kCase, source, "case"};
|
||||
if (str == "compute")
|
||||
return {Token::Type::kCompute, source, "compute"};
|
||||
if (str == "const")
|
||||
return {Token::Type::kConst, source, "const"};
|
||||
if (str == "continue")
|
||||
@ -607,8 +595,6 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
|
||||
return {Token::Type::kFormatRgba8Unorm, source, "rgba8unorm"};
|
||||
if (str == "rgba8unorm_srgb")
|
||||
return {Token::Type::kFormatRgba8UnormSrgb, source, "rgba8unorm_srgb"};
|
||||
if (str == "fragment")
|
||||
return {Token::Type::kFragment, source, "fragment"};
|
||||
if (str == "function")
|
||||
return {Token::Type::kFunction, source, "function"};
|
||||
if (str == "i32")
|
||||
@ -621,8 +607,6 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
|
||||
return {Token::Type::kImport, source, "import"};
|
||||
if (str == "in")
|
||||
return {Token::Type::kIn, source, "in"};
|
||||
if (str == "location")
|
||||
return {Token::Type::kLocation, source, "location"};
|
||||
if (str == "loop")
|
||||
return {Token::Type::kLoop, source, "loop"};
|
||||
if (str == "mat2x2")
|
||||
@ -643,8 +627,6 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
|
||||
return {Token::Type::kMat4x3, source, "mat4x3"};
|
||||
if (str == "mat4x4")
|
||||
return {Token::Type::kMat4x4, source, "mat4x4"};
|
||||
if (str == "offset")
|
||||
return {Token::Type::kOffset, source, "offset"};
|
||||
if (str == "out")
|
||||
return {Token::Type::kOut, source, "out"};
|
||||
if (str == "private")
|
||||
@ -657,14 +639,8 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
|
||||
return {Token::Type::kSampler, source, "sampler"};
|
||||
if (str == "sampler_comparison")
|
||||
return {Token::Type::kComparisonSampler, source, "sampler_comparison"};
|
||||
if (str == "set")
|
||||
return {Token::Type::kSet, source, "set"};
|
||||
if (str == "stage")
|
||||
return {Token::Type::kStage, source, "stage"};
|
||||
if (str == "storage_buffer")
|
||||
return {Token::Type::kStorageBuffer, source, "storage_buffer"};
|
||||
if (str == "stride")
|
||||
return {Token::Type::kStride, source, "stride"};
|
||||
if (str == "struct")
|
||||
return {Token::Type::kStruct, source, "struct"};
|
||||
if (str == "switch")
|
||||
@ -807,14 +783,10 @@ Token Lexer::check_keyword(const Source& source, const std::string& str) {
|
||||
return {Token::Type::kVec3, source, "vec3"};
|
||||
if (str == "vec4")
|
||||
return {Token::Type::kVec4, source, "vec4"};
|
||||
if (str == "vertex")
|
||||
return {Token::Type::kVertex, source, "vertex"};
|
||||
if (str == "void")
|
||||
return {Token::Type::kVoid, source, "void"};
|
||||
if (str == "workgroup")
|
||||
return {Token::Type::kWorkgroup, source, "workgroup"};
|
||||
if (str == "workgroup_size")
|
||||
return {Token::Type::kWorkgroupSize, source, "workgroup_size"};
|
||||
return {};
|
||||
}
|
||||
|
||||
|
||||
@ -435,7 +435,6 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
TokenData{"%", Token::Type::kMod},
|
||||
TokenData{"!=", Token::Type::kNotEqual},
|
||||
TokenData{"-", Token::Type::kMinus},
|
||||
TokenData{"::", Token::Type::kNamespace},
|
||||
TokenData{".", Token::Type::kPeriod},
|
||||
TokenData{"+", Token::Type::kPlus},
|
||||
TokenData{"|", Token::Type::kOr},
|
||||
@ -468,14 +467,10 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
KeywordTest,
|
||||
testing::Values(
|
||||
TokenData{"array", Token::Type::kArray},
|
||||
TokenData{"binding", Token::Type::kBinding},
|
||||
TokenData{"bitcast", Token::Type::kBitcast},
|
||||
TokenData{"block", Token::Type::kBlock},
|
||||
TokenData{"bool", Token::Type::kBool},
|
||||
TokenData{"break", Token::Type::kBreak},
|
||||
TokenData{"builtin", Token::Type::kBuiltin},
|
||||
TokenData{"case", Token::Type::kCase},
|
||||
TokenData{"compute", Token::Type::kCompute},
|
||||
TokenData{"const", Token::Type::kConst},
|
||||
TokenData{"continue", Token::Type::kContinue},
|
||||
TokenData{"continuing", Token::Type::kContinuing},
|
||||
@ -523,14 +518,12 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
TokenData{"rgba8uint", Token::Type::kFormatRgba8Uint},
|
||||
TokenData{"rgba8unorm", Token::Type::kFormatRgba8Unorm},
|
||||
TokenData{"rgba8unorm_srgb", Token::Type::kFormatRgba8UnormSrgb},
|
||||
TokenData{"fragment", Token::Type::kFragment},
|
||||
TokenData{"function", Token::Type::kFunction},
|
||||
TokenData{"i32", Token::Type::kI32},
|
||||
TokenData{"if", Token::Type::kIf},
|
||||
TokenData{"image", Token::Type::kImage},
|
||||
TokenData{"import", Token::Type::kImport},
|
||||
TokenData{"in", Token::Type::kIn},
|
||||
TokenData{"location", Token::Type::kLocation},
|
||||
TokenData{"loop", Token::Type::kLoop},
|
||||
TokenData{"mat2x2", Token::Type::kMat2x2},
|
||||
TokenData{"mat2x3", Token::Type::kMat2x3},
|
||||
@ -541,17 +534,13 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
TokenData{"mat4x2", Token::Type::kMat4x2},
|
||||
TokenData{"mat4x3", Token::Type::kMat4x3},
|
||||
TokenData{"mat4x4", Token::Type::kMat4x4},
|
||||
TokenData{"offset", Token::Type::kOffset},
|
||||
TokenData{"out", Token::Type::kOut},
|
||||
TokenData{"private", Token::Type::kPrivate},
|
||||
TokenData{"ptr", Token::Type::kPtr},
|
||||
TokenData{"return", Token::Type::kReturn},
|
||||
TokenData{"sampler", Token::Type::kSampler},
|
||||
TokenData{"sampler_comparison", Token::Type::kComparisonSampler},
|
||||
TokenData{"set", Token::Type::kSet},
|
||||
TokenData{"stage", Token::Type::kStage},
|
||||
TokenData{"storage_buffer", Token::Type::kStorageBuffer},
|
||||
TokenData{"stride", Token::Type::kStride},
|
||||
TokenData{"struct", Token::Type::kStruct},
|
||||
TokenData{"switch", Token::Type::kSwitch},
|
||||
TokenData{"texture_1d", Token::Type::kTextureSampled1d},
|
||||
@ -621,10 +610,8 @@ INSTANTIATE_TEST_SUITE_P(
|
||||
TokenData{"vec2", Token::Type::kVec2},
|
||||
TokenData{"vec3", Token::Type::kVec3},
|
||||
TokenData{"vec4", Token::Type::kVec4},
|
||||
TokenData{"vertex", Token::Type::kVertex},
|
||||
TokenData{"void", Token::Type::kVoid},
|
||||
TokenData{"workgroup", Token::Type::kWorkgroup},
|
||||
TokenData{"workgroup_size", Token::Type::kWorkgroupSize}));
|
||||
TokenData{"workgroup", Token::Type::kWorkgroup}));
|
||||
|
||||
using KeywordTest_Reserved = testing::TestWithParam<const char*>;
|
||||
TEST_P(KeywordTest_Reserved, Parses) {
|
||||
|
||||
@ -91,6 +91,13 @@ constexpr uint32_t kMaxConstExprDepth = 128;
|
||||
/// parser on error.
|
||||
constexpr size_t const kMaxResynchronizeLookahead = 32;
|
||||
|
||||
const char kVertexStage[] = "vertex";
|
||||
const char kFragmentStage[] = "fragment";
|
||||
const char kComputeStage[] = "compute";
|
||||
|
||||
const char kReadAccessControl[] = "read";
|
||||
const char kReadWriteAccessControl[] = "read_write";
|
||||
|
||||
ast::Builtin ident_to_builtin(const std::string& str) {
|
||||
if (str == "position") {
|
||||
return ast::Builtin::kPosition;
|
||||
@ -122,10 +129,27 @@ ast::Builtin ident_to_builtin(const std::string& str) {
|
||||
return ast::Builtin::kNone;
|
||||
}
|
||||
|
||||
const char kAccessDecoration[] = "access";
|
||||
const char kBindingDecoration[] = "binding";
|
||||
const char kBlockDecoration[] = "block";
|
||||
const char kBuiltinDecoration[] = "builtin";
|
||||
const char kLocationDecoration[] = "location";
|
||||
const char kOffsetDecoration[] = "offset";
|
||||
const char kSetDecoration[] = "set";
|
||||
const char kStageDecoration[] = "stage";
|
||||
const char kStrideDecoration[] = "stride";
|
||||
const char kWorkgroupSizeDecoration[] = "workgroup_size";
|
||||
|
||||
bool is_decoration(Token t) {
|
||||
return t.IsLocation() || t.IsBinding() || t.IsSet() || t.IsBuiltin() ||
|
||||
t.IsWorkgroupSize() || t.IsStage() || t.IsBlock() || t.IsStride() ||
|
||||
t.IsOffset();
|
||||
if (!t.IsIdentifier())
|
||||
return false;
|
||||
|
||||
auto s = t.to_str();
|
||||
return s == kAccessDecoration || s == kBindingDecoration ||
|
||||
s == kBlockDecoration || s == kBuiltinDecoration ||
|
||||
s == kLocationDecoration || s == kOffsetDecoration ||
|
||||
s == kSetDecoration || s == kStageDecoration ||
|
||||
s == kStrideDecoration || s == kWorkgroupSizeDecoration;
|
||||
}
|
||||
|
||||
/// Enter-exit counters for block token types.
|
||||
@ -850,9 +874,9 @@ Expect<ast::AccessControl> ParserImpl::expect_access_type() {
|
||||
if (ident.errored)
|
||||
return Failure::kErrored;
|
||||
|
||||
if (ident.value == "read")
|
||||
if (ident.value == kReadAccessControl)
|
||||
return {ast::AccessControl::kReadOnly, ident.source};
|
||||
if (ident.value == "read_write")
|
||||
if (ident.value == kReadWriteAccessControl)
|
||||
return {ast::AccessControl::kReadWrite, ident.source};
|
||||
|
||||
return add_error(ident.source, "invalid value for access decoration");
|
||||
@ -1338,15 +1362,24 @@ Expect<ast::VariableList> ParserImpl::expect_param_list() {
|
||||
// | FRAGMENT
|
||||
// | COMPUTE
|
||||
Expect<ast::PipelineStage> ParserImpl::expect_pipeline_stage() {
|
||||
Source source;
|
||||
if (match(Token::Type::kVertex, &source))
|
||||
return {ast::PipelineStage::kVertex, source};
|
||||
auto t = peek();
|
||||
if (!t.IsIdentifier()) {
|
||||
return add_error(t, "invalid value for stage decoration");
|
||||
}
|
||||
|
||||
if (match(Token::Type::kFragment, &source))
|
||||
return {ast::PipelineStage::kFragment, source};
|
||||
|
||||
if (match(Token::Type::kCompute, &source))
|
||||
return {ast::PipelineStage::kCompute, source};
|
||||
auto s = t.to_str();
|
||||
if (s == kVertexStage) {
|
||||
next(); // Consume the peek
|
||||
return {ast::PipelineStage::kVertex, t.source()};
|
||||
}
|
||||
if (s == kFragmentStage) {
|
||||
next(); // Consume the peek
|
||||
return {ast::PipelineStage::kFragment, t.source()};
|
||||
}
|
||||
if (s == kComputeStage) {
|
||||
next(); // Consume the peek
|
||||
return {ast::PipelineStage::kCompute, t.source()};
|
||||
}
|
||||
|
||||
return add_error(peek(), "invalid value for stage decoration");
|
||||
}
|
||||
@ -2774,7 +2807,13 @@ Expect<ast::Decoration*> ParserImpl::expect_decoration() {
|
||||
Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
using Result = Maybe<ast::Decoration*>;
|
||||
auto t = next();
|
||||
if (t.IsIdentifier() && t.to_str() == "access") {
|
||||
|
||||
if (!t.IsIdentifier()) {
|
||||
return Failure::kNoMatch;
|
||||
}
|
||||
|
||||
auto s = t.to_str();
|
||||
if (s == kAccessDecoration) {
|
||||
const char* use = "access decoration";
|
||||
return expect_paren_block(use, [&]() -> Result {
|
||||
auto val = expect_access_type();
|
||||
@ -2784,7 +2823,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::AccessDecoration>(val.value, val.source);
|
||||
});
|
||||
}
|
||||
if (t.IsLocation()) {
|
||||
|
||||
if (s == kLocationDecoration) {
|
||||
const char* use = "location decoration";
|
||||
return expect_paren_block(use, [&]() -> Result {
|
||||
auto val = expect_positive_sint(use);
|
||||
@ -2794,7 +2834,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::LocationDecoration>(val.value, val.source);
|
||||
});
|
||||
}
|
||||
if (t.IsBinding()) {
|
||||
|
||||
if (s == kBindingDecoration) {
|
||||
const char* use = "binding decoration";
|
||||
return expect_paren_block(use, [&]() -> Result {
|
||||
auto val = expect_positive_sint(use);
|
||||
@ -2804,7 +2845,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::BindingDecoration>(val.value, val.source);
|
||||
});
|
||||
}
|
||||
if (t.IsSet()) {
|
||||
|
||||
if (s == kSetDecoration) {
|
||||
const char* use = "set decoration";
|
||||
return expect_paren_block(use, [&]() -> Result {
|
||||
auto val = expect_positive_sint(use);
|
||||
@ -2814,7 +2856,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::SetDecoration>(val.value, val.source);
|
||||
});
|
||||
}
|
||||
if (t.IsBuiltin()) {
|
||||
|
||||
if (s == kBuiltinDecoration) {
|
||||
return expect_paren_block("builtin decoration", [&]() -> Result {
|
||||
auto builtin = expect_builtin();
|
||||
if (builtin.errored)
|
||||
@ -2823,7 +2866,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::BuiltinDecoration>(builtin.value, builtin.source);
|
||||
});
|
||||
}
|
||||
if (t.IsWorkgroupSize()) {
|
||||
|
||||
if (s == kWorkgroupSizeDecoration) {
|
||||
return expect_paren_block("workgroup_size decoration", [&]() -> Result {
|
||||
uint32_t x;
|
||||
uint32_t y = 1;
|
||||
@ -2851,7 +2895,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::WorkgroupDecoration>(x, y, z, t.source());
|
||||
});
|
||||
}
|
||||
if (t.IsStage()) {
|
||||
|
||||
if (s == kStageDecoration) {
|
||||
return expect_paren_block("stage decoration", [&]() -> Result {
|
||||
auto stage = expect_pipeline_stage();
|
||||
if (stage.errored)
|
||||
@ -2860,10 +2905,12 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::StageDecoration>(stage.value, stage.source);
|
||||
});
|
||||
}
|
||||
if (t.IsBlock()) {
|
||||
|
||||
if (s == kBlockDecoration) {
|
||||
return create<ast::StructBlockDecoration>(t.source());
|
||||
}
|
||||
if (t.IsStride()) {
|
||||
|
||||
if (s == kStrideDecoration) {
|
||||
const char* use = "stride decoration";
|
||||
return expect_paren_block(use, [&]() -> Result {
|
||||
auto val = expect_nonzero_positive_sint(use);
|
||||
@ -2873,7 +2920,8 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::StrideDecoration>(val.value, t.source());
|
||||
});
|
||||
}
|
||||
if (t.IsOffset()) {
|
||||
|
||||
if (s == kOffsetDecoration) {
|
||||
const char* use = "offset decoration";
|
||||
return expect_paren_block(use, [&]() -> Result {
|
||||
auto val = expect_positive_sint(use);
|
||||
@ -2883,6 +2931,7 @@ Maybe<ast::Decoration*> ParserImpl::decoration() {
|
||||
return create<ast::StructMemberOffsetDecoration>(val.value, t.source());
|
||||
});
|
||||
}
|
||||
|
||||
return Failure::kNoMatch;
|
||||
}
|
||||
|
||||
|
||||
@ -84,8 +84,6 @@ std::string Token::TypeToName(Type type) {
|
||||
return "!=";
|
||||
case Token::Type::kMinus:
|
||||
return "-";
|
||||
case Token::Type::kNamespace:
|
||||
return "::";
|
||||
case Token::Type::kPeriod:
|
||||
return ".";
|
||||
case Token::Type::kPlus:
|
||||
@ -107,22 +105,14 @@ std::string Token::TypeToName(Type type) {
|
||||
|
||||
case Token::Type::kArray:
|
||||
return "array";
|
||||
case Token::Type::kBinding:
|
||||
return "binding";
|
||||
case Token::Type::kBitcast:
|
||||
return "bitcast";
|
||||
case Token::Type::kBlock:
|
||||
return "block";
|
||||
case Token::Type::kBool:
|
||||
return "bool";
|
||||
case Token::Type::kBreak:
|
||||
return "break";
|
||||
case Token::Type::kBuiltin:
|
||||
return "builtin";
|
||||
case Token::Type::kCase:
|
||||
return "case";
|
||||
case Token::Type::kCompute:
|
||||
return "compute";
|
||||
case Token::Type::kConst:
|
||||
return "const";
|
||||
case Token::Type::kContinue:
|
||||
@ -217,8 +207,6 @@ std::string Token::TypeToName(Type type) {
|
||||
return "rgba8unorm";
|
||||
case Token::Type::kFormatRgba8UnormSrgb:
|
||||
return "rgba8unorm_srgb";
|
||||
case Token::Type::kFragment:
|
||||
return "fragment";
|
||||
case Token::Type::kFunction:
|
||||
return "function";
|
||||
case Token::Type::kI32:
|
||||
@ -231,8 +219,6 @@ std::string Token::TypeToName(Type type) {
|
||||
return "import";
|
||||
case Token::Type::kIn:
|
||||
return "in";
|
||||
case Token::Type::kLocation:
|
||||
return "location";
|
||||
case Token::Type::kLoop:
|
||||
return "loop";
|
||||
case Token::Type::kMat2x2:
|
||||
@ -253,8 +239,6 @@ std::string Token::TypeToName(Type type) {
|
||||
return "mat4x3";
|
||||
case Token::Type::kMat4x4:
|
||||
return "mat4x4";
|
||||
case Token::Type::kOffset:
|
||||
return "offset";
|
||||
case Token::Type::kOut:
|
||||
return "out";
|
||||
case Token::Type::kPrivate:
|
||||
@ -267,14 +251,8 @@ std::string Token::TypeToName(Type type) {
|
||||
return "sampler";
|
||||
case Token::Type::kComparisonSampler:
|
||||
return "sampler_comparison";
|
||||
case Token::Type::kSet:
|
||||
return "set";
|
||||
case Token::Type::kStorageBuffer:
|
||||
return "storage_buffer";
|
||||
case Token::Type::kStride:
|
||||
return "stride";
|
||||
case Token::Type::kStage:
|
||||
return "stage";
|
||||
case Token::Type::kStruct:
|
||||
return "struct";
|
||||
case Token::Type::kSwitch:
|
||||
@ -341,14 +319,10 @@ std::string Token::TypeToName(Type type) {
|
||||
return "vec3";
|
||||
case Token::Type::kVec4:
|
||||
return "vec4";
|
||||
case Token::Type::kVertex:
|
||||
return "vertex";
|
||||
case Token::Type::kVoid:
|
||||
return "void";
|
||||
case Token::Type::kWorkgroup:
|
||||
return "workgroup";
|
||||
case Token::Type::kWorkgroupSize:
|
||||
return "workgroup_size";
|
||||
}
|
||||
|
||||
return "<unknown>";
|
||||
|
||||
@ -93,8 +93,6 @@ class Token {
|
||||
kMod,
|
||||
/// A '-'
|
||||
kMinus,
|
||||
/// A '::'
|
||||
kNamespace,
|
||||
/// A '!='
|
||||
kNotEqual,
|
||||
/// A '.'
|
||||
@ -118,22 +116,14 @@ class Token {
|
||||
|
||||
/// A 'array'
|
||||
kArray,
|
||||
/// A 'binding'
|
||||
kBinding,
|
||||
/// A 'bitcast'
|
||||
kBitcast,
|
||||
/// A 'bool'
|
||||
kBool,
|
||||
/// A 'block'
|
||||
kBlock,
|
||||
/// A 'break'
|
||||
kBreak,
|
||||
/// A 'builtin'
|
||||
kBuiltin,
|
||||
/// A 'case'
|
||||
kCase,
|
||||
/// A 'compute'
|
||||
kCompute,
|
||||
/// A 'const'
|
||||
kConst,
|
||||
/// A 'continue'
|
||||
@ -228,8 +218,6 @@ class Token {
|
||||
kFormatRgba8Unorm,
|
||||
// A 'Rgba8UnormSrgb' format
|
||||
kFormatRgba8UnormSrgb,
|
||||
/// A 'fragment'
|
||||
kFragment,
|
||||
/// A 'function'
|
||||
kFunction,
|
||||
/// A 'i32'
|
||||
@ -242,8 +230,6 @@ class Token {
|
||||
kImport,
|
||||
/// A 'in'
|
||||
kIn,
|
||||
/// A 'location'
|
||||
kLocation,
|
||||
/// A 'loop'
|
||||
kLoop,
|
||||
/// A 'mat2x2'
|
||||
@ -264,8 +250,6 @@ class Token {
|
||||
kMat4x3,
|
||||
/// A 'mat4x4'
|
||||
kMat4x4,
|
||||
/// A 'offset'
|
||||
kOffset,
|
||||
/// A 'out'
|
||||
kOut,
|
||||
/// A 'private'
|
||||
@ -278,14 +262,8 @@ class Token {
|
||||
kSampler,
|
||||
/// A 'sampler_comparison'
|
||||
kComparisonSampler,
|
||||
/// A 'set'
|
||||
kSet,
|
||||
/// A 'storage_buffer'
|
||||
kStorageBuffer,
|
||||
/// A 'stage'
|
||||
kStage,
|
||||
/// A 'stride'
|
||||
kStride,
|
||||
/// A 'struct'
|
||||
kStruct,
|
||||
/// A 'switch'
|
||||
@ -352,14 +330,10 @@ class Token {
|
||||
kVec3,
|
||||
/// A 'vec4'
|
||||
kVec4,
|
||||
/// A 'vertex'
|
||||
kVertex,
|
||||
/// A 'void'
|
||||
kVoid,
|
||||
/// A 'workgroup'
|
||||
kWorkgroup,
|
||||
/// A 'workgroup_size'
|
||||
kWorkgroupSize,
|
||||
};
|
||||
|
||||
/// Converts a token type to a name
|
||||
@ -468,8 +442,6 @@ class Token {
|
||||
bool IsMod() const { return type_ == Type::kMod; }
|
||||
/// @returns true if token is a '-'
|
||||
bool IsMinus() const { return type_ == Type::kMinus; }
|
||||
/// @returns true if token is a '::'
|
||||
bool IsNamespace() const { return type_ == Type::kNamespace; }
|
||||
/// @returns true if token is a '!='
|
||||
bool IsNotEqual() const { return type_ == Type::kNotEqual; }
|
||||
/// @returns true if token is a '.'
|
||||
@ -493,24 +465,16 @@ class Token {
|
||||
|
||||
/// @returns true if token is a 'array'
|
||||
bool IsArray() const { return type_ == Type::kArray; }
|
||||
/// @returns true if token is a 'binding'
|
||||
bool IsBinding() const { return type_ == Type::kBinding; }
|
||||
/// @returns true if token is a 'bitcast'
|
||||
bool IsBitcast() const { return type_ == Type::kBitcast; }
|
||||
/// @returns true if token is a 'block'
|
||||
bool IsBlock() const { return type_ == Type::kBlock; }
|
||||
/// @returns true if token is a 'bool'
|
||||
bool IsBool() const { return type_ == Type::kBool; }
|
||||
/// @returns true if token is a 'break'
|
||||
bool IsBreak() const { return type_ == Type::kBreak; }
|
||||
/// @returns true if token is a 'builtin'
|
||||
bool IsBuiltin() const { return type_ == Type::kBuiltin; }
|
||||
/// @returns true if token is a 'case'
|
||||
bool IsCase() const { return type_ == Type::kCase; }
|
||||
/// @returns true if token is a 'sampler_comparison'
|
||||
bool IsComparisonSampler() const { return type_ == Type::kComparisonSampler; }
|
||||
/// @returns true if token is a 'compute'
|
||||
bool IsCompute() const { return type_ == Type::kCompute; }
|
||||
/// @returns true if token is a 'const'
|
||||
bool IsConst() const { return type_ == Type::kConst; }
|
||||
/// @returns true if token is a 'continue'
|
||||
@ -613,8 +577,6 @@ class Token {
|
||||
bool IsFormatRgba8UnormSrgb() const {
|
||||
return type_ == Type::kFormatRgba8UnormSrgb;
|
||||
}
|
||||
/// @returns true if token is a 'fragment'
|
||||
bool IsFragment() const { return type_ == Type::kFragment; }
|
||||
/// @returns true if token is a 'function'
|
||||
bool IsFunction() const { return type_ == Type::kFunction; }
|
||||
/// @returns true if token is a 'i32'
|
||||
@ -627,8 +589,6 @@ class Token {
|
||||
bool IsImport() const { return type_ == Type::kImport; }
|
||||
/// @returns true if token is a 'in'
|
||||
bool IsIn() const { return type_ == Type::kIn; }
|
||||
/// @returns true if token is a 'location'
|
||||
bool IsLocation() const { return type_ == Type::kLocation; }
|
||||
/// @returns true if token is a 'loop'
|
||||
bool IsLoop() const { return type_ == Type::kLoop; }
|
||||
/// @returns true if token is a 'mat2x2'
|
||||
@ -649,8 +609,6 @@ class Token {
|
||||
bool IsMat4x3() const { return type_ == Type::kMat4x3; }
|
||||
/// @returns true if token is a 'mat4x4'
|
||||
bool IsMat4x4() const { return type_ == Type::kMat4x4; }
|
||||
/// @returns true if token is a 'offset'
|
||||
bool IsOffset() const { return type_ == Type::kOffset; }
|
||||
/// @returns true if token is a 'out'
|
||||
bool IsOut() const { return type_ == Type::kOut; }
|
||||
/// @returns true if token is a 'private'
|
||||
@ -661,14 +619,8 @@ class Token {
|
||||
bool IsReturn() const { return type_ == Type::kReturn; }
|
||||
/// @returns true if token is a 'sampler'
|
||||
bool IsSampler() const { return type_ == Type::kSampler; }
|
||||
/// @returns true if token is a 'set'
|
||||
bool IsSet() const { return type_ == Type::kSet; }
|
||||
/// @returns true if token is a 'stage'
|
||||
bool IsStage() const { return type_ == Type::kStage; }
|
||||
/// @returns true if token is a 'storage_buffer'
|
||||
bool IsStorageBuffer() const { return type_ == Type::kStorageBuffer; }
|
||||
/// @returns true if token is a 'stride'
|
||||
bool IsStride() const { return type_ == Type::kStride; }
|
||||
/// @returns true if token is a 'struct'
|
||||
bool IsStruct() const { return type_ == Type::kStruct; }
|
||||
/// @returns true if token is a 'switch'
|
||||
@ -769,14 +721,10 @@ class Token {
|
||||
bool IsVec3() const { return type_ == Type::kVec3; }
|
||||
/// @returns true if token is a 'vec4'
|
||||
bool IsVec4() const { return type_ == Type::kVec4; }
|
||||
/// @returns true if token is a 'vertex'
|
||||
bool IsVertex() const { return type_ == Type::kVertex; }
|
||||
/// @returns true if token is a 'void'
|
||||
bool IsVoid() const { return type_ == Type::kVoid; }
|
||||
/// @returns true if token is a 'workgroup'
|
||||
bool IsWorkgroup() const { return type_ == Type::kWorkgroup; }
|
||||
/// @returns true if token is a 'workgroup_size'
|
||||
bool IsWorkgroupSize() const { return type_ == Type::kWorkgroupSize; }
|
||||
|
||||
/// @returns the source information for this token
|
||||
Source source() const { return source_; }
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user