/// \brief Helper class for tracking macro definitions.
typedef std::vector<AsmToken> MacroArgument;
+typedef std::vector<MacroArgument> MacroArguments;
+typedef StringRef MacroParameter;
+typedef std::vector<MacroParameter> MacroParameters;
struct Macro {
StringRef Name;
StringRef Body;
- std::vector<StringRef> Parameters;
+ MacroParameters Parameters;
public:
- Macro(StringRef N, StringRef B, const std::vector<StringRef> &P) :
+ Macro(StringRef N, StringRef B, const MacroParameters &P) :
Name(N), Body(B), Parameters(P) {}
};
bool HandleMacroEntry(StringRef Name, SMLoc NameLoc, const Macro *M);
bool expandMacro(raw_svector_ostream &OS, StringRef Body,
- const std::vector<StringRef> &Parameters,
- const std::vector<MacroArgument> &A,
+ const MacroParameters &Parameters,
+ const MacroArguments &A,
const SMLoc &L);
void HandleMacroExit();
void EatToEndOfStatement();
bool ParseMacroArgument(MacroArgument &MA);
- bool ParseMacroArguments(const Macro *M, std::vector<MacroArgument> &A);
+ bool ParseMacroArguments(const Macro *M, MacroArguments &A);
/// \brief Parse up to the end of statement and a return the contents from the
/// current token until the end of the statement; the current token on exit
}
bool AsmParser::expandMacro(raw_svector_ostream &OS, StringRef Body,
- const std::vector<StringRef> &Parameters,
- const std::vector<MacroArgument> &A,
+ const MacroParameters &Parameters,
+ const MacroArguments &A,
const SMLoc &L) {
unsigned NParameters = Parameters.size();
if (NParameters != 0 && NParameters != A.size())
}
// Parse the macro instantiation arguments.
-bool AsmParser::ParseMacroArguments(const Macro *M,
- std::vector<MacroArgument> &A) {
+bool AsmParser::ParseMacroArguments(const Macro *M, MacroArguments &A) {
const unsigned NParameters = M ? M->Parameters.size() : 0;
// Parse two kinds of macro invocations:
if (ActiveMacros.size() == 20)
return TokError("macros cannot be nested more than 20 levels deep");
- std::vector<MacroArgument> MacroArguments;
- if (ParseMacroArguments(M, MacroArguments))
+ MacroArguments A;
+ if (ParseMacroArguments(M, A))
return true;
// Remove any trailing empty arguments. Do this after-the-fact as we have
// to keep empty arguments in the middle of the list or positionality
// gets off. e.g., "foo 1, , 2" vs. "foo 1, 2,"
- while (!MacroArguments.empty() && MacroArguments.back().empty())
- MacroArguments.pop_back();
+ while (!A.empty() && A.back().empty())
+ A.pop_back();
// Macro instantiation is lexical, unfortunately. We construct a new buffer
// to hold the macro body with substitutions.
StringRef Body = M->Body;
raw_svector_ostream OS(Buf);
- if (expandMacro(OS, Body, M->Parameters, MacroArguments, getTok().getLoc()))
+ if (expandMacro(OS, Body, M->Parameters, A, getTok().getLoc()))
return true;
// We include the .endmacro in the buffer as our queue to exit the macro
if (getParser().ParseIdentifier(Name))
return TokError("expected identifier in directive");
- std::vector<StringRef> Parameters;
+ MacroParameters Parameters;
if (getLexer().isNot(AsmToken::EndOfStatement)) {
for(;;) {
StringRef Parameter;
/// ::= .endm
/// ::= .endmacro
bool GenericAsmParser::ParseDirectiveEndMacro(StringRef Directive,
- SMLoc DirectiveLoc) {
+ SMLoc DirectiveLoc) {
if (getLexer().isNot(AsmToken::EndOfStatement))
return TokError("unexpected token in '" + Directive + "' directive");
// We Are Anonymous.
StringRef Name;
- std::vector<StringRef> Parameters;
+ MacroParameters Parameters;
return new Macro(Name, Body, Parameters);
}
// Macro instantiation is lexical, unfortunately. We construct a new buffer
// to hold the macro body with substitutions.
SmallString<256> Buf;
- std::vector<StringRef> Parameters;
- const std::vector<MacroArgument> A;
+ MacroParameters Parameters;
+ MacroArguments A;
raw_svector_ostream OS(Buf);
while (Count--) {
if (expandMacro(OS, M->Body, Parameters, A, getTok().getLoc()))
/// ParseDirectiveIrp
/// ::= .irp symbol,values
bool AsmParser::ParseDirectiveIrp(SMLoc DirectiveLoc) {
- std::vector<StringRef> Parameters;
- StringRef Parameter;
+ MacroParameters Parameters;
+ MacroParameter Parameter;
if (ParseIdentifier(Parameter))
return TokError("expected identifier in '.irp' directive");
Lex();
- std::vector<MacroArgument> A;
+ MacroArguments A;
if (ParseMacroArguments(0, A))
return true;
/// ParseDirectiveIrpc
/// ::= .irpc symbol,values
bool AsmParser::ParseDirectiveIrpc(SMLoc DirectiveLoc) {
- std::vector<StringRef> Parameters;
- StringRef Parameter;
+ MacroParameters Parameters;
+ MacroParameter Parameter;
if (ParseIdentifier(Parameter))
return TokError("expected identifier in '.irpc' directive");
Lex();
- std::vector<MacroArgument> A;
+ MacroArguments A;
if (ParseMacroArguments(0, A))
return true;
MacroArgument Arg;
Arg.push_back(AsmToken(AsmToken::Identifier, Values.slice(I, I+1)));
- std::vector<MacroArgument> Args;
+ MacroArguments Args;
Args.push_back(Arg);
if (expandMacro(OS, M->Body, Parameters, Args, getTok().getLoc()))