[llvm-rc] Add VERSIONINFO parsing ability. [6/8]

[mnbvmar]

Summary

This extends the set of parser's available resources by another one, VERSIONINFO (msdn.microsoft.com/en-us/library/windows/desktop/aa381058(v=vs.85).aspx).

[ecbeckmann]

llvm/tools/llvm-rc/ResourceScriptParser.cpp

483

No else after return.

495

ditto

514

use early continue pattern, remove else clause

[mnbvmar]

Change temp files to pipes in tests; fix readability issues.

[zturner]

llvm/tools/llvm-rc/ResourceScriptParser.cpp

511–512

Can you make a RetType::isTypeSupported() function and just call it?

[mnbvmar]

Small style fixes.

[rnk]

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

169

Just .count(Type.upper()) seems more idiomatic.

173

ditto

llvm/tools/llvm-rc/ResourceScriptStmt.h

387–388

Generally, you don't need to template over the size of a SmallVector. You can simply take a SmallVectorImpl<T> &, which is the base SmallVectors of any size.

However, for a const reference, it's usually better to accept an ArrayRef<T> Value. That is implicitly constructible from any SmallVector, and passes a pointer and size by value.

389

Does this need Name.upper()? I'm concerned about things like:

VERSIONINFO
  FileVersion 1, 2, 3
  FILEVERSION 4, 5, 6
BEGIN
END

Should that be an error? Maybe the best way to handle this is to have an enumeration, map from string to enum, maintain an array of all possible fields, and on set, check if the field is already set and report an error if so.

[mnbvmar]

llvm/tools/llvm-rc/ResourceScriptStmt.h

389

The original tool seems not to care about this one and just take the last occurrence of FILEVERSION. Of course, what you suggest is way better, and I think I'm going to do it your way.

[mnbvmar]

Rewritten fixed fields implementation a little bit. Now, we have an enumeration describing fixed field types, a list of field names, and a mapping from names to their types.

Also, added a sanity check determining if the user provided multiple occurrences of the same fixed field.

[rnk]

Looks good!

llvm/test/tools/llvm-rc/Inputs/parser-correct-everything.rc

BEGIN
   EDITTEXT 5, 1, 2, 4, 7, 8
 END
 
 25 DIALOG 1, 2, 3, 4
 BEGIN
 END
 
 26 DIALOGEX 1, 2, 3, 4 {}
+
+1 VERSIONINFO
+FILEVERSION 1, 2, 3, 4
+PRODUCTVERSION 5, 6, 7, 8
+FILEFLAGSMASK 50
+FILEFLAGS 555
+FILEOS 110
+FILETYPE 555555
+FILESUBTYPE 14
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904E4"
+        {
+            VALUE "CompanyName",      "a"
+            VALUE "FileDescription",  "b"
+            VALUE "FileVersion",      "c"
+            VALUE "InternalName",     "d"
+            VALUE "LegalCopyright",   "e"
+            VALUE "LegalTrademarks1", "f"
+            VALUE "LegalTrademarks2", "g"
+            VALUE "OriginalFilename", L"h"
+            VALUE "ProductName",      "ii", 2, 3
+            VALUE "ProductVersion"
+        }
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1252
+
+    END
+END

llvm/test/tools/llvm-rc/Inputs/parser-versioninfo-bad-type.rc

+1 VERSIONINFO
+BEGIN
+  INCORRECT "1", "2"
+END

llvm/test/tools/llvm-rc/Inputs/parser-versioninfo-named-main-block.rc

+1 VERSIONINFO
+BLOCK "hello"
+BEGIN
+END

llvm/test/tools/llvm-rc/Inputs/parser-versioninfo-unnamed-inner-block.rc

+1 VERSIONINFO
+BEGIN
+  BLOCK {}
+END

llvm/test/tools/llvm-rc/Inputs/parser-versioninfo-unnamed-value.rc

+1 VERSIONINFO
+BEGIN
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE
+  END
+END

llvm/test/tools/llvm-rc/Inputs/parser-versioninfo-wrong-fixed.rc

+1 VERSIONINFO
+WEIRDFIXED 5
+BEGIN END

