Token.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 "SourceArea.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
 
#include <memory>
 
namespace CeresEngine::ShaderCompiler {
 
    // Token class used by the scanners and parsers.
    class Token {
    public:
        // Token type enumeration.
        enum class Types {
            Undefined,
 
            // MARK: Identifiers
            Ident, // (letter | '_') (letter | '_' | digit)*
 
            // MARK: Literals
            BoolLiteral, // true | false
            IntLiteral, // digit+
            FloatLiteral, // digit+ '.' digit+
            StringLiteral, // '"' ANY+ '"'
            CharLiteral, // '\'' ANY '\''
            NullLiteral, // NULL
 
            // MARK: Operators
            AssignOp, // =, +=, -=, *=, /=, %=, <<=, >>=, |= , &=, ^=
            BinaryOp, // &&, ||, |, ^, &, <<, >>, +, -, *, /, %, ==, !=, <, >, <=, >=
            UnaryOp, // !, ~, +, -, ++, --
            TernaryOp, // ?
 
            // MARK: Punctuation
            Dot, // .
            Colon, // :
            DColon, // ::
            Semicolon, // ;
            Comma, // ,
 
            // MARK: Brackets
            LBracket, // (
            RBracket, // )
            LCurly, // {
            RCurly, // }
            LParen, // [
            RParen, // ]
 
            // MARK: Type denoters
            StringType, // string
            ScalarType, // bool, int, uint, half, float, double
            VectorType, // ScalarType ('1'-'4')
            MatrixType, // ScalarType ('1'-'4') 'x' ('1'-'4')
 
            UniformBuffer, // cbuffer, tbuffer (HLSL); uniform (GLSL)
            Sampler, // sampler, sampler1D, sampler2D, sampler3D, samplerCUBE (HLSL); sampler2D, isampler1DArray etc. (GLSL)
 
            Void, // void
 
            // MARK: Keywords
            Reserved, // reserved keyword (not allowed, but reserved for future use)
            Unsupported, // unsupported keyword: interface, class (HLSL); subroutine (GLSL)
 
            Do, // do
            While, // while
            For, // for
 
            If, // if
            Else, // else
 
            Switch, // switch
            Case, // case
            Default, // default
 
            Struct, // struct
            Class, // class
            //Interface,          // interface
 
            CtrlTransfer, // break, continue, discard
            Return, // return
 
            InputModifier, // in, out, inout, uniform
            InterpModifier, // linear, centroid, nointerpolation, noperspective, sample
            TypeModifier, // const, row_major, column_major (also 'snorm' and 'unorm' for floats)
            StorageClass, // extern, precise, shared, groupshared, static, uniform, volatile
 
            Inline, // inline
 
            // MARK: HLSL only Tokens
            SamplerState, // sampler_state, SamplerState, SamplerComparisonState
 
            Typedef, // typedef
            Register, // register
            PackOffset, // packoffset
 
            Buffer, // texture, Texture2D, RWStructuredBuffer etc.
            PrimitiveType, // point, line, lineadj, triangle, triangleadj
            Vector, // vector (e.g. "vector<float, 3>")
            Matrix, // matrix (e.g. "matrix<int, 4, 4>")
 
            // MARK: GLSL only Tokens
            Attribute, // attribute
            Varying, // varying
            Precision, // precision
            LayoutQualifier, // layout
            MemoryQualifier, // coherent, volatile, restrict, readonly, writeonly
            InvariantQualifier, // invariant
            PrecisionQualifier, // lowp, mediump, highp
 
            Image, // image1D, uimageCube etc. (GLSL)
            StorageBuffer, // buffer (GLSL)
            AtomicCounter, // atomic_uint (GLSL)
 
            // MARK: Technique keywords
            Technique, // technique
            Pass, // pass
            Compile, // compile
 
            // MARK: Preprocessor specific tokens
            Directive, // Preprocessor directive ('#' IDENT).
            DirectiveConcat, // Preprocessor directive concatenation ('##').
            Comment, // Commentary (only a single text line)
            WhiteSpace, // White spaces (' ', '\t')
            NewLine, // New-line characters ('\n', '\r')
            LineBreak, // Line break for pre-processor directives '\'
            VarArg, // Variadic argument specifier ('...').
            Misc, // Miscellaneous
 
            // MARK: Special tokens
            EndOfStream, // End-of-stream
        };
 
        Token(Token&& other);
 
        Token(const SourcePosition& pos, const Types type);
        Token(const SourcePosition& pos, const Types type, const String& spell);
        Token(const SourcePosition& pos, const Types type, String&& spell);
 
        // Returns the source area of this token.
        [[nodiscard]] SourceArea getSourceArea() const;
 
        // Returns a descriptive string for the specified token type.
        static String typeToString(const Types type);
 
        // Returns the token spelling of the content (e.g. only the content of a string literal within the quotes).
        [[nodiscard]] String getSpellContent() const;
 
        // Returns the token type.
        [[nodiscard]] inline Types getType() const { return mType; }
 
        // Returns the token source position.
        [[nodiscard]] inline const SourcePosition& getPosition() const { return mPos; }
 
        // Returns the token spelling.
        [[nodiscard]] inline const String& getSpelling() const { return mSpell; }
 
    private:
        Types mType; // Type of this token.
        SourcePosition mPos; // Source area of this token.
        String mSpell; // Token spelling.
    };
 
    // Token shared pointer type.
    using TokenPtr = SPtr<Token>;
 
    // Keyword-to-Token map type.
    using KeywordMapType = Map<String, Token::Types>;
 
} // namespace CeresEngine::ShaderCompiler