Adding parsing ability for .res file, building the resource directory tree

[ecbeckmann]

Some minor formatting changes.

[ecbeckmann]

Another format change.

[zturner]

llvm/include/llvm/Object/WindowsResource.h

60–65 ↗

(On Diff #100316)

I don't think we need to propagate these Error values out of the function. The constructor should assert that HeaderBytes is a good size, and at that point none of the reads can fail and you can just return the values instead of taking them by reference.

112 ↗

(On Diff #100316)

You can just say = default;

113 ↗

(On Diff #100316)

No need to explicitly initialize Name, its default constructor will get invoked implicitly.

114 ↗

(On Diff #100316)

Same as above, but this time for ID, and you can initialize Name directly I believe. Name(NameRef)

179 ↗

(On Diff #100316)

Can you do an inline initialization here? uint16_t ID = 0xFFFF;

llvm/lib/Object/WindowsResource.cpp

89–91 ↗

(On Diff #100316)

Instead of doing this seeking and reading on every function call, can you just initialize all these values in the constructor and then just return them? It makes the logic simpler to follow if you just read everything out all at once, because then there's no seeking going on. It's just read / read / read / read.

[ruiu]

llvm/include/llvm/Object/WindowsResource.h

51–54 ↗

(On Diff #100316)

I'd move this out of namespace llvm as namespaces have no effect on C macros.

62 ↗

(On Diff #100316)

isString -> IsString

110 ↗

(On Diff #100316)

Move function definitions for this class to the .cpp file.

117–118 ↗

(On Diff #100316)

(You want to add newlines between multi-line inline functions so that they don't look like a single blob of some code.)

131 ↗

(On Diff #100316)

This is a question not only for this but for all the other functions you added in this patch.

Can you do error checking only when you are reading files?

Currently, you are doing error checking both when reading files and writing to files. However, as long as you verify that input files, and you don't generate malformed data in your code (if it does, it is a bug), you don't need to check for errors when you are writing.

The reason why I'm saying is because the code is not easy to read because that contains probably too much error checking snippets. Other file reading/writing tools don't have this much ErrorOr or Expected internally, so they can be reduced.

[ecbeckmann]

Move implementation to source file, removed a lot of unnecessary error checking.

llvm/include/llvm/Object/WindowsResource.h

51–54 ↗

(On Diff #100316)

I moved it to the source file since it is no longer necessary in header.

62 ↗

(On Diff #100316)

returns bool instead of Error now

131 ↗

(On Diff #100316)

All the error checking is now done when the file is initially read.

179 ↗

(On Diff #100316)

What is the purpose of this initialization? We only ever check the ID if it is in the IDChildren list, and before adding to this list we always give the ID that was written in the .res file.

[zturner]

llvm/include/llvm/Object/WindowsResource.h

179 ↗

(On Diff #100316)

You were already initializing it in the constructor to -1, but the initialization was repeated each time there was a new overload of the constructor. If you initialize it this way, it's functionally equivalent to the code you had before, but you're just not repeating the specification of the value -1.

[ecbeckmann]

llvm/include/llvm/Object/WindowsResource.h

179 ↗

(On Diff #100316)

Ah okay. I actually decided we don't really need to initialize the numeric ID.

[zturner]

llvm/include/llvm/Object/WindowsResource.h

101 ↗

(On Diff #100497)

Should this function be const?

112 ↗

(On Diff #100497)

Can this argument be a StringRef?

llvm/lib/Object/WindowsResource.cpp

80 ↗

(On Diff #100497)

I think this function would be a lot clearer if we had some structs that we could just read out in one or two lines rather than reading some fields, ignoring others, skipping sometimes, reading sometimes, etc. How about this?

class ResourceEntryRef {
  struct HeaderPrefix {
    ulittle32_t DataSize;
    ulittle32_t HeaderSize;
    ulittle16_t Unknown;
    ulittle16_t TypeID;
    ulittle16_t IDFlag;
    ulittle16_t NameID;
  };

  struct HeaderSuffix {
    ulittle32_t DataVersion;
    ulittle16_t MemoryFlags;
    ulittle16_t LanguageID;
    ulittle32_t Version;
    ulittle32_t Characteristics;
  };

  const HeaderPrefix *Prefix = nullptr;
  const HeaderSuffix *Suffix = nullptr;
};

...

Error ResourceEntryRef::loadNext() {
  RETURN_IF_ERROR(Reader.readObject(Prefix));
  if (Prefix->IDFlag != 0xFFFF) {
    Reader.setOffset(Reader.getOffset() - 4);
    RETURN_IF_ERROR(Reader.readWideString(Name));
  }

  RETURN_IF_ERROR(Reader.readObject(Suffix));
  RETURN_IF_ERROR(Reader.readArray(Data, Prefix->DataSize);
  RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t));
  return Error::success();
}

100 ↗

(On Diff #100497)

Is this math actually necessary? It sounds like we just want to read until the first null terminator. Maybe add a function to BinaryStreamReader similar to readCString but called readWideString?

206–209 ↗

(On Diff #100497)

Can you try this?

StringChildren.emplace(NameString, std::move(NewChild));

[ecbeckmann]

Read some header entries into struct instead of reading individually.

Create readWideString function in BinaryStreamReader.

Be able to read user-defined types and add test case for this.

llvm/lib/Object/WindowsResource.cpp

80 ↗

(On Diff #100497)

Hmmm this issue is actually pretty difficult because we can't really use a HeaderPrefix structure at all. I didn't realize this when I first implemented this but actually both the Type and the Name can either be numeric IDs or variable length strings; therefore there isn't really any "standard" length that we can read into a structure easily. Perhaps we can have a HeaderSuffix structure though....

[zturner]

llvm/lib/Object/WindowsResource.cpp

80 ↗

(On Diff #100497)

I see. In that case, can you add a function

Error ResourceEntryRef::readStringOrId(BinaryStreamReader &Reader, uint16_t &ID, ArrayRef<UTF16> &Str);

and then write:

RETURN_IF_ERROR(readStringOrId(Reader, TypeID, Type));
RETURN_IF_ERROR(readStringOrId(Reader, NameID, Name));

[ecbeckmann]

Add helper function for readability.

[ecbeckmann]

llvm/lib/Object/WindowsResource.cpp

80 ↗

(On Diff #100497)

Okay. I feel like this function shouldn't be a member function of ResourceEntryRef because it only really has a use in this specific instance and it's precondition is that the offset of the reader has been directed to a specific point.

[zturner]

lgtm with the last two suggested changes.

llvm/lib/Object/WindowsResource.cpp

102–104 ↗

(On Diff #100651)

It looks like this is no longer being used, so we can probably delete this line.

80 ↗

(On Diff #100497)

Seems reasonable. But if it's going to be global, make it static so that its linkage doesn't leak outside of this TU.

[ecbeckmann]

Last minor changes.

[ecbeckmann]

Still some build bot errors that need to be fixed.

[ecbeckmann]

• This patch should fix various clang warnings and a use of to_string

[ecbeckmann]

Fixed in rL304255.

llvm/trunk/include/llvm/Object/WindowsResource.h

 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648007(v=vs.85).aspx
 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_INCLUDE_LLVM_OBJECT_RESFILE_H
 #define LLVM_INCLUDE_LLVM_OBJECT_RESFILE_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/Binary.h"
+#include "llvm/Object/Error.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/COFF.h"
+#include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+#include <map>
 
 namespace llvm {
 namespace object {
 
 class WindowsResource;
 
 class ResourceEntryRef {
 public:
   Error moveNext(bool &End);
+  bool checkTypeString() const { return IsStringType; }
+  ArrayRef<UTF16> getTypeString() const { return Type; }
+  uint16_t getTypeID() const { return TypeID; }
+  bool checkNameString() const { return IsStringName; }
+  ArrayRef<UTF16> getNameString() const { return Name; }
+  uint16_t getNameID() const { return NameID; }
+  uint16_t getLanguage() const { return Suffix->Language; }
 
 private:
   friend class WindowsResource;
 
   ResourceEntryRef(BinaryStreamRef Ref, const WindowsResource *Owner,
                    Error &Err);
+
   Error loadNext();
 
+  struct HeaderSuffix {
+    support::ulittle32_t DataVersion;
+    support::ulittle16_t MemoryFlags;
+    support::ulittle16_t Language;
+    support::ulittle32_t Version;
+    support::ulittle32_t Characteristics;
+  };
+
   BinaryStreamReader Reader;
-  BinaryStreamRef HeaderBytes;
-  BinaryStreamRef DataBytes;
+  bool IsStringType;
+  ArrayRef<UTF16> Type;
+  uint16_t TypeID;
+  bool IsStringName;
+  ArrayRef<UTF16> Name;
+  uint16_t NameID;
+  const HeaderSuffix *Suffix = nullptr;
+  ArrayRef<uint8_t> Data;
   const WindowsResource *OwningRes = nullptr;
 };
 
 class WindowsResource : public Binary {
 public:
-  ~WindowsResource() override;
   Expected<ResourceEntryRef> getHeadEntry();
 
   static bool classof(const Binary *V) { return V->isWinRes(); }
 
   static Expected<std::unique_ptr<WindowsResource>>
   createWindowsResource(MemoryBufferRef Source);
 
 private:
   friend class ResourceEntryRef;
 
   WindowsResource(MemoryBufferRef Source);
 
   BinaryByteStream BBS;
 };
 
+class WindowsResourceParser {
+public:
+  WindowsResourceParser();
+
+  Error parse(WindowsResource *WR);
+
+  void printTree() const;
+
+private:
+  class TreeNode {
+  public:
+    TreeNode() = default;
+    explicit TreeNode(uint32_t ID);
+    explicit TreeNode(ArrayRef<UTF16> Ref);
+    void addEntry(const ResourceEntryRef &Entry);
+    void print(ScopedPrinter &Writer, StringRef Name) const;
+
+  private:
+    TreeNode &addTypeNode(const ResourceEntryRef &Entry);
+    TreeNode &addNameNode(const ResourceEntryRef &Entry);
+    TreeNode &addLanguageNode(const ResourceEntryRef &Entry);
+    TreeNode &addChild(uint32_t ID);
+    TreeNode &addChild(ArrayRef<UTF16> NameRef);
+    uint16_t ID;
+    std::vector<UTF16> Name;
+    std::map<uint32_t, std::unique_ptr<TreeNode>> IDChildren;
+    std::map<std::string, std::unique_ptr<TreeNode>> StringChildren;
+  };
+
+  TreeNode Root;
+};
+
 } // namespace object
 } // namespace llvm
 
 #endif

llvm/trunk/include/llvm/Support/BinaryStreamReader.h

 //===- BinaryStreamReader.h - Reads objects from a binary stream *- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H
 #define LLVM_SUPPORT_BINARYSTREAMREADER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/BinaryStreamRef.h"
+#include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/type_traits.h"
 
 #include <string>
 #include <type_traits>
 
 namespace llvm {
public:
   /// Read a null terminated string from \p Dest.  Whether a copy occurs depends
   /// on the implementation of the underlying stream.  Updates the stream's
   /// offset to point after the newly read data.
   ///
   /// \returns a success error code if the data was successfully read, otherwise
   /// returns an appropriate error code.
   Error readCString(StringRef &Dest);
 
+  /// Similar to readCString, however read a null-terminated UTF16 string
+  /// instead.
+  ///
+  /// \returns a success error code if the data was successfully read, otherwise
+  /// returns an appropriate error code.
+  Error readWideString(ArrayRef<UTF16> &Dest);
+
   /// Read a \p Length byte string into \p Dest.  Whether a copy occurs depends
   /// on the implementation of the underlying stream.  Updates the stream's
   /// offset to point after the newly read data.
   ///
   /// \returns a success error code if the data was successfully read, otherwise
   /// returns an appropriate error code.
   Error readFixedString(StringRef &Dest, uint32_t Length);
 

llvm/trunk/lib/Object/WindowsResource.cpp

 //===-- WindowsResource.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the .res file class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/WindowsResource.h"
-#include "llvm/Object/Error.h"
+#include "llvm/Support/COFF.h"
 #include <system_error>
 
 namespace llvm {
 namespace object {
 
+#define RETURN_IF_ERROR(X)                                                     \
+  if (auto EC = X)                                                             \
+    return std::move(EC);
+
+const uint32_t MIN_HEADER_SIZE = 7 * sizeof(uint32_t) + 2 * sizeof(uint16_t);
+
 static const size_t ResourceMagicSize = 16;
 
 static const size_t NullEntrySize = 16;
 
-#define RETURN_IF_ERROR(X)                                                     \
-  if (auto EC = X)                                                             \
-    return EC;
-
 WindowsResource::WindowsResource(MemoryBufferRef Source)
     : Binary(Binary::ID_WinRes, Source) {
   size_t LeadingSize = ResourceMagicSize + NullEntrySize;
   BBS = BinaryByteStream(Data.getBuffer().drop_front(LeadingSize),
                          support::little);
 }
 
-WindowsResource::~WindowsResource() = default;
-
 Expected<std::unique_ptr<WindowsResource>>
 WindowsResource::createWindowsResource(MemoryBufferRef Source) {
   if (Source.getBufferSize() < ResourceMagicSize + NullEntrySize)
     return make_error<GenericBinaryError>(
         "File too small to be a resource file",
         object_error::invalid_file_type);
   std::unique_ptr<WindowsResource> Ret(new WindowsResource(Source));
   return std::move(Ret);
if (Reader.bytesRemaining() == 0) {
     End = true;
     return Error::success();
   }
   RETURN_IF_ERROR(loadNext());
 
   return Error::success();
 }
 
+static Error readStringOrId(BinaryStreamReader &Reader, uint16_t &ID,
+                            ArrayRef<UTF16> &Str, bool &IsString) {
+  uint16_t IDFlag;
+  RETURN_IF_ERROR(Reader.readInteger(IDFlag));
+  IsString = IDFlag != 0xffff;
+
+  if (IsString) {
+    Reader.setOffset(
+        Reader.getOffset() -
+        sizeof(uint16_t)); // Re-read the bytes which we used to check the flag.
+    RETURN_IF_ERROR(Reader.readWideString(Str));
+  } else
+    RETURN_IF_ERROR(Reader.readInteger(ID));
+
+  return Error::success();
+}
+
 Error ResourceEntryRef::loadNext() {
   uint32_t DataSize;
   RETURN_IF_ERROR(Reader.readInteger(DataSize));
   uint32_t HeaderSize;
   RETURN_IF_ERROR(Reader.readInteger(HeaderSize));
-  // The data and header size ints are themselves part of the header, so we must
-  // subtract them from the size.
-  RETURN_IF_ERROR(
-      Reader.readStreamRef(HeaderBytes, HeaderSize - 2 * sizeof(uint32_t)));
-  RETURN_IF_ERROR(Reader.readStreamRef(DataBytes, DataSize));
+
+  if (HeaderSize < MIN_HEADER_SIZE)
+    return make_error<GenericBinaryError>("Header size is too small.",
+                                          object_error::parse_failed);
+
+  RETURN_IF_ERROR(readStringOrId(Reader, TypeID, Type, IsStringType));
+
+  RETURN_IF_ERROR(readStringOrId(Reader, NameID, Name, IsStringName));
+
   RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t)));
+
+  RETURN_IF_ERROR(Reader.readObject(Suffix));
+
+  RETURN_IF_ERROR(Reader.readArray(Data, DataSize));
+
+  RETURN_IF_ERROR(Reader.padToAlignment(sizeof(uint32_t)));
+
   return Error::success();
 }
 
+WindowsResourceParser::WindowsResourceParser() {}
+
+Error WindowsResourceParser::parse(WindowsResource *WR) {
+  auto EntryOrErr = WR->getHeadEntry();
+  if (!EntryOrErr)
+    return EntryOrErr.takeError();
+
+  ResourceEntryRef Entry = EntryOrErr.get();
+  bool End = false;
+
+  while (!End) {
+
+    Root.addEntry(Entry);
+
+    RETURN_IF_ERROR(Entry.moveNext(End));
+  }
+
+  return Error::success();
+}
+
+void WindowsResourceParser::printTree() const {
+  ScopedPrinter Writer(outs());
+  Root.print(Writer, "Resource Tree");
+}
+
+void WindowsResourceParser::TreeNode::addEntry(const ResourceEntryRef &Entry) {
+  TreeNode &TypeNode = addTypeNode(Entry);
+  TreeNode &NameNode = TypeNode.addNameNode(Entry);
+  NameNode.addLanguageNode(Entry);
+}
+
+WindowsResourceParser::TreeNode::TreeNode(uint32_t ID) : ID(ID) {}
+
+WindowsResourceParser::TreeNode::TreeNode(ArrayRef<UTF16> NameRef)
+    : Name(NameRef) {}
+
+WindowsResourceParser::TreeNode &
+WindowsResourceParser::TreeNode::addTypeNode(const ResourceEntryRef &Entry) {
+  if (Entry.checkTypeString())
+    return addChild(Entry.getTypeString());
+  else
+    return addChild(Entry.getTypeID());
+}
+
+WindowsResourceParser::TreeNode &
+WindowsResourceParser::TreeNode::addNameNode(const ResourceEntryRef &Entry) {
+  if (Entry.checkNameString())
+    return addChild(Entry.getNameString());
+  else
+    return addChild(Entry.getNameID());
+}
+
+WindowsResourceParser::TreeNode &
+WindowsResourceParser::TreeNode::addLanguageNode(
+    const ResourceEntryRef &Entry) {
+  return addChild(Entry.getLanguage());
+}
+
+WindowsResourceParser::TreeNode &
+WindowsResourceParser::TreeNode::addChild(uint32_t ID) {
+  auto Child = IDChildren.find(ID);
+  if (Child == IDChildren.end()) {
+    auto NewChild = llvm::make_unique<WindowsResourceParser::TreeNode>(ID);
+    WindowsResourceParser::TreeNode &Node = *NewChild;
+    IDChildren.emplace(ID, std::move(NewChild));
+    return Node;
+  } else
+    return *(Child->second);
+}
+
+WindowsResourceParser::TreeNode &
+WindowsResourceParser::TreeNode::addChild(ArrayRef<UTF16> NameRef) {
+  std::string NameString;
+  ArrayRef<UTF16> CorrectedName;
+  if (llvm::sys::IsBigEndianHost) {
+    std::vector<UTF16> EndianCorrectedName;
+    EndianCorrectedName.resize(NameRef.size() + 1);
+    std::copy(NameRef.begin(), NameRef.end(), EndianCorrectedName.begin() + 1);
+    EndianCorrectedName[0] = UNI_UTF16_BYTE_ORDER_MARK_SWAPPED;
+    CorrectedName = makeArrayRef(EndianCorrectedName);
+  } else
+    CorrectedName = NameRef;
+  llvm::convertUTF16ToUTF8String(CorrectedName, NameString);
+
+  auto Child = StringChildren.find(NameString);
+  if (Child == StringChildren.end()) {
+    auto NewChild = llvm::make_unique<WindowsResourceParser::TreeNode>(NameRef);
+    WindowsResourceParser::TreeNode &Node = *NewChild;
+    StringChildren.emplace(NameString, std::move(NewChild));
+    return Node;
+  } else
+    return *(Child->second);
+}
+
+void WindowsResourceParser::TreeNode::print(ScopedPrinter &Writer,
+                                            StringRef Name) const {
+  ListScope NodeScope(Writer, Name);
+  for (auto const &Child : StringChildren) {
+    Child.second->print(Writer, Child.first);
+  }
+  for (auto const &Child : IDChildren) {
+    Child.second->print(Writer, std::to_string(Child.first));
+  }
+}
+
 } // namespace object
 } // namespace llvm

llvm/trunk/lib/Support/BinaryStreamReader.cpp

Error BinaryStreamReader::readCString(StringRef &Dest) {
   if (auto EC = readFixedString(Dest, Length))
     return EC;
 
   // Now set the offset back to after the null terminator.
   setOffset(FoundOffset + 1);
   return Error::success();
 }
 
+Error BinaryStreamReader::readWideString(ArrayRef<UTF16> &Dest) {
+  uint32_t Length = 0;
+  uint32_t OriginalOffset = getOffset();
+  const UTF16 *C;
+  while (true) {
+    if (auto EC = readObject(C))
+      return EC;
+    if (*C == 0x0000)
+      break;
+    ++Length;
+  }
+  uint32_t NewOffset = getOffset();
+  setOffset(OriginalOffset);
+
+  if (auto EC = readArray(Dest, Length))
+    return EC;
+  setOffset(NewOffset);
+  return Error::success();
+}
+
 Error BinaryStreamReader::readFixedString(StringRef &Dest, uint32_t Length) {
   ArrayRef<uint8_t> Bytes;
   if (auto EC = readBytes(Bytes, Length))
     return EC;
   Dest = StringRef(reinterpret_cast<const char *>(Bytes.begin()), Bytes.size());
   return Error::success();
 }
 
BinaryStreamReader::split(uint32_t Off) const {
   BinaryStreamRef First = Stream.drop_front(Offset);
 
   BinaryStreamRef Second = First.drop_front(Off);
   First = First.keep_front(Off);
   BinaryStreamReader W1{First};
   BinaryStreamReader W2{Second};
   return std::make_pair(W1, W2);
 }
 No newline at end of file

llvm/trunk/test/tools/llvm-cvtres/Inputs/test_resource.rc

 
 "eat" MENU
 LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_AUS
 {
   MENUITEM "fish", 100
   MENUITEM "salad", 101
   MENUITEM "duck", 102
 }
+
+
+myresource stringarray {
+  "this is a user defined resource\0",
+  "it contains many strings\0",
+}
 No newline at end of file

llvm/trunk/test/tools/llvm-cvtres/resource.test

 // The input was generated with the following command, using the original Windows
 // rc.exe:
 // > rc /fo test_resource.res /nologo test_resource.rc
 
 RUN: llvm-cvtres %p/Inputs/test_resource.res | FileCheck %s
 
-CHECK: Number of resources: 7
+CHECK:      Number of resources: 8
+CHECK-NEXT: Resource Tree [
+CHECK-NEXT:   STRINGARRAY [
+CHECK-NEXT:     MYRESOURCE [
+CHECK-NEXT:       1033 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:   ]
+CHECK-NEXT:   2 [
+CHECK-NEXT:     CURSOR [
+CHECK-NEXT:       1033 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:     OKAY [
+CHECK-NEXT:       1033 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:   ]
+CHECK-NEXT:   4 [
+CHECK-NEXT:     "EAT" [
+CHECK-NEXT:       3081 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:     14432 [
+CHECK-NEXT:       2052 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:   ]
+CHECK-NEXT:   5 [
+CHECK-NEXT:     TESTDIALOG [
+CHECK-NEXT:       1033 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:   ]
+CHECK-NEXT:   9 [
+CHECK-NEXT:     MYACCELERATORS [
+CHECK-NEXT:       1033 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:     12 [
+CHECK-NEXT:       1033 [
+CHECK-NEXT:       ]
+CHECK-NEXT:     ]
+CHECK-NEXT:   ]
+CHECK-NEXT: ]

llvm/trunk/tools/llvm-cvtres/llvm-cvtres.cpp

int main(int argc_, const char *argv_[]) {
   } else {
     outs() << "Machine architecture not specified; assumed X64.\n";
     Machine = machine::X64;
   }
 
   std::vector<std::string> InputFiles = InputArgs.getAllArgValues(OPT_INPUT);
 
   if (InputFiles.size() == 0) {
-    reportError("No input file specified");
+    reportError("No input file specified.\n");
   }
 
   SmallString<128> OutputFile;
 
   if (InputArgs.hasArg(OPT_OUT)) {
     OutputFile = InputArgs.getLastArgValue(OPT_OUT);
   } else {
     OutputFile = StringRef(InputFiles[0]);
     llvm::sys::path::replace_extension(OutputFile, ".obj");
   }
 
+  outs() << "Machine: ";
+  switch (Machine) {
+  case machine::ARM:
+    outs() << "ARM\n";
+    break;
+  case machine::X86:
+    outs() << "X86\n";
+    break;
+  default:
+    outs() << "X64\n";
+  }
+
+  WindowsResourceParser Parser;
+
   for (const auto &File : InputFiles) {
     Expected<object::OwningBinary<object::Binary>> BinaryOrErr =
         object::createBinary(File);
     if (!BinaryOrErr)
       reportError(File, errorToErrorCode(BinaryOrErr.takeError()));
 
     Binary &Binary = *BinaryOrErr.get().getBinary();
 
     WindowsResource *RF = dyn_cast<WindowsResource>(&Binary);
     if (!RF)
       reportError(File + ": unrecognized file format.\n");
 
     int EntryNumber = 0;
     Expected<ResourceEntryRef> EntryOrErr = RF->getHeadEntry();
     if (!EntryOrErr)
       error(EntryOrErr.takeError());
     ResourceEntryRef Entry = EntryOrErr.get();
     bool End = false;
     while (!End) {
       error(Entry.moveNext(End));
       EntryNumber++;
     }
     outs() << "Number of resources: " << EntryNumber << "\n";
+
+    error(Parser.parse(RF));
   }
-  outs() << "Machine: ";
-  switch (Machine) {
-  case machine::ARM:
-    outs() << "ARM\n";
-    break;
-  case machine::X86:
-    outs() << "X86\n";
-    break;
-  default:
-    outs() << "X64\n";
-  }
+
+  Parser.printTree();
+
   return 0;
 }