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