bool X86ATTAsmParser::ParseRegister(X86Operand &Op) {
+ const AsmToken &TokPercent = getLexer().getTok();
+ assert(TokPercent.is(AsmToken::Percent) && "Invalid token kind!");
+ getLexer().Lex(); // Eat percent token.
+
const AsmToken &Tok = getLexer().getTok();
- assert(Tok.is(AsmToken::Register) && "Invalid token kind!");
+ assert(TokPercent.is(AsmToken::Identifier) && "Invalid token kind!");
// FIXME: Validate register for the current architecture; we have to do
// validation later, so maybe there is no need for this here.
unsigned RegNo;
- assert(Tok.getString().startswith("%") && "Invalid register name!");
- RegNo = MatchRegisterName(Tok.getString().substr(1));
+ RegNo = MatchRegisterName(Tok.getString());
if (RegNo == 0)
return Error(Tok.getLoc(), "invalid register name");
Op = X86Operand::CreateReg(RegNo);
- getLexer().Lex(); // Eat register token.
+ getLexer().Lex(); // Eat identifier token.
return false;
}
switch (getLexer().getKind()) {
default:
return ParseMemOperand(Op);
- case AsmToken::Register:
+ case AsmToken::Percent:
// FIXME: if a segment register, this could either be just the seg reg, or
// the start of a memory operand.
return ParseRegister(Op);
// so we have to eat the ( to see beyond it.
getLexer().Lex(); // Eat the '('.
- if (getLexer().is(AsmToken::Register) || getLexer().is(AsmToken::Comma)) {
+ if (getLexer().is(AsmToken::Percent) || getLexer().is(AsmToken::Comma)) {
// Nothing to do here, fall into the code below with the '(' part of the
// memory operand consumed.
} else {
// the rest of the memory operand.
unsigned BaseReg = 0, IndexReg = 0, Scale = 1;
- if (getLexer().is(AsmToken::Register)) {
+ if (getLexer().is(AsmToken::Percent)) {
if (ParseRegister(Op))
return true;
BaseReg = Op.getReg();
//
// Not that even though it would be completely consistent to support syntax
// like "1(%eax,,1)", the assembler doesn't.
- if (getLexer().is(AsmToken::Register)) {
+ if (getLexer().is(AsmToken::Percent)) {
if (ParseRegister(Op))
return true;
IndexReg = Op.getReg();
return AsmToken(AsmToken::Identifier, StringRef(TokStart, CurPtr - TokStart));
}
-/// LexPercent: Register: %[a-zA-Z0-9]+
-AsmToken AsmLexer::LexPercent() {
- if (!isalnum(*CurPtr))
- return AsmToken(AsmToken::Percent, StringRef(CurPtr, 1)); // Single %.
-
- while (isalnum(*CurPtr))
- ++CurPtr;
-
- return AsmToken(AsmToken::Register, StringRef(TokStart, CurPtr - TokStart));
-}
-
/// LexSlash: Slash: /
/// C-Style Comment: /* ... */
AsmToken AsmLexer::LexSlash() {
if (*CurPtr == '=')
return ++CurPtr, AsmToken(AsmToken::ExclaimEqual, StringRef(TokStart, 2));
return AsmToken(AsmToken::Exclaim, StringRef(TokStart, 1));
- case '%': return LexPercent();
+ case '%': return AsmToken(AsmToken::Percent, StringRef(TokStart, 1));
case '/': return LexSlash();
case '#': return LexLineComment();
case '"': return LexQuote();