[llvm] Conditionally include target intrinsics, based on --enable-target

utils/TableGen/TGLexer.cpp

 //===- TGLexer.cpp - Lexer for TableGen -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Implement the Lexer for TableGen.
 //
 //===----------------------------------------------------------------------===//
 
 #include "TGLexer.h"
 #include "Error.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Config/config.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
+#include <algorithm>
 #include <cctype>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cerrno>
 using namespace llvm;
 
-TGLexer::TGLexer(SourceMgr &SM) : SrcMgr(SM) {
+TGLexer::TGLexer(SourceMgr &SM, std::vector<std::string> PPD)
+  : SrcMgr(SM), PreProcDefines(PPD) {
   CurBuffer = 0;
   CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
   CurPtr = CurBuf->getBufferStart();
   TokStart = 0;
 }
 
 SMLoc TGLexer::getLoc() const {
   return SMLoc::getFromPointer(TokStart);
 }
 
+bool TGLexer::hasPreProcDefine(const std::string &define) const {
+  return std::find(PreProcDefines.begin(), PreProcDefines.end(),
+                   define) != PreProcDefines.end();
+}
+
 /// ReturnError - Set the error to the specified string at the specified
 /// location.  This is defined to always return tgtok::Error.
 tgtok::TokKind TGLexer::ReturnError(const char *Loc, const Twine &Msg) {
   PrintError(Loc, Msg);
   return tgtok::Error;
 }
 
 int TGLexer::getNextChar() {
   char CurChar = *CurPtr++;
   switch (CurChar) {
@@ skipping 179 matching lines @@
   
   if (Len == 5 && !memcmp(IdentStart, "class", 5)) return tgtok::Class;
   if (Len == 3 && !memcmp(IdentStart, "def", 3)) return tgtok::Def;
   if (Len == 4 && !memcmp(IdentStart, "defm", 4)) return tgtok::Defm;
   if (Len == 10 && !memcmp(IdentStart, "multiclass", 10))
     return tgtok::MultiClass;
   if (Len == 5 && !memcmp(IdentStart, "field", 5)) return tgtok::Field;
   if (Len == 3 && !memcmp(IdentStart, "let", 3)) return tgtok::Let;
   if (Len == 2 && !memcmp(IdentStart, "in", 2)) return tgtok::In;
   
+  if (Len == 10 && !memcmp(IdentStart, "include_if", 10)) {
+    if (LexIncludeIf()) return tgtok::Error;
+    return Lex();
+  }
   if (Len == 7 && !memcmp(IdentStart, "include", 7)) {
     if (LexInclude()) return tgtok::Error;
     return Lex();
   }
     
   CurStrVal.assign(IdentStart, CurPtr);
   return tgtok::Id;
 }
 
+/// LexIncludeIf - We just read the "include_if" token.  Get the next two
+/// string tokens. The first is the pre-processor symbol required, and the
+/// next is the filename. Finally enter the include only if the
+/// pre-processor symbol was defined at the command-line.
+bool TGLexer::LexIncludeIf() {
+
+  // The next two token after the include must be strings.
+  tgtok::TokKind PreProcTok = LexToken();
+  if (PreProcTok == tgtok::Error) return true;
+  if (PreProcTok != tgtok::StrVal) {
+    PrintError(getLoc(), "Expected pre-proc symbol after include_if");
+    return true;
+  }
+  // Get the string.
+  std::string PreProcSymbol = CurStrVal;
+
+  // The token after the include must be a string.
+  tgtok::TokKind FileTok = LexToken();
+  if (FileTok == tgtok::Error) return true;
+  if (FileTok != tgtok::StrVal) {
+    PrintError(getLoc(), "Expected filename after include_if");
+    return true;
+  }
+
+  // Get the string.
+  std::string Filename = CurStrVal;
+  if (hasPreProcDefine(PreProcSymbol))
+    return AddIncludeFile(Filename);
+  else {
+    return false;
+  }
+}
+
 /// LexInclude - We just read the "include" token.  Get the string token that
 /// comes next and enter the include.
 bool TGLexer::LexInclude() {
   // The token after the include must be a string.
   tgtok::TokKind Tok = LexToken();
   if (Tok == tgtok::Error) return true;
   if (Tok != tgtok::StrVal) {
     PrintError(getLoc(), "Expected filename after include");
     return true;
   }
 
   // Get the string.
   std::string Filename = CurStrVal;
+  return AddIncludeFile(Filename);
+}
+
+bool TGLexer::AddIncludeFile(const std::string &Filename) {
   std::string IncludedFile;
-
-  
   CurBuffer = SrcMgr.AddIncludeFile(Filename, SMLoc::getFromPointer(CurPtr),
                                     IncludedFile);
   if (CurBuffer == -1) {
     PrintError(getLoc(), "Could not find include file '" + Filename + "'");
     return true;
   }
-  
+
   Dependencies.push_back(IncludedFile);
   // Save the line number and lex buffer of the includer.
   CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
   CurPtr = CurBuf->getBufferStart();
   return false;
 }
 
 void TGLexer::SkipBCPLComment() {
   ++CurPtr;  // skip the second slash.
   while (1) {
@@ skipping 145 matching lines @@
     .Case("srl", tgtok::XSRL)
     .Case("cast", tgtok::XCast)
     .Case("empty", tgtok::XEmpty)
     .Case("subst", tgtok::XSubst)
     .Case("foreach", tgtok::XForEach)
     .Case("strconcat", tgtok::XStrConcat)
     .Default(tgtok::Error);
 
   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 }
-