[llvm-rc] Add additional optional statements serialization support for DIALOG(EX) resources (serialization, pt 5).

[mnbvmar]

Summary

This allows DIALOG and DIALOGEX to serialize if dialog-specific optional statements are provided. These are (as of now): CAPTION, FONT, and STYLE.

Notably, FONT statement can take more than two arguments when describing DIALOGEX resources (as in msdn.microsoft.com/en-us/library/windows/desktop/aa381013.aspx). I made some changes to the parser to reflect this fact.

[mnbvmar]

Moved binary .res output to its printable representation in dialog test.

[rnk]

Looks good

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

POPUP "&Items"
     MENUITEM "&Word", 502
   }
 }
 
 14 DIALOGEX 50, 60, 10, 20, 500
 LANGUAGE 1, 2
 CHARACTERISTICS 50
 VERSION 100
-FONT 12, "Arial"
+FONT 12, "Arial", 500, 1, 13
 CAPTION "RC parser dialog"
 STYLE 0x51234
 BEGIN
   LTEXT "Hello world!", 14, 20, 20, 50, 50
   RTEXT "Heh", 50, 51, 52, 53, 54, 55, 56
   CTEXT "Muuuu", 1, 2, 3, 4, 5, 6, 7, 8
   PUSHBUTTON "Muuuu", 1, 2, 3, 4, 5, 6, 7, 8
   DEFPUSHBUTTON "Muuuu", 1, 2, 3, 4, 5, 6

llvm/test/tools/llvm-rc/Inputs/parser-dialog-simple-font.rc

+1 DIALOG 1, 2, 3, 4
+FONT 12, "Face", 100, 1, 0
+BEGIN
+END

llvm/test/tools/llvm-rc/Inputs/tag-dialog-bad-style.rc

+1 DIALOG 1, 2, 3, 4
+STYLE 0xFFFF0001 {}

llvm/test/tools/llvm-rc/Inputs/tag-dialog-headers.rc

+1 DIALOGEX 1, 2, 3, 4 {}
+2 DIALOG 1, 2, 3, 4 {}
+
+3 DIALOGEX 10000, 20000, 30000, 32767
+CAPTION "My Caption" {}
+4 DIALOG -32768, 32767, 0, 32767
+CAPTION "My Caption" {}
+
+5 DIALOGEX 0, 1, 0, 9
+STYLE 0x01234567 {}
+6 DIALOG 0, 1, 0, 9
+STYLE 0x01234567 {}
+
+7 DIALOGEX 8, 7, 6, 5
+FONT 50, "a" {}
+8 DIALOG 8, 7, 6, 5
+FONT 50, "aaaa" {}
+9 DIALOGEX 8, 7, 6, 5
+FONT 50, L"a" {}
+10 DIALOG 8, 7, 6, 5
+FONT 50, L"aaaa" {}
+11 DIALOGEX 1, 2, 3, 4
+FONT 50, "FONT", 51 {}
+12 DIALOGEX 1, 2, 3, 4
+FONT 50, "FONT", 51, 52 {}
+13 DIALOGEX 1, 2, 3, 4
+FONT 50, "FONT", 51, 52, 53 {}
+
+14 DIALOGEX 1, 1, 1, 1
+CAPTION "CAPTION" FONT 42, "FONT" {}
+15 DIALOG 1, 1, 1, 1
+CAPTION "CAPTION" FONT 42, "FONT" {}
+
+16 DIALOGEX 2, 2, 2, 2
+CAPTION "CAPTION" FONT 42, "FONT" STYLE 0 {}
+17 DIALOG 2, 2, 2, 2
+CAPTION "CAPTION" FONT 42, "FONT" STYLE 0 {}
+
+18 DIALOGEX 3, 3, 3, 3
+CAPTION "CAPTION" STYLE 0 {}
+19 DIALOG 3, 3, 3, 3
+CAPTION "CAPTION" STYLE 0 {}
+
+20 DIALOGEX 4, 4, 4, 4 STYLE 0xFF00FF00 {}
+21 DIALOG 4, 4, 4, 4 STYLE 0xFF00FF00 {}
+22 DIALOGEX 4, 4, 4, 4 STYLE 0x00FF00FF {}
+23 DIALOG 4, 4, 4, 4 STYLE 0x00FF00FF {}
+
+24 DIALOGEX 5, 5, 5, 5 CAPTION "" STYLE 0 {}
+25 DIALOG 5, 5, 5, 5 CAPTION "" STYLE 0 {}
+
+26 DIALOGEX 1, 2, 3, 4, 5 {}
+

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

 ; PGOOD-NEXT:    Menu separator
 ; PGOOD-NEXT:    MenuItem ("&Word"), ID = 502
 ; PGOOD-NEXT:    Menu list ends
 ; PGOOD-NEXT:    Menu list ends
 ; PGOOD-NEXT:  DialogEx (14): loc: (50, 60), size: [10, 20], help ID: 500
 ; PGOOD-NEXT:    Option: Language: 1, Sublanguage: 2
 ; PGOOD-NEXT:    Option: Characteristics: 50
 ; PGOOD-NEXT:    Option: Version: 100
