mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 10:27:35 +00:00
LibGLSL: Add initial GLSL parser implementation
This commit is contained in:
parent
0b6424d883
commit
29972876e4
11 changed files with 4093 additions and 0 deletions
715
Userland/Libraries/LibGLSL/AST.h
Normal file
715
Userland/Libraries/LibGLSL/AST.h
Normal file
|
@ -0,0 +1,715 @@
|
|||
/*
|
||||
* Copyright (c) 2021, Itamar S. <itamar8910@gmail.com>
|
||||
* Copyright (c) 2023, Volodymyr V. <vvmposeydon@gmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/FlyString.h>
|
||||
#include <AK/Optional.h>
|
||||
#include <AK/RefCounted.h>
|
||||
#include <AK/String.h>
|
||||
#include <AK/StringView.h>
|
||||
#include <AK/TypeCasts.h>
|
||||
#include <AK/Vector.h>
|
||||
#include <LibCore/File.h>
|
||||
#include <LibGLSL/Lexer.h>
|
||||
|
||||
namespace GLSL {
|
||||
|
||||
class ASTNode;
|
||||
class TranslationUnit;
|
||||
class Declaration;
|
||||
class FunctionDefinition;
|
||||
class Type;
|
||||
class Parameter;
|
||||
class Statement;
|
||||
class Name;
|
||||
|
||||
class ASTNode : public RefCounted<ASTNode> {
|
||||
public:
|
||||
virtual ~ASTNode() = default;
|
||||
virtual StringView class_name() const = 0;
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const;
|
||||
|
||||
template<typename T>
|
||||
bool fast_is() const = delete;
|
||||
|
||||
ASTNode const* parent() const { return m_parent; }
|
||||
Position start() const
|
||||
{
|
||||
VERIFY(m_start.has_value());
|
||||
return m_start.value();
|
||||
}
|
||||
Position end() const
|
||||
{
|
||||
VERIFY(m_end.has_value());
|
||||
return m_end.value();
|
||||
}
|
||||
FlyString const& filename() const
|
||||
{
|
||||
return m_filename;
|
||||
}
|
||||
void set_end(Position const& end) { m_end = end; }
|
||||
void set_parent(ASTNode const& parent) { m_parent = &parent; }
|
||||
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const { return {}; }
|
||||
|
||||
virtual bool is_variable_or_parameter_declaration() const { return false; }
|
||||
virtual bool is_function_call() const { return false; }
|
||||
virtual bool is_type() const { return false; }
|
||||
virtual bool is_declaration() const { return false; }
|
||||
virtual bool is_name() const { return false; }
|
||||
virtual bool is_member_expression() const { return true; }
|
||||
virtual bool is_dummy_node() const { return false; }
|
||||
|
||||
protected:
|
||||
ASTNode(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: m_parent(parent)
|
||||
, m_start(start)
|
||||
, m_end(end)
|
||||
, m_filename(filename)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
ASTNode const* m_parent { nullptr };
|
||||
Optional<Position> m_start;
|
||||
Optional<Position> m_end;
|
||||
FlyString m_filename;
|
||||
};
|
||||
|
||||
class TranslationUnit : public ASTNode {
|
||||
|
||||
public:
|
||||
virtual ~TranslationUnit() override = default;
|
||||
virtual StringView class_name() const override { return "TranslationUnit"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override { return m_declarations; }
|
||||
|
||||
TranslationUnit(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: ASTNode(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
void set_declarations(Vector<NonnullRefPtr<Declaration const>>&& declarations) { m_declarations = move(declarations); }
|
||||
|
||||
private:
|
||||
Vector<NonnullRefPtr<Declaration const>> m_declarations;
|
||||
};
|
||||
|
||||
class Statement : public ASTNode {
|
||||
public:
|
||||
virtual ~Statement() override = default;
|
||||
virtual StringView class_name() const override { return "Statement"sv; }
|
||||
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
|
||||
protected:
|
||||
Statement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: ASTNode(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class Declaration : public Statement {
|
||||
|
||||
public:
|
||||
virtual bool is_declaration() const override { return true; }
|
||||
virtual bool is_variable_declaration() const { return false; }
|
||||
virtual bool is_parameter() const { return false; }
|
||||
virtual bool is_struct() const { return false; }
|
||||
virtual bool is_function() const { return false; }
|
||||
Name const* name() const { return m_name; }
|
||||
void set_name(RefPtr<Name const> name) { m_name = move(name); }
|
||||
|
||||
protected:
|
||||
Declaration(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
RefPtr<Name const> m_name;
|
||||
};
|
||||
|
||||
class InvalidDeclaration : public Declaration {
|
||||
|
||||
public:
|
||||
virtual ~InvalidDeclaration() override = default;
|
||||
virtual StringView class_name() const override { return "InvalidDeclaration"sv; }
|
||||
InvalidDeclaration(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Declaration(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class FunctionDeclaration : public Declaration {
|
||||
public:
|
||||
virtual ~FunctionDeclaration() override = default;
|
||||
virtual StringView class_name() const override { return "FunctionDeclaration"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual bool is_function() const override { return true; }
|
||||
RefPtr<FunctionDefinition const> definition() { return m_definition; }
|
||||
|
||||
FunctionDeclaration(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Declaration(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
Type const* return_type() const { return m_return_type.ptr(); }
|
||||
void set_return_type(RefPtr<Type const> const& return_type) { m_return_type = return_type; }
|
||||
Vector<NonnullRefPtr<Parameter const>> const& parameters() const { return m_parameters; }
|
||||
void set_parameters(Vector<NonnullRefPtr<Parameter const>> const& parameters) { m_parameters = parameters; }
|
||||
FunctionDefinition const* definition() const { return m_definition.ptr(); }
|
||||
void set_definition(RefPtr<FunctionDefinition const>&& definition) { m_definition = move(definition); }
|
||||
|
||||
private:
|
||||
RefPtr<Type const> m_return_type;
|
||||
Vector<NonnullRefPtr<Parameter const>> m_parameters;
|
||||
RefPtr<FunctionDefinition const> m_definition;
|
||||
};
|
||||
|
||||
class VariableOrParameterDeclaration : public Declaration {
|
||||
public:
|
||||
virtual ~VariableOrParameterDeclaration() override = default;
|
||||
virtual bool is_variable_or_parameter_declaration() const override { return true; }
|
||||
|
||||
void set_type(RefPtr<Type const>&& type) { m_type = move(type); }
|
||||
Type const* type() const { return m_type.ptr(); }
|
||||
|
||||
protected:
|
||||
VariableOrParameterDeclaration(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Declaration(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
RefPtr<Type const> m_type;
|
||||
};
|
||||
|
||||
class Parameter : public VariableOrParameterDeclaration {
|
||||
public:
|
||||
virtual ~Parameter() override = default;
|
||||
virtual StringView class_name() const override { return "Parameter"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual bool is_parameter() const override { return true; }
|
||||
|
||||
Parameter(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename, RefPtr<Name const> name)
|
||||
: VariableOrParameterDeclaration(parent, start, end, filename)
|
||||
{
|
||||
m_name = name;
|
||||
}
|
||||
};
|
||||
|
||||
enum class StorageTypeQualifier {
|
||||
Const,
|
||||
In,
|
||||
Out,
|
||||
Inout,
|
||||
Centroid,
|
||||
Patch,
|
||||
Sample,
|
||||
Uniform,
|
||||
Buffer,
|
||||
Shared,
|
||||
Coherent,
|
||||
Volatile,
|
||||
Restrict,
|
||||
Readonly,
|
||||
Writeonly,
|
||||
Subroutine,
|
||||
};
|
||||
|
||||
class Type : public ASTNode {
|
||||
public:
|
||||
virtual ~Type() override = default;
|
||||
virtual StringView class_name() const override { return "Type"sv; }
|
||||
virtual bool is_type() const override { return true; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
Type(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: ASTNode(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
Name const* name() const { return m_name.ptr(); }
|
||||
void set_name(RefPtr<Name const>&& name) { m_name = move(name); }
|
||||
|
||||
Vector<StorageTypeQualifier> const& storage_qualifiers() const { return m_storage_qualifiers; }
|
||||
void set_storage_qualifiers(Vector<StorageTypeQualifier>&& storage_qualifiers) { m_storage_qualifiers = move(storage_qualifiers); }
|
||||
|
||||
private:
|
||||
RefPtr<Name const> m_name;
|
||||
Vector<StorageTypeQualifier> m_storage_qualifiers;
|
||||
};
|
||||
|
||||
class FunctionDefinition : public ASTNode {
|
||||
public:
|
||||
virtual ~FunctionDefinition() override = default;
|
||||
virtual StringView class_name() const override { return "FunctionDefinition"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
FunctionDefinition(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: ASTNode(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
Vector<NonnullRefPtr<Statement const>> const& statements() { return m_statements; }
|
||||
void add_statement(NonnullRefPtr<Statement const>&& statement) { m_statements.append(move(statement)); }
|
||||
|
||||
private:
|
||||
Vector<NonnullRefPtr<Statement const>> m_statements;
|
||||
};
|
||||
|
||||
class InvalidStatement : public Statement {
|
||||
public:
|
||||
virtual ~InvalidStatement() override = default;
|
||||
virtual StringView class_name() const override { return "InvalidStatement"sv; }
|
||||
InvalidStatement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class Expression : public Statement {
|
||||
public:
|
||||
virtual ~Expression() override = default;
|
||||
virtual StringView class_name() const override { return "Expression"sv; }
|
||||
|
||||
protected:
|
||||
Expression(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class InvalidExpression : public Expression {
|
||||
public:
|
||||
virtual ~InvalidExpression() override = default;
|
||||
virtual StringView class_name() const override { return "InvalidExpression"sv; }
|
||||
InvalidExpression(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class VariableDeclaration : public VariableOrParameterDeclaration {
|
||||
public:
|
||||
virtual ~VariableDeclaration() override = default;
|
||||
virtual StringView class_name() const override { return "VariableDeclaration"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
VariableDeclaration(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: VariableOrParameterDeclaration(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual bool is_variable_declaration() const override { return true; }
|
||||
|
||||
Expression const* initial_value() const { return m_initial_value; }
|
||||
void set_initial_value(RefPtr<Expression const>&& initial_value) { m_initial_value = move(initial_value); }
|
||||
|
||||
private:
|
||||
RefPtr<Expression const> m_initial_value;
|
||||
};
|
||||
|
||||
class Name : public Expression {
|
||||
public:
|
||||
virtual ~Name() override = default;
|
||||
virtual StringView class_name() const override { return "Name"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual bool is_name() const override { return true; }
|
||||
virtual bool is_sized() const { return false; }
|
||||
|
||||
Name(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
StringView name() const { return m_name; }
|
||||
void set_name(StringView name) { m_name = name; }
|
||||
|
||||
private:
|
||||
StringView m_name;
|
||||
};
|
||||
|
||||
class SizedName : public Name {
|
||||
public:
|
||||
virtual ~SizedName() override = default;
|
||||
virtual StringView class_name() const override { return "SizedName"sv; }
|
||||
virtual bool is_sized() const override { return true; }
|
||||
ErrorOr<void> dump(AK::Stream&, size_t indent) const override;
|
||||
|
||||
SizedName(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Name(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
void append_dimension(StringView dim) { m_dimensions.append(dim); }
|
||||
|
||||
private:
|
||||
Vector<StringView> m_dimensions;
|
||||
};
|
||||
|
||||
class NumericLiteral : public Expression {
|
||||
public:
|
||||
virtual ~NumericLiteral() override = default;
|
||||
virtual StringView class_name() const override { return "NumericLiteral"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
NumericLiteral(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename, StringView value)
|
||||
: Expression(parent, start, end, filename)
|
||||
, m_value(value)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
StringView m_value;
|
||||
};
|
||||
|
||||
class BooleanLiteral : public Expression {
|
||||
public:
|
||||
virtual ~BooleanLiteral() override = default;
|
||||
virtual StringView class_name() const override { return "BooleanLiteral"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
BooleanLiteral(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename, bool value)
|
||||
: Expression(parent, start, end, filename)
|
||||
, m_value(value)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
bool m_value;
|
||||
};
|
||||
|
||||
enum class BinaryOp {
|
||||
Addition,
|
||||
Subtraction,
|
||||
Multiplication,
|
||||
Division,
|
||||
Modulo,
|
||||
GreaterThan,
|
||||
GreaterThanEquals,
|
||||
LessThan,
|
||||
LessThanEquals,
|
||||
BitwiseAnd,
|
||||
BitwiseOr,
|
||||
BitwiseXor,
|
||||
LeftShift,
|
||||
RightShift,
|
||||
EqualsEquals,
|
||||
NotEqual,
|
||||
LogicalOr,
|
||||
LogicalXor,
|
||||
LogicalAnd,
|
||||
Assignment,
|
||||
AdditionAssignment,
|
||||
SubtractionAssignment,
|
||||
MultiplicationAssignment,
|
||||
DivisionAssignment,
|
||||
ModuloAssignment,
|
||||
AndAssignment,
|
||||
OrAssignment,
|
||||
XorAssignment,
|
||||
LeftShiftAssignment,
|
||||
RightShiftAssignment,
|
||||
};
|
||||
|
||||
class BinaryExpression : public Expression {
|
||||
public:
|
||||
BinaryExpression(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~BinaryExpression() override = default;
|
||||
virtual StringView class_name() const override { return "BinaryExpression"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
BinaryOp op() const { return m_op; }
|
||||
void set_op(BinaryOp op) { m_op = op; }
|
||||
Expression const* lhs() const { return m_lhs.ptr(); }
|
||||
void set_lhs(RefPtr<Expression const>&& e) { m_lhs = move(e); }
|
||||
Expression const* rhs() const { return m_rhs.ptr(); }
|
||||
void set_rhs(RefPtr<Expression const>&& e) { m_rhs = move(e); }
|
||||
|
||||
private:
|
||||
BinaryOp m_op;
|
||||
RefPtr<Expression const> m_lhs;
|
||||
RefPtr<Expression const> m_rhs;
|
||||
};
|
||||
|
||||
class FunctionCall : public Expression {
|
||||
public:
|
||||
FunctionCall(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~FunctionCall() override = default;
|
||||
virtual StringView class_name() const override { return "FunctionCall"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual bool is_function_call() const override { return true; }
|
||||
|
||||
Expression const* callee() const { return m_callee; }
|
||||
void set_callee(RefPtr<Expression const>&& callee) { m_callee = move(callee); }
|
||||
|
||||
void set_arguments(Vector<NonnullRefPtr<Expression const>>&& args) { m_arguments = move(args); }
|
||||
Vector<NonnullRefPtr<Expression const>> const& arguments() const { return m_arguments; }
|
||||
|
||||
private:
|
||||
RefPtr<Expression const> m_callee;
|
||||
Vector<NonnullRefPtr<Expression const>> m_arguments;
|
||||
};
|
||||
|
||||
class StringLiteral final : public Expression {
|
||||
public:
|
||||
StringLiteral(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
~StringLiteral() override = default;
|
||||
virtual StringView class_name() const override { return "StringLiteral"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
String const& value() const { return m_value; }
|
||||
void set_value(String value) { m_value = move(value); }
|
||||
|
||||
private:
|
||||
String m_value;
|
||||
};
|
||||
|
||||
class ReturnStatement : public Statement {
|
||||
public:
|
||||
virtual ~ReturnStatement() override = default;
|
||||
virtual StringView class_name() const override { return "ReturnStatement"sv; }
|
||||
|
||||
ReturnStatement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
Expression const* value() const { return m_value.ptr(); }
|
||||
void set_value(RefPtr<Expression const>&& value) { m_value = move(value); }
|
||||
|
||||
private:
|
||||
RefPtr<Expression const> m_value;
|
||||
};
|
||||
|
||||
class DiscardStatement : public Statement {
|
||||
public:
|
||||
virtual ~DiscardStatement() override = default;
|
||||
virtual StringView class_name() const override { return "DiscardStatement"sv; }
|
||||
|
||||
DiscardStatement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class StructDeclaration : public Declaration {
|
||||
public:
|
||||
virtual ~StructDeclaration() override = default;
|
||||
virtual StringView class_name() const override { return "StructDeclaration"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual bool is_struct() const override { return true; }
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
|
||||
StructDeclaration(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Declaration(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
Vector<NonnullRefPtr<Declaration const>> const& members() const { return m_members; }
|
||||
void set_members(Vector<NonnullRefPtr<Declaration const>>&& members) { m_members = move(members); }
|
||||
|
||||
private:
|
||||
Vector<NonnullRefPtr<Declaration const>> m_members;
|
||||
};
|
||||
|
||||
enum class UnaryOp {
|
||||
BitwiseNot,
|
||||
Not,
|
||||
Plus,
|
||||
Minus,
|
||||
PlusPlus,
|
||||
MinusMinus,
|
||||
};
|
||||
|
||||
class UnaryExpression : public Expression {
|
||||
public:
|
||||
UnaryExpression(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~UnaryExpression() override = default;
|
||||
virtual StringView class_name() const override { return "UnaryExpression"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
UnaryOp op() const { return m_op; }
|
||||
void set_op(UnaryOp op) { m_op = op; }
|
||||
Expression const* lhs() const { return m_lhs.ptr(); }
|
||||
void set_lhs(RefPtr<Expression const>&& e) { m_lhs = move(e); }
|
||||
bool is_postfix() const { return m_is_postfix; }
|
||||
void set_is_postfix(bool is_postfix) { m_is_postfix = is_postfix; }
|
||||
|
||||
private:
|
||||
UnaryOp m_op;
|
||||
RefPtr<Expression const> m_lhs;
|
||||
bool m_is_postfix = false;
|
||||
};
|
||||
|
||||
class MemberExpression : public Expression {
|
||||
public:
|
||||
MemberExpression(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~MemberExpression() override = default;
|
||||
virtual StringView class_name() const override { return "MemberExpression"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual bool is_member_expression() const override { return true; }
|
||||
|
||||
Expression const* object() const { return m_object.ptr(); }
|
||||
void set_object(RefPtr<Expression const>&& object) { m_object = move(object); }
|
||||
Expression const* property() const { return m_property.ptr(); }
|
||||
void set_property(RefPtr<Expression const>&& property) { m_property = move(property); }
|
||||
|
||||
private:
|
||||
RefPtr<Expression const> m_object;
|
||||
RefPtr<Expression const> m_property;
|
||||
};
|
||||
|
||||
class ArrayElementExpression : public Expression {
|
||||
public:
|
||||
ArrayElementExpression(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Expression(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~ArrayElementExpression() override = default;
|
||||
virtual StringView class_name() const override { return "ArrayElementExpression"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
Expression const* array() const { return m_array.ptr(); }
|
||||
void set_array(RefPtr<Expression const>&& array) { m_array = move(array); }
|
||||
Expression const* index() const { return m_index.ptr(); }
|
||||
void set_index(RefPtr<Expression const>&& index) { m_index = move(index); }
|
||||
|
||||
private:
|
||||
RefPtr<Expression const> m_array;
|
||||
RefPtr<Expression const> m_index;
|
||||
};
|
||||
|
||||
class ForStatement : public Statement {
|
||||
public:
|
||||
ForStatement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~ForStatement() override = default;
|
||||
virtual StringView class_name() const override { return "ForStatement"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
|
||||
void set_init(RefPtr<VariableDeclaration const>&& init) { m_init = move(init); }
|
||||
void set_test(RefPtr<Expression const>&& test) { m_test = move(test); }
|
||||
void set_update(RefPtr<Expression const>&& update) { m_update = move(update); }
|
||||
void set_body(RefPtr<Statement const>&& body) { m_body = move(body); }
|
||||
Statement const* body() const { return m_body.ptr(); }
|
||||
|
||||
private:
|
||||
RefPtr<VariableDeclaration const> m_init;
|
||||
RefPtr<Expression const> m_test;
|
||||
RefPtr<Expression const> m_update;
|
||||
RefPtr<Statement const> m_body;
|
||||
};
|
||||
|
||||
class BlockStatement final : public Statement {
|
||||
public:
|
||||
BlockStatement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~BlockStatement() override = default;
|
||||
virtual StringView class_name() const override { return "BlockStatement"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
|
||||
void add_statement(NonnullRefPtr<Statement const>&& statement) { m_statements.append(move(statement)); }
|
||||
|
||||
private:
|
||||
Vector<NonnullRefPtr<Statement const>> m_statements;
|
||||
};
|
||||
|
||||
class IfStatement : public Statement {
|
||||
public:
|
||||
IfStatement(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: Statement(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~IfStatement() override = default;
|
||||
virtual StringView class_name() const override { return "IfStatement"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t indent = 0) const override;
|
||||
virtual Vector<NonnullRefPtr<Declaration const>> declarations() const override;
|
||||
|
||||
void set_predicate(RefPtr<Expression const>&& predicate) { m_predicate = move(predicate); }
|
||||
void set_then_statement(RefPtr<Statement const>&& then) { m_then = move(then); }
|
||||
void set_else_statement(RefPtr<Statement const>&& _else) { m_else = move(_else); }
|
||||
|
||||
Statement const* then_statement() const { return m_then.ptr(); }
|
||||
Statement const* else_statement() const { return m_else.ptr(); }
|
||||
|
||||
private:
|
||||
RefPtr<Expression const> m_predicate;
|
||||
RefPtr<Statement const> m_then;
|
||||
RefPtr<Statement const> m_else;
|
||||
};
|
||||
|
||||
class DummyAstNode : public ASTNode {
|
||||
public:
|
||||
DummyAstNode(ASTNode const* parent, Optional<Position> start, Optional<Position> end, String const& filename)
|
||||
: ASTNode(parent, start, end, filename)
|
||||
{
|
||||
}
|
||||
virtual bool is_dummy_node() const override { return true; }
|
||||
virtual StringView class_name() const override { return "DummyAstNode"sv; }
|
||||
virtual ErrorOr<void> dump(AK::Stream&, size_t = 0) const override { return {}; }
|
||||
};
|
||||
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<MemberExpression>() const { return is_member_expression(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<VariableOrParameterDeclaration>() const { return is_variable_or_parameter_declaration(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<FunctionCall>() const { return is_function_call(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<Type>() const { return is_type(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<Declaration>() const { return is_declaration(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<Name>() const { return is_name(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<DummyAstNode>() const { return is_dummy_node(); }
|
||||
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<VariableDeclaration>() const { return is_declaration() && verify_cast<Declaration>(*this).is_variable_declaration(); }
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<FunctionDeclaration>() const { return is_declaration() && verify_cast<Declaration>(*this).is_function(); }
|
||||
|
||||
template<>
|
||||
inline bool ASTNode::fast_is<SizedName>() const { return is_name() && verify_cast<Name>(*this).is_sized(); }
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue