MCAsmParser.h revision a005c3140d8c16fd68b7e3a3dffb3153609f7527 
1//===-- llvm/MC/MCAsmParser.h - Abstract Asm Parser 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_MCASMPARSER_H
11#define LLVM_MC_MCASMPARSER_H
12
13#include "llvm/Support/DataTypes.h"
14#include "llvm/ADT/ArrayRef.h"
15
16namespace llvm {
17class AsmToken;
18class MCAsmInfo;
19class MCAsmLexer;
20class MCAsmParserExtension;
21class MCContext;
22class MCExpr;
23class MCStreamer;
24class MCTargetAsmParser;
25class SMLoc;
26class SMRange;
27class SourceMgr;
28class StringRef;
29class Twine;
30
31/// MCAsmParser - Generic assembler parser interface, for use by target specific
32/// assembly parsers.
33class MCAsmParser {
34public:
35  typedef bool (*DirectiveHandler)(MCAsmParserExtension*, StringRef, SMLoc);
36
37private:
38  MCAsmParser(const MCAsmParser &);   // DO NOT IMPLEMENT
39  void operator=(const MCAsmParser &);  // DO NOT IMPLEMENT
40
41  MCTargetAsmParser *TargetParser;
42
43  unsigned ShowParsedOperands : 1;
44
45protected: // Can only create subclasses.
46  MCAsmParser();
47
48public:
49  virtual ~MCAsmParser();
50
51  virtual void AddDirectiveHandler(MCAsmParserExtension *Object,
52                                   StringRef Directive,
53                                   DirectiveHandler Handler) = 0;
54
55  virtual SourceMgr &getSourceManager() = 0;
56
57  virtual MCAsmLexer &getLexer() = 0;
58
59  virtual MCContext &getContext() = 0;
60
61  /// getStreamer - Return the output streamer for the assembler.
62  virtual MCStreamer &getStreamer() = 0;
63
64  MCTargetAsmParser &getTargetParser() const { return *TargetParser; }
65  void setTargetParser(MCTargetAsmParser &P);
66
67  virtual unsigned getAssemblerDialect() { return 0;}
68
69  bool getShowParsedOperands() const { return ShowParsedOperands; }
70  void setShowParsedOperands(bool Value) { ShowParsedOperands = Value; }
71
72  /// Run - Run the parser on the input source buffer.
73  virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
74
75  /// Warning - Emit a warning at the location \arg L, with the message \arg
76  /// Msg.
77  ///
78  /// \return The return value is true, if warnings are fatal.
79  virtual bool Warning(SMLoc L, const Twine &Msg,
80                       ArrayRef<SMRange> Ranges = ArrayRef<SMRange>()) = 0;
81
82  /// Error - Emit an error at the location \arg L, with the message \arg
83  /// Msg.
84  ///
85  /// \return The return value is always true, as an idiomatic convenience to
86  /// clients.
87  virtual bool Error(SMLoc L, const Twine &Msg,
88                     ArrayRef<SMRange> Ranges = ArrayRef<SMRange>()) = 0;
89
90  /// Lex - Get the next AsmToken in the stream, possibly handling file
91  /// inclusion first.
92  virtual const AsmToken &Lex() = 0;
93
94  /// getTok - Get the current AsmToken from the stream.
95  const AsmToken &getTok();
96
97  /// \brief Report an error at the current lexer location.
98  bool TokError(const Twine &Msg,
99                ArrayRef<SMRange> Ranges = ArrayRef<SMRange>());
100
101  /// ParseIdentifier - Parse an identifier or string (as a quoted identifier)
102  /// and set \arg Res to the identifier contents.
103  virtual bool ParseIdentifier(StringRef &Res) = 0;
104
105  /// \brief Parse up to the end of statement and return the contents from the
106  /// current token until the end of the statement; the current token on exit
107  /// will be either the EndOfStatement or EOF.
108  virtual StringRef ParseStringToEndOfStatement() = 0;
109
110  /// EatToEndOfStatement - Skip to the end of the current statement, for error
111  /// recovery.
112  virtual void EatToEndOfStatement() = 0;
113
114  /// ParseExpression - Parse an arbitrary expression.
115  ///
116  /// @param Res - The value of the expression. The result is undefined
117  /// on error.
118  /// @result - False on success.
119  virtual bool ParseExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0;
120  bool ParseExpression(const MCExpr *&Res);
121
122  /// ParseParenExpression - Parse an arbitrary expression, assuming that an
123  /// initial '(' has already been consumed.
124  ///
125  /// @param Res - The value of the expression. The result is undefined
126  /// on error.
127  /// @result - False on success.
128  virtual bool ParseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) = 0;
129
130  /// ParseAbsoluteExpression - Parse an expression which must evaluate to an
131  /// absolute value.
132  ///
133  /// @param Res - The value of the absolute expression. The result is undefined
134  /// on error.
135  /// @result - False on success.
136  virtual bool ParseAbsoluteExpression(int64_t &Res) = 0;
137};
138
139/// \brief Create an MCAsmParser instance.
140MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &,
141                               MCStreamer &, const MCAsmInfo &);
142
143} // End llvm namespace
144
145#endif
146