-; PGOOD-NEXT:    Option: Font: size = 12, face = "Arial"
+; PGOOD-NEXT:    Option: Font: size = 12, face = "Arial", weight = 500, italic, charset = 13
 ; PGOOD-NEXT:    Option: Caption: "RC parser dialog"
 ; PGOOD-NEXT:    Option: Style: 332340
 ; 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

 ; PDIALOG4:  llvm-rc: Error parsing file: expected control type, END or '}', got UNKNOWN
 
 
 ; RUN: not llvm-rc /dry-run /V %p/Inputs/parser-dialog-unnecessary-string.rc 2>&1 | FileCheck %s --check-prefix PDIALOG5
 
 ; PDIALOG5:  llvm-rc: Error parsing file: expected '-', '~', integer or '(', got "This shouldn't be here"
 
 
+; RUN: not llvm-rc /dry-run /V %p/Inputs/parser-dialog-simple-font.rc 2>&1 | FileCheck %s --check-prefix PDIALOG6
+
+; PDIALOG6:  llvm-rc: Error parsing file: expected identifier, got ,
+
+
 ; RUN: not llvm-rc /dry-run /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 /dry-run /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

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

 ; RUN: llvm-rc /FO %t %p/Inputs/tag-dialog.rc
 ; RUN: diff %t %p/Inputs/tag-dialog.res
 
+; RUN: llvm-rc /FO %t %p/Inputs/tag-dialog-headers.rc
+; RUN: diff %t %p/Inputs/tag-dialog-headers.res
+
 
 ; RUN: not llvm-rc /FO %t %p/Inputs/tag-dialog-large-coord.rc 2>&1 | FileCheck %s --check-prefix COORD1
 
 ; COORD1: llvm-rc: Error in DIALOGEX statement (ID 1):
 ; COORD1-NEXT: Dialog x-coordinate (50000) does not fit in 16-bit signed integer type.
 
 
 ; RUN: not llvm-rc /FO %t %p/Inputs/tag-dialog-large-coord-neg.rc 2>&1 | FileCheck %s --check-prefix COORD2

 ; CTL-ID-NEXT: Control ID in simple DIALOG resource (100000) does not fit in 16 bits.
 
 
 ; RUN: not llvm-rc /FO %t %p/Inputs/tag-dialog-ctl-large-ref-id.rc 2>&1 | FileCheck %s --check-prefix CTL-REF-ID
 
 ; CTL-REF-ID: llvm-rc: Error in DIALOGEX statement (ID 1):
 ; CTL-REF-ID-NEXT: Error in CTEXT control (ID 42):
 ; CTL-REF-ID-NEXT: Control reference ID (65536) does not fit in 16 bits.