llvm/test/tools/llvm-rc/parser.test

 ; PGOOD-NEXT:    Control (14): LTEXT, title: "Hello world!", loc: (20, 20), size: [50, 50]
 ; PGOOD-NEXT:    Control (50): RTEXT, title: "Heh", loc: (51, 52), size: [53, 54], style: 55, ext. style: 56
 ; PGOOD-NEXT:    Control (1): CTEXT, title: "Muuuu", loc: (2, 3), size: [4, 5], style: 6, ext. style: 7, help ID: 8
 ; PGOOD-NEXT:    Control (1): PUSHBUTTON, title: "Muuuu", loc: (2, 3), size: [4, 5], style: 6, ext. style: 7, help ID: 8
 ; PGOOD-NEXT:    Control (1): DEFPUSHBUTTON, title: "Muuuu", loc: (2, 3), size: [4, 5], style: 6
 ; PGOOD-NEXT:    Control (5): EDITTEXT, title: , loc: (1, 2), size: [4, 7], style: 8
 ; PGOOD-NEXT:  Dialog (25): loc: (1, 2), size: [3, 4], help ID: 0
 ; PGOOD-NEXT:  DialogEx (26): loc: (1, 2), size: [3, 4], help ID: 0
+; PGOOD-NEXT:  VersionInfo (1):
+; PGOOD-NEXT:    Fixed: FILEVERSION: 1 2 3 4
+; PGOOD-NEXT:    Fixed: PRODUCTVERSION: 5 6 7 8
+; PGOOD-NEXT:    Fixed: FILEOS: 110
+; PGOOD-NEXT:    Fixed: FILETYPE: 555555
+; PGOOD-NEXT:    Fixed: FILEFLAGSMASK: 50
+; PGOOD-NEXT:    Fixed: FILESUBTYPE: 14
+; PGOOD-NEXT:    Fixed: FILEFLAGS: 555
+; PGOOD-NEXT:    Start of block (name: )
+; PGOOD-NEXT:    Start of block (name: "StringFileInfo")
+; PGOOD-NEXT:    Start of block (name: "040904E4")
+; PGOOD-NEXT:    "CompanyName" => "a"
+; PGOOD-NEXT:    "FileDescription" => "b"
+; PGOOD-NEXT:    "FileVersion" => "c"
+; PGOOD-NEXT:    "InternalName" => "d"
+; PGOOD-NEXT:    "LegalCopyright" => "e"
+; PGOOD-NEXT:    "LegalTrademarks1" => "f"
+; PGOOD-NEXT:    "LegalTrademarks2" => "g"
+; PGOOD-NEXT:    "OriginalFilename" => L"h"
+; PGOOD-NEXT:    "ProductName" => "ii" 2 3
+; PGOOD-NEXT:    "ProductVersion" =>
+; PGOOD-NEXT:    End of block
+; PGOOD-NEXT:    End of block
+; PGOOD-NEXT:    Start of block (name: "VarFileInfo")
+; PGOOD-NEXT:    "Translation" => 1033 1252
+; PGOOD-NEXT:    End of block
+; PGOOD-NEXT:    End of block
+
 
 ; RUN: not llvm-rc /V %p/Inputs/parser-stringtable-no-string.rc 2> %t2
 ; RUN: FileCheck %s --check-prefix PSTRINGTABLE1 --input-file %t2
 
 ; PSTRINGTABLE1:  llvm-rc: Error parsing file: expected string, got }
 
 
 ; RUN: not llvm-rc /V %p/Inputs/parser-stringtable-weird-option.rc 2> %t3

 
 ; PDIALOG4:  llvm-rc: Error parsing file: expected control type, END or '}', got UNKNOWN
 
 
 ; RUN: not llvm-rc /V %p/Inputs/parser-dialog-unnecessary-string.rc 2> %t21
 ; RUN: FileCheck %s --check-prefix PDIALOG5 --input-file %t21
 
 ; PDIALOG5:  llvm-rc: Error parsing file: expected integer, got "This shouldn't be here"
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-wrong-fixed.rc 2> %t22
+; RUN: FileCheck %s --check-prefix PVERSIONINFO1 --input-file %t22
+
+; PVERSIONINFO1:  llvm-rc: Error parsing file: expected fixed VERSIONINFO statement type, got WEIRDFIXED
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-named-main-block.rc 2> %t23
+; RUN: FileCheck %s --check-prefix PVERSIONINFO2 --input-file %t23
+
+; PVERSIONINFO2:  llvm-rc: Error parsing file: expected fixed VERSIONINFO statement type, got BLOCK
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-unnamed-inner-block.rc 2> %t24
+; RUN: FileCheck %s --check-prefix PVERSIONINFO3 --input-file %t24
+
+; PVERSIONINFO3:  llvm-rc: Error parsing file: expected string, got {
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-unnamed-value.rc 2> %t25
+; RUN: FileCheck %s --check-prefix PVERSIONINFO4 --input-file %t25
+
+; PVERSIONINFO4:  llvm-rc: Error parsing file: expected string, got END
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-bad-type.rc 2> %t26
+; RUN: FileCheck %s --check-prefix PVERSIONINFO5 --input-file %t26
+
+; PVERSIONINFO5:  llvm-rc: Error parsing file: expected BLOCK or VALUE, got INCORRECT

llvm/tools/llvm-rc/ResourceScriptParser.h

private:
   ParseType parseLanguageResource();
   ParseType parseAcceleratorsResource();
   ParseType parseCursorResource();
   ParseType parseDialogResource(bool IsExtended);
   ParseType parseIconResource();
   ParseType parseHTMLResource();
   ParseType parseMenuResource();
   ParseType parseStringTableResource();
+  ParseType parseVersionInfoResource();
 
   // Helper DIALOG parser - a single control.
   Expected<Control> parseControl();
 
   // Helper MENU parser.
   Expected<MenuDefinitionList> parseMenuItemsList();
 
+  // Helper VERSIONINFO parser - read the contents of a single BLOCK statement,
+  // from BEGIN to END.
+  Expected<std::unique_ptr<VersionInfoBlock>>
+  parseVersionInfoBlockContents(StringRef BlockName);
+  // Helper VERSIONINFO parser - read either VALUE or BLOCK statement.
+  Expected<std::unique_ptr<VersionInfoStmt>> parseVersionInfoStmt();
+  // Helper VERSIONINFO parser - read fixed VERSIONINFO statements.
+  Expected<VersionInfoResource::VersionInfoFixed> parseVersionInfoFixed();
+
   // Optional statement parsers.
   ParseOptionType parseLanguageStmt();
   ParseOptionType parseCharacteristicsStmt();
   ParseOptionType parseVersionStmt();
   ParseOptionType parseCaptionStmt();
   ParseOptionType parseFontStmt();
   ParseOptionType parseStyleStmt();
 

llvm/tools/llvm-rc/ResourceScriptParser.cpp

RCParser::ParseType RCParser::parseSingleResource() {
   else if (TypeToken->equalsLower("DIALOGEX"))
     Result = parseDialogResource(true);
   else if (TypeToken->equalsLower("ICON"))
     Result = parseIconResource();
   else if (TypeToken->equalsLower("HTML"))
     Result = parseHTMLResource();
   else if (TypeToken->equalsLower("MENU"))
     Result = parseMenuResource();
+  else if (TypeToken->equalsLower("VERSIONINFO"))
+    Result = parseVersionInfoResource();
   else
     return getExpectedError("resource type", /* IsAlreadyRead = */ true);
 
   if (Result)
     (*Result)->setName(*NameToken);
 
   return Result;
 }
RCParser::ParseType RCParser::parseDialogResource(bool IsExtended) {
   while (!consumeOptionalType(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(ControlDefResult, parseControl());
     Dialog->addControl(std::move(*ControlDefResult));
   }
 
   return std::move(Dialog);
 }
 
+RCParser::ParseType RCParser::parseVersionInfoResource() {
+  ASSIGN_OR_RETURN(FixedResult, parseVersionInfoFixed());
+  ASSIGN_OR_RETURN(BlockResult, parseVersionInfoBlockContents(StringRef()));
+  return make_unique<VersionInfoResource>(std::move(**BlockResult),
+                                          std::move(*FixedResult));
+}
+
 Expected<Control> RCParser::parseControl() {
   // Each control definition (except CONTROL) follows one of the schemes below
   // depending on the control class:
   //  [class] text, id, x, y, width, height [, style] [, exstyle] [, helpID]
   //  [class]       id, x, y, width, height [, style] [, exstyle] [, helpID]
   // Note that control ids must be integers.
   ASSIGN_OR_RETURN(ClassResult, readIdentifier());
   StringRef ClassUpper = ClassResult->upper();
while (!consumeOptionalType(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(IDResult, readInt());
     ASSIGN_OR_RETURN(StrResult, readString());
     Table->addString(*IDResult, *StrResult);
   }
 
   return std::move(Table);
 }
 
+Expected<std::unique_ptr<VersionInfoBlock>>
+RCParser::parseVersionInfoBlockContents(StringRef BlockName) {
+  RETURN_IF_ERROR(consumeType(Kind::BlockBegin));
+
+  auto Contents = make_unique<VersionInfoBlock>(BlockName);
+
+  while (!isNextTokenKind(Kind::BlockEnd)) {
+    ASSIGN_OR_RETURN(Stmt, parseVersionInfoStmt());
+    Contents->addStmt(std::move(*Stmt));
+  }
+
+  consume(); // Consume BlockEnd.
+
+  return std::move(Contents);
+}
+
+Expected<std::unique_ptr<VersionInfoStmt>> RCParser::parseVersionInfoStmt() {
+  // Expect either BLOCK or VALUE, then a name or a key (a string).
+  ASSIGN_OR_RETURN(TypeResult, readIdentifier());
+
+  if (TypeResult->equals_lower("BLOCK")) {
+    ASSIGN_OR_RETURN(NameResult, readString());
+    return parseVersionInfoBlockContents(*NameResult);
+  } else if (TypeResult->equals_lower("VALUE")) {
+    ASSIGN_OR_RETURN(KeyResult, readString());
+    // Read a (possibly empty) list of strings and/or ints, each preceded by
+    // a comma.
+    std::vector<IntOrString> Values;
+
+    while (consumeOptionalType(Kind::Comma)) {
+      ASSIGN_OR_RETURN(ValueResult, readIntOrString());
+      Values.push_back(*ValueResult);
+    }
+    return make_unique<VersionInfoValue>(*KeyResult, std::move(Values));
+
+  } else {
+    return getExpectedError("BLOCK or VALUE", true);
+  }
+}
+
+Expected<VersionInfoResource::VersionInfoFixed>
+RCParser::parseVersionInfoFixed() {
+  using RetType = VersionInfoResource::VersionInfoFixed;
+  RetType Result;
+
+  // Read until the beginning of the block.
+  while (!isNextTokenKind(Kind::BlockBegin)) {
+    ASSIGN_OR_RETURN(TypeResult, readIdentifier());
+
+    if (RetType::SupportedTypes.find(TypeResult->upper()) ==
+        RetType::SupportedTypes.end())
+      return getExpectedError("fixed VERSIONINFO statement type", true);
+
+    // Read either four integers or one integer, depending on type.
+    if (RetType::VersionTypes.find(TypeResult->upper()) !=
+        RetType::VersionTypes.end()) {
+      // Version takes four integers.
+      ASSIGN_OR_RETURN(ArgsResult, readIntsWithCommas(4, 4));
+      Result.setValue(*TypeResult, *ArgsResult);
+    } else {
+      ASSIGN_OR_RETURN(ArgResult, readInt());
+      Result.setValue(*TypeResult, *ArgResult);
+    }
+  }
+
+  return Result;
+}
+
 RCParser::ParseOptionType RCParser::parseLanguageStmt() {
   ASSIGN_OR_RETURN(Args, readIntsWithCommas(/* min = */ 2, /* max = */ 2));
   return make_unique<LanguageResource>((*Args)[0], (*Args)[1]);
 }
 
 RCParser::ParseOptionType RCParser::parseCharacteristicsStmt() {
   ASSIGN_OR_RETURN(Arg, readInt());
   return make_unique<CharacteristicsStmt>(*Arg);

llvm/tools/llvm-rc/ResourceScriptStmt.h

DialogResource(uint32_t PosX, uint32_t PosY, uint32_t DlgWidth,
       : X(PosX), Y(PosY), Width(DlgWidth), Height(DlgHeight), HelpID(DlgHelpID),
         OptStatements(std::move(OptStmts)), IsExtended(IsDialogEx) {}
 
   void addControl(Control &&Ctl) { Controls.push_back(std::move(Ctl)); }
 
   raw_ostream &log(raw_ostream &) const override;
 };
 
+// -- VERSIONINFO resource and its helper classes --
+//
+// This resource lists the version information on the executable/library.
+// The declaration consists of the following items:
+//   * A number of fixed optional version statements (e.g. FILEVERSION, FILEOS)
+//   * BEGIN
+//   * A number of BLOCK and/or VALUE statements. BLOCK recursively defines
+//       another block of version information, whereas VALUE defines a
+//       key -> value correspondence. There might be more than one value
+//       corresponding to the single key.
+//   * END
+//
+// Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381058(v=vs.85).aspx
+
+// A single VERSIONINFO statement;
+class VersionInfoStmt {
+public:
+  virtual raw_ostream &log(raw_ostream &OS) const { return OS << "VI stmt\n"; }
+  virtual ~VersionInfoStmt() {}
+};
+
+// BLOCK definition; also the main VERSIONINFO declaration is considered a
+// BLOCK, although it has no name.
+// The correct top-level blocks are "VarFileInfo" and "StringFileInfo". We don't
+// care about them at the parsing phase.
+class VersionInfoBlock : public VersionInfoStmt {
+  std::vector<std::unique_ptr<VersionInfoStmt>> Stmts;
+  StringRef Name;
+
+public:
+  VersionInfoBlock(StringRef BlockName) : Name(BlockName) {}
+  void addStmt(std::unique_ptr<VersionInfoStmt> Stmt) {
+    Stmts.push_back(std::move(Stmt));
+  }
+  raw_ostream &log(raw_ostream &) const override;
+};
+
+class VersionInfoValue : public VersionInfoStmt {
+  StringRef Key;
+  std::vector<IntOrString> Values;
+
+public:
+  VersionInfoValue(StringRef InfoKey, std::vector<IntOrString> &&Vals)
+      : Key(InfoKey), Values(std::move(Vals)) {}
+  raw_ostream &log(raw_ostream &) const override;
+};
+
+class VersionInfoResource : public RCResource {
+public:
+  // A class listing fixed VERSIONINFO statements (occuring before main BEGIN).
+  // If any of these is not specified, it is assumed by the original tool to
+  // be equal to 0.
+  class VersionInfoFixed {
+  public:
+    StringMap<SmallVector<uint32_t, 4>> VersionData;
+    StringMap<uint32_t> FlagsData;
+
+    static const StringSet<> SupportedTypes;
+    static const StringSet<> VersionTypes;
+
+    VersionInfoFixed() {}
+
+    template <uint32_t Sz>
+    void setValue(StringRef Name, const SmallVector<uint32_t, Sz> &Value) {
+      VersionData[Name] = SmallVector<uint32_t, 4>(Value.begin(), Value.end());
+    }
+    void setValue(StringRef Name, uint32_t Value) { FlagsData[Name] = Value; }
+
+    raw_ostream &log(raw_ostream &) const;
+  };
+
+private:
+  VersionInfoBlock MainBlock;
+  VersionInfoFixed FixedData;
+
+public:
+  VersionInfoResource(VersionInfoBlock &&TopLevelBlock,
+                      VersionInfoFixed &&FixedInfo)
+      : MainBlock(std::move(TopLevelBlock)), FixedData(std::move(FixedInfo)) {}
+
+  raw_ostream &log(raw_ostream &) const override;
+};
+
 // CHARACTERISTICS optional statement.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa380872(v=vs.85).aspx
 class CharacteristicsStmt : public OptionalStmt {
   uint32_t Value;
 
 public:
   CharacteristicsStmt(uint32_t Characteristic) : Value(Characteristic) {}

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

OS << "Dialog" << (IsExtended ? "Ex" : "") << " (" << ResName << "): loc: ("
      << X << ", " << Y << "), size: [" << Width << ", " << Height
      << "], help ID: " << HelpID << "\n";
   OptStatements.log(OS);
   for (auto &Ctl : Controls)
     Ctl.log(OS);
   return OS;
 }
 
+raw_ostream &VersionInfoBlock::log(raw_ostream &OS) const {
+  OS << "  Start of block (name: " << Name << ")\n";
+  for (auto &Stmt : Stmts)
+    Stmt->log(OS);
+  return OS << "  End of block\n";
+}
+
+raw_ostream &VersionInfoValue::log(raw_ostream &OS) const {
+  OS << "  " << Key << " =>";
+  for (auto &Value : Values)
+    OS << " " << Value;
+  return OS << "\n";
+}
+
+using VersionInfoFixed = VersionInfoResource::VersionInfoFixed;
+
+const StringSet<> VersionInfoFixed::SupportedTypes = {
+    "FILEVERSION", "PRODUCTVERSION", "FILEFLAGSMASK", "FILEFLAGS",
+    "FILEOS",      "FILETYPE",       "FILESUBTYPE"};
+
+const StringSet<> VersionInfoFixed::VersionTypes = {"FILEVERSION",
+                                                    "PRODUCTVERSION"};
+
+raw_ostream &VersionInfoFixed::log(raw_ostream &OS) const {
+  for (auto &Info : VersionData) {
+    OS << "  Fixed: " << Info.getKey() << ":";
+    for (uint32_t Val : Info.getValue())
+      OS << " " << Val;
+    OS << "\n";
+  }
+  for (auto &Info : FlagsData)
+    OS << "  Fixed: " << Info.getKey() << ": " << Info.getValue() << "\n";
+  return OS;
+}
+
+raw_ostream &VersionInfoResource::log(raw_ostream &OS) const {
+  OS << "VersionInfo (" << ResName << "):\n";
+  FixedData.log(OS);
+  return MainBlock.log(OS);
+}
+
 raw_ostream &CharacteristicsStmt::log(raw_ostream &OS) const {
   return OS << "Characteristics: " << Value << "\n";
 }
 
 raw_ostream &VersionStmt::log(raw_ostream &OS) const {
   return OS << "Version: " << Value << "\n";
 }