lib/TableGen/TGLexer.cpp

   1 //===- TGLexer.cpp - Lexer for TableGen -----------------------------------===//
   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 // Implement the Lexer for TableGen.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "TGLexer.h"
  15 #include "llvm/TableGen/Error.h"
  16 #include "llvm/Support/SourceMgr.h"
  17 #include "llvm/Support/MemoryBuffer.h"
  18 #include "llvm/Config/config.h"
  19 #include "llvm/ADT/StringSwitch.h"
  20 #include "llvm/ADT/Twine.h"
  21 #include <cctype>
  22 #include <cstdio>
  23 #include <cstdlib>
  24 #include <cstring>
  25 #include <cerrno>
  26 using namespace llvm;
  27
  28 TGLexer::TGLexer(SourceMgr &SM) : SrcMgr(SM) {
  29   CurBuffer = 0;
  30   CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
  31   CurPtr = CurBuf->getBufferStart();
  32   TokStart = 0;
  33 }
  34
  35 SMLoc TGLexer::getLoc() const {
  36   return SMLoc::getFromPointer(TokStart);
  37 }
  38
  39 /// ReturnError - Set the error to the specified string at the specified
  40 /// location.  This is defined to always return tgtok::Error.
  41 tgtok::TokKind TGLexer::ReturnError(const char *Loc, const Twine &Msg) {
  42   PrintError(Loc, Msg);
  43   return tgtok::Error;
  44 }
  45
  46 int TGLexer::getNextChar() {
  47   char CurChar = *CurPtr++;
  48   switch (CurChar) {
  49   default:
  50     return (unsigned char)CurChar;
  51   case 0: {
  52     // A nul character in the stream is either the end of the current buffer or
  53     // a random nul in the file.  Disambiguate that here.
  54     if (CurPtr-1 != CurBuf->getBufferEnd())
  55       return 0;  // Just whitespace.
  56
  57     // If this is the end of an included file, pop the parent file off the
  58     // include stack.
  59     SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
  60     if (ParentIncludeLoc != SMLoc()) {
  61       CurBuffer = SrcMgr.FindBufferContainingLoc(ParentIncludeLoc);
  62       CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
  63       CurPtr = ParentIncludeLoc.getPointer();
  64       return getNextChar();
  65     }
  66
  67     // Otherwise, return end of file.
  68     --CurPtr;  // Another call to lex will return EOF again.
  69     return EOF;
  70   }
  71   case '\n':
  72   case '\r':
  73     // Handle the newline character by ignoring it and incrementing the line
  74     // count.  However, be careful about 'dos style' files with \n\r in them.
  75     // Only treat a \n\r or \r\n as a single line.
  76     if ((*CurPtr == '\n' || (*CurPtr == '\r')) &&
  77         *CurPtr != CurChar)
  78       ++CurPtr;  // Eat the two char newline sequence.
  79     return '\n';
  80   }
  81 }
  82
  83 tgtok::TokKind TGLexer::LexToken() {
  84   TokStart = CurPtr;
  85   // This always consumes at least one character.
  86   int CurChar = getNextChar();
  87
  88   switch (CurChar) {
  89   default:
  90     // Handle letters: [a-zA-Z_#]
  91     if (isalpha(CurChar) || CurChar == '_' || CurChar == '#')
  92       return LexIdentifier();
  93
  94     // Unknown character, emit an error.
  95     return ReturnError(TokStart, "Unexpected character");
  96   case EOF: return tgtok::Eof;
  97   case ':': return tgtok::colon;
  98   case ';': return tgtok::semi;
  99   case '.': return tgtok::period;
 100   case ',': return tgtok::comma;
 101   case '<': return tgtok::less;
 102   case '>': return tgtok::greater;
 103   case ']': return tgtok::r_square;
 104   case '{': return tgtok::l_brace;
 105   case '}': return tgtok::r_brace;
 106   case '(': return tgtok::l_paren;
 107   case ')': return tgtok::r_paren;
 108   case '=': return tgtok::equal;
 109   case '?': return tgtok::question;
 110
 111   case 0:
 112   case ' ':
 113   case '\t':
 114   case '\n':
 115   case '\r':
 116     // Ignore whitespace.
 117     return LexToken();
 118   case '/':
 119     // If this is the start of a // comment, skip until the end of the line or
 120     // the end of the buffer.
 121     if (*CurPtr == '/')
 122       SkipBCPLComment();
 123     else if (*CurPtr == '*') {
 124       if (SkipCComment())
 125         return tgtok::Error;
 126     } else // Otherwise, this is an error.
 127       return ReturnError(TokStart, "Unexpected character");
 128     return LexToken();
 129   case '-': case '+':
 130   case '0': case '1': case '2': case '3': case '4': case '5': case '6':
 131   case '7': case '8': case '9':
 132     return LexNumber();
 133   case '"': return LexString();
 134   case '$': return LexVarName();
 135   case '[': return LexBracket();
 136   case '!': return LexExclaim();
 137   }
 138 }
 139
 140 /// LexString - Lex "[^"]*"
 141 tgtok::TokKind TGLexer::LexString() {
 142   const char *StrStart = CurPtr;
 143
 144   CurStrVal = "";
 145
 146   while (*CurPtr != '"') {
 147     // If we hit the end of the buffer, report an error.
 148     if (*CurPtr == 0 && CurPtr == CurBuf->getBufferEnd())
 149       return ReturnError(StrStart, "End of file in string literal");
 150
 151     if (*CurPtr == '\n' || *CurPtr == '\r')
 152       return ReturnError(StrStart, "End of line in string literal");
 153
 154     if (*CurPtr != '\\') {
 155       CurStrVal += *CurPtr++;
 156       continue;
 157     }
 158
 159     ++CurPtr;
 160
 161     switch (*CurPtr) {
 162     case '\\': case '\'': case '"':
 163       // These turn into their literal character.
 164       CurStrVal += *CurPtr++;
 165       break;
 166     case 't':
 167       CurStrVal += '\t';
 168       ++CurPtr;
 169       break;
 170     case 'n':
 171       CurStrVal += '\n';
 172       ++CurPtr;
 173       break;
 174
 175     case '\n':
 176     case '\r':
 177       return ReturnError(CurPtr, "escaped newlines not supported in tblgen");
 178
 179     // If we hit the end of the buffer, report an error.
 180     case '\0':
 181       if (CurPtr == CurBuf->getBufferEnd())
 182         return ReturnError(StrStart, "End of file in string literal");
 183       // FALL THROUGH
 184     default:
 185       return ReturnError(CurPtr, "invalid escape in string literal");
 186     }
 187   }
 188
 189   ++CurPtr;
 190   return tgtok::StrVal;
 191 }
 192
 193 tgtok::TokKind TGLexer::LexVarName() {
 194   if (!isalpha(CurPtr[0]) && CurPtr[0] != '_')
 195     return ReturnError(TokStart, "Invalid variable name");
 196
 197   // Otherwise, we're ok, consume the rest of the characters.
 198   const char *VarNameStart = CurPtr++;
 199
 200   while (isalpha(*CurPtr) || isdigit(*CurPtr) || *CurPtr == '_')
 201     ++CurPtr;
 202
 203   CurStrVal.assign(VarNameStart, CurPtr);
 204   return tgtok::VarName;
 205 }
 206
 207
 208 tgtok::TokKind TGLexer::LexIdentifier() {
 209   // The first letter is [a-zA-Z_#].
 210   const char *IdentStart = TokStart;
 211
 212   // Match the rest of the identifier regex: [0-9a-zA-Z_#]*
 213   while (isalpha(*CurPtr) || isdigit(*CurPtr) || *CurPtr == '_' ||
 214          *CurPtr == '#')
 215     ++CurPtr;
 216
 217   // Check to see if this identifier is a keyword.
 218   StringRef Str(IdentStart, CurPtr-IdentStart);
 219
 220   if (Str == "int") return tgtok::Int;
 221   if (Str == "bit") return tgtok::Bit;
 222   if (Str == "bits") return tgtok::Bits;
 223   if (Str == "string") return tgtok::String;
 224   if (Str == "list") return tgtok::List;
 225   if (Str == "code") return tgtok::Code;
 226   if (Str == "dag") return tgtok::Dag;
 227
 228   if (Str == "class") return tgtok::Class;
 229   if (Str == "def") return tgtok::Def;
 230   if (Str == "multidef") return tgtok::MultiDef;
 231   if (Str == "defm") return tgtok::Defm;
 232   if (Str == "multiclass") return tgtok::MultiClass;
 233   if (Str == "field") return tgtok::Field;
 234   if (Str == "let") return tgtok::Let;
 235   if (Str == "in") return tgtok::In;
 236
 237   if (Str == "include") {
 238     if (LexInclude()) return tgtok::Error;
 239     return Lex();
 240   }
 241
 242   CurStrVal.assign(Str.begin(), Str.end());
 243   return tgtok::Id;
 244 }
 245
 246 /// LexInclude - We just read the "include" token.  Get the string token that
 247 /// comes next and enter the include.
 248 bool TGLexer::LexInclude() {
 249   // The token after the include must be a string.
 250   tgtok::TokKind Tok = LexToken();
 251   if (Tok == tgtok::Error) return true;
 252   if (Tok != tgtok::StrVal) {
 253     PrintError(getLoc(), "Expected filename after include");
 254     return true;
 255   }
 256
 257   // Get the string.
 258   std::string Filename = CurStrVal;
 259   std::string IncludedFile;
 260
 261
 262   CurBuffer = SrcMgr.AddIncludeFile(Filename, SMLoc::getFromPointer(CurPtr),
 263                                     IncludedFile);
 264   if (CurBuffer == -1) {
 265     PrintError(getLoc(), "Could not find include file '" + Filename + "'");
 266     return true;
 267   }
 268
 269   Dependencies.push_back(IncludedFile);
 270   // Save the line number and lex buffer of the includer.
 271   CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
 272   CurPtr = CurBuf->getBufferStart();
 273   return false;
 274 }
 275
 276 void TGLexer::SkipBCPLComment() {
 277   ++CurPtr;  // skip the second slash.
 278   while (1) {
 279     switch (*CurPtr) {
 280     case '\n':
 281     case '\r':
 282       return;  // Newline is end of comment.
 283     case 0:
 284       // If this is the end of the buffer, end the comment.
 285       if (CurPtr == CurBuf->getBufferEnd())
 286         return;
 287       break;
 288     }
 289     // Otherwise, skip the character.
 290     ++CurPtr;
 291   }
 292 }
 293
 294 /// SkipCComment - This skips C-style /**/ comments.  The only difference from C
 295 /// is that we allow nesting.
 296 bool TGLexer::SkipCComment() {
 297   ++CurPtr;  // skip the star.
 298   unsigned CommentDepth = 1;
 299
 300   while (1) {
 301     int CurChar = getNextChar();
 302     switch (CurChar) {
 303     case EOF:
 304       PrintError(TokStart, "Unterminated comment!");
 305       return true;
 306     case '*':
 307       // End of the comment?
 308       if (CurPtr[0] != '/') break;
 309
 310       ++CurPtr;   // End the */.
 311       if (--CommentDepth == 0)
 312         return false;
 313       break;
 314     case '/':
 315       // Start of a nested comment?
 316       if (CurPtr[0] != '*') break;
 317       ++CurPtr;
 318       ++CommentDepth;
 319       break;
 320     }
 321   }
 322 }
 323
 324 /// LexNumber - Lex:
 325 ///    [-+]?[0-9]+
 326 ///    0x[0-9a-fA-F]+
 327 ///    0b[01]+
 328 tgtok::TokKind TGLexer::LexNumber() {
 329   if (CurPtr[-1] == '0') {
 330     if (CurPtr[0] == 'x') {
 331       ++CurPtr;
 332       const char *NumStart = CurPtr;
 333       while (isxdigit(CurPtr[0]))
 334         ++CurPtr;
 335
 336       // Requires at least one hex digit.
 337       if (CurPtr == NumStart)
 338         return ReturnError(TokStart, "Invalid hexadecimal number");
 339
 340       errno = 0;
 341       CurIntVal = strtoll(NumStart, 0, 16);
 342       if (errno == EINVAL)
 343         return ReturnError(TokStart, "Invalid hexadecimal number");
 344       if (errno == ERANGE) {
 345         errno = 0;
 346         CurIntVal = (int64_t)strtoull(NumStart, 0, 16);
 347         if (errno == EINVAL)
 348           return ReturnError(TokStart, "Invalid hexadecimal number");
 349         if (errno == ERANGE)
 350           return ReturnError(TokStart, "Hexadecimal number out of range");
 351       }
 352       return tgtok::IntVal;
 353     } else if (CurPtr[0] == 'b') {
 354       ++CurPtr;
 355       const char *NumStart = CurPtr;
 356       while (CurPtr[0] == '0' || CurPtr[0] == '1')
 357         ++CurPtr;
 358
 359       // Requires at least one binary digit.
 360       if (CurPtr == NumStart)
 361         return ReturnError(CurPtr-2, "Invalid binary number");
 362       CurIntVal = strtoll(NumStart, 0, 2);
 363       return tgtok::IntVal;
 364     }
 365   }
 366
 367   // Check for a sign without a digit.
 368   if (!isdigit(CurPtr[0])) {
 369     if (CurPtr[-1] == '-')
 370       return tgtok::minus;
 371     else if (CurPtr[-1] == '+')
 372       return tgtok::plus;
 373   }
 374
 375   while (isdigit(CurPtr[0]))
 376     ++CurPtr;
 377   CurIntVal = strtoll(TokStart, 0, 10);
 378   return tgtok::IntVal;
 379 }
 380
 381 /// LexBracket - We just read '['.  If this is a code block, return it,
 382 /// otherwise return the bracket.  Match: '[' and '[{ ( [^}]+ | }[^]] )* }]'
 383 tgtok::TokKind TGLexer::LexBracket() {
 384   if (CurPtr[0] != '{')
 385     return tgtok::l_square;
 386   ++CurPtr;
 387   const char *CodeStart = CurPtr;
 388   while (1) {
 389     int Char = getNextChar();
 390     if (Char == EOF) break;
 391
 392     if (Char != '}') continue;
 393
 394     Char = getNextChar();
 395     if (Char == EOF) break;
 396     if (Char == ']') {
 397       CurStrVal.assign(CodeStart, CurPtr-2);
 398       return tgtok::CodeFragment;
 399     }
 400   }
 401
 402   return ReturnError(CodeStart-2, "Unterminated Code Block");
 403 }
 404
 405 /// LexExclaim - Lex '!' and '![a-zA-Z]+'.
 406 tgtok::TokKind TGLexer::LexExclaim() {
 407   if (!isalpha(*CurPtr))
 408     return ReturnError(CurPtr - 1, "Invalid \"!operator\"");
 409
 410   const char *Start = CurPtr++;
 411   while (isalpha(*CurPtr))
 412     ++CurPtr;
 413
 414   // Check to see which operator this is.
 415   tgtok::TokKind Kind =
 416     StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
 417     .Case("eq", tgtok::XEq)
 418     .Case("if", tgtok::XIf)
 419     .Case("head", tgtok::XHead)
 420     .Case("tail", tgtok::XTail)
 421     .Case("con", tgtok::XConcat)
 422     .Case("shl", tgtok::XSHL)
 423     .Case("sra", tgtok::XSRA)
 424     .Case("srl", tgtok::XSRL)
 425     .Case("cast", tgtok::XCast)
 426     .Case("empty", tgtok::XEmpty)
 427     .Case("subst", tgtok::XSubst)
 428     .Case("foreach", tgtok::XForEach)
 429     .Case("strconcat", tgtok::XStrConcat)
 430     .Default(tgtok::Error);
 431
 432   return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");
 433 }
 434