+
+
+; RUN: not llvm-rc /FO %t %p/Inputs/tag-dialog-bad-style.rc 2>&1 | FileCheck %s --check-prefix STYLE
+
+; STYLE: llvm-rc: Error in DIALOG statement (ID 1):
+; STYLE-NEXT: 16 higher bits of DIALOG resource style cannot be equal to 0xFFFF

llvm/tools/llvm-rc/ResourceScriptParser.h

private:
   //    CHARACTERISTICS, LANGUAGE, VERSION
   // However, DIALOG and DIALOGEX extend this list by the following items:
   //    CAPTION, CLASS, EXSTYLE, FONT, MENU, STYLE
   // UseExtendedStatements flag (off by default) allows the parser to read
   // the additional types of statements.
   //
   // Ref (to the list of all optional statements):
   //    msdn.microsoft.com/en-us/library/windows/desktop/aa381002(v=vs.85).aspx
+  enum class OptStmtType { BasicStmt, DialogStmt, DialogExStmt };
+
   Expected<OptionalStmtList>
-  parseOptionalStatements(bool UseExtendedStatements = false);
+  parseOptionalStatements(OptStmtType StmtsType = OptStmtType::BasicStmt);
 
   // Read a single optional statement.
   Expected<std::unique_ptr<OptionalStmt>>
-  parseSingleOptionalStatement(bool UseExtendedStatements = false);
+  parseSingleOptionalStatement(OptStmtType StmtsType = OptStmtType::BasicStmt);
 
   // Top-level resource parsers.
   ParseType parseLanguageResource();
   ParseType parseAcceleratorsResource();
   ParseType parseCursorResource();
   ParseType parseDialogResource(bool IsExtended);
   ParseType parseIconResource();
   ParseType parseHTMLResource();
private:
   // 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 parseFontStmt(OptStmtType DialogType);
   ParseOptionType parseStyleStmt();
 
   // Raises an error. If IsAlreadyRead = false (default), this complains about
   // the token that couldn't be parsed. If the flag is on, this complains about
   // the correctly read token that makes no sense (that is, the current parser
   // state is beyond the erroneous token.)
   Error getExpectedError(const Twine Message, bool IsAlreadyRead = false);
 

llvm/tools/llvm-rc/ResourceScriptParser.cpp

while (isNextTokenKind(Kind::Comma)) {
 
     if (!FoundFlag)
       return getExpectedError(join(FlagDesc, "/"), true);
   }
 
   return Result;
 }
 
