mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-05-16 04:11:25 +00:00
753f40b869
Change-Id: I7a61bd4363b01bf186e235bf76e97bd513d2fd12 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/26081 Reviewed-by: Ryan Harrison <rharrison@google.com>
360 lines
16 KiB
C++
360 lines
16 KiB
C++
// Copyright 2020 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.
|
|
|
|
#ifndef SRC_READER_WGSL_PARSER_IMPL_H_
|
|
#define SRC_READER_WGSL_PARSER_IMPL_H_
|
|
|
|
#include <deque>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
|
|
#include "src/ast/assignment_statement.h"
|
|
#include "src/ast/builtin.h"
|
|
#include "src/ast/call_statement.h"
|
|
#include "src/ast/case_statement.h"
|
|
#include "src/ast/constructor_expression.h"
|
|
#include "src/ast/else_statement.h"
|
|
#include "src/ast/entry_point.h"
|
|
#include "src/ast/function.h"
|
|
#include "src/ast/import.h"
|
|
#include "src/ast/literal.h"
|
|
#include "src/ast/loop_statement.h"
|
|
#include "src/ast/module.h"
|
|
#include "src/ast/pipeline_stage.h"
|
|
#include "src/ast/statement.h"
|
|
#include "src/ast/storage_class.h"
|
|
#include "src/ast/struct.h"
|
|
#include "src/ast/struct_decoration.h"
|
|
#include "src/ast/struct_member.h"
|
|
#include "src/ast/struct_member_decoration.h"
|
|
#include "src/ast/type/type.h"
|
|
#include "src/ast/variable.h"
|
|
#include "src/ast/variable_decoration.h"
|
|
#include "src/context.h"
|
|
#include "src/reader/wgsl/token.h"
|
|
|
|
namespace tint {
|
|
namespace reader {
|
|
namespace wgsl {
|
|
|
|
class Lexer;
|
|
|
|
/// ParserImpl for WGSL source data
|
|
class ParserImpl {
|
|
public:
|
|
/// Creates a new parser
|
|
/// @param ctx the non-null context object
|
|
/// @param input the input string to parse
|
|
ParserImpl(Context* ctx, const std::string& input);
|
|
~ParserImpl();
|
|
|
|
/// Run the parser
|
|
/// @returns true if the parse was successful, false otherwise.
|
|
bool Parse();
|
|
|
|
/// @returns true if an error was encountered
|
|
bool has_error() const { return error_.size() > 0; }
|
|
/// @returns the parser error string
|
|
const std::string& error() const { return error_; }
|
|
|
|
/// @returns the module. The module in the parser will be reset after this.
|
|
ast::Module module() { return std::move(module_); }
|
|
|
|
/// @returns the next token
|
|
Token next();
|
|
/// @returns the next token without advancing
|
|
Token peek();
|
|
/// Peeks ahead and returns the token at |idx| head of the current position
|
|
/// @param idx the index of the token to return
|
|
/// @returns the token |idx| positions ahead without advancing
|
|
Token peek(size_t idx);
|
|
/// Sets the error from |t|
|
|
/// @param t the token to set the error from
|
|
void set_error(const Token& t);
|
|
/// Sets the error from |t| or |msg| if |t| is not in error
|
|
/// @param t the token to set the error from
|
|
/// @param msg the error message
|
|
void set_error(const Token& t, const std::string& msg);
|
|
|
|
/// Registers a type alias into the parser
|
|
/// @param name the alias name
|
|
/// @param type the alias'd type
|
|
void register_alias(const std::string& name, ast::type::Type* type);
|
|
/// Retrieves an aliased type
|
|
/// @param name The alias name to lookup
|
|
/// @returns the alias type for |name| or nullptr if not found
|
|
ast::type::Type* get_alias(const std::string& name);
|
|
|
|
/// Parses the `translation_unit` grammar element
|
|
void translation_unit();
|
|
/// Parses the `global_decl` grammar element
|
|
void global_decl();
|
|
/// Parses the `import_decl grammar element
|
|
/// @returns the import object or nullptr if an error was encountered
|
|
std::unique_ptr<ast::Import> import_decl();
|
|
/// Parses a `global_variable_decl` grammar element
|
|
/// @returns the variable parsed or nullptr
|
|
std::unique_ptr<ast::Variable> global_variable_decl();
|
|
/// Parses a `global_constant_decl` grammar element
|
|
/// @returns the const object or nullptr
|
|
std::unique_ptr<ast::Variable> global_constant_decl();
|
|
/// Parses a `variable_decoration_list` grammar element
|
|
/// @returns the parsed variable decorations
|
|
ast::VariableDecorationList variable_decoration_list();
|
|
/// Parses a `variable_decoration` grammar element
|
|
/// @returns the variable decoration or nullptr if an error is encountered
|
|
std::unique_ptr<ast::VariableDecoration> variable_decoration();
|
|
/// Parses a `variable_decl` grammar element
|
|
/// @returns the parsed variable or nullptr otherwise
|
|
std::unique_ptr<ast::Variable> variable_decl();
|
|
/// Parses a `variable_ident_decl` grammar element
|
|
/// @returns the identifier and type parsed or empty otherwise
|
|
std::pair<std::string, ast::type::Type*> variable_ident_decl();
|
|
/// Parses a `variable_storage_decoration` grammar element
|
|
/// @returns the storage class or StorageClass::kNone if none matched
|
|
ast::StorageClass variable_storage_decoration();
|
|
/// Parses a `type_alias` grammar element
|
|
/// @returns the type alias or nullptr on error
|
|
ast::type::AliasType* type_alias();
|
|
/// Parses a `type_decl` grammar element
|
|
/// @returns the parsed Type or nullptr if none matched. The returned type
|
|
// is owned by the TypeManager.
|
|
ast::type::Type* type_decl();
|
|
/// Parses a `storage_class` grammar element
|
|
/// @returns the storage class or StorageClass::kNone if none matched
|
|
ast::StorageClass storage_class();
|
|
/// Parses a `struct_decl` grammar element
|
|
/// @returns the struct type or nullptr on error
|
|
std::unique_ptr<ast::type::StructType> struct_decl();
|
|
/// Parses a `struct_decoration_decl` grammar element
|
|
/// @returns the struct decoration or StructDecoraton::kNone
|
|
ast::StructDecoration struct_decoration_decl();
|
|
/// Parses a `struct_decoration` grammar element
|
|
/// @param t the current token
|
|
/// @returns the struct decoration or StructDecoraton::kNone if none matched
|
|
ast::StructDecoration struct_decoration(Token t);
|
|
/// Parses a `struct_body_decl` grammar element
|
|
/// @returns the struct members
|
|
ast::StructMemberList struct_body_decl();
|
|
/// Parses a `struct_member` grammar element
|
|
/// @returns the struct member or nullptr
|
|
std::unique_ptr<ast::StructMember> struct_member();
|
|
/// Parses a `struct_member_decoration_decl` grammar element
|
|
/// @returns the list of decorations
|
|
ast::StructMemberDecorationList struct_member_decoration_decl();
|
|
/// Parses a `struct_member_decoration` grammar element
|
|
/// @returns the decoration or nullptr if none found
|
|
std::unique_ptr<ast::StructMemberDecoration> struct_member_decoration();
|
|
/// Parses a `function_decl` grammar element
|
|
/// @returns the parsed function, nullptr otherwise
|
|
std::unique_ptr<ast::Function> function_decl();
|
|
/// Parses a `function_type_decl` grammar element
|
|
/// @returns the parsed type or nullptr otherwise
|
|
ast::type::Type* function_type_decl();
|
|
/// Parses a `function_header` grammar element
|
|
/// @returns the parsed function nullptr otherwise
|
|
std::unique_ptr<ast::Function> function_header();
|
|
/// Parses a `param_list` grammar element
|
|
/// @returns the parsed variables
|
|
ast::VariableList param_list();
|
|
/// Parses a `entry_point_decl` grammar element
|
|
/// @returns the EntryPoint or nullptr on error
|
|
std::unique_ptr<ast::EntryPoint> entry_point_decl();
|
|
/// Parses a `pipeline_stage` grammar element
|
|
/// @returns the pipeline stage or PipelineStage::kNone if none matched
|
|
ast::PipelineStage pipeline_stage();
|
|
/// Parses a `body_stmt` grammar element
|
|
/// @returns the parsed statements
|
|
std::unique_ptr<ast::BlockStatement> body_stmt();
|
|
/// Parses a `paren_rhs_stmt` grammar element
|
|
/// @returns the parsed element or nullptr
|
|
std::unique_ptr<ast::Expression> paren_rhs_stmt();
|
|
/// Parses a `statements` grammar element
|
|
/// @returns the statements parsed
|
|
std::unique_ptr<ast::BlockStatement> statements();
|
|
/// Parses a `statement` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::Statement> statement();
|
|
/// Parses a `break_stmt` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::BreakStatement> break_stmt();
|
|
/// Parses a `return_stmt` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::ReturnStatement> return_stmt();
|
|
/// Parses a `continue_stmt` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::ContinueStatement> continue_stmt();
|
|
/// Parses a `variable_stmt` grammar element
|
|
/// @returns the parsed variable or nullptr
|
|
std::unique_ptr<ast::VariableDeclStatement> variable_stmt();
|
|
/// Parses a `if_stmt` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::IfStatement> if_stmt();
|
|
/// Parses a `elseif_stmt` grammar element
|
|
/// @returns the parsed elements
|
|
ast::ElseStatementList elseif_stmt();
|
|
/// Parses a `else_stmt` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::ElseStatement> else_stmt();
|
|
/// Parses a `switch_stmt` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::SwitchStatement> switch_stmt();
|
|
/// Parses a `switch_body` grammar element
|
|
/// @returns the parsed statement or nullptr
|
|
std::unique_ptr<ast::CaseStatement> switch_body();
|
|
/// Parses a `case_selectors` grammar element
|
|
/// @returns the list of literals
|
|
ast::CaseSelectorList case_selectors();
|
|
/// Parses a `case_body` grammar element
|
|
/// @returns the parsed statements
|
|
std::unique_ptr<ast::BlockStatement> case_body();
|
|
/// Parses a `func_call_stmt` grammar element
|
|
/// @returns the parsed function call or nullptr
|
|
std::unique_ptr<ast::CallStatement> func_call_stmt();
|
|
/// Parses a `loop_stmt` grammar element
|
|
/// @returns the parsed loop or nullptr
|
|
std::unique_ptr<ast::LoopStatement> loop_stmt();
|
|
/// Parses a `continuing_stmt` grammar element
|
|
/// @returns the parsed statements
|
|
std::unique_ptr<ast::BlockStatement> continuing_stmt();
|
|
/// Parses a `const_literal` grammar element
|
|
/// @returns the const literal parsed or nullptr if none found
|
|
std::unique_ptr<ast::Literal> const_literal();
|
|
/// Parses a `const_expr` grammar element
|
|
/// @returns the parsed constructor expression or nullptr on error
|
|
std::unique_ptr<ast::ConstructorExpression> const_expr();
|
|
/// Parses a `primary_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> primary_expression();
|
|
/// Parses a `argument_expression_list` grammar element
|
|
/// @returns the list of arguments
|
|
ast::ExpressionList argument_expression_list();
|
|
/// Parses the recursive portion of the postfix_expression
|
|
/// @param prefix the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> postfix_expr(
|
|
std::unique_ptr<ast::Expression> prefix);
|
|
/// Parses a `postfix_expression` grammar elment
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> postfix_expression();
|
|
/// Parses a `unary_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> unary_expression();
|
|
/// Parses the recursive part of the `multiplicative_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> multiplicative_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `multiplicative_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> multiplicative_expression();
|
|
/// Parses the recursive part of the `additive_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> additive_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `additive_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> additive_expression();
|
|
/// Parses the recursive part of the `shift_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> shift_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `shift_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> shift_expression();
|
|
/// Parses the recursive part of the `relational_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> relational_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `relational_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> relational_expression();
|
|
/// Parses the recursive part of the `equality_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> equality_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `equality_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> equality_expression();
|
|
/// Parses the recursive part of the `and_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> and_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `and_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> and_expression();
|
|
/// Parses the recursive part of the `exclusive_or_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> exclusive_or_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `exclusive_or_expression` grammar elememnt
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> exclusive_or_expression();
|
|
/// Parses the recursive part of the `inclusive_or_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> inclusive_or_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses the `inclusive_or_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> inclusive_or_expression();
|
|
/// Parses the recursive part of the `logical_and_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> logical_and_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses a `logical_and_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> logical_and_expression();
|
|
/// Parses the recursive part of the `logical_or_expression`
|
|
/// @param lhs the left side of the expression
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> logical_or_expr(
|
|
std::unique_ptr<ast::Expression> lhs);
|
|
/// Parses a `logical_or_expression` grammar element
|
|
/// @returns the parsed expression or nullptr
|
|
std::unique_ptr<ast::Expression> logical_or_expression();
|
|
/// Parses a `assignment_stmt` grammar element
|
|
/// @returns the parsed assignment or nullptr
|
|
std::unique_ptr<ast::AssignmentStatement> assignment_stmt();
|
|
|
|
private:
|
|
ast::type::Type* type_decl_pointer(Token t);
|
|
ast::type::Type* type_decl_vector(Token t);
|
|
ast::type::Type* type_decl_array(Token t, uint32_t stride);
|
|
uint32_t array_decoration_list();
|
|
ast::type::Type* type_decl_matrix(Token t);
|
|
|
|
Context& ctx_;
|
|
std::string error_;
|
|
std::unique_ptr<Lexer> lexer_;
|
|
std::deque<Token> token_queue_;
|
|
std::unordered_map<std::string, ast::type::Type*> registered_aliases_;
|
|
ast::Module module_;
|
|
};
|
|
|
|
} // namespace wgsl
|
|
} // namespace reader
|
|
} // namespace tint
|
|
|
|
#endif // SRC_READER_WGSL_PARSER_IMPL_H_
|