blob: b1ac41e50250936d7aa3b2c22e8db5ee2fe6e5c4 [file] [log] [blame] [edit]
// Copyright 2021 The Tint Authors.
//
// 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.
////////////////////////////////////////////////////////////////////////////////
// File generated by tools/src/cmd/gen
// using the template:
// src/tint/resolver/intrinsic_table.inl.tmpl
//
// Do not modify this file directly
////////////////////////////////////////////////////////////////////////////////
// clang-format off
/// TypeMatcher for 'type bool'
class Bool : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Bool::Match(MatchState& state, const sem::Type* ty) const {
if (!match_bool(ty)) {
return nullptr;
}
return build_bool(state);
}
std::string Bool::String(MatchState*) const {
return "bool";
}
/// TypeMatcher for 'type ia'
class Ia : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Ia::Match(MatchState& state, const sem::Type* ty) const {
if (!match_ia(ty)) {
return nullptr;
}
return build_ia(state);
}
std::string Ia::String(MatchState*) const {
std::stringstream ss;
ss << "abstract-int";
return ss.str();
}
/// TypeMatcher for 'type fa'
class Fa : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Fa::Match(MatchState& state, const sem::Type* ty) const {
if (!match_fa(ty)) {
return nullptr;
}
return build_fa(state);
}
std::string Fa::String(MatchState*) const {
std::stringstream ss;
ss << "abstract-float";
return ss.str();
}
/// TypeMatcher for 'type i32'
class I32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* I32::Match(MatchState& state, const sem::Type* ty) const {
if (!match_i32(ty)) {
return nullptr;
}
return build_i32(state);
}
std::string I32::String(MatchState*) const {
return "i32";
}
/// TypeMatcher for 'type u32'
class U32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* U32::Match(MatchState& state, const sem::Type* ty) const {
if (!match_u32(ty)) {
return nullptr;
}
return build_u32(state);
}
std::string U32::String(MatchState*) const {
return "u32";
}
/// TypeMatcher for 'type f32'
class F32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* F32::Match(MatchState& state, const sem::Type* ty) const {
if (!match_f32(ty)) {
return nullptr;
}
return build_f32(state);
}
std::string F32::String(MatchState*) const {
return "f32";
}
/// TypeMatcher for 'type f16'
class F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* F16::Match(MatchState& state, const sem::Type* ty) const {
if (!match_f16(ty)) {
return nullptr;
}
return build_f16(state);
}
std::string F16::String(MatchState*) const {
return "f16";
}
/// TypeMatcher for 'type vec2'
class Vec2 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Vec2::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_vec2(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_vec2(state, T);
}
std::string Vec2::String(MatchState* state) const {
const std::string T = state->TypeName();
return "vec2<" + T + ">";
}
/// TypeMatcher for 'type vec3'
class Vec3 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Vec3::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_vec3(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_vec3(state, T);
}
std::string Vec3::String(MatchState* state) const {
const std::string T = state->TypeName();
return "vec3<" + T + ">";
}
/// TypeMatcher for 'type vec4'
class Vec4 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Vec4::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_vec4(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_vec4(state, T);
}
std::string Vec4::String(MatchState* state) const {
const std::string T = state->TypeName();
return "vec4<" + T + ">";
}
/// TypeMatcher for 'type mat2x2'
class Mat2X2 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat2X2::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat2x2(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat2x2(state, T);
}
std::string Mat2X2::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat2x2<" + T + ">";
}
/// TypeMatcher for 'type mat2x3'
class Mat2X3 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat2X3::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat2x3(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat2x3(state, T);
}
std::string Mat2X3::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat2x3<" + T + ">";
}
/// TypeMatcher for 'type mat2x4'
class Mat2X4 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat2X4::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat2x4(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat2x4(state, T);
}
std::string Mat2X4::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat2x4<" + T + ">";
}
/// TypeMatcher for 'type mat3x2'
class Mat3X2 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat3X2::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat3x2(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat3x2(state, T);
}
std::string Mat3X2::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat3x2<" + T + ">";
}
/// TypeMatcher for 'type mat3x3'
class Mat3X3 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat3X3::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat3x3(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat3x3(state, T);
}
std::string Mat3X3::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat3x3<" + T + ">";
}
/// TypeMatcher for 'type mat3x4'
class Mat3X4 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat3X4::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat3x4(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat3x4(state, T);
}
std::string Mat3X4::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat3x4<" + T + ">";
}
/// TypeMatcher for 'type mat4x2'
class Mat4X2 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat4X2::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat4x2(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat4x2(state, T);
}
std::string Mat4X2::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat4x2<" + T + ">";
}
/// TypeMatcher for 'type mat4x3'
class Mat4X3 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat4X3::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat4x3(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat4x3(state, T);
}
std::string Mat4X3::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat4x3<" + T + ">";
}
/// TypeMatcher for 'type mat4x4'
class Mat4X4 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat4X4::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_mat4x4(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat4x4(state, T);
}
std::string Mat4X4::String(MatchState* state) const {
const std::string T = state->TypeName();
return "mat4x4<" + T + ">";
}
/// TypeMatcher for 'type vec'
class Vec : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Vec::Match(MatchState& state, const sem::Type* ty) const {
Number N = Number::invalid;
const sem::Type* T = nullptr;
if (!match_vec(ty, N, T)) {
return nullptr;
}
N = state.Num(N);
if (!N.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_vec(state, N, T);
}
std::string Vec::String(MatchState* state) const {
const std::string N = state->NumName();
const std::string T = state->TypeName();
std::stringstream ss;
ss << "vec" << N << "<" << T << ">";
return ss.str();
}
/// TypeMatcher for 'type mat'
class Mat : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Mat::Match(MatchState& state, const sem::Type* ty) const {
Number N = Number::invalid;
Number M = Number::invalid;
const sem::Type* T = nullptr;
if (!match_mat(ty, N, M, T)) {
return nullptr;
}
N = state.Num(N);
if (!N.IsValid()) {
return nullptr;
}
M = state.Num(M);
if (!M.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_mat(state, N, M, T);
}
std::string Mat::String(MatchState* state) const {
const std::string N = state->NumName();
const std::string M = state->NumName();
const std::string T = state->TypeName();
std::stringstream ss;
ss << "mat" << N << "x" << M << "<" << T << ">";
return ss.str();
}
/// TypeMatcher for 'type ptr'
class Ptr : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Ptr::Match(MatchState& state, const sem::Type* ty) const {
Number S = Number::invalid;
const sem::Type* T = nullptr;
Number A = Number::invalid;
if (!match_ptr(ty, S, T, A)) {
return nullptr;
}
S = state.Num(S);
if (!S.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return build_ptr(state, S, T, A);
}
std::string Ptr::String(MatchState* state) const {
const std::string S = state->NumName();
const std::string T = state->TypeName();
const std::string A = state->NumName();
return "ptr<" + S + ", " + T + ", " + A + ">";
}
/// TypeMatcher for 'type atomic'
class Atomic : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Atomic::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_atomic(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_atomic(state, T);
}
std::string Atomic::String(MatchState* state) const {
const std::string T = state->TypeName();
return "atomic<" + T + ">";
}
/// TypeMatcher for 'type array'
class Array : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Array::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_array(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_array(state, T);
}
std::string Array::String(MatchState* state) const {
const std::string T = state->TypeName();
return "array<" + T + ">";
}
/// TypeMatcher for 'type sampler'
class Sampler : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Sampler::Match(MatchState& state, const sem::Type* ty) const {
if (!match_sampler(ty)) {
return nullptr;
}
return build_sampler(state);
}
std::string Sampler::String(MatchState*) const {
return "sampler";
}
/// TypeMatcher for 'type sampler_comparison'
class SamplerComparison : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* SamplerComparison::Match(MatchState& state, const sem::Type* ty) const {
if (!match_sampler_comparison(ty)) {
return nullptr;
}
return build_sampler_comparison(state);
}
std::string SamplerComparison::String(MatchState*) const {
return "sampler_comparison";
}
/// TypeMatcher for 'type texture_1d'
class Texture1D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Texture1D::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_1d(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_1d(state, T);
}
std::string Texture1D::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_1d<" + T + ">";
}
/// TypeMatcher for 'type texture_2d'
class Texture2D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Texture2D::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_2d(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_2d(state, T);
}
std::string Texture2D::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_2d<" + T + ">";
}
/// TypeMatcher for 'type texture_2d_array'
class Texture2DArray : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Texture2DArray::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_2d_array(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_2d_array(state, T);
}
std::string Texture2DArray::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_2d_array<" + T + ">";
}
/// TypeMatcher for 'type texture_3d'
class Texture3D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Texture3D::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_3d(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_3d(state, T);
}
std::string Texture3D::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_3d<" + T + ">";
}
/// TypeMatcher for 'type texture_cube'
class TextureCube : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureCube::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_cube(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_cube(state, T);
}
std::string TextureCube::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_cube<" + T + ">";
}
/// TypeMatcher for 'type texture_cube_array'
class TextureCubeArray : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureCubeArray::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_cube_array(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_cube_array(state, T);
}
std::string TextureCubeArray::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_cube_array<" + T + ">";
}
/// TypeMatcher for 'type texture_multisampled_2d'
class TextureMultisampled2D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureMultisampled2D::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_texture_multisampled_2d(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_texture_multisampled_2d(state, T);
}
std::string TextureMultisampled2D::String(MatchState* state) const {
const std::string T = state->TypeName();
return "texture_multisampled_2d<" + T + ">";
}
/// TypeMatcher for 'type texture_depth_2d'
class TextureDepth2D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureDepth2D::Match(MatchState& state, const sem::Type* ty) const {
if (!match_texture_depth_2d(ty)) {
return nullptr;
}
return build_texture_depth_2d(state);
}
std::string TextureDepth2D::String(MatchState*) const {
return "texture_depth_2d";
}
/// TypeMatcher for 'type texture_depth_2d_array'
class TextureDepth2DArray : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureDepth2DArray::Match(MatchState& state, const sem::Type* ty) const {
if (!match_texture_depth_2d_array(ty)) {
return nullptr;
}
return build_texture_depth_2d_array(state);
}
std::string TextureDepth2DArray::String(MatchState*) const {
return "texture_depth_2d_array";
}
/// TypeMatcher for 'type texture_depth_cube'
class TextureDepthCube : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureDepthCube::Match(MatchState& state, const sem::Type* ty) const {
if (!match_texture_depth_cube(ty)) {
return nullptr;
}
return build_texture_depth_cube(state);
}
std::string TextureDepthCube::String(MatchState*) const {
return "texture_depth_cube";
}
/// TypeMatcher for 'type texture_depth_cube_array'
class TextureDepthCubeArray : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureDepthCubeArray::Match(MatchState& state, const sem::Type* ty) const {
if (!match_texture_depth_cube_array(ty)) {
return nullptr;
}
return build_texture_depth_cube_array(state);
}
std::string TextureDepthCubeArray::String(MatchState*) const {
return "texture_depth_cube_array";
}
/// TypeMatcher for 'type texture_depth_multisampled_2d'
class TextureDepthMultisampled2D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureDepthMultisampled2D::Match(MatchState& state, const sem::Type* ty) const {
if (!match_texture_depth_multisampled_2d(ty)) {
return nullptr;
}
return build_texture_depth_multisampled_2d(state);
}
std::string TextureDepthMultisampled2D::String(MatchState*) const {
return "texture_depth_multisampled_2d";
}
/// TypeMatcher for 'type texture_storage_1d'
class TextureStorage1D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureStorage1D::Match(MatchState& state, const sem::Type* ty) const {
Number F = Number::invalid;
Number A = Number::invalid;
if (!match_texture_storage_1d(ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return build_texture_storage_1d(state, F, A);
}
std::string TextureStorage1D::String(MatchState* state) const {
const std::string F = state->NumName();
const std::string A = state->NumName();
return "texture_storage_1d<" + F + ", " + A + ">";
}
/// TypeMatcher for 'type texture_storage_2d'
class TextureStorage2D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureStorage2D::Match(MatchState& state, const sem::Type* ty) const {
Number F = Number::invalid;
Number A = Number::invalid;
if (!match_texture_storage_2d(ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return build_texture_storage_2d(state, F, A);
}
std::string TextureStorage2D::String(MatchState* state) const {
const std::string F = state->NumName();
const std::string A = state->NumName();
return "texture_storage_2d<" + F + ", " + A + ">";
}
/// TypeMatcher for 'type texture_storage_2d_array'
class TextureStorage2DArray : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureStorage2DArray::Match(MatchState& state, const sem::Type* ty) const {
Number F = Number::invalid;
Number A = Number::invalid;
if (!match_texture_storage_2d_array(ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return build_texture_storage_2d_array(state, F, A);
}
std::string TextureStorage2DArray::String(MatchState* state) const {
const std::string F = state->NumName();
const std::string A = state->NumName();
return "texture_storage_2d_array<" + F + ", " + A + ">";
}
/// TypeMatcher for 'type texture_storage_3d'
class TextureStorage3D : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureStorage3D::Match(MatchState& state, const sem::Type* ty) const {
Number F = Number::invalid;
Number A = Number::invalid;
if (!match_texture_storage_3d(ty, F, A)) {
return nullptr;
}
F = state.Num(F);
if (!F.IsValid()) {
return nullptr;
}
A = state.Num(A);
if (!A.IsValid()) {
return nullptr;
}
return build_texture_storage_3d(state, F, A);
}
std::string TextureStorage3D::String(MatchState* state) const {
const std::string F = state->NumName();
const std::string A = state->NumName();
return "texture_storage_3d<" + F + ", " + A + ">";
}
/// TypeMatcher for 'type texture_external'
class TextureExternal : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* TextureExternal::Match(MatchState& state, const sem::Type* ty) const {
if (!match_texture_external(ty)) {
return nullptr;
}
return build_texture_external(state);
}
std::string TextureExternal::String(MatchState*) const {
return "texture_external";
}
/// TypeMatcher for 'type __modf_result'
class ModfResult : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ModfResult::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_modf_result(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_modf_result(state, T);
}
std::string ModfResult::String(MatchState* state) const {
const std::string T = state->TypeName();
std::stringstream ss;
ss << "__modf_result_" << T;
return ss.str();
}
/// TypeMatcher for 'type __modf_result_vec'
class ModfResultVec : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ModfResultVec::Match(MatchState& state, const sem::Type* ty) const {
Number N = Number::invalid;
const sem::Type* T = nullptr;
if (!match_modf_result_vec(ty, N, T)) {
return nullptr;
}
N = state.Num(N);
if (!N.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_modf_result_vec(state, N, T);
}
std::string ModfResultVec::String(MatchState* state) const {
const std::string N = state->NumName();
const std::string T = state->TypeName();
std::stringstream ss;
ss << "__modf_result_vec" << N << "_" << T;
return ss.str();
}
/// TypeMatcher for 'type __frexp_result'
class FrexpResult : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FrexpResult::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_frexp_result(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_frexp_result(state, T);
}
std::string FrexpResult::String(MatchState* state) const {
const std::string T = state->TypeName();
std::stringstream ss;
ss << "__frexp_result_" << T;
return ss.str();
}
/// TypeMatcher for 'type __frexp_result_vec'
class FrexpResultVec : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FrexpResultVec::Match(MatchState& state, const sem::Type* ty) const {
Number N = Number::invalid;
const sem::Type* T = nullptr;
if (!match_frexp_result_vec(ty, N, T)) {
return nullptr;
}
N = state.Num(N);
if (!N.IsValid()) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_frexp_result_vec(state, N, T);
}
std::string FrexpResultVec::String(MatchState* state) const {
const std::string N = state->NumName();
const std::string T = state->TypeName();
std::stringstream ss;
ss << "__frexp_result_vec" << N << "_" << T;
return ss.str();
}
/// TypeMatcher for 'type __atomic_compare_exchange_result'
class AtomicCompareExchangeResult : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* AtomicCompareExchangeResult::Match(MatchState& state, const sem::Type* ty) const {
const sem::Type* T = nullptr;
if (!match_atomic_compare_exchange_result(ty, T)) {
return nullptr;
}
T = state.Type(T);
if (T == nullptr) {
return nullptr;
}
return build_atomic_compare_exchange_result(state, T);
}
std::string AtomicCompareExchangeResult::String(MatchState* state) const {
const std::string T = state->TypeName();
return "__atomic_compare_exchange_result<" + T + ">";
}
/// TypeMatcher for 'match abstract_or_scalar'
class AbstractOrScalar : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* AbstractOrScalar::Match(MatchState& state, const sem::Type* ty) const {
if (match_ia(ty)) {
return build_ia(state);
}
if (match_fa(ty)) {
return build_fa(state);
}
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
if (match_bool(ty)) {
return build_bool(state);
}
return nullptr;
}
std::string AbstractOrScalar::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Ia().String(nullptr) << ", " << Fa().String(nullptr) << ", " << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match scalar'
class Scalar : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Scalar::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
if (match_bool(ty)) {
return build_bool(state);
}
return nullptr;
}
std::string Scalar::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match scalar_no_f32'
class ScalarNoF32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ScalarNoF32::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
if (match_bool(ty)) {
return build_bool(state);
}
return nullptr;
}
std::string ScalarNoF32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << I32().String(nullptr) << ", " << F16().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match scalar_no_f16'
class ScalarNoF16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ScalarNoF16::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_bool(ty)) {
return build_bool(state);
}
return nullptr;
}
std::string ScalarNoF16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match scalar_no_i32'
class ScalarNoI32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ScalarNoI32::Match(MatchState& state, const sem::Type* ty) const {
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
if (match_bool(ty)) {
return build_bool(state);
}
return nullptr;
}
std::string ScalarNoI32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << U32().String(nullptr) << " or " << Bool().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match scalar_no_u32'
class ScalarNoU32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ScalarNoU32::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
if (match_bool(ty)) {
return build_bool(state);
}
return nullptr;
}
std::string ScalarNoU32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << " or " << Bool().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match scalar_no_bool'
class ScalarNoBool : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* ScalarNoBool::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string ScalarNoBool::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << F16().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fia_fiu32_f16'
class FiaFiu32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FiaFiu32F16::Match(MatchState& state, const sem::Type* ty) const {
if (match_ia(ty)) {
return build_ia(state);
}
if (match_fa(ty)) {
return build_fa(state);
}
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string FiaFiu32F16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Fa().String(nullptr) << ", " << Ia().String(nullptr) << ", " << F32().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << F16().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fia_fi32_f16'
class FiaFi32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FiaFi32F16::Match(MatchState& state, const sem::Type* ty) const {
if (match_ia(ty)) {
return build_ia(state);
}
if (match_fa(ty)) {
return build_fa(state);
}
if (match_i32(ty)) {
return build_i32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string FiaFi32F16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Fa().String(nullptr) << ", " << Ia().String(nullptr) << ", " << F32().String(nullptr) << ", " << I32().String(nullptr) << " or " << F16().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fia_fiu32'
class FiaFiu32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FiaFiu32::Match(MatchState& state, const sem::Type* ty) const {
if (match_ia(ty)) {
return build_ia(state);
}
if (match_fa(ty)) {
return build_fa(state);
}
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
return nullptr;
}
std::string FiaFiu32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Fa().String(nullptr) << ", " << Ia().String(nullptr) << ", " << F32().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fa_f32'
class FaF32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FaF32::Match(MatchState& state, const sem::Type* ty) const {
if (match_fa(ty)) {
return build_fa(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
return nullptr;
}
std::string FaF32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Fa().String(nullptr) << " or " << F32().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fa_f32_f16'
class FaF32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* FaF32F16::Match(MatchState& state, const sem::Type* ty) const {
if (match_fa(ty)) {
return build_fa(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string FaF32F16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Fa().String(nullptr) << ", " << F32().String(nullptr) << " or " << F16().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match ia_iu32'
class IaIu32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* IaIu32::Match(MatchState& state, const sem::Type* ty) const {
if (match_ia(ty)) {
return build_ia(state);
}
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
return nullptr;
}
std::string IaIu32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << Ia().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fiu32_f16'
class Fiu32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Fiu32F16::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string Fiu32F16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << I32().String(nullptr) << ", " << U32().String(nullptr) << " or " << F16().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fiu32'
class Fiu32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Fiu32::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
return nullptr;
}
std::string Fiu32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << I32().String(nullptr) << " or " << U32().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fi32_f16'
class Fi32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Fi32F16::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string Fi32F16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << ", " << I32().String(nullptr) << " or " << F16().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match fi32'
class Fi32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Fi32::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_f32(ty)) {
return build_f32(state);
}
return nullptr;
}
std::string Fi32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << " or " << I32().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match f32_f16'
class F32F16 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* F32F16::Match(MatchState& state, const sem::Type* ty) const {
if (match_f32(ty)) {
return build_f32(state);
}
if (match_f16(ty)) {
return build_f16(state);
}
return nullptr;
}
std::string F32F16::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << F32().String(nullptr) << " or " << F16().String(nullptr);
return ss.str();
}
/// TypeMatcher for 'match iu32'
class Iu32 : public TypeMatcher {
public:
/// Checks whether the given type matches the matcher rules, and returns the
/// expected, canonicalized type on success.
/// Match may define and refine the template types and numbers in state.
/// @param state the MatchState
/// @param type the type to match
/// @returns the canonicalized type on match, otherwise nullptr
const sem::Type* Match(MatchState& state,
const sem::Type* type) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
const sem::Type* Iu32::Match(MatchState& state, const sem::Type* ty) const {
if (match_i32(ty)) {
return build_i32(state);
}
if (match_u32(ty)) {
return build_u32(state);
}
return nullptr;
}
std::string Iu32::String(MatchState*) const {
std::stringstream ss;
// Note: We pass nullptr to the TypeMatcher::String() functions, as 'matcher's do not support
// template arguments, nor can they match sub-types. As such, they have no use for the MatchState.
ss << I32().String(nullptr) << " or " << U32().String(nullptr);
return ss.str();
}
/// EnumMatcher for 'match f32_texel_format'
class F32TexelFormat : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number F32TexelFormat::Match(MatchState&, Number number) const {
switch (static_cast<TexelFormat>(number.Value())) {
case TexelFormat::kRgba8Unorm:
case TexelFormat::kRgba8Snorm:
case TexelFormat::kRgba16Float:
case TexelFormat::kR32Float:
case TexelFormat::kRg32Float:
case TexelFormat::kRgba32Float:
return number;
default:
return Number::invalid;
}
}
std::string F32TexelFormat::String(MatchState*) const {
return "rgba8unorm, rgba8snorm, rgba16float, r32float, rg32float or rgba32float";
}
/// EnumMatcher for 'match i32_texel_format'
class I32TexelFormat : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number I32TexelFormat::Match(MatchState&, Number number) const {
switch (static_cast<TexelFormat>(number.Value())) {
case TexelFormat::kRgba8Sint:
case TexelFormat::kRgba16Sint:
case TexelFormat::kR32Sint:
case TexelFormat::kRg32Sint:
case TexelFormat::kRgba32Sint:
return number;
default:
return Number::invalid;
}
}
std::string I32TexelFormat::String(MatchState*) const {
return "rgba8sint, rgba16sint, r32sint, rg32sint or rgba32sint";
}
/// EnumMatcher for 'match u32_texel_format'
class U32TexelFormat : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number U32TexelFormat::Match(MatchState&, Number number) const {
switch (static_cast<TexelFormat>(number.Value())) {
case TexelFormat::kRgba8Uint:
case TexelFormat::kRgba16Uint:
case TexelFormat::kR32Uint:
case TexelFormat::kRg32Uint:
case TexelFormat::kRgba32Uint:
return number;
default:
return Number::invalid;
}
}
std::string U32TexelFormat::String(MatchState*) const {
return "rgba8uint, rgba16uint, r32uint, rg32uint or rgba32uint";
}
/// EnumMatcher for 'match write'
class Write : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number Write::Match(MatchState&, Number number) const {
if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kWrite)) {
return Number(static_cast<uint32_t>(Access::kWrite));
}
return Number::invalid;
}
std::string Write::String(MatchState*) const {
return "write";
}
/// EnumMatcher for 'match read_write'
class ReadWrite : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number ReadWrite::Match(MatchState&, Number number) const {
if (number.IsAny() || number.Value() == static_cast<uint32_t>(Access::kReadWrite)) {
return Number(static_cast<uint32_t>(Access::kReadWrite));
}
return Number::invalid;
}
std::string ReadWrite::String(MatchState*) const {
return "read_write";
}
/// EnumMatcher for 'match function_private_workgroup'
class FunctionPrivateWorkgroup : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number FunctionPrivateWorkgroup::Match(MatchState&, Number number) const {
switch (static_cast<StorageClass>(number.Value())) {
case StorageClass::kFunction:
case StorageClass::kPrivate:
case StorageClass::kWorkgroup:
return number;
default:
return Number::invalid;
}
}
std::string FunctionPrivateWorkgroup::String(MatchState*) const {
return "function, private or workgroup";
}
/// EnumMatcher for 'match workgroup_or_storage'
class WorkgroupOrStorage : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number WorkgroupOrStorage::Match(MatchState&, Number number) const {
switch (static_cast<StorageClass>(number.Value())) {
case StorageClass::kWorkgroup:
case StorageClass::kStorage:
return number;
default:
return Number::invalid;
}
}
std::string WorkgroupOrStorage::String(MatchState*) const {
return "workgroup or storage";
}
/// EnumMatcher for 'match storage'
class Storage : public NumberMatcher {
public:
/// Checks whether the given number matches the enum matcher rules.
/// Match may define template numbers in state.
/// @param state the MatchState
/// @param number the enum value as a Number
/// @return true if the enum value matches the set
Number Match(MatchState& state, Number number) const override;
/// @param state the MatchState
/// @return a string representation of the matcher.
std::string String(MatchState* state) const override;
};
Number Storage::Match(MatchState&, Number number) const {
if (number.IsAny() || number.Value() == static_cast<uint32_t>(StorageClass::kStorage)) {
return Number(static_cast<uint32_t>(StorageClass::kStorage));
}
return Number::invalid;
}
std::string Storage::String(MatchState*) const {
return "storage";
}
/// Matchers holds type and number matchers
class Matchers {
private:
TemplateTypeMatcher template_type_0_{0};
TemplateTypeMatcher template_type_1_{1};
TemplateNumberMatcher template_number_0_{0};
TemplateNumberMatcher template_number_1_{1};
TemplateNumberMatcher template_number_2_{2};
Bool Bool_;
Ia Ia_;
Fa Fa_;
I32 I32_;
U32 U32_;
F32 F32_;
F16 F16_;
Vec2 Vec2_;
Vec3 Vec3_;
Vec4 Vec4_;
Mat2X2 Mat2X2_;
Mat2X3 Mat2X3_;
Mat2X4 Mat2X4_;
Mat3X2 Mat3X2_;
Mat3X3 Mat3X3_;
Mat3X4 Mat3X4_;
Mat4X2 Mat4X2_;
Mat4X3 Mat4X3_;
Mat4X4 Mat4X4_;
Vec Vec_;
Mat Mat_;
Ptr Ptr_;
Atomic Atomic_;
Array Array_;
Sampler Sampler_;
SamplerComparison SamplerComparison_;
Texture1D Texture1D_;
Texture2D Texture2D_;
Texture2DArray Texture2DArray_;
Texture3D Texture3D_;
TextureCube TextureCube_;
TextureCubeArray TextureCubeArray_;
TextureMultisampled2D TextureMultisampled2D_;
TextureDepth2D TextureDepth2D_;
TextureDepth2DArray TextureDepth2DArray_;
TextureDepthCube TextureDepthCube_;
TextureDepthCubeArray TextureDepthCubeArray_;
TextureDepthMultisampled2D TextureDepthMultisampled2D_;
TextureStorage1D TextureStorage1D_;
TextureStorage2D TextureStorage2D_;
TextureStorage2DArray TextureStorage2DArray_;
TextureStorage3D TextureStorage3D_;
TextureExternal TextureExternal_;
ModfResult ModfResult_;
ModfResultVec ModfResultVec_;
FrexpResult FrexpResult_;
FrexpResultVec FrexpResultVec_;
AtomicCompareExchangeResult AtomicCompareExchangeResult_;
AbstractOrScalar AbstractOrScalar_;
Scalar Scalar_;
ScalarNoF32 ScalarNoF32_;
ScalarNoF16 ScalarNoF16_;
ScalarNoI32 ScalarNoI32_;
ScalarNoU32 ScalarNoU32_;
ScalarNoBool ScalarNoBool_;
FiaFiu32F16 FiaFiu32F16_;
FiaFi32F16 FiaFi32F16_;
FiaFiu32 FiaFiu32_;
FaF32 FaF32_;
FaF32F16 FaF32F16_;
IaIu32 IaIu32_;
Fiu32F16 Fiu32F16_;
Fiu32 Fiu32_;
Fi32F16 Fi32F16_;
Fi32 Fi32_;
F32F16 F32F16_;
Iu32 Iu32_;
F32TexelFormat F32TexelFormat_;
I32TexelFormat I32TexelFormat_;
U32TexelFormat U32TexelFormat_;
Write Write_;
ReadWrite ReadWrite_;
FunctionPrivateWorkgroup FunctionPrivateWorkgroup_;
WorkgroupOrStorage WorkgroupOrStorage_;
Storage Storage_;
public:
/// Constructor
Matchers();
/// Destructor
~Matchers();
/// The template types, types, and type matchers
TypeMatcher const* const type[69] = {
/* [0] */ &template_type_0_,
/* [1] */ &template_type_1_,
/* [2] */ &Bool_,
/* [3] */ &Ia_,
/* [4] */ &Fa_,
/* [5] */ &I32_,
/* [6] */ &U32_,
/* [7] */ &F32_,
/* [8] */ &F16_,
/* [9] */ &Vec2_,
/* [10] */ &Vec3_,
/* [11] */ &Vec4_,
/* [12] */ &Mat2X2_,
/* [13] */ &Mat2X3_,
/* [14] */ &Mat2X4_,
/* [15] */ &Mat3X2_,
/* [16] */ &Mat3X3_,
/* [17] */ &Mat3X4_,
/* [18] */ &Mat4X2_,
/* [19] */ &Mat4X3_,
/* [20] */ &Mat4X4_,
/* [21] */ &Vec_,
/* [22] */ &Mat_,
/* [23] */ &Ptr_,
/* [24] */ &Atomic_,
/* [25] */ &Array_,
/* [26] */ &Sampler_,
/* [27] */ &SamplerComparison_,
/* [28] */ &Texture1D_,
/* [29] */ &Texture2D_,
/* [30] */ &Texture2DArray_,
/* [31] */ &Texture3D_,
/* [32] */ &TextureCube_,
/* [33] */ &TextureCubeArray_,
/* [34] */ &TextureMultisampled2D_,
/* [35] */ &TextureDepth2D_,
/* [36] */ &TextureDepth2DArray_,
/* [37] */ &TextureDepthCube_,
/* [38] */ &TextureDepthCubeArray_,
/* [39] */ &TextureDepthMultisampled2D_,
/* [40] */ &TextureStorage1D_,
/* [41] */ &TextureStorage2D_,
/* [42] */ &TextureStorage2DArray_,
/* [43] */ &TextureStorage3D_,
/* [44] */ &TextureExternal_,
/* [45] */ &ModfResult_,
/* [46] */ &ModfResultVec_,
/* [47] */ &FrexpResult_,
/* [48] */ &FrexpResultVec_,
/* [49] */ &AtomicCompareExchangeResult_,
/* [50] */ &AbstractOrScalar_,
/* [51] */ &Scalar_,
/* [52] */ &ScalarNoF32_,
/* [53] */ &ScalarNoF16_,
/* [54] */ &ScalarNoI32_,
/* [55] */ &ScalarNoU32_,
/* [56] */ &ScalarNoBool_,
/* [57] */ &FiaFiu32F16_,
/* [58] */ &FiaFi32F16_,
/* [59] */ &FiaFiu32_,
/* [60] */ &FaF32_,
/* [61] */ &FaF32F16_,
/* [62] */ &IaIu32_,
/* [63] */ &Fiu32F16_,
/* [64] */ &Fiu32_,
/* [65] */ &Fi32F16_,
/* [66] */ &Fi32_,
/* [67] */ &F32F16_,
/* [68] */ &Iu32_,
};
/// The template numbers, and number matchers
NumberMatcher const* const number[11] = {
/* [0] */ &template_number_0_,
/* [1] */ &template_number_1_,
/* [2] */ &template_number_2_,
/* [3] */ &F32TexelFormat_,
/* [4] */ &I32TexelFormat_,
/* [5] */ &U32TexelFormat_,
/* [6] */ &Write_,
/* [7] */ &ReadWrite_,
/* [8] */ &FunctionPrivateWorkgroup_,
/* [9] */ &WorkgroupOrStorage_,
/* [10] */ &Storage_,
};
};
Matchers::Matchers() = default;
Matchers::~Matchers() = default;
constexpr MatcherIndex kMatcherIndices[] = {
/* [0] */ 23,
/* [1] */ 0,
/* [2] */ 24,
/* [3] */ 0,
/* [4] */ 7,
/* [5] */ 23,
/* [6] */ 10,
/* [7] */ 25,
/* [8] */ 0,
/* [9] */ 0,
/* [10] */ 22,
/* [11] */ 0,
/* [12] */ 1,
/* [13] */ 0,
/* [14] */ 22,
/* [15] */ 0,
/* [16] */ 2,
/* [17] */ 0,
/* [18] */ 22,
/* [19] */ 1,
/* [20] */ 0,
/* [21] */ 0,
/* [22] */ 22,
/* [23] */ 1,
/* [24] */ 2,
/* [25] */ 0,
/* [26] */ 22,
/* [27] */ 0,
/* [28] */ 0,
/* [29] */ 0,
/* [30] */ 21,
/* [31] */ 0,
/* [32] */ 0,
/* [33] */ 43,
/* [34] */ 5,
/* [35] */ 6,
/* [36] */ 42,
/* [37] */ 5,
/* [38] */ 6,
/* [39] */ 21,
/* [40] */ 0,
/* [41] */ 2,
/* [42] */ 41,
/* [43] */ 5,
/* [44] */ 6,
/* [45] */ 40,
/* [46] */ 5,
/* [47] */ 6,
/* [48] */ 42,
/* [49] */ 0,
/* [50] */ 1,
/* [51] */ 43,
/* [52] */ 4,
/* [53] */ 6,
/* [54] */ 42,
/* [55] */ 4,
/* [56] */ 6,
/* [57] */ 41,
/* [58] */ 4,
/* [59] */ 6,
/* [60] */ 21,
/* [61] */ 0,
/* [62] */ 7,
/* [63] */ 40,
/* [64] */ 4,
/* [65] */ 6,
/* [66] */ 43,
/* [67] */ 3,
/* [68] */ 6,
/* [69] */ 21,
/* [70] */ 1,
/* [71] */ 0,
/* [72] */ 42,
/* [73] */ 3,
/* [74] */ 6,
/* [75] */ 41,
/* [76] */ 3,
/* [77] */ 6,
/* [78] */ 48,
/* [79] */ 0,
/* [80] */ 0,
/* [81] */ 43,
/* [82] */ 0,
/* [83] */ 1,
/* [84] */ 41,
/* [85] */ 0,
/* [86] */ 1,
/* [87] */ 40,
/* [88] */ 0,
/* [89] */ 1,
/* [90] */ 21,
/* [91] */ 0,
/* [92] */ 5,
/* [93] */ 21,
/* [94] */ 0,
/* [95] */ 6,
/* [96] */ 46,
/* [97] */ 0,
/* [98] */ 0,
/* [99] */ 40,
/* [100] */ 3,
/* [101] */ 6,
/* [102] */ 17,
/* [103] */ 0,
/* [104] */ 10,
/* [105] */ 7,
/* [106] */ 10,
/* [107] */ 1,
/* [108] */ 10,
/* [109] */ 8,
/* [110] */ 10,
/* [111] */ 5,
/* [112] */ 10,
/* [113] */ 0,
/* [114] */ 10,
/* [115] */ 6,
/* [116] */ 9,
/* [117] */ 0,
/* [118] */ 10,