|
|
|
|
@ -1,223 +0,0 @@
|
|
|
|
|
//===-- llvm-mcmarkup.cpp - Parse the MC assembly markup tags -------------===//
|
|
|
|
|
//
|
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
|
//
|
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
//
|
|
|
|
|
// Example simple parser implementation for the MC assembly markup language.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
|
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
|
|
|
#include "llvm/Support/Signals.h"
|
|
|
|
|
#include "llvm/Support/SourceMgr.h"
|
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
|
|
static cl::list<std::string>
|
|
|
|
|
InputFilenames(cl::Positional, cl::desc("<input files>"),
|
|
|
|
|
cl::ZeroOrMore);
|
|
|
|
|
static cl::opt<bool>
|
|
|
|
|
DumpTags("dump-tags", cl::desc("List all tags encountered in input"));
|
|
|
|
|
|
|
|
|
|
static StringRef ToolName;
|
|
|
|
|
|
|
|
|
|
/// Trivial lexer for the markup parser. Input is always handled a character
|
|
|
|
|
/// at a time. The lexer just encapsulates EOF and lookahead handling.
|
|
|
|
|
class MarkupLexer {
|
|
|
|
|
StringRef::const_iterator Start;
|
|
|
|
|
StringRef::const_iterator CurPtr;
|
|
|
|
|
StringRef::const_iterator End;
|
|
|
|
|
public:
|
|
|
|
|
MarkupLexer(StringRef Source)
|
|
|
|
|
: Start(Source.begin()), CurPtr(Source.begin()), End(Source.end()) {}
|
|
|
|
|
// When processing non-markup, input is consumed a character at a time.
|
|
|
|
|
bool isEOF() { return CurPtr == End; }
|
|
|
|
|
int getNextChar() {
|
|
|
|
|
if (CurPtr == End) return EOF;
|
|
|
|
|
return *CurPtr++;
|
|
|
|
|
}
|
|
|
|
|
int peekNextChar() {
|
|
|
|
|
if (CurPtr == End) return EOF;
|
|
|
|
|
return *CurPtr;
|
|
|
|
|
}
|
|
|
|
|
StringRef::const_iterator getPosition() const { return CurPtr; }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/// A markup tag is a name and a (usually empty) list of modifiers.
|
|
|
|
|
class MarkupTag {
|
|
|
|
|
StringRef Name;
|
|
|
|
|
StringRef Modifiers;
|
|
|
|
|
SMLoc StartLoc;
|
|
|
|
|
public:
|
|
|
|
|
MarkupTag(StringRef n, StringRef m, SMLoc Loc)
|
|
|
|
|
: Name(n), Modifiers(m), StartLoc(Loc) {}
|
|
|
|
|
StringRef getName() const { return Name; }
|
|
|
|
|
StringRef getModifiers() const { return Modifiers; }
|
|
|
|
|
SMLoc getLoc() const { return StartLoc; }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/// A simple parser implementation for creating MarkupTags from input text.
|
|
|
|
|
class MarkupParser {
|
|
|
|
|
MarkupLexer &Lex;
|
|
|
|
|
SourceMgr &SM;
|
|
|
|
|
public:
|
|
|
|
|
MarkupParser(MarkupLexer &lex, SourceMgr &SrcMgr) : Lex(lex), SM(SrcMgr) {}
|
|
|
|
|
/// Create a MarkupTag from the current position in the MarkupLexer.
|
|
|
|
|
/// The parseTag() method should be called when the lexer has processed
|
|
|
|
|
/// the opening '<' character. Input will be consumed up to and including
|
|
|
|
|
/// the ':' which terminates the tag open.
|
|
|
|
|
MarkupTag parseTag();
|
|
|
|
|
/// Issue a diagnostic and terminate program execution.
|
|
|
|
|
void FatalError(SMLoc Loc, StringRef Msg);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
void MarkupParser::FatalError(SMLoc Loc, StringRef Msg) {
|
|
|
|
|
SM.PrintMessage(Loc, SourceMgr::DK_Error, Msg);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Example handler for when a tag is recognized.
|
|
|
|
|
static void processStartTag(MarkupTag &Tag) {
|
|
|
|
|
// If we're just printing the tags, do that, otherwise do some simple
|
|
|
|
|
// colorization.
|
|
|
|
|
if (DumpTags) {
|
|
|
|
|
outs() << Tag.getName();
|
|
|
|
|
if (Tag.getModifiers().size())
|
|
|
|
|
outs() << " " << Tag.getModifiers();
|
|
|
|
|
outs() << "\n";
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!outs().has_colors())
|
|
|
|
|
return;
|
|
|
|
|
// Color registers as red and immediates as cyan. Those don't have nested
|
|
|
|
|
// tags, so don't bother keeping a stack of colors to reset to.
|
|
|
|
|
if (Tag.getName() == "reg")
|
|
|
|
|
outs().changeColor(raw_ostream::RED);
|
|
|
|
|
else if (Tag.getName() == "imm")
|
|
|
|
|
outs().changeColor(raw_ostream::CYAN);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Example handler for when the end of a tag is recognized.
|
|
|
|
|
static void processEndTag(MarkupTag &Tag) {
|
|
|
|
|
// If we're printing the tags, there's nothing more to do here. Otherwise,
|
|
|
|
|
// set the color back the normal.
|
|
|
|
|
if (DumpTags)
|
|
|
|
|
return;
|
|
|
|
|
if (!outs().has_colors())
|
|
|
|
|
return;
|
|
|
|
|
// Just reset to basic white.
|
|
|
|
|
outs().changeColor(raw_ostream::WHITE, false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
MarkupTag MarkupParser::parseTag() {
|
|
|
|
|
// First off, extract the tag into it's own StringRef so we can look at it
|
|
|
|
|
// outside of the context of consuming input.
|
|
|
|
|
StringRef::const_iterator Start = Lex.getPosition();
|
|
|
|
|
SMLoc Loc = SMLoc::getFromPointer(Start - 1);
|
|
|
|
|
while(Lex.getNextChar() != ':') {
|
|
|
|
|
// EOF is an error.
|
|
|
|
|
if (Lex.isEOF())
|
|
|
|
|
FatalError(SMLoc::getFromPointer(Start), "unterminated markup tag");
|
|
|
|
|
}
|
|
|
|
|
StringRef RawTag(Start, Lex.getPosition() - Start - 1);
|
|
|
|
|
std::pair<StringRef, StringRef> SplitTag = RawTag.split(' ');
|
|
|
|
|
return MarkupTag(SplitTag.first, SplitTag.second, Loc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void parseMCMarkup(StringRef Filename) {
|
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferPtr =
|
|
|
|
|
MemoryBuffer::getFileOrSTDIN(Filename);
|
|
|
|
|
if (std::error_code EC = BufferPtr.getError()) {
|
|
|
|
|
errs() << ToolName << ": " << EC.message() << '\n';
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
std::unique_ptr<MemoryBuffer> &Buffer = BufferPtr.get();
|
|
|
|
|
|
|
|
|
|
SourceMgr SrcMgr;
|
|
|
|
|
|
|
|
|
|
StringRef InputSource = Buffer->getBuffer();
|
|
|
|
|
|
|
|
|
|
// Tell SrcMgr about this buffer, which is what the parser will pick up.
|
|
|
|
|
SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
|
|
|
|
|
|
|
|
|
|
MarkupLexer Lex(InputSource);
|
|
|
|
|
MarkupParser Parser(Lex, SrcMgr);
|
|
|
|
|
|
|
|
|
|
SmallVector<MarkupTag, 4> TagStack;
|
|
|
|
|
|
|
|
|
|
for (int CurChar = Lex.getNextChar();
|
|
|
|
|
CurChar != EOF;
|
|
|
|
|
CurChar = Lex.getNextChar()) {
|
|
|
|
|
switch (CurChar) {
|
|
|
|
|
case '<': {
|
|
|
|
|
// A "<<" is output as a literal '<' and does not start a markup tag.
|
|
|
|
|
if (Lex.peekNextChar() == '<') {
|
|
|
|
|
(void)Lex.getNextChar();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
// Parse the markup entry.
|
|
|
|
|
TagStack.push_back(Parser.parseTag());
|
|
|
|
|
|
|
|
|
|
// Do any special handling for the start of a tag.
|
|
|
|
|
processStartTag(TagStack.back());
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
case '>': {
|
|
|
|
|
SMLoc Loc = SMLoc::getFromPointer(Lex.getPosition() - 1);
|
|
|
|
|
// A ">>" is output as a literal '>' and does not end a markup tag.
|
|
|
|
|
if (Lex.peekNextChar() == '>') {
|
|
|
|
|
(void)Lex.getNextChar();
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
// Close out the innermost tag.
|
|
|
|
|
if (TagStack.empty())
|
|
|
|
|
Parser.FatalError(Loc, "'>' without matching '<'");
|
|
|
|
|
|
|
|
|
|
// Do any special handling for the end of a tag.
|
|
|
|
|
processEndTag(TagStack.back());
|
|
|
|
|
|
|
|
|
|
TagStack.pop_back();
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
// For anything else, just echo the character back out.
|
|
|
|
|
if (!DumpTags && CurChar != EOF)
|
|
|
|
|
outs() << (char)CurChar;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If there are any unterminated markup tags, issue diagnostics for them.
|
|
|
|
|
while (!TagStack.empty()) {
|
|
|
|
|
MarkupTag &Tag = TagStack.back();
|
|
|
|
|
SrcMgr.PrintMessage(Tag.getLoc(), SourceMgr::DK_Error,
|
|
|
|
|
"unterminated markup tag");
|
|
|
|
|
TagStack.pop_back();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int main(int argc, char **argv) {
|
|
|
|
|
// Print a stack trace if we signal out.
|
|
|
|
|
sys::PrintStackTraceOnErrorSignal(argv[0]);
|
|
|
|
|
PrettyStackTraceProgram X(argc, argv);
|
|
|
|
|
|
|
|
|
|
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
|
|
|
|
|
cl::ParseCommandLineOptions(argc, argv, "llvm MC markup parser\n");
|
|
|
|
|
|
|
|
|
|
ToolName = argv[0];
|
|
|
|
|
|
|
|
|
|
// If no input files specified, read from stdin.
|
|
|
|
|
if (InputFilenames.size() == 0)
|
|
|
|
|
InputFilenames.push_back("-");
|
|
|
|
|
|
|
|
|
|
llvm::for_each(InputFilenames, parseMCMarkup);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
Eric Christopher