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