LLVM  8.0.0svn
MCAsmLexer.h
Go to the documentation of this file.
1 //===- llvm/MC/MCAsmLexer.h - Abstract Asm Lexer Interface ------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_MC_MCPARSER_MCASMLEXER_H
11 #define LLVM_MC_MCPARSER_MCASMLEXER_H
12 
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/SmallVector.h"
15 #include "llvm/MC/MCAsmMacro.h"
16 #include <algorithm>
17 #include <cassert>
18 #include <cstddef>
19 #include <cstdint>
20 #include <string>
21 
22 namespace llvm {
23 
24 /// A callback class which is notified of each comment in an assembly file as
25 /// it is lexed.
27 public:
28  virtual ~AsmCommentConsumer() = default;
29 
30  /// Callback function for when a comment is lexed. Loc is the start of the
31  /// comment text (excluding the comment-start marker). CommentText is the text
32  /// of the comment, excluding the comment start and end markers, and the
33  /// newline for single-line comments.
34  virtual void HandleComment(SMLoc Loc, StringRef CommentText) = 0;
35 };
36 
37 
38 /// Generic assembler lexer interface, for use by target specific assembly
39 /// lexers.
40 class MCAsmLexer {
41  /// The current token, stored in the base class for faster access.
43 
44  /// The location and description of the current error
45  SMLoc ErrLoc;
46  std::string Err;
47 
48 protected: // Can only create subclasses.
49  const char *TokStart = nullptr;
50  bool SkipSpace = true;
52  bool IsAtStartOfStatement = true;
53  AsmCommentConsumer *CommentConsumer = nullptr;
54 
55  MCAsmLexer();
56 
57  virtual AsmToken LexToken() = 0;
58 
59  void SetError(SMLoc errLoc, const std::string &err) {
60  ErrLoc = errLoc;
61  Err = err;
62  }
63 
64 public:
65  MCAsmLexer(const MCAsmLexer &) = delete;
66  MCAsmLexer &operator=(const MCAsmLexer &) = delete;
67  virtual ~MCAsmLexer();
68 
69  /// Consume the next token from the input stream and return it.
70  ///
71  /// The lexer will continuously return the end-of-file token once the end of
72  /// the main input file has been reached.
73  const AsmToken &Lex() {
74  assert(!CurTok.empty());
75  // Mark if we parsing out a EndOfStatement.
76  IsAtStartOfStatement = CurTok.front().getKind() == AsmToken::EndOfStatement;
77  CurTok.erase(CurTok.begin());
78  // LexToken may generate multiple tokens via UnLex but will always return
79  // the first one. Place returned value at head of CurTok vector.
80  if (CurTok.empty()) {
81  AsmToken T = LexToken();
82  CurTok.insert(CurTok.begin(), T);
83  }
84  return CurTok.front();
85  }
86 
87  void UnLex(AsmToken const &Token) {
88  IsAtStartOfStatement = false;
89  CurTok.insert(CurTok.begin(), Token);
90  }
91 
92  bool isAtStartOfStatement() { return IsAtStartOfStatement; }
93 
94  virtual StringRef LexUntilEndOfStatement() = 0;
95 
96  /// Get the current source location.
97  SMLoc getLoc() const;
98 
99  /// Get the current (last) lexed token.
100  const AsmToken &getTok() const {
101  return CurTok[0];
102  }
103 
104  /// Look ahead at the next token to be lexed.
105  const AsmToken peekTok(bool ShouldSkipSpace = true) {
106  AsmToken Tok;
107 
108  MutableArrayRef<AsmToken> Buf(Tok);
109  size_t ReadCount = peekTokens(Buf, ShouldSkipSpace);
110 
111  assert(ReadCount == 1);
112  (void)ReadCount;
113 
114  return Tok;
115  }
116 
117  /// Look ahead an arbitrary number of tokens.
118  virtual size_t peekTokens(MutableArrayRef<AsmToken> Buf,
119  bool ShouldSkipSpace = true) = 0;
120 
121  /// Get the current error location
123  return ErrLoc;
124  }
125 
126  /// Get the current error string
127  const std::string &getErr() {
128  return Err;
129  }
130 
131  /// Get the kind of current token.
132  AsmToken::TokenKind getKind() const { return getTok().getKind(); }
133 
134  /// Check if the current token has kind \p K.
135  bool is(AsmToken::TokenKind K) const { return getTok().is(K); }
136 
137  /// Check if the current token has kind \p K.
138  bool isNot(AsmToken::TokenKind K) const { return getTok().isNot(K); }
139 
140  /// Set whether spaces should be ignored by the lexer
141  void setSkipSpace(bool val) { SkipSpace = val; }
142 
143  bool getAllowAtInIdentifier() { return AllowAtInIdentifier; }
144  void setAllowAtInIdentifier(bool v) { AllowAtInIdentifier = v; }
145 
146  void setCommentConsumer(AsmCommentConsumer *CommentConsumer) {
147  this->CommentConsumer = CommentConsumer;
148  }
149 };
150 
151 } // end namespace llvm
152 
153 #endif // LLVM_MC_MCPARSER_MCASMLEXER_H
const AsmToken & getTok() const
Get the current (last) lexed token.
Definition: MCAsmLexer.h:100
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void setSkipSpace(bool val)
Set whether spaces should be ignored by the lexer.
Definition: MCAsmLexer.h:141
bool is(AsmToken::TokenKind K) const
Check if the current token has kind K.
Definition: MCAsmLexer.h:135
Generic assembler lexer interface, for use by target specific assembly lexers.
Definition: MCAsmLexer.h:40
Target independent representation for an assembler token.
Definition: MCAsmMacro.h:22
#define T
void SetError(SMLoc errLoc, const std::string &err)
Definition: MCAsmLexer.h:59
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:291
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:129
const std::string & getErr()
Get the current error string.
Definition: MCAsmLexer.h:127
const AsmToken peekTok(bool ShouldSkipSpace=true)
Look ahead at the next token to be lexed.
Definition: MCAsmLexer.h:105
bool getAllowAtInIdentifier()
Definition: MCAsmLexer.h:143
iterator erase(const_iterator CI)
Definition: SmallVector.h:445
void setCommentConsumer(AsmCommentConsumer *CommentConsumer)
Definition: MCAsmLexer.h:146
AsmToken::TokenKind getKind() const
Get the kind of current token.
Definition: MCAsmLexer.h:132
void UnLex(AsmToken const &Token)
Definition: MCAsmLexer.h:87
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
virtual ~AsmCommentConsumer()=default
const AsmToken & Lex()
Consume the next token from the input stream and return it.
Definition: MCAsmLexer.h:73
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:478
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:56
bool isNot(AsmToken::TokenKind K) const
Check if the current token has kind K.
Definition: MCAsmLexer.h:138
A callback class which is notified of each comment in an assembly file as it is lexed.
Definition: MCAsmLexer.h:26
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
SMLoc getErrLoc()
Get the current error location.
Definition: MCAsmLexer.h:122
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Represents a location in source code.
Definition: SMLoc.h:24
bool isAtStartOfStatement()
Definition: MCAsmLexer.h:92
bool AllowAtInIdentifier
Definition: MCAsmLexer.h:51
virtual void HandleComment(SMLoc Loc, StringRef CommentText)=0
Callback function for when a comment is lexed.
void setAllowAtInIdentifier(bool v)
Definition: MCAsmLexer.h:144