ASTFactory.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "AST.hpp"
#include "TypeDenoter.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    class Variant;
 
    namespace ASTFactory {
        [[nodiscard]] CallExpressionPtr makeIntrinsicCallExpression(const Intrinsic intrinsic, const String& ident, const TypeDenoterPtr& typeDenoter, const Vector<ExpressionPtr>& arguments);
 
        [[nodiscard]] CallExpressionPtr makeTextureSamplerBindingCallExpression(const ExpressionPtr& textureObjectExpression, const ExpressionPtr& samplerObjectExpression);
 
        // Makes a call expression to a wrapper function.
        [[nodiscard]] CallExpressionPtr makeWrapperCallExpression(const String& funcIdent, const TypeDenoterPtr& typeDenoter, const Vector<ExpressionPtr>& arguments);
 
        [[nodiscard]] InitializerExpressionPtr makeInitializerExpression(const Vector<ExpressionPtr>& expressions);
 
        // Makes a type constructor function call.
        [[nodiscard]] CallExpressionPtr makeTypeCtorCallExpression(const TypeDenoterPtr& typeDenoter, const Vector<ExpressionPtr>& arguments);
 
        [[nodiscard]] CastExpressionPtr makeCastExpression(const TypeDenoterPtr& typeDenoter, const ExpressionPtr& valueExpression);
        [[nodiscard]] CastExpressionPtr makeLiteralCastExpression(const TypeDenoterPtr& typeDenoter, const DataType literalType, const String& literalValue);
 
        [[nodiscard]] BinaryExpressionPtr makeBinaryExpression(const ExpressionPtr& lhsExpression, const BinaryOp op, const ExpressionPtr& rhsExpression);
 
        // Makes a new LiteralExpression of the specified data type and literal value.
        [[nodiscard]] LiteralExpressionPtr makeLiteralExpression(const DataType literalType, const String& literalValue);
 
        // Makes a new LiteralExpression if the specified variant is either a boolean, integral, or real type. Otherwise, null is returned.
        [[nodiscard]] LiteralExpressionPtr makeLiteralExpressionOrNull(const Variant& literalValue);
 
        [[nodiscard]] AliasDeclarationStatementPtr makeBaseTypeAlias(const DataType dataType, const String& ident);
 
        [[nodiscard]] TypeSpecifierPtr makeTypeSpecifier(const StructDeclarationPtr& structDeclaration);
        [[nodiscard]] TypeSpecifierPtr makeTypeSpecifier(const TypeDenoterPtr& typeDenoter);
        [[nodiscard]] TypeSpecifierPtr makeTypeSpecifier(const DataType dataType);
 
        [[nodiscard]] VarDeclarationStatementPtr makeVarDeclarationStatement(const TypeSpecifierPtr& typeSpecifier, const String& ident, const ExpressionPtr& initializer = nullptr);
        [[nodiscard]] VarDeclarationStatementPtr makeVarDeclarationStatement(const DataType dataType, const String& ident, const ExpressionPtr& initializer = nullptr);
 
        // Returns a new VarDeclStatement with the specified VarDecl index and removes the specified VarDecl from the input statement, except there is only one VarDecl.
        [[nodiscard]] VarDeclarationStatementPtr makeVarDeclarationStatementSplit(const VarDeclarationStatementPtr& varDeclarationStatement, std::size_t idx);
 
        [[nodiscard]] ObjectExpressionPtr makeObjectExpression(const ExpressionPtr& prefixExpression, const String& ident, Declaration* symbolRef = nullptr);
        [[nodiscard]] ObjectExpressionPtr makeObjectExpression(const String& ident, Declaration* symbolRef = nullptr);
        [[nodiscard]] ObjectExpressionPtr makeObjectExpression(Declaration* symbolRef);
 
        [[nodiscard]] ArrayExpressionPtr makeArrayExpression(const ExpressionPtr& prefixExpression, Vector<ExpressionPtr>&& arrayIndices);
        [[nodiscard]] ArrayExpressionPtr makeArrayExpression(const ExpressionPtr& prefixExpression, const Vector<int>& arrayIndices);
        [[nodiscard]] ArrayExpressionPtr makeArrayExpression(const ExpressionPtr& prefixExpression, const Vector<ExpressionPtr>::const_iterator& arrayIndicesBegin,
            const Vector<ExpressionPtr>::const_iterator& arrayIndicesEnd);
 
        [[nodiscard]] ArrayExpressionPtr makeArrayExpressionSplit(const ArrayExpressionPtr& arrayExpression, std::size_t splitArrayIndex);
 
        [[nodiscard]] RegisterPtr makeRegister(Int32 set, Int32 slot, const RegisterType registerType = RegisterType::Undefined);
 
        // Makes a new bracket expression with the specified sub expression (source area is copied).
        [[nodiscard]] BracketExpressionPtr makeBracketExpression(const ExpressionPtr& expression);
 
        // Return a list expression (or only the input expression) for the specified literal expression, so it can be used as constructor for a struct.
        [[nodiscard]] ExpressionPtr makeConstructorListExpression(const ExpressionPtr& expression, const Vector<TypeDenoterPtr>& listTypeDens);
 
        // Makes an expression statement with an assignment expression.
        [[nodiscard]] ExpressionStatementPtr makeAssignStatement(const ExpressionPtr& lvalueExpression, const ExpressionPtr& rvalueExpression, const AssignOp op = AssignOp::Set);
 
        // Makes an expression statement with an array element assignment for the specified variable, array indices, and assignment expression.
        [[nodiscard]] ExpressionStatementPtr makeArrayAssignStatement(VarDeclaration* varDeclaration, const Vector<int>& arrayIndices, const ExpressionPtr& assignExpression);
 
        [[nodiscard]] ArrayDimensionPtr makeArrayDimension(int arraySize);
 
        // Makes a code block statement with initial code block and the specified statement inserted.
        [[nodiscard]] CodeBlockStatementPtr makeCodeBlockStatement(const StatementPtr& statement);
 
        [[nodiscard]] BasicDeclarationStatementPtr makeStructDeclarationStatement(const StructDeclarationPtr& structDeclaration);
 
        // Makes a uniform buffer declaration with the specified identifier.
        [[nodiscard]] UniformBufferDeclarationPtr makeUniformBufferDeclaration(const String& ident, Int32 bindingSlot = 0,
            const UniformBufferType bufferType = UniformBufferType::ConstantBuffer);
 
        // -----------------------------------------------------------------------------------------
 
        [[nodiscard]] Vector<ExpressionPtr> makeArrayIndices(const Vector<int>& arrayIndices);
        [[nodiscard]] Vector<ArrayDimensionPtr> makeArrayDimensionList(const Vector<int>& arraySizes);
 
        // -----------------------------------------------------------------------------------------
 
        [[nodiscard]] ExpressionPtr convertExpressionBaseType(const DataType dataType, const ExpressionPtr& subExpression);
        [[nodiscard]] ArrayDimensionPtr convertExpressionToArrayDimension(const ExpressionPtr& expression);
        [[nodiscard]] Vector<ArrayDimensionPtr> convertExpressionListToArrayDimensionList(const Vector<ExpressionPtr>& expressions);
 
    } // namespace ASTFactory
 
} // namespace CeresEngine::ShaderCompiler