1 //===- TGLexer.cpp - Lexer for TableGen -----------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Implement the Lexer for TableGen.
12 //===----------------------------------------------------------------------===//
15 #include "llvm/Support/SourceMgr.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 #include "llvm/Config/config.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/ADT/Twine.h"
27 TGLexer::TGLexer(SourceMgr &SM) : SrcMgr(SM) {
29 CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
30 CurPtr = CurBuf->getBufferStart();
34 SMLoc TGLexer::getLoc() const {
35 return SMLoc::getFromPointer(TokStart);
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) {
47 void TGLexer::PrintError(const char *Loc, const Twine &Msg) const {
48 SrcMgr.PrintMessage(SMLoc::getFromPointer(Loc), Msg, "error");
51 void TGLexer::PrintError(SMLoc Loc, const Twine &Msg) const {
52 SrcMgr.PrintMessage(Loc, Msg, "error");
56 int TGLexer::getNextChar() {
57 char CurChar = *CurPtr++;
60 return (unsigned char)CurChar;
62 // A nul character in the stream is either the end of the current buffer or
63 // a random nul in the file. Disambiguate that here.
64 if (CurPtr-1 != CurBuf->getBufferEnd())
65 return 0; // Just whitespace.
67 // If this is the end of an included file, pop the parent file off the
69 SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
70 if (ParentIncludeLoc != SMLoc()) {
71 CurBuffer = SrcMgr.FindBufferContainingLoc(ParentIncludeLoc);
72 CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
73 CurPtr = ParentIncludeLoc.getPointer();
77 // Otherwise, return end of file.
78 --CurPtr; // Another call to lex will return EOF again.
83 // Handle the newline character by ignoring it and incrementing the line
84 // count. However, be careful about 'dos style' files with \n\r in them.
85 // Only treat a \n\r or \r\n as a single line.
86 if ((*CurPtr == '\n' || (*CurPtr == '\r')) &&
88 ++CurPtr; // Eat the two char newline sequence.
93 tgtok::TokKind TGLexer::LexToken() {
95 // This always consumes at least one character.
96 int CurChar = getNextChar();
100 // Handle letters: [a-zA-Z_#]
101 if (isalpha(CurChar) || CurChar == '_' || CurChar == '#')
102 return LexIdentifier();
104 // Unknown character, emit an error.
105 return ReturnError(TokStart, "Unexpected character");
106 case EOF: return tgtok::Eof;
107 case ':': return tgtok::colon;
108 case ';': return tgtok::semi;
109 case '.': return tgtok::period;
110 case ',': return tgtok::comma;
111 case '<': return tgtok::less;
112 case '>': return tgtok::greater;
113 case ']': return tgtok::r_square;
114 case '{': return tgtok::l_brace;
115 case '}': return tgtok::r_brace;
116 case '(': return tgtok::l_paren;
117 case ')': return tgtok::r_paren;
118 case '=': return tgtok::equal;
119 case '?': return tgtok::question;
126 // Ignore whitespace.
129 // If this is the start of a // comment, skip until the end of the line or
130 // the end of the buffer.
133 else if (*CurPtr == '*') {
136 } else // Otherwise, this is an error.
137 return ReturnError(TokStart, "Unexpected character");
140 case '0': case '1': case '2': case '3': case '4': case '5': case '6':
141 case '7': case '8': case '9':
143 case '"': return LexString();
144 case '$': return LexVarName();
145 case '[': return LexBracket();
146 case '!': return LexExclaim();
150 /// LexString - Lex "[^"]*"
151 tgtok::TokKind TGLexer::LexString() {
152 const char *StrStart = CurPtr;
156 while (*CurPtr != '"') {
157 // If we hit the end of the buffer, report an error.
158 if (*CurPtr == 0 && CurPtr == CurBuf->getBufferEnd())
159 return ReturnError(StrStart, "End of file in string literal");
161 if (*CurPtr == '\n' || *CurPtr == '\r')
162 return ReturnError(StrStart, "End of line in string literal");
164 if (*CurPtr != '\\') {
165 CurStrVal += *CurPtr++;
172 case '\\': case '\'': case '"':
173 // These turn into their literal character.
174 CurStrVal += *CurPtr++;
187 return ReturnError(CurPtr, "escaped newlines not supported in tblgen");
189 // If we hit the end of the buffer, report an error.
191 if (CurPtr == CurBuf->getBufferEnd())
192 return ReturnError(StrStart, "End of file in string literal");
195 return ReturnError(CurPtr, "invalid escape in string literal");
200 return tgtok::StrVal;
203 tgtok::TokKind TGLexer::LexVarName() {
204 if (!isalpha(CurPtr[0]) && CurPtr[0] != '_')
205 return ReturnError(TokStart, "Invalid variable name");
207 // Otherwise, we're ok, consume the rest of the characters.
208 const char *VarNameStart = CurPtr++;
210 while (isalpha(*CurPtr) || isdigit(*CurPtr) || *CurPtr == '_')
213 CurStrVal.assign(VarNameStart, CurPtr);
214 return tgtok::VarName;
218 tgtok::TokKind TGLexer::LexIdentifier() {
219 // The first letter is [a-zA-Z_#].
220 const char *IdentStart = TokStart;
222 // Match the rest of the identifier regex: [0-9a-zA-Z_#]*
223 while (isalpha(*CurPtr) || isdigit(*CurPtr) || *CurPtr == '_' ||
228 // Check to see if this identifier is a keyword.
229 unsigned Len = CurPtr-IdentStart;
231 if (Len == 3 && !memcmp(IdentStart, "int", 3)) return tgtok::Int;
232 if (Len == 3 && !memcmp(IdentStart, "bit", 3)) return tgtok::Bit;
233 if (Len == 4 && !memcmp(IdentStart, "bits", 4)) return tgtok::Bits;
234 if (Len == 6 && !memcmp(IdentStart, "string", 6)) return tgtok::String;
235 if (Len == 4 && !memcmp(IdentStart, "list", 4)) return tgtok::List;
236 if (Len == 4 && !memcmp(IdentStart, "code", 4)) return tgtok::Code;
237 if (Len == 3 && !memcmp(IdentStart, "dag", 3)) return tgtok::Dag;
239 if (Len == 5 && !memcmp(IdentStart, "class", 5)) return tgtok::Class;
240 if (Len == 3 && !memcmp(IdentStart, "def", 3)) return tgtok::Def;
241 if (Len == 4 && !memcmp(IdentStart, "defm", 4)) return tgtok::Defm;
242 if (Len == 10 && !memcmp(IdentStart, "multiclass", 10))
243 return tgtok::MultiClass;
244 if (Len == 5 && !memcmp(IdentStart, "field", 5)) return tgtok::Field;
245 if (Len == 3 && !memcmp(IdentStart, "let", 3)) return tgtok::Let;
246 if (Len == 2 && !memcmp(IdentStart, "in", 2)) return tgtok::In;
248 if (Len == 7 && !memcmp(IdentStart, "include", 7)) {
249 if (LexInclude()) return tgtok::Error;
253 CurStrVal.assign(IdentStart, CurPtr);
257 /// LexInclude - We just read the "include" token. Get the string token that
258 /// comes next and enter the include.
259 bool TGLexer::LexInclude() {
260 // The token after the include must be a string.
261 tgtok::TokKind Tok = LexToken();
262 if (Tok == tgtok::Error) return true;
263 if (Tok != tgtok::StrVal) {
264 PrintError(getLoc(), "Expected filename after include");
269 std::string Filename = CurStrVal;
272 CurBuffer = SrcMgr.AddIncludeFile(Filename, SMLoc::getFromPointer(CurPtr));
273 if (CurBuffer == -1) {
274 PrintError(getLoc(), "Could not find include file '" + Filename + "'");
278 // Save the line number and lex buffer of the includer.
279 CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
280 CurPtr = CurBuf->getBufferStart();
284 void TGLexer::SkipBCPLComment() {
285 ++CurPtr; // skip the second slash.
290 return; // Newline is end of comment.
292 // If this is the end of the buffer, end the comment.
293 if (CurPtr == CurBuf->getBufferEnd())
297 // Otherwise, skip the character.
302 /// SkipCComment - This skips C-style /**/ comments. The only difference from C
303 /// is that we allow nesting.
304 bool TGLexer::SkipCComment() {
305 ++CurPtr; // skip the star.
306 unsigned CommentDepth = 1;
309 int CurChar = getNextChar();
312 PrintError(TokStart, "Unterminated comment!");
315 // End of the comment?
316 if (CurPtr[0] != '/') break;
318 ++CurPtr; // End the */.
319 if (--CommentDepth == 0)
323 // Start of a nested comment?
324 if (CurPtr[0] != '*') break;
336 tgtok::TokKind TGLexer::LexNumber() {
337 if (CurPtr[-1] == '0') {
338 if (CurPtr[0] == 'x') {
340 const char *NumStart = CurPtr;
341 while (isxdigit(CurPtr[0]))
344 // Requires at least one hex digit.
345 if (CurPtr == NumStart)
346 return ReturnError(TokStart, "Invalid hexadecimal number");
349 CurIntVal = strtoll(NumStart, 0, 16);
351 return ReturnError(TokStart, "Invalid hexadecimal number");
352 if (errno == ERANGE) {
354 CurIntVal = (int64_t)strtoull(NumStart, 0, 16);
356 return ReturnError(TokStart, "Invalid hexadecimal number");
358 return ReturnError(TokStart, "Hexadecimal number out of range");
360 return tgtok::IntVal;
361 } else if (CurPtr[0] == 'b') {
363 const char *NumStart = CurPtr;
364 while (CurPtr[0] == '0' || CurPtr[0] == '1')
367 // Requires at least one binary digit.
368 if (CurPtr == NumStart)
369 return ReturnError(CurPtr-2, "Invalid binary number");
370 CurIntVal = strtoll(NumStart, 0, 2);
371 return tgtok::IntVal;
375 // Check for a sign without a digit.
376 if (!isdigit(CurPtr[0])) {
377 if (CurPtr[-1] == '-')
379 else if (CurPtr[-1] == '+')
383 while (isdigit(CurPtr[0]))
385 CurIntVal = strtoll(TokStart, 0, 10);
386 return tgtok::IntVal;
389 /// LexBracket - We just read '['. If this is a code block, return it,
390 /// otherwise return the bracket. Match: '[' and '[{ ( [^}]+ | }[^]] )* }]'
391 tgtok::TokKind TGLexer::LexBracket() {
392 if (CurPtr[0] != '{')
393 return tgtok::l_square;
395 const char *CodeStart = CurPtr;
397 int Char = getNextChar();
398 if (Char == EOF) break;
400 if (Char != '}') continue;
402 Char = getNextChar();
403 if (Char == EOF) break;
405 CurStrVal.assign(CodeStart, CurPtr-2);
406 return tgtok::CodeFragment;
410 return ReturnError(CodeStart-2, "Unterminated Code Block");
413 /// LexExclaim - Lex '!' and '![a-zA-Z]+'.
414 tgtok::TokKind TGLexer::LexExclaim() {
415 if (!isalpha(*CurPtr))
416 return ReturnError(CurPtr - 1, "Invalid \"!operator\"");
418 const char *Start = CurPtr++;
419 while (isalpha(*CurPtr))
422 // Check to see which operator this is.
423 tgtok::TokKind Kind =
424 StringSwitch<tgtok::TokKind>(StringRef(Start, CurPtr - Start))
425 .Case("eq", tgtok::XEq)
426 .Case("if", tgtok::XIf)
427 .Case("head", tgtok::XHead)
428 .Case("tail", tgtok::XTail)
429 .Case("con", tgtok::XConcat)
430 .Case("shl", tgtok::XSHL)
431 .Case("sra", tgtok::XSRA)
432 .Case("srl", tgtok::XSRL)
433 .Case("cast", tgtok::XCast)
434 .Case("empty", tgtok::XEmpty)
435 .Case("subst", tgtok::XSubst)
436 .Case("foreach", tgtok::XForEach)
437 .Case("strconcat", tgtok::XStrConcat)
438 .Default(tgtok::Error);
440 return Kind != tgtok::Error ? Kind : ReturnError(Start-1, "Unknown operator");