[llvm-rc] Serialize MENU resources to .res files (serialization, pt 3).

[mnbvmar]

Summary

This allows MENU resources to be serialized.

MENU resource statement doc: msdn.microsoft.com/en-us/library/windows/desktop/aa381025.aspx
POPUP sub-statement doc: msdn.microsoft.com/en-us/library/windows/desktop/aa381030.aspx
MENUITEM sub-statement doc: msdn.microsoft.com/en-us/library/windows/desktop/aa381024.aspx
MENUHEADER structure: msdn.microsoft.com/en-us/library/windows/desktop/ms648018.aspx (and NORMALMENUITEM, POPUPMENUITEM structs).

Thanks for Nico Weber for his original work in this area.

[ecbeckmann]

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

89 ↗

(On Diff #115117)

hmm I'm not a fan of how, in addition to the actual representation of these flags in the .res, you have an "internal" representation where each of the lower 6 bits corresponds directly to a flag, and then have to convert between the two. Why not just keep everything in the .res flag representation? Then you wouldn't need to have "processFlags" because the flags would already be in the correct format. For logFlags you can iterate over the enum to compare. This can be done by putting the enum in a vector or using an enum class.

[mnbvmar]

Rebase wrt patch D37841.

[mnbvmar]

Rewritten binary .res expected output to ASCII format.

[mnbvmar]

Some minor style changes.

[rnk]

lgtm

llvm/test/tools/llvm-rc/tag-menu.test

2

I don't think you need to separate the .rc file from the FileCheck directives for these tests. You can embed comments in the .rc file with //. However, in order for lit to treat a .rc file as a test, you will need to create a lit.local.cfg file that does something like config.suffixes.append('.rc'). You can search the codebase for other examples of this.

This is probably best implemented as a follow-up change, though.

llvm/test/tools/llvm-rc/Inputs/tag-menu-bad-menuitem-id.rc

+1 MENU {
+  MENUITEM "Wrong", 100000, CHECKED
+}

llvm/test/tools/llvm-rc/Inputs/tag-menu.rc

+CheckRecursion MENU {
+  POPUP "A" {
+    POPUP "B" {
+      MENUITEM "a", 1
+      MENUITEM "b", 2
+      MENUITEM "c", 3
+      POPUP "C" {
+        POPUP "D" { POPUP "E" { POPUP "F" { POPUP "G" { POPUP "H" { POPUP "I" {
+          MENUITEM "d", 57134
+        }}}}}}
+      }
+    }
+    MENUITEM "efg", 23333
+  }
+}
+
+
+CheckFlags MENU {
+  MENUITEM "a", 1, CHECKED
+  MENUITEM "b", 2, GRAYED
+  MENUITEM "c", 3, HELP
+  MENUITEM "d", 4, INACTIVE
+  MENUITEM "e", 5, MENUBARBREAK
+  MENUITEM "f", 6, MENUBREAK
+  MENUITEM "ad", 7, CHECKED, INACTIVE
+  MENUITEM SEPARATOR
+  POPUP "A", CHECKED { MENUITEM "x", 100 }
+  POPUP "B", GRAYED { MENUITEM "x", 101 }
+  POPUP "C", HELP { MENUITEM "x", 102 }
+  POPUP "D", INACTIVE { MENUITEM "x", 103 }
+  POPUP "E", MENUBARBREAK { MENUITEM "x", 104 }
+  POPUP "F", MENUBREAK { MENUITEM "x", 105 }
+  POPUP "G", HELP, MENUBARBREAK, GRAYED {
+    POPUP "H", CHECKED, MENUBREAK, HELP, INACTIVE {
+      MENUITEM SEPARATOR
+      MENUITEM "x", 106, INACTIVE, MENUBARBREAK
+      MENUITEM SEPARATOR
+    }
+  }
+  MENUITEM "abcdef", 8, help, inactive, menubarbreak, checked, grayed, menubreak
+}
+
+
+CheckOpts MENU
+CHARACTERISTICS 500
+LANGUAGE 1, 1
+VERSION 128
+BEGIN
+  POPUP "&Only separator" {
+    MENUITEM SEPARATOR
+  }
+  POPUP "O&ther things" {
+    MENUITEM "&abcde", 1
+    MENUITEM "a&bcde", 2
+    MENUITEM "ab&cde", 3
+    MENUITEM "abc&de", 4
+    MENUITEM "abcd&e", 5
+  }
+END
+

llvm/test/tools/llvm-rc/tag-menu.test

+; RUN: llvm-rc /FO %t %p/Inputs/tag-menu.rc
+; RUN: diff %t %p/Inputs/tag-menu.res
+
+; RUN: not llvm-rc /FO %t %p/Inputs/tag-menu-bad-menuitem-id.rc 2>&1 | FileCheck %s --check-prefix BADID
+
+; BADID: llvm-rc: Error in MENU statement (ID 1):
+; BADID-NEXT: MENUITEM action ID (100000) does not fit in 16 bits.

llvm/tools/llvm-rc/ResourceScriptStmt.h

enum Options {
     CHECKED = 0x0008,
     GRAYED = 0x0001,
     HELP = 0x4000,
     INACTIVE = 0x0002,
     MENUBARBREAK = 0x0020,
     MENUBREAK = 0x0040
   };
 
+  enum MenuDefKind { MkBase, MkSeparator, MkMenuItem, MkPopup };
+
   static constexpr size_t NumFlags = 6;
   static StringRef OptionsStr[NumFlags];
   static uint32_t OptionsFlags[NumFlags];
   static raw_ostream &logFlags(raw_ostream &, uint16_t Flags);
   virtual raw_ostream &log(raw_ostream &OS) const {
     return OS << "Base menu definition\n";
   }
   virtual ~MenuDefinition() {}
+
+  virtual uint16_t getResFlags() const { return 0; }
+  virtual MenuDefKind getKind() const { return MkBase; }
 };
 
 // Recursive description of a whole submenu.
 class MenuDefinitionList : public MenuDefinition {
+public:
   std::vector<std::unique_ptr<MenuDefinition>> Definitions;
 
-public:
   void addDefinition(std::unique_ptr<MenuDefinition> Def) {
     Definitions.push_back(std::move(Def));
   }
   raw_ostream &log(raw_ostream &) const override;
 };
 
 // Separator in MENU definition (MENUITEM SEPARATOR).
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381024(v=vs.85).aspx
 class MenuSeparator : public MenuDefinition {
 public:
   raw_ostream &log(raw_ostream &) const override;
+
+  MenuDefKind getKind() const override { return MkSeparator; }
+  static bool classof(const MenuDefinition *D) {
+    return D->getKind() == MkSeparator;
+  }
 };
 
 // MENUITEM statement definition.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381024(v=vs.85).aspx
 class MenuItem : public MenuDefinition {
+public:
   StringRef Name;
   uint32_t Id;
   uint16_t Flags;
 
-public:
   MenuItem(StringRef Caption, uint32_t ItemId, uint16_t ItemFlags)
       : Name(Caption), Id(ItemId), Flags(ItemFlags) {}
   raw_ostream &log(raw_ostream &) const override;
+
+  uint16_t getResFlags() const override { return Flags; }
+  MenuDefKind getKind() const override { return MkMenuItem; }
+  static bool classof(const MenuDefinition *D) {
+    return D->getKind() == MkMenuItem;
+  }
 };
 
 // POPUP statement definition.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381030(v=vs.85).aspx
 class PopupItem : public MenuDefinition {
+public:
   StringRef Name;
   uint16_t Flags;
   MenuDefinitionList SubItems;
 
-public:
   PopupItem(StringRef Caption, uint16_t ItemFlags,
             MenuDefinitionList &&SubItemsList)
       : Name(Caption), Flags(ItemFlags), SubItems(std::move(SubItemsList)) {}
   raw_ostream &log(raw_ostream &) const override;
+
+  // This has an additional (0x10) flag. It doesn't match with documented
+  // 0x01 flag, though.
+  uint16_t getResFlags() const override { return Flags | 0x10; }
+  MenuDefKind getKind() const override { return MkPopup; }
+  static bool classof(const MenuDefinition *D) {
+    return D->getKind() == MkPopup;
+  }
 };
 
 // Menu resource definition.
 class MenuResource : public OptStatementsRCResource {
+public:
   MenuDefinitionList Elements;
 
-public:
   MenuResource(OptionalStmtList &&OptStmts, MenuDefinitionList &&Items)
       : OptStatementsRCResource(std::move(OptStmts)),
         Elements(std::move(Items)) {}
   raw_ostream &log(raw_ostream &) const override;
+
+  IntOrString getResourceType() const override { return RkMenu; }
+  Twine getResourceTypeName() const override { return "MENU"; }
+  Error visit(Visitor *V) const override { return V->visitMenuResource(this); }
+  ResourceKind getKind() const override { return RkMenu; }
+  static bool classof(const RCResource *Res) {
+    return Res->getKind() == RkMenu;
+  }
 };
 
 // STRINGTABLE resource. Contains a list of strings, each having its unique ID.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381050(v=vs.85).aspx
 class StringTableResource : public OptStatementsRCResource {
   std::vector<std::pair<uint32_t, StringRef>> Table;
 

llvm/tools/llvm-rc/ResourceSerializator.h

public:
   ResourceSerializator(std::unique_ptr<raw_fd_ostream> Stream)
       : FS(std::move(Stream)) {
     assert(FS && "Output stream needs to be provided to the serializator");
   }
 
   Error visitNullResource(const RCResource *) override;
   Error visitAcceleratorsResource(const RCResource *) override;
   Error visitHTMLResource(const RCResource *) override;
+  Error visitMenuResource(const RCResource *) override;
 
   Error visitCharacteristicsStmt(const CharacteristicsStmt *) override;
   Error visitLanguageStmt(const LanguageResource *) override;
   Error visitVersionStmt(const VersionStmt *) override;
 
   struct ObjectInfo {
     uint16_t LanguageInfo;
     uint32_t Characteristics;
private:
   // AcceleratorsResource
   Error writeSingleAccelerator(const AcceleratorsResource::Accelerator &,
                                bool IsLastItem);
   Error writeAcceleratorsBody(const RCResource *);
 
   // HTMLResource
   Error writeHTMLBody(const RCResource *);
 
+  // MenuResource
+  Error writeMenuDefinition(const std::unique_ptr<MenuDefinition> &,
+                            uint16_t Flags);
+  Error writeMenuDefinitionList(const MenuDefinitionList &List);
+  Error writeMenuBody(const RCResource *);
+
   // Output stream handling.
   std::unique_ptr<raw_fd_ostream> FS;
 
   uint64_t tell() const { return FS->tell(); }
 
   uint64_t writeObject(const void *Ptr, size_t Size);
 
   template <typename T> uint64_t writeObject(const T &Value) {

llvm/tools/llvm-rc/ResourceSerializator.cpp

 Error ResourceSerializator::visitAcceleratorsResource(const RCResource *Res) {
   return writeResource(Res, &ResourceSerializator::writeAcceleratorsBody);
 }
 
 Error ResourceSerializator::visitHTMLResource(const RCResource *Res) {
   return writeResource(Res, &ResourceSerializator::writeHTMLBody);
 }
 
+Error ResourceSerializator::visitMenuResource(const RCResource *Res) {
+  return writeResource(Res, &ResourceSerializator::writeMenuBody);
+}
+
 Error ResourceSerializator::visitCharacteristicsStmt(
     const CharacteristicsStmt *Stmt) {
   ObjectData.Characteristics = Stmt->Value;
   return Error::success();
 }
 
 Error ResourceSerializator::visitLanguageStmt(const LanguageResource *Stmt) {
   RETURN_IF_ERROR(checkNumberFits(Stmt->Lang, 10, "Primary language ID"));

 }
 
 // --- HTMLResource helpers. --- //
 
 Error ResourceSerializator::writeHTMLBody(const RCResource *Base) {
   return appendFile(cast<HTMLResource>(Base)->HTMLLoc);
 }
 
+// --- MenuResource helpers. --- //
+
+Error ResourceSerializator::writeMenuDefinition(
+    const std::unique_ptr<MenuDefinition> &Def, uint16_t Flags) {
+  assert(Def);
+  const MenuDefinition *DefPtr = Def.get();
+
+  if (auto *MenuItemPtr = dyn_cast<MenuItem>(DefPtr)) {
+    writeObject(ulittle16_t(Flags));
+    RETURN_IF_ERROR(
+        checkNumberFits<uint16_t>(MenuItemPtr->Id, "MENUITEM action ID"));
+    writeObject(ulittle16_t(MenuItemPtr->Id));
+    RETURN_IF_ERROR(writeCString(MenuItemPtr->Name));
+    return Error::success();
+  }
+
+  if (isa<MenuSeparator>(DefPtr)) {
+    writeObject(ulittle16_t(Flags));
+    writeObject(uint32_t(0));
+    return Error::success();
+  }
+
+  auto *PopupPtr = cast<PopupItem>(DefPtr);
+  writeObject(ulittle16_t(Flags));
+  RETURN_IF_ERROR(writeCString(PopupPtr->Name));
+  return writeMenuDefinitionList(PopupPtr->SubItems);
+}
+
+Error ResourceSerializator::writeMenuDefinitionList(
+    const MenuDefinitionList &List) {
+  for (auto &Def : List.Definitions) {
+    uint16_t Flags = Def->getResFlags();
+    // Last element receives an additional 0x80 flag.
+    const uint16_t LastElementFlag = 0x0080;
+    if (&Def == &List.Definitions.back())
+      Flags |= LastElementFlag;
+
+    RETURN_IF_ERROR(writeMenuDefinition(Def, Flags));
+  }
+  return Error::success();
+}
+
+Error ResourceSerializator::writeMenuBody(const RCResource *Base) {
+  // At first, MENUHEADER structure. In fact, these are two WORDs equal to 0.
+  // Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648018.aspx
+  writeObject<uint32_t>(0);
+
+  return writeMenuDefinitionList(cast<MenuResource>(Base)->Elements);
+}
+
 } // namespace rc
 } // namespace llvm

llvm/tools/llvm-rc/ResourceVisitor.h

 class LanguageResource;
 class VersionStmt;
 
 class Visitor {
 public:
   virtual Error visitNullResource(const RCResource *) = 0;
   virtual Error visitAcceleratorsResource(const RCResource *) = 0;
   virtual Error visitHTMLResource(const RCResource *) = 0;
+  virtual Error visitMenuResource(const RCResource *) = 0;
 
   virtual Error visitCharacteristicsStmt(const CharacteristicsStmt *) = 0;
   virtual Error visitLanguageStmt(const LanguageResource *) = 0;
   virtual Error visitVersionStmt(const VersionStmt *) = 0;
 
   virtual ~Visitor() {}
 };
 
 } // namespace rc
 } // namespace llvm
 
 #endif