Tedu files that got removed in LLVM 7.0.1.

1 files changed, 0 insertions, 223 deletions

diff --git a/gnu/llvm/tools/llvm-mcmarkup/llvm-mcmarkup.cpp b/gnu/llvm/tools/llvm-mcmarkup/llvm-mcmarkup.cpp
deleted file mode 100644
index 711493ad830..00000000000
--- a/gnu/llvm/tools/llvm-mcmarkup/llvm-mcmarkup.cpp
+++ /dev/null
@@ -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;
-}