[llvm-commits] [llvm] r77322 - in /llvm/trunk/tools/llvm-mc: AsmLexer.cpp AsmLexer.h AsmParser.cpp MC-X86Specific.cpp llvm-mc.cpp
Daniel Dunbar
daniel at zuster.org
Tue Jul 28 09:08:38 PDT 2009
Author: ddunbar
Date: Tue Jul 28 11:08:33 2009
New Revision: 77322
URL: http://llvm.org/viewvc/llvm-project?rev=77322&view=rev
Log:
llvm-mc: Sink token enum into AsmToken.
Modified:
llvm/trunk/tools/llvm-mc/AsmLexer.cpp
llvm/trunk/tools/llvm-mc/AsmLexer.h
llvm/trunk/tools/llvm-mc/AsmParser.cpp
llvm/trunk/tools/llvm-mc/MC-X86Specific.cpp
llvm/trunk/tools/llvm-mc/llvm-mc.cpp
Modified: llvm/trunk/tools/llvm-mc/AsmLexer.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-mc/AsmLexer.cpp?rev=77322&r1=77321&r2=77322&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-mc/AsmLexer.cpp (original)
+++ llvm/trunk/tools/llvm-mc/AsmLexer.cpp Tue Jul 28 11:08:33 2009
@@ -24,7 +24,7 @@
CurBuffer = 0;
CurBuf = SrcMgr.getMemoryBuffer(CurBuffer);
CurPtr = CurBuf->getBufferStart();
- CurTok = AsmToken(asmtok::Error, StringRef(CurPtr, 0));
+ CurTok = AsmToken(AsmToken::Error, StringRef(CurPtr, 0));
TokStart = 0;
}
@@ -41,10 +41,10 @@
}
/// ReturnError - Set the error to the specified string at the specified
-/// location. This is defined to always return asmtok::Error.
+/// location. This is defined to always return AsmToken::Error.
AsmToken AsmLexer::ReturnError(const char *Loc, const std::string &Msg) {
SrcMgr.PrintMessage(SMLoc::getFromPointer(Loc), Msg, "error");
- return AsmToken(asmtok::Error, StringRef(Loc, 0));
+ return AsmToken(AsmToken::Error, StringRef(Loc, 0));
}
/// EnterIncludeFile - Enter the specified file. This prints an error and
@@ -99,18 +99,18 @@
while (isalnum(*CurPtr) || *CurPtr == '_' || *CurPtr == '$' ||
*CurPtr == '.' || *CurPtr == '@')
++CurPtr;
- return AsmToken(asmtok::Identifier, StringRef(TokStart, CurPtr - TokStart));
+ return AsmToken(AsmToken::Identifier, StringRef(TokStart, CurPtr - TokStart));
}
/// LexPercent: Register: %[a-zA-Z0-9]+
AsmToken AsmLexer::LexPercent() {
if (!isalnum(*CurPtr))
- return AsmToken(asmtok::Percent, StringRef(CurPtr, 1)); // Single %.
+ return AsmToken(AsmToken::Percent, StringRef(CurPtr, 1)); // Single %.
while (isalnum(*CurPtr))
++CurPtr;
- return AsmToken(asmtok::Register, StringRef(TokStart, CurPtr - TokStart));
+ return AsmToken(AsmToken::Register, StringRef(TokStart, CurPtr - TokStart));
}
/// LexSlash: Slash: /
@@ -119,7 +119,7 @@
switch (*CurPtr) {
case '*': break; // C style comment.
case '/': return ++CurPtr, LexLineComment();
- default: return AsmToken(asmtok::Slash, StringRef(CurPtr, 1));
+ default: return AsmToken(AsmToken::Slash, StringRef(CurPtr, 1));
}
// C Style comment.
@@ -149,8 +149,8 @@
CurChar = getNextChar();
if (CurChar == EOF)
- return AsmToken(asmtok::Eof, StringRef(CurPtr, 0));
- return AsmToken(asmtok::EndOfStatement, StringRef(CurPtr, 0));
+ return AsmToken(AsmToken::Eof, StringRef(CurPtr, 0));
+ return AsmToken(AsmToken::EndOfStatement, StringRef(CurPtr, 0));
}
@@ -172,7 +172,7 @@
if (CurPtr[-1] != '0') {
while (isdigit(*CurPtr))
++CurPtr;
- return AsmToken(asmtok::IntVal, StringRef(TokStart, CurPtr - TokStart),
+ return AsmToken(AsmToken::Integer, StringRef(TokStart, CurPtr - TokStart),
strtoll(TokStart, 0, 10));
}
@@ -185,7 +185,7 @@
// Requires at least one binary digit.
if (CurPtr == NumStart)
return ReturnError(CurPtr-2, "Invalid binary number");
- return AsmToken(asmtok::IntVal, StringRef(TokStart, CurPtr - TokStart),
+ return AsmToken(AsmToken::Integer, StringRef(TokStart, CurPtr - TokStart),
strtoll(NumStart, 0, 2));
}
@@ -209,14 +209,14 @@
if (errno == ERANGE)
return ReturnError(CurPtr-2, "Hexadecimal number out of range");
}
- return AsmToken(asmtok::IntVal, StringRef(TokStart, CurPtr - TokStart),
+ return AsmToken(AsmToken::Integer, StringRef(TokStart, CurPtr - TokStart),
(int64_t) strtoull(NumStart, 0, 16));
}
// Must be an octal number, it starts with 0.
while (*CurPtr >= '0' && *CurPtr <= '7')
++CurPtr;
- return AsmToken(asmtok::IntVal, StringRef(TokStart, CurPtr - TokStart),
+ return AsmToken(AsmToken::Integer, StringRef(TokStart, CurPtr - TokStart),
strtoll(TokStart, 0, 8));
}
@@ -236,7 +236,7 @@
CurChar = getNextChar();
}
- return AsmToken(asmtok::String, StringRef(TokStart, CurPtr - TokStart));
+ return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart));
}
@@ -253,7 +253,7 @@
// Unknown character, emit an error.
return ReturnError(TokStart, "invalid character in input");
- case EOF: return AsmToken(asmtok::Eof, StringRef(TokStart, 0));
+ case EOF: return AsmToken(AsmToken::Eof, StringRef(TokStart, 0));
case 0:
case ' ':
case '\t':
@@ -261,33 +261,33 @@
return LexToken();
case '\n': // FALL THROUGH.
case '\r': // FALL THROUGH.
- case ';': return AsmToken(asmtok::EndOfStatement, StringRef(TokStart, 1));
- case ':': return AsmToken(asmtok::Colon, StringRef(TokStart, 1));
- case '+': return AsmToken(asmtok::Plus, StringRef(TokStart, 1));
- case '-': return AsmToken(asmtok::Minus, StringRef(TokStart, 1));
- case '~': return AsmToken(asmtok::Tilde, StringRef(TokStart, 1));
- case '(': return AsmToken(asmtok::LParen, StringRef(TokStart, 1));
- case ')': return AsmToken(asmtok::RParen, StringRef(TokStart, 1));
- case '*': return AsmToken(asmtok::Star, StringRef(TokStart, 1));
- case ',': return AsmToken(asmtok::Comma, StringRef(TokStart, 1));
- case '$': return AsmToken(asmtok::Dollar, StringRef(TokStart, 1));
+ case ';': return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 1));
+ case ':': return AsmToken(AsmToken::Colon, StringRef(TokStart, 1));
+ case '+': return AsmToken(AsmToken::Plus, StringRef(TokStart, 1));
+ case '-': return AsmToken(AsmToken::Minus, StringRef(TokStart, 1));
+ case '~': return AsmToken(AsmToken::Tilde, StringRef(TokStart, 1));
+ case '(': return AsmToken(AsmToken::LParen, StringRef(TokStart, 1));
+ case ')': return AsmToken(AsmToken::RParen, StringRef(TokStart, 1));
+ case '*': return AsmToken(AsmToken::Star, StringRef(TokStart, 1));
+ case ',': return AsmToken(AsmToken::Comma, StringRef(TokStart, 1));
+ case '$': return AsmToken(AsmToken::Dollar, StringRef(TokStart, 1));
case '=':
if (*CurPtr == '=')
- return ++CurPtr, AsmToken(asmtok::EqualEqual, StringRef(TokStart, 2));
- return AsmToken(asmtok::Equal, StringRef(TokStart, 1));
+ return ++CurPtr, AsmToken(AsmToken::EqualEqual, StringRef(TokStart, 2));
+ return AsmToken(AsmToken::Equal, StringRef(TokStart, 1));
case '|':
if (*CurPtr == '|')
- return ++CurPtr, AsmToken(asmtok::PipePipe, StringRef(TokStart, 2));
- return AsmToken(asmtok::Pipe, StringRef(TokStart, 1));
- case '^': return AsmToken(asmtok::Caret, StringRef(TokStart, 1));
+ return ++CurPtr, AsmToken(AsmToken::PipePipe, StringRef(TokStart, 2));
+ return AsmToken(AsmToken::Pipe, StringRef(TokStart, 1));
+ case '^': return AsmToken(AsmToken::Caret, StringRef(TokStart, 1));
case '&':
if (*CurPtr == '&')
- return ++CurPtr, AsmToken(asmtok::AmpAmp, StringRef(TokStart, 2));
- return AsmToken(asmtok::Amp, StringRef(TokStart, 1));
+ return ++CurPtr, AsmToken(AsmToken::AmpAmp, StringRef(TokStart, 2));
+ return AsmToken(AsmToken::Amp, StringRef(TokStart, 1));
case '!':
if (*CurPtr == '=')
- return ++CurPtr, AsmToken(asmtok::ExclaimEqual, StringRef(TokStart, 2));
- return AsmToken(asmtok::Exclaim, StringRef(TokStart, 1));
+ return ++CurPtr, AsmToken(AsmToken::ExclaimEqual, StringRef(TokStart, 2));
+ return AsmToken(AsmToken::Exclaim, StringRef(TokStart, 1));
case '%': return LexPercent();
case '/': return LexSlash();
case '#': return LexLineComment();
@@ -297,21 +297,21 @@
return LexDigit();
case '<':
switch (*CurPtr) {
- case '<': return ++CurPtr, AsmToken(asmtok::LessLess,
+ case '<': return ++CurPtr, AsmToken(AsmToken::LessLess,
StringRef(TokStart, 2));
- case '=': return ++CurPtr, AsmToken(asmtok::LessEqual,
+ case '=': return ++CurPtr, AsmToken(AsmToken::LessEqual,
StringRef(TokStart, 2));
- case '>': return ++CurPtr, AsmToken(asmtok::LessGreater,
+ case '>': return ++CurPtr, AsmToken(AsmToken::LessGreater,
StringRef(TokStart, 2));
- default: return AsmToken(asmtok::Less, StringRef(TokStart, 1));
+ default: return AsmToken(AsmToken::Less, StringRef(TokStart, 1));
}
case '>':
switch (*CurPtr) {
- case '>': return ++CurPtr, AsmToken(asmtok::GreaterGreater,
+ case '>': return ++CurPtr, AsmToken(AsmToken::GreaterGreater,
StringRef(TokStart, 2));
- case '=': return ++CurPtr, AsmToken(asmtok::GreaterEqual,
+ case '=': return ++CurPtr, AsmToken(AsmToken::GreaterEqual,
StringRef(TokStart, 2));
- default: return AsmToken(asmtok::Greater, StringRef(TokStart, 1));
+ default: return AsmToken(AsmToken::Greater, StringRef(TokStart, 1));
}
// TODO: Quoted identifiers (objc methods etc)
Modified: llvm/trunk/tools/llvm-mc/AsmLexer.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-mc/AsmLexer.h?rev=77322&r1=77321&r2=77322&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-mc/AsmLexer.h (original)
+++ llvm/trunk/tools/llvm-mc/AsmLexer.h Tue Jul 28 11:08:33 2009
@@ -25,8 +25,9 @@
class SourceMgr;
class SMLoc;
-namespace asmtok {
- enum TokKind {
+/// AsmToken - Target independent representation for an assembler token.
+struct AsmToken {
+ enum TokenKind {
// Markers
Eof, Error,
@@ -36,7 +37,7 @@
String,
// Integer values.
- IntVal,
+ Integer,
// No-value.
EndOfStatement,
@@ -51,11 +52,8 @@
Less, LessEqual, LessLess, LessGreater,
Greater, GreaterEqual, GreaterGreater
};
-}
-/// AsmToken - Target independent representation for an assembler token.
-struct AsmToken {
- asmtok::TokKind Kind;
+ TokenKind Kind;
/// A reference to the entire token contents; this is always a pointer into
/// a memory buffer owned by the source manager.
@@ -65,19 +63,22 @@
public:
AsmToken() {}
- AsmToken(asmtok::TokKind _Kind, const StringRef &_Str, int64_t _IntVal = 0)
+ AsmToken(TokenKind _Kind, const StringRef &_Str, int64_t _IntVal = 0)
: Kind(_Kind), Str(_Str), IntVal(_IntVal) {}
- asmtok::TokKind getKind() const { return Kind; }
- bool is(asmtok::TokKind K) const { return Kind == K; }
- bool isNot(asmtok::TokKind K) const { return Kind != K; }
+ TokenKind getKind() const { return Kind; }
+ bool is(TokenKind K) const { return Kind == K; }
+ bool isNot(TokenKind K) const { return Kind != K; }
SMLoc getLoc() const;
StringRef getString() const { return Str; }
+ // FIXME: Don't compute this in advance, it makes every token larger, and is
+ // also not generally what we want (it is nicer for recovery etc. to lex 123br
+ // as a single token, then diagnose as an invalid number).
int64_t getIntVal() const {
- assert(Kind == asmtok::IntVal && "This token isn't an integer");
+ assert(Kind == Integer && "This token isn't an integer");
return IntVal;
}
};
@@ -104,13 +105,13 @@
AsmLexer(SourceMgr &SrcMgr);
~AsmLexer();
- asmtok::TokKind Lex() {
+ AsmToken::TokenKind Lex() {
return CurTok = LexToken(), getKind();
}
- asmtok::TokKind getKind() const { return CurTok.getKind(); }
- bool is(asmtok::TokKind K) const { return CurTok.is(K); }
- bool isNot(asmtok::TokKind K) const { return CurTok.isNot(K); }
+ AsmToken::TokenKind getKind() const { return CurTok.getKind(); }
+ bool is(AsmToken::TokenKind K) const { return CurTok.is(K); }
+ bool isNot(AsmToken::TokenKind K) const { return CurTok.isNot(K); }
/// getCurStrVal - Get the string for the current token, this includes all
/// characters (for example, the quotes on strings) in the token.
@@ -125,6 +126,8 @@
}
SMLoc getLoc() const;
+
+ const AsmToken &getTok() const;
/// EnterIncludeFile - Enter the specified file. This returns true on failure.
bool EnterIncludeFile(const std::string &Filename);
Modified: llvm/trunk/tools/llvm-mc/AsmParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-mc/AsmParser.cpp?rev=77322&r1=77321&r2=77322&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-mc/AsmParser.cpp (original)
+++ llvm/trunk/tools/llvm-mc/AsmParser.cpp Tue Jul 28 11:08:33 2009
@@ -45,7 +45,7 @@
bool HadError = false;
// While we have input, parse each statement.
- while (Lexer.isNot(asmtok::Eof)) {
+ while (Lexer.isNot(AsmToken::Eof)) {
if (!ParseStatement()) continue;
// If we had an error, remember it and recover by skipping to the next line.
@@ -58,12 +58,12 @@
/// EatToEndOfStatement - Throw away the rest of the line for testing purposes.
void AsmParser::EatToEndOfStatement() {
- while (Lexer.isNot(asmtok::EndOfStatement) &&
- Lexer.isNot(asmtok::Eof))
+ while (Lexer.isNot(AsmToken::EndOfStatement) &&
+ Lexer.isNot(AsmToken::Eof))
Lexer.Lex();
// Eat EOL.
- if (Lexer.is(asmtok::EndOfStatement))
+ if (Lexer.is(AsmToken::EndOfStatement))
Lexer.Lex();
}
@@ -75,7 +75,7 @@
///
bool AsmParser::ParseParenExpr(AsmExpr *&Res) {
if (ParseExpression(Res)) return true;
- if (Lexer.isNot(asmtok::RParen))
+ if (Lexer.isNot(AsmToken::RParen))
return TokError("expected ')' in parentheses expression");
Lexer.Lex();
return false;
@@ -90,13 +90,13 @@
switch (Lexer.getKind()) {
default:
return TokError("unknown token in expression");
- case asmtok::Exclaim:
+ case AsmToken::Exclaim:
Lexer.Lex(); // Eat the operator.
if (ParsePrimaryExpr(Res))
return true;
Res = new AsmUnaryExpr(AsmUnaryExpr::LNot, Res);
return false;
- case asmtok::Identifier: {
+ case AsmToken::Identifier: {
// This is a label, this should be parsed as part of an expression, to
// handle things like LFOO+4.
MCSymbol *Sym = Ctx.GetOrCreateSymbol(Lexer.getCurStrVal());
@@ -109,26 +109,26 @@
Lexer.Lex(); // Eat identifier.
return false;
}
- case asmtok::IntVal:
+ case AsmToken::Integer:
Res = new AsmConstantExpr(Lexer.getCurIntVal());
Lexer.Lex(); // Eat identifier.
return false;
- case asmtok::LParen:
+ case AsmToken::LParen:
Lexer.Lex(); // Eat the '('.
return ParseParenExpr(Res);
- case asmtok::Minus:
+ case AsmToken::Minus:
Lexer.Lex(); // Eat the operator.
if (ParsePrimaryExpr(Res))
return true;
Res = new AsmUnaryExpr(AsmUnaryExpr::Minus, Res);
return false;
- case asmtok::Plus:
+ case AsmToken::Plus:
Lexer.Lex(); // Eat the operator.
if (ParsePrimaryExpr(Res))
return true;
Res = new AsmUnaryExpr(AsmUnaryExpr::Plus, Res);
return false;
- case asmtok::Tilde:
+ case AsmToken::Tilde:
Lexer.Lex(); // Eat the operator.
if (ParsePrimaryExpr(Res))
return true;
@@ -189,73 +189,73 @@
return false;
}
-static unsigned getBinOpPrecedence(asmtok::TokKind K,
+static unsigned getBinOpPrecedence(AsmToken::TokenKind K,
AsmBinaryExpr::Opcode &Kind) {
switch (K) {
default: return 0; // not a binop.
// Lowest Precedence: &&, ||
- case asmtok::AmpAmp:
+ case AsmToken::AmpAmp:
Kind = AsmBinaryExpr::LAnd;
return 1;
- case asmtok::PipePipe:
+ case AsmToken::PipePipe:
Kind = AsmBinaryExpr::LOr;
return 1;
// Low Precedence: +, -, ==, !=, <>, <, <=, >, >=
- case asmtok::Plus:
+ case AsmToken::Plus:
Kind = AsmBinaryExpr::Add;
return 2;
- case asmtok::Minus:
+ case AsmToken::Minus:
Kind = AsmBinaryExpr::Sub;
return 2;
- case asmtok::EqualEqual:
+ case AsmToken::EqualEqual:
Kind = AsmBinaryExpr::EQ;
return 2;
- case asmtok::ExclaimEqual:
- case asmtok::LessGreater:
+ case AsmToken::ExclaimEqual:
+ case AsmToken::LessGreater:
Kind = AsmBinaryExpr::NE;
return 2;
- case asmtok::Less:
+ case AsmToken::Less:
Kind = AsmBinaryExpr::LT;
return 2;
- case asmtok::LessEqual:
+ case AsmToken::LessEqual:
Kind = AsmBinaryExpr::LTE;
return 2;
- case asmtok::Greater:
+ case AsmToken::Greater:
Kind = AsmBinaryExpr::GT;
return 2;
- case asmtok::GreaterEqual:
+ case AsmToken::GreaterEqual:
Kind = AsmBinaryExpr::GTE;
return 2;
// Intermediate Precedence: |, &, ^
//
// FIXME: gas seems to support '!' as an infix operator?
- case asmtok::Pipe:
+ case AsmToken::Pipe:
Kind = AsmBinaryExpr::Or;
return 3;
- case asmtok::Caret:
+ case AsmToken::Caret:
Kind = AsmBinaryExpr::Xor;
return 3;
- case asmtok::Amp:
+ case AsmToken::Amp:
Kind = AsmBinaryExpr::And;
return 3;
// Highest Precedence: *, /, %, <<, >>
- case asmtok::Star:
+ case AsmToken::Star:
Kind = AsmBinaryExpr::Mul;
return 4;
- case asmtok::Slash:
+ case AsmToken::Slash:
Kind = AsmBinaryExpr::Div;
return 4;
- case asmtok::Percent:
+ case AsmToken::Percent:
Kind = AsmBinaryExpr::Mod;
return 4;
- case asmtok::LessLess:
+ case AsmToken::LessLess:
Kind = AsmBinaryExpr::Shl;
return 4;
- case asmtok::GreaterGreater:
+ case AsmToken::GreaterGreater:
Kind = AsmBinaryExpr::Shr;
return 4;
}
@@ -304,10 +304,10 @@
switch (Lexer.getKind()) {
default:
return TokError("unexpected token at start of statement");
- case asmtok::EndOfStatement:
+ case AsmToken::EndOfStatement:
Lexer.Lex();
return false;
- case asmtok::Identifier:
+ case AsmToken::Identifier:
break;
// TODO: Recurse on local labels etc.
}
@@ -318,7 +318,7 @@
// Consume the identifier, see what is after it.
switch (Lexer.Lex()) {
- case asmtok::Colon: {
+ case AsmToken::Colon: {
// identifier ':' -> Label.
Lexer.Lex();
@@ -341,7 +341,7 @@
return ParseStatement();
}
- case asmtok::Equal:
+ case AsmToken::Equal:
// identifier '=' ... -> assignment statement
Lexer.Lex();
@@ -554,7 +554,7 @@
getTargetParser().ParseInstruction(*this, IDVal, Inst))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in argument list");
// Eat the end of statement marker.
@@ -575,7 +575,7 @@
if (ParseRelocatableExpression(Value))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in assignment");
// Eat the end of statement marker.
@@ -603,12 +603,12 @@
/// ParseDirectiveSet:
/// ::= .set identifier ',' expression
bool AsmParser::ParseDirectiveSet() {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier after '.set' directive");
StringRef Name = Lexer.getCurStrVal();
- if (Lexer.Lex() != asmtok::Comma)
+ if (Lexer.Lex() != AsmToken::Comma)
return TokError("unexpected token in '.set'");
Lexer.Lex();
@@ -620,24 +620,24 @@
/// FIXME: This should actually parse out the segment, section, attributes and
/// sizeof_stub fields.
bool AsmParser::ParseDirectiveDarwinSection() {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier after '.section' directive");
std::string Section = Lexer.getCurStrVal();
Lexer.Lex();
// Accept a comma separated list of modifiers.
- while (Lexer.is(asmtok::Comma)) {
+ while (Lexer.is(AsmToken::Comma)) {
Lexer.Lex();
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier in '.section' directive");
Section += ',';
Section += Lexer.getCurStrVal().str();
Lexer.Lex();
}
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.section' directive");
Lexer.Lex();
@@ -647,7 +647,7 @@
bool AsmParser::ParseDirectiveSectionSwitch(const char *Section,
const char *Directives) {
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in section switching directive");
Lexer.Lex();
@@ -664,9 +664,9 @@
/// ParseDirectiveAscii:
/// ::= ( .ascii | .asciz ) [ "string" ( , "string" )* ]
bool AsmParser::ParseDirectiveAscii(bool ZeroTerminated) {
- if (Lexer.isNot(asmtok::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
for (;;) {
- if (Lexer.isNot(asmtok::String))
+ if (Lexer.isNot(AsmToken::String))
return TokError("expected string in '.ascii' or '.asciz' directive");
// FIXME: This shouldn't use a const char* + strlen, the string could have
@@ -679,10 +679,10 @@
Lexer.Lex();
- if (Lexer.is(asmtok::EndOfStatement))
+ if (Lexer.is(AsmToken::EndOfStatement))
break;
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.ascii' or '.asciz' directive");
Lexer.Lex();
}
@@ -695,7 +695,7 @@
/// ParseDirectiveValue
/// ::= (.byte | .short | ... ) [ expression (, expression)* ]
bool AsmParser::ParseDirectiveValue(unsigned Size) {
- if (Lexer.isNot(asmtok::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
for (;;) {
MCValue Expr;
if (ParseRelocatableExpression(Expr))
@@ -703,11 +703,11 @@
Out.EmitValue(Expr, Size);
- if (Lexer.is(asmtok::EndOfStatement))
+ if (Lexer.is(AsmToken::EndOfStatement))
break;
// FIXME: Improve diagnostic.
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
}
@@ -726,8 +726,8 @@
int64_t FillExpr = 0;
bool HasFillExpr = false;
- if (Lexer.isNot(asmtok::EndOfStatement)) {
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.space' directive");
Lexer.Lex();
@@ -736,7 +736,7 @@
HasFillExpr = true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.space' directive");
}
@@ -759,7 +759,7 @@
if (ParseAbsoluteExpression(NumValues))
return true;
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.fill' directive");
Lexer.Lex();
@@ -767,7 +767,7 @@
if (ParseAbsoluteExpression(FillSize))
return true;
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.fill' directive");
Lexer.Lex();
@@ -775,7 +775,7 @@
if (ParseAbsoluteExpression(FillExpr))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.fill' directive");
Lexer.Lex();
@@ -798,15 +798,15 @@
// Parse optional fill expression.
int64_t FillExpr = 0;
- if (Lexer.isNot(asmtok::EndOfStatement)) {
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.org' directive");
Lexer.Lex();
if (ParseAbsoluteExpression(FillExpr))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.org' directive");
}
@@ -830,22 +830,22 @@
bool HasFillExpr = false;
int64_t FillExpr = 0;
int64_t MaxBytesToFill = 0;
- if (Lexer.isNot(asmtok::EndOfStatement)) {
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
// The fill expression can be omitted while specifying a maximum number of
// alignment bytes, e.g:
// .align 3,,4
- if (Lexer.isNot(asmtok::Comma)) {
+ if (Lexer.isNot(AsmToken::Comma)) {
HasFillExpr = true;
if (ParseAbsoluteExpression(FillExpr))
return true;
}
- if (Lexer.isNot(asmtok::EndOfStatement)) {
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
@@ -853,7 +853,7 @@
if (ParseAbsoluteExpression(MaxBytesToFill))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in directive");
}
}
@@ -895,9 +895,9 @@
/// ParseDirectiveSymbolAttribute
/// ::= { ".globl", ".weak", ... } [ identifier ( , identifier )* ]
bool AsmParser::ParseDirectiveSymbolAttribute(MCStreamer::SymbolAttr Attr) {
- if (Lexer.isNot(asmtok::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
for (;;) {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier in directive");
MCSymbol *Sym = Ctx.GetOrCreateSymbol(Lexer.getCurStrVal());
@@ -909,10 +909,10 @@
Out.EmitSymbolAttribute(Sym, Attr);
- if (Lexer.is(asmtok::EndOfStatement))
+ if (Lexer.is(AsmToken::EndOfStatement))
break;
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
}
@@ -925,7 +925,7 @@
/// ParseDirectiveDarwinSymbolDesc
/// ::= .desc identifier , expression
bool AsmParser::ParseDirectiveDarwinSymbolDesc() {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier in directive");
// handle the identifier as the key symbol.
@@ -933,7 +933,7 @@
MCSymbol *Sym = Ctx.GetOrCreateSymbol(Lexer.getCurStrVal());
Lexer.Lex();
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.desc' directive");
Lexer.Lex();
@@ -942,7 +942,7 @@
if (ParseAbsoluteExpression(DescValue))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.desc' directive");
Lexer.Lex();
@@ -956,7 +956,7 @@
/// ParseDirectiveComm
/// ::= ( .comm | .lcomm ) identifier , size_expression [ , align_expression ]
bool AsmParser::ParseDirectiveComm(bool IsLocal) {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier in directive");
// handle the identifier as the key symbol.
@@ -964,7 +964,7 @@
MCSymbol *Sym = Ctx.GetOrCreateSymbol(Lexer.getCurStrVal());
Lexer.Lex();
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
@@ -975,14 +975,14 @@
int64_t Pow2Alignment = 0;
SMLoc Pow2AlignmentLoc;
- if (Lexer.is(asmtok::Comma)) {
+ if (Lexer.is(AsmToken::Comma)) {
Lexer.Lex();
Pow2AlignmentLoc = Lexer.getLoc();
if (ParseAbsoluteExpression(Pow2Alignment))
return true;
}
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.comm' or '.lcomm' directive");
Lexer.Lex();
@@ -1014,17 +1014,17 @@
/// ::= .zerofill segname , sectname [, identifier , size_expression [
/// , align_expression ]]
bool AsmParser::ParseDirectiveDarwinZerofill() {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected segment name after '.zerofill' directive");
std::string Section = Lexer.getCurStrVal();
Lexer.Lex();
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Section += ',';
Lexer.Lex();
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected section name after comma in '.zerofill' "
"directive");
Section += Lexer.getCurStrVal().str();
@@ -1040,17 +1040,17 @@
// If this is the end of the line all that was wanted was to create the
// the section but with no symbol.
- if (Lexer.is(asmtok::EndOfStatement)) {
+ if (Lexer.is(AsmToken::EndOfStatement)) {
// Create the zerofill section but no symbol
Out.EmitZerofill(Ctx.GetSection(Section.c_str()));
return false;
}
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier in directive");
// handle the identifier as the key symbol.
@@ -1058,7 +1058,7 @@
MCSymbol *Sym = Ctx.GetOrCreateSymbol(Lexer.getCurStrVal());
Lexer.Lex();
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in directive");
Lexer.Lex();
@@ -1069,14 +1069,14 @@
int64_t Pow2Alignment = 0;
SMLoc Pow2AlignmentLoc;
- if (Lexer.is(asmtok::Comma)) {
+ if (Lexer.is(AsmToken::Comma)) {
Lexer.Lex();
Pow2AlignmentLoc = Lexer.getLoc();
if (ParseAbsoluteExpression(Pow2Alignment))
return true;
}
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.zerofill' directive");
Lexer.Lex();
@@ -1105,7 +1105,7 @@
/// ParseDirectiveDarwinSubsectionsViaSymbols
/// ::= .subsections_via_symbols
bool AsmParser::ParseDirectiveDarwinSubsectionsViaSymbols() {
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.subsections_via_symbols' directive");
Lexer.Lex();
@@ -1122,8 +1122,8 @@
SMLoc Loc = Lexer.getLoc();
StringRef Str = "";
- if (Lexer.isNot(asmtok::EndOfStatement)) {
- if (Lexer.isNot(asmtok::String))
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::String))
return TokError("expected string in '.abort' directive");
Str = Lexer.getCurStrVal();
@@ -1131,7 +1131,7 @@
Lexer.Lex();
}
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.abort' directive");
Lexer.Lex();
@@ -1148,7 +1148,7 @@
/// ParseDirectiveLsym
/// ::= .lsym identifier , expression
bool AsmParser::ParseDirectiveDarwinLsym() {
- if (Lexer.isNot(asmtok::Identifier))
+ if (Lexer.isNot(AsmToken::Identifier))
return TokError("expected identifier in directive");
// handle the identifier as the key symbol.
@@ -1156,7 +1156,7 @@
MCSymbol *Sym = Ctx.GetOrCreateSymbol(Lexer.getCurStrVal());
Lexer.Lex();
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return TokError("unexpected token in '.lsym' directive");
Lexer.Lex();
@@ -1164,7 +1164,7 @@
if (ParseRelocatableExpression(Expr))
return true;
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.lsym' directive");
Lexer.Lex();
@@ -1178,14 +1178,14 @@
/// ParseDirectiveInclude
/// ::= .include "filename"
bool AsmParser::ParseDirectiveInclude() {
- if (Lexer.isNot(asmtok::String))
+ if (Lexer.isNot(AsmToken::String))
return TokError("expected string in '.include' directive");
std::string Filename = Lexer.getCurStrVal();
SMLoc IncludeLoc = Lexer.getLoc();
Lexer.Lex();
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.include' directive");
// Strip the quotes.
@@ -1206,14 +1206,14 @@
/// ParseDirectiveDarwinDumpOrLoad
/// ::= ( .dump | .load ) "filename"
bool AsmParser::ParseDirectiveDarwinDumpOrLoad(SMLoc IDLoc, bool IsDump) {
- if (Lexer.isNot(asmtok::String))
+ if (Lexer.isNot(AsmToken::String))
return TokError("expected string in '.dump' or '.load' directive");
Lexer.getCurStrVal();
Lexer.Lex();
- if (Lexer.isNot(asmtok::EndOfStatement))
+ if (Lexer.isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '.dump' or '.load' directive");
Lexer.Lex();
Modified: llvm/trunk/tools/llvm-mc/MC-X86Specific.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-mc/MC-X86Specific.cpp?rev=77322&r1=77321&r2=77322&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-mc/MC-X86Specific.cpp (original)
+++ llvm/trunk/tools/llvm-mc/MC-X86Specific.cpp Tue Jul 28 11:08:33 2009
@@ -81,7 +81,7 @@
};
bool AsmParser::ParseX86Register(X86Operand &Op) {
- assert(Lexer.getKind() == asmtok::Register && "Invalid token kind!");
+ assert(Lexer.getKind() == AsmToken::Register && "Invalid token kind!");
// FIXME: Decode register number.
Op = X86Operand::CreateReg(123);
@@ -94,11 +94,11 @@
switch (Lexer.getKind()) {
default:
return ParseX86MemOperand(Op);
- case asmtok::Register:
+ case AsmToken::Register:
// FIXME: if a segment register, this could either be just the seg reg, or
// the start of a memory operand.
return ParseX86Register(Op);
- case asmtok::Dollar: {
+ case AsmToken::Dollar: {
// $42 -> immediate.
Lexer.Lex();
MCValue Val;
@@ -107,10 +107,10 @@
Op = X86Operand::CreateImm(Val);
return false;
}
- case asmtok::Star: {
+ case AsmToken::Star: {
Lexer.Lex(); // Eat the star.
- if (Lexer.is(asmtok::Register)) {
+ if (Lexer.is(AsmToken::Register)) {
if (ParseX86Register(Op))
return true;
} else if (ParseX86MemOperand(Op))
@@ -132,12 +132,12 @@
// only way to do this without lookahead is to eat the ( and see what is after
// it.
MCValue Disp = MCValue::get(0, 0, 0);
- if (Lexer.isNot(asmtok::LParen)) {
+ if (Lexer.isNot(AsmToken::LParen)) {
if (ParseRelocatableExpression(Disp)) return true;
// After parsing the base expression we could either have a parenthesized
// memory address or not. If not, return now. If so, eat the (.
- if (Lexer.isNot(asmtok::LParen)) {
+ if (Lexer.isNot(AsmToken::LParen)) {
Op = X86Operand::CreateMem(SegReg, Disp, 0, 0, 0);
return false;
}
@@ -149,7 +149,7 @@
// so we have to eat the ( to see beyond it.
Lexer.Lex(); // Eat the '('.
- if (Lexer.is(asmtok::Register) || Lexer.is(asmtok::Comma)) {
+ if (Lexer.is(AsmToken::Register) || Lexer.is(AsmToken::Comma)) {
// Nothing to do here, fall into the code below with the '(' part of the
// memory operand consumed.
} else {
@@ -159,7 +159,7 @@
// After parsing the base expression we could either have a parenthesized
// memory address or not. If not, return now. If so, eat the (.
- if (Lexer.isNot(asmtok::LParen)) {
+ if (Lexer.isNot(AsmToken::LParen)) {
Op = X86Operand::CreateMem(SegReg, Disp, 0, 0, 0);
return false;
}
@@ -173,13 +173,13 @@
// the rest of the memory operand.
unsigned BaseReg = 0, IndexReg = 0, Scale = 0;
- if (Lexer.is(asmtok::Register)) {
+ if (Lexer.is(AsmToken::Register)) {
if (ParseX86Register(Op))
return true;
BaseReg = Op.getReg();
}
- if (Lexer.is(asmtok::Comma)) {
+ if (Lexer.is(AsmToken::Comma)) {
Lexer.Lex(); // Eat the comma.
// Following the comma we should have either an index register, or a scale
@@ -188,20 +188,20 @@
//
// Not that even though it would be completely consistent to support syntax
// like "1(%eax,,1)", the assembler doesn't.
- if (Lexer.is(asmtok::Register)) {
+ if (Lexer.is(AsmToken::Register)) {
if (ParseX86Register(Op))
return true;
IndexReg = Op.getReg();
Scale = 1; // If not specified, the scale defaults to 1.
- if (Lexer.isNot(asmtok::RParen)) {
+ if (Lexer.isNot(AsmToken::RParen)) {
// Parse the scale amount:
// ::= ',' [scale-expression]
- if (Lexer.isNot(asmtok::Comma))
+ if (Lexer.isNot(AsmToken::Comma))
return true;
Lexer.Lex(); // Eat the comma.
- if (Lexer.isNot(asmtok::RParen)) {
+ if (Lexer.isNot(AsmToken::RParen)) {
int64_t ScaleVal;
if (ParseAbsoluteExpression(ScaleVal))
return true;
@@ -212,7 +212,7 @@
Scale = (unsigned)ScaleVal;
}
}
- } else if (Lexer.isNot(asmtok::RParen)) {
+ } else if (Lexer.isNot(AsmToken::RParen)) {
// Otherwise we have the unsupported form of a scale amount without an
// index.
SMLoc Loc = Lexer.getLoc();
@@ -226,7 +226,7 @@
}
// Ok, we've eaten the memory operand, verify we have a ')' and eat it too.
- if (Lexer.isNot(asmtok::RParen))
+ if (Lexer.isNot(AsmToken::RParen))
return TokError("unexpected token in memory operand");
Lexer.Lex(); // Eat the ')'.
@@ -247,13 +247,13 @@
bool AsmParser::ParseX86InstOperands(const StringRef &InstName, MCInst &Inst) {
llvm::SmallVector<X86Operand, 3> Operands;
- if (Lexer.isNot(asmtok::EndOfStatement)) {
+ if (Lexer.isNot(AsmToken::EndOfStatement)) {
// Read the first operand.
Operands.push_back(X86Operand());
if (ParseX86Operand(Operands.back()))
return true;
- while (Lexer.is(asmtok::Comma)) {
+ while (Lexer.is(AsmToken::Comma)) {
Lexer.Lex(); // Eat the comma.
// Parse and remember the operand.
Modified: llvm/trunk/tools/llvm-mc/llvm-mc.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-mc/llvm-mc.cpp?rev=77322&r1=77321&r2=77322&view=diff
==============================================================================
--- llvm/trunk/tools/llvm-mc/llvm-mc.cpp (original)
+++ llvm/trunk/tools/llvm-mc/llvm-mc.cpp Tue Jul 28 11:08:33 2009
@@ -83,58 +83,58 @@
bool Error = false;
- asmtok::TokKind Tok = Lexer.Lex();
- while (Tok != asmtok::Eof) {
+ AsmToken::TokenKind Tok = Lexer.Lex();
+ while (Tok != AsmToken::Eof) {
switch (Tok) {
default:
Lexer.PrintMessage(Lexer.getLoc(), "unknown token", "warning");
Error = true;
break;
- case asmtok::Error:
+ case AsmToken::Error:
Error = true; // error already printed.
break;
- case asmtok::Identifier:
+ case AsmToken::Identifier:
outs() << "identifier: " << Lexer.getCurStrVal() << '\n';
break;
- case asmtok::Register:
+ case AsmToken::Register:
outs() << "register: " << Lexer.getCurStrVal() << '\n';
break;
- case asmtok::String:
+ case AsmToken::String:
outs() << "string: " << Lexer.getCurStrVal() << '\n';
break;
- case asmtok::IntVal:
+ case AsmToken::Integer:
outs() << "int: " << Lexer.getCurIntVal() << '\n';
break;
- case asmtok::Amp: outs() << "Amp\n"; break;
- case asmtok::AmpAmp: outs() << "AmpAmp\n"; break;
- case asmtok::Caret: outs() << "Caret\n"; break;
- case asmtok::Colon: outs() << "Colon\n"; break;
- case asmtok::Comma: outs() << "Comma\n"; break;
- case asmtok::Dollar: outs() << "Dollar\n"; break;
- case asmtok::EndOfStatement: outs() << "EndOfStatement\n"; break;
- case asmtok::Eof: outs() << "Eof\n"; break;
- case asmtok::Equal: outs() << "Equal\n"; break;
- case asmtok::EqualEqual: outs() << "EqualEqual\n"; break;
- case asmtok::Exclaim: outs() << "Exclaim\n"; break;
- case asmtok::ExclaimEqual: outs() << "ExclaimEqual\n"; break;
- case asmtok::Greater: outs() << "Greater\n"; break;
- case asmtok::GreaterEqual: outs() << "GreaterEqual\n"; break;
- case asmtok::GreaterGreater: outs() << "GreaterGreater\n"; break;
- case asmtok::LParen: outs() << "LParen\n"; break;
- case asmtok::Less: outs() << "Less\n"; break;
- case asmtok::LessEqual: outs() << "LessEqual\n"; break;
- case asmtok::LessGreater: outs() << "LessGreater\n"; break;
- case asmtok::LessLess: outs() << "LessLess\n"; break;
- case asmtok::Minus: outs() << "Minus\n"; break;
- case asmtok::Percent: outs() << "Percent\n"; break;
- case asmtok::Pipe: outs() << "Pipe\n"; break;
- case asmtok::PipePipe: outs() << "PipePipe\n"; break;
- case asmtok::Plus: outs() << "Plus\n"; break;
- case asmtok::RParen: outs() << "RParen\n"; break;
- case asmtok::Slash: outs() << "Slash\n"; break;
- case asmtok::Star: outs() << "Star\n"; break;
- case asmtok::Tilde: outs() << "Tilde\n"; break;
+ case AsmToken::Amp: outs() << "Amp\n"; break;
+ case AsmToken::AmpAmp: outs() << "AmpAmp\n"; break;
+ case AsmToken::Caret: outs() << "Caret\n"; break;
+ case AsmToken::Colon: outs() << "Colon\n"; break;
+ case AsmToken::Comma: outs() << "Comma\n"; break;
+ case AsmToken::Dollar: outs() << "Dollar\n"; break;
+ case AsmToken::EndOfStatement: outs() << "EndOfStatement\n"; break;
+ case AsmToken::Eof: outs() << "Eof\n"; break;
+ case AsmToken::Equal: outs() << "Equal\n"; break;
+ case AsmToken::EqualEqual: outs() << "EqualEqual\n"; break;
+ case AsmToken::Exclaim: outs() << "Exclaim\n"; break;
+ case AsmToken::ExclaimEqual: outs() << "ExclaimEqual\n"; break;
+ case AsmToken::Greater: outs() << "Greater\n"; break;
+ case AsmToken::GreaterEqual: outs() << "GreaterEqual\n"; break;
+ case AsmToken::GreaterGreater: outs() << "GreaterGreater\n"; break;
+ case AsmToken::LParen: outs() << "LParen\n"; break;
+ case AsmToken::Less: outs() << "Less\n"; break;
+ case AsmToken::LessEqual: outs() << "LessEqual\n"; break;
+ case AsmToken::LessGreater: outs() << "LessGreater\n"; break;
+ case AsmToken::LessLess: outs() << "LessLess\n"; break;
+ case AsmToken::Minus: outs() << "Minus\n"; break;
+ case AsmToken::Percent: outs() << "Percent\n"; break;
+ case AsmToken::Pipe: outs() << "Pipe\n"; break;
+ case AsmToken::PipePipe: outs() << "PipePipe\n"; break;
+ case AsmToken::Plus: outs() << "Plus\n"; break;
+ case AsmToken::RParen: outs() << "RParen\n"; break;
+ case AsmToken::Slash: outs() << "Slash\n"; break;
+ case AsmToken::Star: outs() << "Star\n"; break;
+ case AsmToken::Tilde: outs() << "Tilde\n"; break;
}
Tok = Lexer.Lex();
More information about the llvm-commits
mailing list