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