-// As for now, we ignore the extended set of statements.
-Expected<OptionalStmtList> RCParser::parseOptionalStatements(bool IsExtended) {
+Expected<OptionalStmtList>
+RCParser::parseOptionalStatements(OptStmtType StmtsType) {
   OptionalStmtList Result;
 
   // The last statement is always followed by the start of the block.
   while (!isNextTokenKind(Kind::BlockBegin)) {
-    ASSIGN_OR_RETURN(SingleParse, parseSingleOptionalStatement(IsExtended));
+    ASSIGN_OR_RETURN(SingleParse, parseSingleOptionalStatement(StmtsType));
     Result.addStmt(std::move(*SingleParse));
   }
 
   return std::move(Result);
 }
 
 Expected<std::unique_ptr<OptionalStmt>>
-RCParser::parseSingleOptionalStatement(bool IsExtended) {
+RCParser::parseSingleOptionalStatement(OptStmtType StmtsType) {
   ASSIGN_OR_RETURN(TypeToken, readIdentifier());
   if (TypeToken->equals_lower("CHARACTERISTICS"))
     return parseCharacteristicsStmt();
   if (TypeToken->equals_lower("LANGUAGE"))
     return parseLanguageStmt();
   if (TypeToken->equals_lower("VERSION"))
     return parseVersionStmt();
 
-  if (IsExtended) {
+  if (StmtsType != OptStmtType::BasicStmt) {
     if (TypeToken->equals_lower("CAPTION"))
       return parseCaptionStmt();
     if (TypeToken->equals_lower("FONT"))
-      return parseFontStmt();
+      return parseFontStmt(StmtsType);
     if (TypeToken->equals_lower("STYLE"))
       return parseStyleStmt();
   }
 
   return getExpectedError("optional statement type, BEGIN or '{'",
                           /* IsAlreadyRead = */ true);
 }
 
RCParser::ParseType RCParser::parseDialogResource(bool IsExtended) {
   ASSIGN_OR_RETURN(LocResult, readIntsWithCommas(4, 4));
 
   uint32_t HelpID = 0; // When HelpID is unset, it's assumed to be 0.
   if (IsExtended && consumeOptionalType(Kind::Comma)) {
     ASSIGN_OR_RETURN(HelpIDResult, readInt());
     HelpID = *HelpIDResult;
   }
 
-  ASSIGN_OR_RETURN(OptStatements,
-                   parseOptionalStatements(/*UseExtendedStmts = */ true));
+  ASSIGN_OR_RETURN(OptStatements, parseOptionalStatements(
+                                      IsExtended ? OptStmtType::DialogExStmt
+                                                 : OptStmtType::DialogStmt));
 
   assert(isNextTokenKind(Kind::BlockBegin) &&
          "parseOptionalStatements, when successful, halts on BlockBegin.");
   consume();
 
   auto Dialog = make_unique<DialogResource>(
       (*LocResult)[0], (*LocResult)[1], (*LocResult)[2], (*LocResult)[3],
       HelpID, std::move(*OptStatements), IsExtended);
RCParser::ParseOptionType RCParser::parseVersionStmt() {
   return make_unique<VersionStmt>(*Arg);
 }
 
 RCParser::ParseOptionType RCParser::parseCaptionStmt() {
   ASSIGN_OR_RETURN(Arg, readString());
   return make_unique<CaptionStmt>(*Arg);
 }
 
-RCParser::ParseOptionType RCParser::parseFontStmt() {
+RCParser::ParseOptionType RCParser::parseFontStmt(OptStmtType DialogType) {
+  assert(DialogType != OptStmtType::BasicStmt);
+
   ASSIGN_OR_RETURN(SizeResult, readInt());
   RETURN_IF_ERROR(consumeType(Kind::Comma));
   ASSIGN_OR_RETURN(NameResult, readString());
-  return make_unique<FontStmt>(*SizeResult, *NameResult);
+
+  // Default values for the optional arguments.
+  uint32_t FontWeight = 0;
+  bool FontItalic = false;
+  uint32_t FontCharset = 1;
+  if (DialogType == OptStmtType::DialogExStmt) {
+    if (consumeOptionalType(Kind::Comma)) {
+      ASSIGN_OR_RETURN(Args, readIntsWithCommas(/* min = */ 0, /* max = */ 3));
+      if (Args->size() >= 1)
+        FontWeight = (*Args)[0];
+      if (Args->size() >= 2)
+        FontItalic = (*Args)[1] != 0;
+      if (Args->size() >= 3)
+        FontCharset = (*Args)[2];
+    }
+  }
+  return make_unique<FontStmt>(*SizeResult, *NameResult, FontWeight, FontItalic,
+                               FontCharset);
 }
 
 RCParser::ParseOptionType RCParser::parseStyleStmt() {
   ASSIGN_OR_RETURN(Arg, readInt());
   return make_unique<StyleStmt>(*Arg);
 }
 
 Error RCParser::getExpectedError(const Twine Message, bool IsAlreadyRead) {
   return make_error<ParserError>(
       Message, IsAlreadyRead ? std::prev(CurLoc) : CurLoc, End);
 }
 
 } // namespace rc
 } // namespace llvm

llvm/tools/llvm-rc/ResourceScriptStmt.h

public:
   Twine getResourceTypeName() const override { return "VERSION"; }
   Error visit(Visitor *V) const override { return V->visitVersionStmt(this); }
 };
 
 // CAPTION optional statement.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa380778(v=vs.85).aspx
 class CaptionStmt : public OptionalStmt {
+public:
   StringRef Value;
 
-public:
   CaptionStmt(StringRef Caption) : Value(Caption) {}
   raw_ostream &log(raw_ostream &) const override;
+  Twine getResourceTypeName() const override { return "CAPTION"; }
+  Error visit(Visitor *V) const override { return V->visitCaptionStmt(this); }
 };
 
 // FONT optional statement.
 // Note that the documentation is inaccurate: it expects five arguments to be
 // given, however the example provides only two. In fact, the original tool
 // expects two arguments - point size and name of the typeface.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381013(v=vs.85).aspx
 class FontStmt : public OptionalStmt {
-  uint32_t Size;
-  StringRef Typeface;
-
 public:
-  FontStmt(uint32_t FontSize, StringRef FontName)
-      : Size(FontSize), Typeface(FontName) {}
+  uint32_t Size, Weight, Charset;
+  StringRef Name;
+  bool Italic;
+
+  FontStmt(uint32_t FontSize, StringRef FontName, uint32_t FontWeight,
+           bool FontItalic, uint32_t FontCharset)
+      : Size(FontSize), Weight(FontWeight), Charset(FontCharset),
+        Name(FontName), Italic(FontItalic) {}
   raw_ostream &log(raw_ostream &) const override;
+  Twine getResourceTypeName() const override { return "FONT"; }
+  Error visit(Visitor *V) const override { return V->visitFontStmt(this); }
 };
 
 // STYLE optional statement.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381051(v=vs.85).aspx
 class StyleStmt : public OptionalStmt {
+public:
   uint32_t Value;
 
-public:
   StyleStmt(uint32_t Style) : Value(Style) {}
   raw_ostream &log(raw_ostream &) const override;
+  Twine getResourceTypeName() const override { return "STYLE"; }
+  Error visit(Visitor *V) const override { return V->visitStyleStmt(this); }
 };
 
 } // namespace rc
 } // namespace llvm
 
 #endif

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

