[ELF] - Add ScriptParserBase::expect(ArrayRef<StringRef>)

[grimar]

Summary

What about adding
ScriptParserBase::expect(ArrayRef<StringRef> Expect) ?

That helps to reduce the code a bit.

[grimar]

ELF/SymbolListFile.cpp

115

Unrelated, I`ll remove.

[grimar]

Looks no one likes this.

ELF/LinkerScript.cpp

while (!Error && !skip("}")) {
     if (peek() == "=")
       readSymbolAssignment(Tok);
     else
       readOutputSectionDescription(Tok);
   }
 }
 
 void ScriptParser::readLocationCounterValue() {
-  expect(".");
-  expect("=");
+  expect({".", "="});
   std::vector<StringRef> Expr = readSectionsCommandExpr();
   if (Expr.empty())
     error("error in location counter expression");
   else
     Opt.Commands.push_back(llvm::make_unique<SymbolAssignment>(".", Expr));
 }
 
 void ScriptParser::readOutputSectionDescription(StringRef OutSec) {
   OutputSectionCommand *Cmd = new OutputSectionCommand(OutSec);
   Opt.Commands.emplace_back(Cmd);
-  expect(":");
-  expect("{");
+  expect({":", "{"});
 
   while (!Error && !skip("}")) {
     StringRef Tok = next();
     if (Tok == "*") {
       auto *InCmd = new InputSectionDescription();
       Cmd->Commands.emplace_back(InCmd);
       expect("(");
       while (!Error && !skip(")"))
         InCmd->Patterns.push_back(next());
     } else if (Tok == "KEEP") {
-      expect("(");
-      expect("*");
-      expect("(");
+      expect({"(", "*", "("});
       auto *InCmd = new InputSectionDescription();
       Cmd->Commands.emplace_back(InCmd);
       while (!Error && !skip(")")) {
         Opt.KeptSections.push_back(peek());
         InCmd->Patterns.push_back(next());
       }
       expect(")");
     } else {

ELF/ScriptParser.h

protected:
   void setError(const Twine &Msg);
   static std::vector<StringRef> tokenize(StringRef S);
   static StringRef skipSpace(StringRef S);
   bool atEOF();
   StringRef next();
   StringRef peek();
   bool skip(StringRef Tok);
   void expect(StringRef Expect);
+  void expect(ArrayRef<StringRef> Expect);
 
   size_t getPos();
   void printErrorPos();
 
   StringRef Input;
   std::vector<StringRef> Tokens;
   size_t Pos = 0;
   bool Error = false;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/ScriptParser.cpp

 //===- ScriptParser.cpp ---------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the base parser class for linker script and dynamic
 // list.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ScriptParser.h"
 #include "Error.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Twine.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::elf;
 
 // Returns the line that the character S[Pos] is in.
 static StringRef getLine(StringRef S, size_t Pos) {

 void ScriptParserBase::expect(StringRef Expect) {
   if (Error)
     return;
   StringRef Tok = next();
   if (Tok != Expect)
     setError(Expect + " expected, but got " + Tok);
 }
 
+void ScriptParserBase::expect(ArrayRef<StringRef> Expect) {
+  for (StringRef Tok : Expect)
+    expect(Tok);
+}
+
 // Returns the current line number.
 size_t ScriptParserBase::getPos() {
   if (Pos == 0)
     return 1;
   const char *Begin = Input.data();
   const char *Tok = Tokens[Pos - 1].data();
   return StringRef(Begin, Tok - Begin).count('\n') + 1;
 }

ELF/SymbolListFile.cpp

void VersionScriptParser::parseVersion(StringRef VerStr) {
   // runtime doesn't care about them at all. In LLD, we simply skip the token.
   if (!VerStr.empty() && peek() != ";")
     next();
   expect(";");
 }
 
 void VersionScriptParser::parseLocal() {
   Config->DefaultSymbolVersion = VER_NDX_LOCAL;
-  expect("*");
-  expect(";");
+  expect({"*", ";"});
 }
 
 void VersionScriptParser::parseExtern(std::vector<SymbolVersion> *Globals) {
-  expect("C++");
-  expect("{");
+  expect({ "C++", "{" });
 
   for (;;) {
     if (peek() == "}" || Error)
       break;
-    Globals->push_back({next(), true});
+    Globals->push_back({ next(), true });
     expect(";");
   }
 
-  expect("}");
-  expect(";");
+  expect({"}", ";"});
 }
 
 void VersionScriptParser::parseGlobal(StringRef VerStr) {
   std::vector<SymbolVersion> *Globals;
   if (VerStr.empty())
     Globals = &Config->VersionScriptGlobals;
   else
     Globals = &Config->VersionDefinitions.back().Globals;