LLVM  7.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 
56  MCAsmLexer();
57 
58  virtual AsmToken LexToken() = 0;
59 
60  void SetError(SMLoc errLoc, const std::string &err) {
61  ErrLoc = errLoc;
62  Err = err;
63  }
64 
65 public:
66  MCAsmLexer(const MCAsmLexer &) = delete;
67  MCAsmLexer &operator=(const MCAsmLexer &) = delete;
68  virtual ~MCAsmLexer();
69 
70  bool IsaAltMacroMode() {
71  return AltMacroMode;
72  }
73 
74  void SetAltMacroMode(bool AltMacroSet) {
75  AltMacroMode = AltMacroSet;
76  }
77 
78  /// Consume the next token from the input stream and return it.
79  ///
80  /// The lexer will continuosly return the end-of-file token once the end of
81  /// the main input file has been reached.
82  const AsmToken &Lex() {
83  assert(!CurTok.empty());
84  // Mark if we parsing out a EndOfStatement.
85  IsAtStartOfStatement = CurTok.front().getKind() == AsmToken::EndOfStatement;
86  CurTok.erase(CurTok.begin());
87  // LexToken may generate multiple tokens via UnLex but will always return
88  // the first one. Place returned value at head of CurTok vector.
89  if (CurTok.empty()) {
90  AsmToken T = LexToken();
91  CurTok.insert(CurTok.begin(), T);
92  }
93  return CurTok.front();
94  }
95 
96  void UnLex(AsmToken const &Token) {
97  IsAtStartOfStatement = false;
98  CurTok.insert(CurTok.begin(), Token);
99  }
100 
101  bool isAtStartOfStatement() { return IsAtStartOfStatement; }
102 
103  virtual StringRef LexUntilEndOfStatement() = 0;
104 
105  /// Get the current source location.
106  SMLoc getLoc() const;
107 
108  /// Get the current (last) lexed token.
109  const AsmToken &getTok() const {
110  return CurTok[0];
111  }
112 
113  /// Look ahead at the next token to be lexed.
114  const AsmToken peekTok(bool ShouldSkipSpace = true) {
115  AsmToken Tok;
116 
117  MutableArrayRef<AsmToken> Buf(Tok);
118  size_t ReadCount = peekTokens(Buf, ShouldSkipSpace);
119 
120  assert(ReadCount == 1);
121  (void)ReadCount;
122 
123  return Tok;
124  }
125 
126  /// Look ahead an arbitrary number of tokens.
127  virtual size_t peekTokens(MutableArrayRef<AsmToken> Buf,
128  bool ShouldSkipSpace = true) = 0;
129 
130  /// Get the current error location
132  return ErrLoc;
133  }
134 
135  /// Get the current error string
136  const std::string &getErr() {
137  return Err;
138  }
139 
140  /// Get the kind of current token.
141  AsmToken::TokenKind getKind() const { return getTok().getKind(); }
142 
143  /// Check if the current token has kind \p K.
144  bool is(AsmToken::TokenKind K) const { return getTok().is(K); }
145 
146  /// Check if the current token has kind \p K.
147  bool isNot(AsmToken::TokenKind K) const { return getTok().isNot(K); }
148 
149  /// Set whether spaces should be ignored by the lexer
150  void setSkipSpace(bool val) { SkipSpace = val; }
151 
152  bool getAllowAtInIdentifier() { return AllowAtInIdentifier; }
153  void setAllowAtInIdentifier(bool v) { AllowAtInIdentifier = v; }
154 
155  void setCommentConsumer(AsmCommentConsumer *CommentConsumer) {
156  this->CommentConsumer = CommentConsumer;
157  }
158 };
159 
160 } // end namespace llvm
161 
162 #endif // LLVM_MC_MCPARSER_MCASMLEXER_H
const AsmToken & getTok() const
Get the current (last) lexed token.
Definition: MCAsmLexer.h:109
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:150
bool is(AsmToken::TokenKind K) const
Check if the current token has kind K.
Definition: MCAsmLexer.h:144
bool IsaAltMacroMode()
Definition: MCAsmLexer.h:70
Generic assembler lexer interface, for use by target specific assembly lexers.
Definition: MCAsmLexer.h:40
void SetAltMacroMode(bool AltMacroSet)
Definition: MCAsmLexer.h:74
Target independent representation for an assembler token.
Definition: MCAsmMacro.h:22
#define T
void SetError(SMLoc errLoc, const std::string &err)
Definition: MCAsmLexer.h:60
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:124
const std::string & getErr()
Get the current error string.
Definition: MCAsmLexer.h:136
const AsmToken peekTok(bool ShouldSkipSpace=true)
Look ahead at the next token to be lexed.
Definition: MCAsmLexer.h:114
bool getAllowAtInIdentifier()
Definition: MCAsmLexer.h:152
iterator erase(const_iterator CI)
Definition: SmallVector.h:440
void setCommentConsumer(AsmCommentConsumer *CommentConsumer)
Definition: MCAsmLexer.h:155
AsmToken::TokenKind getKind() const
Get the kind of current token.
Definition: MCAsmLexer.h:141
void UnLex(AsmToken const &Token)
Definition: MCAsmLexer.h:96
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
virtual ~AsmCommentConsumer()=default
const AsmToken & Lex()
Consume the next token from the input stream and return it.
Definition: MCAsmLexer.h:82
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:473
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:147
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:131
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:101
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:153