raw_ostream &VersionStmt::log(raw_ostream &OS) const {
   return OS << "Version: " << Value << "\n";
 }
 
 raw_ostream &CaptionStmt::log(raw_ostream &OS) const {
   return OS << "Caption: " << Value << "\n";
 }
 
 raw_ostream &FontStmt::log(raw_ostream &OS) const {
-  return OS << "Font: size = " << Size << ", face = " << Typeface << "\n";
+  OS << "Font: size = " << Size << ", face = " << Name
+     << ", weight = " << Weight;
+  if (Italic)
+    OS << ", italic";
+  return OS << ", charset = " << Charset << "\n";
 }
 
 raw_ostream &StyleStmt::log(raw_ostream &OS) const {
   return OS << "Style: " << Value << "\n";
 }
 
 } // namespace rc
 } // namespace llvm

llvm/tools/llvm-rc/ResourceSerializator.h

public:
   }
 
   Error visitNullResource(const RCResource *) override;
   Error visitAcceleratorsResource(const RCResource *) override;
   Error visitDialogResource(const RCResource *) override;
   Error visitHTMLResource(const RCResource *) override;
   Error visitMenuResource(const RCResource *) override;
 
+  Error visitCaptionStmt(const CaptionStmt *) override;
   Error visitCharacteristicsStmt(const CharacteristicsStmt *) override;
+  Error visitFontStmt(const FontStmt *) override;
   Error visitLanguageStmt(const LanguageResource *) override;
