[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

488

No else after return.

500

ditto

519

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

516–517

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>&1 | FileCheck %s --check-prefix PSTRINGTABLE1
 
 ; PSTRINGTABLE1:  llvm-rc: Error parsing file: expected string, got }
 
 
 ; RUN: not llvm-rc /V %p/Inputs/parser-stringtable-weird-option.rc 2>&1 | FileCheck %s --check-prefix PSTRINGTABLE2

 ; RUN: not llvm-rc /V %p/Inputs/parser-dialog-unknown-type.rc 2>&1 | FileCheck %s --check-prefix PDIALOG4
 
 ; 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>&1 | FileCheck %s --check-prefix PDIALOG5
 
 ; 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>&1 | FileCheck %s --check-prefix PVERSIONINFO1
+
+; 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>&1 | FileCheck %s --check-prefix PVERSIONINFO2
+
+; 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>&1 | FileCheck %s --check-prefix PVERSIONINFO3
+
+; PVERSIONINFO3:  llvm-rc: Error parsing file: expected string, got {
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-unnamed-value.rc 2>&1 | FileCheck %s --check-prefix PVERSIONINFO4
+
+; PVERSIONINFO4:  llvm-rc: Error parsing file: expected string, got END
+
+
+; RUN: not llvm-rc /V %p/Inputs/parser-versioninfo-bad-type.rc 2>&1 | FileCheck %s --check-prefix PVERSIONINFO5
+
+; PVERSIONINFO5:  llvm-rc: Error parsing file: expected BLOCK or VALUE, got INCORRECT

llvm/tools/llvm-rc/ResourceScriptParser.h

private:
   Expected<SmallVector<uint32_t, 8>> readIntsWithCommas(size_t MinCount,
                                                         size_t MaxCount);
 
   // Read an unknown number of flags preceded by commas. Each correct flag
   // has an entry in FlagDesc array of length NumFlags. In case i-th
   // flag (0-based) has been read, the i-th bit of the result is set.
   // As long as parser has a comma to read, it expects to be fed with
   // a correct flag afterwards.
-  Expected<uint32_t> parseFlags(ArrayRef<StringRef> FlagDesc);
+  Expected<uint32_t> parseFlags(const StringRef FlagDesc[], size_t NumFlags);
 
   // Reads a set of optional statements. These can change the behavior of
   // a number of resource types (e.g. STRINGTABLE, MENU or DIALOG) if provided
   // before the main block with the contents of the resource.
   // Usually, resources use a basic set of optional statements:
   //    CHARACTERISTICS, LANGUAGE, VERSION
   // However, DIALOG and DIALOGEX extend this list by the following items:
   //    CAPTION, CLASS, EXSTYLE, FONT, MENU, STYLE
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;
 }
if (auto IntResult = readInt())
       Result.push_back(*IntResult);
     else
       return FailureHandler(IntResult.takeError());
   }
 
   return std::move(Result);
 }
 
