LexHLSLRootSignature.h

Go to the documentation of this file.

//===--- LexHLSLRootSignature.h ---------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
//  This file defines the LexHLSLRootSignature interface.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_LEX_LEXHLSLROOTSIGNATURE_H
#define LLVM_CLANG_LEX_LEXHLSLROOTSIGNATURE_H
 
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/SourceLocation.h"
 
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
 
namespace clang {
namespace hlsl {
 
struct RootSignatureToken {
  enum Kind {
#define TOK(X, SPELLING) X,
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
  };
 
  Kind TokKind = Kind::invalid;
 
  // Retain the location offset of the token in the Signature
  // string
  uint32_t LocOffset;
 
  // Retain spelling of an numeric constant to be parsed later
  StringRef NumSpelling;
 
  // Constructors
  RootSignatureToken(uint32_t LocOffset) : LocOffset(LocOffset) {}
  RootSignatureToken(Kind TokKind, uint32_t LocOffset)
      : TokKind(TokKind), LocOffset(LocOffset) {}
};
 
inline const DiagnosticBuilder &
operator<<(const DiagnosticBuilder &DB, const RootSignatureToken::Kind Kind) {
  switch (Kind) {
#define TOK(X, SPELLING)                                                       \
  case RootSignatureToken::Kind::X:                                            \
    DB << SPELLING;                                                            \
    break;
#define PUNCTUATOR(X, SPELLING)                                                \
  case RootSignatureToken::Kind::pu_##X:                                       \
    DB << #SPELLING;                                                           \
    break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
  }
  return DB;
}
 
class RootSignatureLexer {
public:
  RootSignatureLexer(StringRef Signature) : Buffer(Signature) {}
 
  /// Consumes and returns the next token.
  RootSignatureToken consumeToken();
 
  /// Returns the token that proceeds CurToken
  RootSignatureToken peekNextToken();
 
  bool isEndOfBuffer() {
    advanceBuffer(Buffer.take_while(isspace).size());
    return Buffer.empty();
  }
 
private:
  // Internal buffer state
  StringRef Buffer;
  uint32_t LocOffset = 0;
 
  // Current peek state
  std::optional<RootSignatureToken> NextToken = std::nullopt;
 
  /// Consumes the buffer and returns the lexed token.
  RootSignatureToken lexToken();
 
  /// Advance the buffer by the specified number of characters.
  /// Updates the SourceLocation appropriately.
  void advanceBuffer(unsigned NumCharacters = 1) {
    Buffer = Buffer.drop_front(NumCharacters);
    LocOffset += NumCharacters;
  }
};
 
} // namespace hlsl
} // namespace clang
 
#endif // LLVM_CLANG_LEX_PARSEHLSLROOTSIGNATURE_H