+  Error visitStyleStmt(const StyleStmt *) override;
   Error visitVersionStmt(const VersionStmt *) override;
 
   struct ObjectInfo {
     uint16_t LanguageInfo;
     uint32_t Characteristics;
     uint32_t VersionInfo;
 
+    Optional<uint32_t> Style;
+    StringRef Caption;
+    struct FontInfo {
+      uint32_t Size;
+      StringRef Typeface;
+      uint32_t Weight;
+      bool IsItalic;
+      uint32_t Charset;
+    };
+    Optional<FontInfo> Font;
+
     ObjectInfo() : LanguageInfo(0), Characteristics(0), VersionInfo(0) {}
   } ObjectData;
 
 private:
   Error handleError(Error &&Err, const RCResource *Res);
 
   Error
   writeResource(const RCResource *Res,

llvm/tools/llvm-rc/ResourceSerializator.cpp

 Error ResourceSerializator::visitAcceleratorsResource(const RCResource *Res) {
   return writeResource(Res, &ResourceSerializator::writeAcceleratorsBody);
 }
 
 Error ResourceSerializator::visitDialogResource(const RCResource *Res) {
   return writeResource(Res, &ResourceSerializator::writeDialogBody);
 }
 
+Error ResourceSerializator::visitCaptionStmt(const CaptionStmt *Stmt) {
+  ObjectData.Caption = Stmt->Value;
+  return Error::success();
+}
+
 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::visitFontStmt(const FontStmt *Stmt) {
+  RETURN_IF_ERROR(checkNumberFits<uint16_t>(Stmt->Size, "Font size"));
+  RETURN_IF_ERROR(checkNumberFits<uint16_t>(Stmt->Weight, "Font weight"));
+  RETURN_IF_ERROR(checkNumberFits<uint8_t>(Stmt->Charset, "Font charset"));
+  ObjectInfo::FontInfo Font{Stmt->Size, Stmt->Name, Stmt->Weight, Stmt->Italic,
+                            Stmt->Charset};
+  ObjectData.Font.emplace(Font);
+  return Error::success();
+}
+
 Error ResourceSerializator::visitLanguageStmt(const LanguageResource *Stmt) {
   RETURN_IF_ERROR(checkNumberFits(Stmt->Lang, 10, "Primary language ID"));
   RETURN_IF_ERROR(checkNumberFits(Stmt->SubLang, 6, "Sublanguage ID"));
   ObjectData.LanguageInfo = Stmt->Lang | (Stmt->SubLang << 10);
   return Error::success();
 }
 
+Error ResourceSerializator::visitStyleStmt(const StyleStmt *Stmt) {
+  ObjectData.Style = Stmt->Value;
+  return Error::success();
+}
+
 Error ResourceSerializator::visitVersionStmt(const VersionStmt *Stmt) {
   ObjectData.VersionInfo = Stmt->Value;
   return Error::success();
 }
 
 Error ResourceSerializator::writeResource(
     const RCResource *Res,
     Error (ResourceSerializator::*BodyWriter)(const RCResource *)) {
Error ResourceSerializator::writeSingleDialogControl(const Control &Ctl,
 
   return Error::success();
 }
 
 Error ResourceSerializator::writeDialogBody(const RCResource *Base) {
   auto *Res = cast<DialogResource>(Base);
 
   // Default style: WS_POPUP | WS_BORDER | WS_SYSMENU.
-  const uint32_t UsedStyle = 0x80880000;
+  const uint32_t DefaultStyle = 0x80880000;
+  const uint32_t StyleFontFlag = 0x40;
+  const uint32_t StyleCaptionFlag = 0x00C00000;
+
+  uint32_t UsedStyle = ObjectData.Style.getValueOr(DefaultStyle);
+  if (ObjectData.Font)
+    UsedStyle |= StyleFontFlag;
+  else
+    UsedStyle &= ~StyleFontFlag;
+
+  // Actually, in case of empty (but existent) caption, the examined field
+  // is equal to "\"\"". That's why empty captions are still noticed.
+  if (ObjectData.Caption != "")
+    UsedStyle |= StyleCaptionFlag;
+
+  const uint16_t DialogExMagic = 0xFFFF;
 
   // Write DIALOG(EX) header prefix. These are pretty different.
   if (!Res->IsExtended) {
+    // We cannot let the higher word of DefaultStyle be equal to 0xFFFF.
+    // In such a case, whole object (in .res file) is equivalent to a
+    // DIALOGEX. It might lead to access violation/segmentation fault in
+    // resource readers. For example,
+    //   1 DIALOG 0, 0, 0, 65432
+    //   STYLE 0xFFFF0001 {}
+    // would be compiled to a DIALOGEX with 65432 controls.
+    if ((UsedStyle >> 16) == DialogExMagic)
+      return createError("16 higher bits of DIALOG resource style cannot be"
+                         " equal to 0xFFFF");
+
     struct {
       ulittle32_t Style;
       ulittle32_t ExtStyle;
     } Prefix{ulittle32_t(UsedStyle),
              ulittle32_t(0)}; // As of now, we don't keep EXSTYLE.
 
     writeObject(Prefix);
   } else {
-    const uint16_t DialogExMagic = 0xFFFF;
-
     struct {
       ulittle16_t Version;
       ulittle16_t Magic;
       ulittle32_t HelpID;
       ulittle32_t ExtStyle;
       ulittle32_t Style;
     } Prefix{ulittle16_t(1), ulittle16_t(DialogExMagic),
              ulittle32_t(Res->HelpID), ulittle32_t(0), ulittle32_t(UsedStyle)};
Error ResourceSerializator::writeDialogBody(const RCResource *Base) {
 
   // MENU field. As of now, we don't keep them in the state and can peacefully
   // think there is no menu attached to the dialog.
   writeObject<uint16_t>(0);
 
   // Window CLASS field. Not kept here.
   writeObject<uint16_t>(0);
 
-  // Window title. There is no title for now, so all we output is '\0'.
-  writeObject<uint16_t>(0);
+  // Window title or a single word equal to 0.
+  RETURN_IF_ERROR(writeCString(ObjectData.Caption));
+
+  // If there *is* a window font declared, output its data.
+  auto &Font = ObjectData.Font;
+  if (Font) {
+    writeObject(ulittle16_t(Font->Size));
+    // Additional description occurs only in DIALOGEX.
+    if (Res->IsExtended) {
+      writeObject(ulittle16_t(Font->Weight));
+      writeObject(uint8_t(Font->IsItalic));
+      writeObject(uint8_t(Font->Charset));
+    }
+    RETURN_IF_ERROR(writeCString(Font->Typeface));
+  }
 
   auto handleCtlError = [&](Error &&Err, const Control &Ctl) -> Error {
     if (!Err)
       return Error::success();
     return joinErrors(createError("Error in " + Twine(Ctl.Type) +
                                   " control  (ID " + Twine(Ctl.ID) + "):"),
                       std::move(Err));
   };

llvm/tools/llvm-rc/ResourceVisitor.h

 
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace rc {
 
 class RCResource;
 
+class CaptionStmt;
 class CharacteristicsStmt;
+class FontStmt;
 class LanguageResource;
+class StyleStmt;
 class VersionStmt;
 
 class Visitor {
 public:
   virtual Error visitNullResource(const RCResource *) = 0;
   virtual Error visitAcceleratorsResource(const RCResource *) = 0;
   virtual Error visitDialogResource(const RCResource *) = 0;
   virtual Error visitHTMLResource(const RCResource *) = 0;
   virtual Error visitMenuResource(const RCResource *) = 0;
 
+  virtual Error visitCaptionStmt(const CaptionStmt *) = 0;
   virtual Error visitCharacteristicsStmt(const CharacteristicsStmt *) = 0;
+  virtual Error visitFontStmt(const FontStmt *) = 0;
   virtual Error visitLanguageStmt(const LanguageResource *) = 0;
+  virtual Error visitStyleStmt(const StyleStmt *) = 0;
   virtual Error visitVersionStmt(const VersionStmt *) = 0;
 
   virtual ~Visitor() {}
 };
 
 } // namespace rc
 } // namespace llvm
 
 #endif