-Expected<uint32_t> RCParser::parseFlags(ArrayRef<StringRef> FlagDesc) {
-  assert(FlagDesc.size() <= 32 && "More than 32 flags won't fit in result.");
-  assert(!FlagDesc.empty());
+Expected<uint32_t> RCParser::parseFlags(const StringRef FlagDesc[],
+                                        size_t NumFlags) {
+  assert(NumFlags <= 32 && "More than 32 flags won't fit in result.");
+  assert(NumFlags > 0);
 
   uint32_t Result = 0;
   while (isNextTokenKind(Kind::Comma)) {
     consume();
     ASSIGN_OR_RETURN(FlagResult, readIdentifier());
-    bool FoundFlag = false;
 
-    for (size_t FlagId = 0; FlagId < FlagDesc.size(); ++FlagId) {
-      if (!FlagResult->equals_lower(FlagDesc[FlagId]))
-        continue;
+    bool FoundFlag = false;
 
+    for (size_t FlagId = 0; FlagId < NumFlags; ++FlagId) {
+      if (FlagResult->equals_lower(FlagDesc[FlagId])) {
         Result |= (1U << FlagId);
         FoundFlag = true;
         break;
       }
+    }
 
-    if (!FoundFlag)
-      return getExpectedError(join(FlagDesc, "/"), true);
+    if (!FoundFlag) {
+      std::string ExpectedList = FlagDesc[0];
+      for (size_t FlagId = 1; FlagId < NumFlags; ++FlagId)
+        ExpectedList += ("/" + FlagDesc[FlagId]).str();
+      return getExpectedError(ExpectedList, true);
+    }
   }
 
   return Result;
 }
 
 // As for now, we ignore the extended set of statements.
 Expected<OptionalStmtList> RCParser::parseOptionalStatements(bool IsExtended) {
   OptionalStmtList Result;
RCParser::parseSingleOptionalStatement(bool IsExtended) {
   if (IsExtended) {
     if (TypeToken->equals_lower("CAPTION"))
       return parseCaptionStmt();
     if (TypeToken->equals_lower("FONT"))
       return parseFontStmt();
     if (TypeToken->equals_lower("STYLE"))
       return parseStyleStmt();
   }
-  
   return getExpectedError("optional statement type, BEGIN or '{'",
                           /* IsAlreadyRead = */ true);
 }
 
 RCParser::ParseType RCParser::parseLanguageResource() {
   // Read LANGUAGE as an optional statement. If it's read correctly, we can
   // upcast it to RCResource.
   return parseLanguageStmt();
 }
 
 RCParser::ParseType RCParser::parseAcceleratorsResource() {
   ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements());
   RETURN_IF_ERROR(consumeType(Kind::BlockBegin));
 
   auto Accels = make_unique<AcceleratorsResource>(std::move(*OptStatements));
 
   while (!consumeOptionalType(Kind::BlockEnd)) {
     ASSIGN_OR_RETURN(EventResult, readIntOrString());
     RETURN_IF_ERROR(consumeType(Kind::Comma));
     ASSIGN_OR_RETURN(IDResult, readInt());
     ASSIGN_OR_RETURN(FlagsResult,
-                     parseFlags(AcceleratorsResource::Accelerator::OptionsStr));
+                     parseFlags(AcceleratorsResource::Accelerator::OptionsStr,
+                                AcceleratorsResource::Accelerator::NumFlags));
     Accels->addAccelerator(*EventResult, *IDResult, *FlagsResult);
   }
 
   return std::move(Accels);
 }
 
 RCParser::ParseType RCParser::parseCursorResource() {
   ASSIGN_OR_RETURN(Arg, readString());
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());
-  std::string ClassUpper = ClassResult->upper();
+  StringRef ClassUpper = ClassResult->upper();
   if (Control::SupportedCtls.find(ClassUpper) == Control::SupportedCtls.end())
     return getExpectedError("control type, END or '}'", true);
 
   // Read caption if necessary.
   StringRef Caption;
   if (Control::CtlsWithTitle.find(ClassUpper) != Control::CtlsWithTitle.end()) {
     ASSIGN_OR_RETURN(CaptionResult, readString());
     RETURN_IF_ERROR(consumeType(Kind::Comma));
while (!consumeOptionalType(Kind::BlockEnd)) {
 
     if (IsMenuItem && isNextTokenKind(Kind::Identifier)) {
       // Now, expecting SEPARATOR.
       ASSIGN_OR_RETURN(SeparatorResult, readIdentifier());
       if (SeparatorResult->equals_lower("SEPARATOR")) {
         List.addDefinition(make_unique<MenuSeparator>());
         continue;
       }
-      
       return getExpectedError("SEPARATOR or string", true);
     }
 
     // Not a separator. Read the caption.
     ASSIGN_OR_RETURN(CaptionResult, readString());
 
     // If MENUITEM, expect also a comma and an integer.
     uint32_t MenuResult = -1;
 
     if (IsMenuItem) {
       RETURN_IF_ERROR(consumeType(Kind::Comma));
       ASSIGN_OR_RETURN(IntResult, readInt());
       MenuResult = *IntResult;
     }
 
-    ASSIGN_OR_RETURN(FlagsResult, parseFlags(MenuDefinition::OptionsStr));
+    ASSIGN_OR_RETURN(FlagsResult, parseFlags(MenuDefinition::OptionsStr,
+                                             MenuDefinition::NumFlags));
 
     if (IsPopup) {
       // If POPUP, read submenu items recursively.
       ASSIGN_OR_RETURN(SubMenuResult, parseMenuItemsList());
       List.addDefinition(make_unique<PopupItem>(*CaptionResult, *FlagsResult,
                                                 std::move(*SubMenuResult)));
       continue;
     }
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);
+  }
+
+  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));
+  }
+
+  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::isTypeSupported(*TypeResult))
+      return getExpectedError("fixed VERSIONINFO statement type", true);
+
+    if (RetType::isVersionType(*TypeResult)) {
+      // VERSION variations take four integers.
+      ASSIGN_OR_RETURN(ArgsResult, readIntsWithCommas(4, 4));
+      Result.setValue(*TypeResult, *ArgsResult);
+      continue;
+    }
+
+    // Other ones take exactly one integer.
+    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 {
+    static const StringSet<> SupportedTypes;
+    static const StringSet<> VersionTypes;
+
+  public:
+    StringMap<SmallVector<uint32_t, 4>> VersionData;
+    StringMap<uint32_t> FlagsData;
+
+    static bool isTypeSupported(StringRef Type);
+    static bool isVersionType(StringRef Type);
+
+    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"};
+
+bool VersionInfoFixed::isTypeSupported(StringRef Type) {
+  return SupportedTypes.find(Type.upper()) != SupportedTypes.end();
+}
+
+bool VersionInfoFixed::isVersionType(StringRef Type) {
+  return VersionTypes.find(Type.upper()) != VersionTypes.end();
+}
+
+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";
 }