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

[mnbvmar]

Summary

This allows to process HTML resources defined in .rc scripts and output them to resulting .res files. Additionally, some infrastructure allowing to output these files is created.

This is the first resource type we can operate on.

[mnbvmar]

One file was missing from the patch.

[ecbeckmann]

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

148

It would be good if we could reuse the .res file structures defined in WindowsResource.h, to ensure the sizes of each field are kept in sync and also have a single unified place in the code for defining the .res format. So instead of writing each field individually, you could define a local struct WinResHeaderPrefix and then call Writer.write<struct WinResHeaderPrefix>(the struct)

[mnbvmar]

Changed the code according to Eric's suggestion; some bugfixes.

[ecbeckmann]

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

114

Instead of an overload you should rename this to writeIntOrString for clarity.

[mnbvmar]

Refactored the code to simplify the patches following this one.

Previously, resource classes had ability to output themselves, using and possibly modifying the current context. Now, Visitor class is introduced which holds the current context and processes resources one by one and serializes them.

This still holds the ability to output HTML resources.

[mnbvmar]

This fixes @ecbeckmann's comment https://reviews.llvm.org/D37824#inline-329768 (set type IDs and memory flags as constants). It's probably better to fix this in the first patch this appears in.

[rnk]

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

2–4

nit: personally I like RUN: rm -rf %t && mkdir %t && cd %t as the standard one-line idiom for "get this test a clean working directory"

7

Do we have any tools that can dump resource files? These kind of "golden file" tests are pretty fragile and aren't easy to debug when they fail.

llvm/tools/llvm-rc/ResourceSerializator.h

1 ↗

(On Diff #115144)

Even if "Serializator" is a word, I'd recommend something more common, like ResourceFileWriter or something.

56 ↗

(On Diff #115144)

Maybe call this writeBytes, and take ArrayRef<uint8_t>?

58 ↗

(On Diff #115144)

I'm concerned that an object could easily contain endian-swapped fields, but I can't think of a clean way to defend against it, so let's go with this.

[mnbvmar]

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

7

We could pipe the output of llvm-cvtres to llvm-readobj. However, cvtres needs to reorder the resources, and readobj can only extract header information.

llvm/tools/llvm-rc/ResourceSerializator.h

58 ↗

(On Diff #115144)

The only thing I can think of is some std::disable_if detecting basic integral types larger than a byte. This is nowhere close to perfect, though.

[zturner]

llvm/tools/llvm-rc/ResourceSerializator.h

56 ↗

(On Diff #115144)

It seems like all of these functions are reproducing logic that already exists in BinaryStreamWriter. Is there some reason we can't use that here?

The nice thing about them is they prevent endianness errors up front, because you don't have to remember to call writeObject() with some endian-aware type, because as soon as you set the endianness on the stream, all integers get written appropriately.

It also contains functions for writing c strings, arrays, arbitrary objects, and seeking, so it seems like a good fit here and reduces some boilerplate?

llvm/tools/llvm-rc/llvm-rc.cpp

179

Can this be a unique_ptr?

[mnbvmar]

llvm/tools/llvm-rc/ResourceSerializator.h

56 ↗

(On Diff #115144)

BinaryStreamWriter expects to know the size of the underlying buffer beforehand, so I can't really use it here.

However, is it a good idea to teach this to write little-endian integers only (and convert native-endian ints to ulittle{}_t when necessary)?

[zturner]

llvm/tools/llvm-rc/ResourceSerializator.h

56 ↗

(On Diff #115144)

Yes, just call it writeInteger and do the endian conversion inside the function. Then call the function writeInteger<uint64_t>(12);

[mnbvmar]

Style fixes suggested in the comments. Integrated llvm-readobj into test invocation.

(I changed file and class names to ResourceFileWriter. However, I leave the revision as-is not to make confusion.)

[rnk]

lgtm, thanks!

[mnbvmar]

Seems this revision didn't close automatically. Fixing that.

llvm/test/tools/llvm-rc/Inputs/output-boundary-values-error-1.rc

+LANGUAGE 1024, 10

llvm/test/tools/llvm-rc/Inputs/output-boundary-values-error-2.rc

+LANGUAGE 500, 64

llvm/test/tools/llvm-rc/Inputs/output-boundary-values.rc

+LANGUAGE 1023, 63

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

+100 HTML "webpage1.html"
+Kittens HTML "webpage2.html"

llvm/test/tools/llvm-rc/Inputs/webpage1.html

+<html>
+  <body>
+    Hello!
+  </body>
+</html>

llvm/test/tools/llvm-rc/Inputs/webpage2.html

+<!-- Should not embed the image. -->
+<img src="kittens.bmp">

llvm/test/tools/llvm-rc/helpmsg.test

 ; RUN: llvm-rc /h > %t1
 ; RUN: llvm-rc '/?' > %t2
 ; RUN: diff %t1 %t2
 ; RUN: FileCheck -input-file=%t1 %s
 
 ; CHECK:  OVERVIEW: Resource Converter
 ; CHECK-DAG:  USAGE: rc [options] <inputs>
 ; CHECK-DAG:  OPTIONS:
 ; CHECK-NEXT:    /?          Display this help and exit.
+; CHECK-NEXT:    /dry-run    Don't compile the input; only try to parse it.
 ; CHECK-NEXT:    /D <value>  Define a symbol for the C preprocessor.
 ; CHECK-NEXT:    /FO <value> Change the output file location.
 ; CHECK-NEXT:    /H          Display this help and exit.
 ; CHECK-NEXT:    /I <value>  Add an include path.
 ; CHECK-NEXT:    /LN <value> Set the default language name.
 ; CHECK-NEXT:    /L <value>  Set the default language identifier.
 ; CHECK-NEXT:    /N          Null-terminate all strings in the string table.
 ; CHECK-NEXT:    /U <value>  Undefine a symbol for the C preprocessor.
 ; CHECK-NEXT:    /V          Be verbose.
 ; CHECK-NEXT:    /X          Ignore 'include' variable.
 ; CHECK-NEXT:    /Y          Suppress warnings on duplicate resource IDs.

llvm/test/tools/llvm-rc/output-boundary-values.test

+; RUN: llvm-rc /FO %t %p/Inputs/output-boundary-values.rc
+; RUN: diff %t %p/Inputs/empty.res
+
+; RUN: not llvm-rc /FO %t %p/Inputs/output-boundary-values-error-1.rc 2>&1 | FileCheck %s --check-prefix ERR1
+; ERR1: llvm-rc: Primary language ID (1024) does not fit in 10 bits.
+
+; RUN: not llvm-rc /FO %t %p/Inputs/output-boundary-values-error-2.rc 2>&1 | FileCheck %s --check-prefix ERR2
+; ERR2: llvm-rc: Sublanguage ID (64) does not fit in 6 bits.

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

-; RUN: llvm-rc /V %p/Inputs/parser-expr.rc | FileCheck %s
+; RUN: llvm-rc /dry-run /V %p/Inputs/parser-expr.rc | FileCheck %s
 
 ; CHECK:  Language: 5, Sublanguage: 1
 ; CHECK-NEXT:  Language: 3, Sublanguage: 2
 ; CHECK-NEXT:  Language: 4294967293, Sublanguage: 4294967292
 ; CHECK-NEXT:  Language: 0, Sublanguage: 1
 ; CHECK-NEXT:  Language: 2, Sublanguage: 4
 ; CHECK-NEXT:  Language: 3, Sublanguage: 5
 ; CHECK-NEXT:  Language: 2, Sublanguage: 0
 ; CHECK-NEXT:  Language: 4294967295, Sublanguage: 1
 ; CHECK-NEXT:  Language: 1, Sublanguage: 4294967295
 ; CHECK-NEXT:  Language: 4294967294, Sublanguage: 1
 ; CHECK-NEXT:  Language: 1, Sublanguage: 4294967294
 ; CHECK-NEXT:  Language: 2, Sublanguage: 1
 ; CHECK-NEXT:  Language: 3, Sublanguage: 5
 ; CHECK-NEXT:  Language: 0, Sublanguage: 13
 ; CHECK-NEXT:  Language: 5, Sublanguage: 7
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-bad-binary-1.rc 2>&1 | FileCheck %s --check-prefix BINARY1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-bad-binary-1.rc 2>&1 | FileCheck %s --check-prefix BINARY1
 
 ; BINARY1: llvm-rc: Error parsing file: expected '-', '~', integer or '(', got &
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-bad-binary-2.rc 2>&1 | FileCheck %s --check-prefix BINARY2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-bad-binary-2.rc 2>&1 | FileCheck %s --check-prefix BINARY2
 
 ; BINARY2: llvm-rc: Error parsing file: expected '-', '~', integer or '(', got |
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-bad-binary-3.rc 2>&1 | FileCheck %s --check-prefix BINARY3
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-bad-binary-3.rc 2>&1 | FileCheck %s --check-prefix BINARY3
 
 ; BINARY3: llvm-rc: Error parsing file: expected '-', '~', integer or '(', got +
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-bad-unary.rc 2>&1 | FileCheck %s --check-prefix UNARY
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-bad-unary.rc 2>&1 | FileCheck %s --check-prefix UNARY
 
 ; UNARY: llvm-rc: Error parsing file: expected ',', got ~
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-unbalanced-1.rc 2>&1 | FileCheck %s --check-prefix UNBALANCED1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-unbalanced-1.rc 2>&1 | FileCheck %s --check-prefix UNBALANCED1
 
 ; UNBALANCED1: llvm-rc: Error parsing file: expected ')', got ,
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-unbalanced-2.rc 2>&1 | FileCheck %s --check-prefix UNBALANCED2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-unbalanced-2.rc 2>&1 | FileCheck %s --check-prefix UNBALANCED2
 
 ; UNBALANCED2: llvm-rc: Error parsing file: expected ',', got )
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-expr-unbalanced-3.rc 2>&1 | FileCheck %s --check-prefix UNBALANCED3
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-expr-unbalanced-3.rc 2>&1 | FileCheck %s --check-prefix UNBALANCED3
 
 ; UNBALANCED3: llvm-rc: Error parsing file: expected ',', got )

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

-; RUN: llvm-rc /V %p/Inputs/parser-correct-everything.rc | FileCheck %s --check-prefix PGOOD
+; RUN: llvm-rc /dry-run /V %p/Inputs/parser-correct-everything.rc | FileCheck %s --check-prefix PGOOD
 
 ; PGOOD:  Icon (meh): "hello.bmp"
 ; PGOOD-NEXT:  Icon (Icon): "Icon"
 ; PGOOD-NEXT:  Language: 5, Sublanguage: 12
 ; PGOOD-NEXT:  StringTable:
 ; PGOOD-NEXT:    Option: Language: 1, Sublanguage: 1
 ; PGOOD-NEXT:    Option: Characteristics: 500
 ; PGOOD-NEXT:    Option: Language: 3, Sublanguage: 4

 ; PGOOD-NEXT:  User-defined (type: 600, name: 500): "other filename"
 ; PGOOD-NEXT:  User-defined (type: INTEGERS, name: HELLO): data = 1 2 3 4
 ; PGOOD-NEXT:  User-defined (type: STRINGS, name: HELLO): data = "1" "2" "3" "4"
 ; PGOOD-NEXT:  User-defined (type: MIXED, name: 4): data = 1 "2" 3 "4"
 
 
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-stringtable-no-string.rc 2>&1 | FileCheck %s --check-prefix PSTRINGTABLE1
+; RUN: not llvm-rc /dry-run %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 /dry-run %p/Inputs/parser-stringtable-weird-option.rc 2>&1 | FileCheck %s --check-prefix PSTRINGTABLE2
 
 ; PSTRINGTABLE2:  llvm-rc: Error parsing file: expected optional statement type, BEGIN or '{', got NONSENSETYPE
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-eof.rc 2>&1 | FileCheck %s --check-prefix PEOF
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-eof.rc 2>&1 | FileCheck %s --check-prefix PEOF
 
 ; PEOF:  llvm-rc: Error parsing file: expected '-', '~', integer or '(', got <EOF>
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-no-characteristics-arg.rc 2>&1 | FileCheck %s --check-prefix PCHARACTERISTICS1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-no-characteristics-arg.rc 2>&1 | FileCheck %s --check-prefix PCHARACTERISTICS1
 
 ; PCHARACTERISTICS1:  llvm-rc: Error parsing file: expected '-', '~', integer or '(', got BEGIN
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-nonsense-token.rc 2>&1 | FileCheck %s --check-prefix PNONSENSE1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-nonsense-token.rc 2>&1 | FileCheck %s --check-prefix PNONSENSE1
 
 ; PNONSENSE1:  llvm-rc: Error parsing file: expected int or identifier, got &
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-nonsense-type.rc 2>&1 | FileCheck %s --check-prefix PNONSENSE2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-nonsense-type.rc 2>&1 | FileCheck %s --check-prefix PNONSENSE2
 
 ; PNONSENSE2:  llvm-rc: Error parsing file: expected filename, '{' or BEGIN, got <EOF>
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-nonsense-type-eof.rc 2>&1 | FileCheck %s --check-prefix PNONSENSE3
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-nonsense-type-eof.rc 2>&1 | FileCheck %s --check-prefix PNONSENSE3
 
 ; PNONSENSE3:  llvm-rc: Error parsing file: expected int or identifier, got <EOF>
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-language-no-comma.rc 2>&1 | FileCheck %s --check-prefix PLANGUAGE1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-language-no-comma.rc 2>&1 | FileCheck %s --check-prefix PLANGUAGE1
 
 ; PLANGUAGE1:  llvm-rc: Error parsing file: expected ',', got 7
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-language-too-many-commas.rc 2>&1 | FileCheck %s --check-prefix PLANGUAGE2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-language-too-many-commas.rc 2>&1 | FileCheck %s --check-prefix PLANGUAGE2
 
 ; PLANGUAGE2:  llvm-rc: Error parsing file: expected '-', '~', integer or '(', got ,
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-html-bad-string.rc 2>&1 | FileCheck %s --check-prefix PHTML1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-html-bad-string.rc 2>&1 | FileCheck %s --check-prefix PHTML1
 
 ; PHTML1:  llvm-rc: Error parsing file: expected string, got ThisPassesInTheOriginalToolButDocSaysItShouldBeQuoted
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-html-extra-comma.rc 2>&1 | FileCheck %s --check-prefix PHTML2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-html-extra-comma.rc 2>&1 | FileCheck %s --check-prefix PHTML2
 
 ; PHTML2:  llvm-rc: Error parsing file: expected string, got ,
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-accelerators-bad-flag.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-accelerators-bad-flag.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS1
 
 ; PACCELERATORS1:  llvm-rc: Error parsing file: expected ASCII/VIRTKEY/NOINVERT/ALT/SHIFT/CONTROL, got HELLO
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-accelerators-bad-int-or-string.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-accelerators-bad-int-or-string.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS2
 
 ; PACCELERATORS2:  llvm-rc: Error parsing file: expected int or string, got NotIntOrString
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-accelerators-no-comma.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS3
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-accelerators-no-comma.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS3
 
 ; PACCELERATORS3:  llvm-rc: Error parsing file: expected int or string, got CONTROL
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-accelerators-no-comma-2.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS4
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-accelerators-no-comma-2.rc 2>&1 | FileCheck %s --check-prefix PACCELERATORS4
 
 ; PACCELERATORS4:  llvm-rc: Error parsing file: expected ',', got 10
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-menu-bad-id.rc 2>&1 | FileCheck %s --check-prefix PMENU1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-menu-bad-id.rc 2>&1 | FileCheck %s --check-prefix PMENU1
 
 ; PMENU1:  llvm-rc: Error parsing file: expected '-', '~', integer or '(', got A
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-menu-bad-flag.rc 2>&1 | FileCheck %s --check-prefix PMENU2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-menu-bad-flag.rc 2>&1 | FileCheck %s --check-prefix PMENU2
 
 ; PMENU2:  llvm-rc: Error parsing file: expected CHECKED/GRAYED/HELP/INACTIVE/MENUBARBREAK/MENUBREAK, got ERRONEOUS
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-menu-missing-block.rc 2>&1 | FileCheck %s --check-prefix PMENU3
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-menu-missing-block.rc 2>&1 | FileCheck %s --check-prefix PMENU3
 
 ; PMENU3:  llvm-rc: Error parsing file: expected '{', got POPUP
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-menu-misspelled-separator.rc 2>&1 | FileCheck %s --check-prefix PMENU4
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-menu-misspelled-separator.rc 2>&1 | FileCheck %s --check-prefix PMENU4
 
 ; PMENU4:  llvm-rc: Error parsing file: expected SEPARATOR or string, got NOTSEPARATOR
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-dialog-cant-give-helpid.rc 2>&1 | FileCheck %s --check-prefix PDIALOG1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-dialog-cant-give-helpid.rc 2>&1 | FileCheck %s --check-prefix PDIALOG1
 
 ; PDIALOG1:  llvm-rc: Error parsing file: expected identifier, got ,
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-dialog-too-few-args.rc 2>&1 | FileCheck %s --check-prefix PDIALOG2
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-dialog-too-few-args.rc 2>&1 | FileCheck %s --check-prefix PDIALOG2
 
 ; PDIALOG2:  llvm-rc: Error parsing file: expected ',', got }
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-dialog-too-many-args.rc 2>&1 | FileCheck %s --check-prefix PDIALOG3
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-dialog-too-many-args.rc 2>&1 | FileCheck %s --check-prefix PDIALOG3
 
 ; PDIALOG3:  llvm-rc: Error parsing file: expected identifier, got ,
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-dialog-unknown-type.rc 2>&1 | FileCheck %s --check-prefix PDIALOG4
+; RUN: not llvm-rc /dry-run %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
+; RUN: not llvm-rc /dry-run %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 /V %p/Inputs/parser-versioninfo-wrong-fixed.rc 2>&1 | FileCheck %s --check-prefix PVERSIONINFO1
+; RUN: not llvm-rc /dry-run %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
+; RUN: not llvm-rc /dry-run %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
+; RUN: not llvm-rc /dry-run %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
+; RUN: not llvm-rc /dry-run %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
+; RUN: not llvm-rc /dry-run %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
 
 
-; RUN: not llvm-rc /V %p/Inputs/parser-user-invalid-contents.rc 2>&1 | FileCheck %s --check-prefix PUSER1
+; RUN: not llvm-rc /dry-run %p/Inputs/parser-user-invalid-contents.rc 2>&1 | FileCheck %s --check-prefix PUSER1
 
 ; PUSER1:  llvm-rc: Error parsing file: expected int or string, got InvalidToken

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

+; RUN: rm -rf %t
+; RUN: mkdir %t
+; RUN: cd %t
+; RUN: cp %p/Inputs/webpage*.html .
+; RUN: llvm-rc /FO %t/tag-html.res %p/Inputs/tag-html.rc
+; RUN: diff %t/tag-html.res %p/Inputs/tag-html.res

llvm/tools/llvm-rc/Opts.td

def DUPID_NOWARN : Flag<[ "/", "-" ], "Y">,
                    HelpText<"Suppress warnings on duplicate resource IDs.">;
 
 def VERBOSE : Flag<[ "/", "-" ], "V">, HelpText<"Be verbose.">;
 def HELP : Flag<[ "/", "-" ], "?">, HelpText<"Display this help and exit.">;
 def H : Flag<[ "/", "-" ], "H">,
         Alias<HELP>,
         HelpText<"Display this help and exit.">;
 
+def DRY_RUN : Flag<[ "/", "-" ], "dry-run">,
+              HelpText<"Don't compile the input; only try to parse it.">;
+
 // Unused switches (at least for now). These will stay unimplemented
 // in an early stage of development and can be ignored. However, we need to
 // parse them in order to preserve the compatibility with the original tool.
 
 def NOLOGO : Flag<[ "/", "-" ], "NOLOGO">;
 def R : Flag<[ "/", "-" ], "R">;
 def SL : Flag<[ "/", "-" ], "SL">;
 

llvm/tools/llvm-rc/ResourceScriptParser.cpp

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();
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 (TypeResult->equals_lower("VALUE")) {
     // 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::SupportedTypes.find(TypeResult->upper()) ==
         RetType::SupportedTypes.end())
       return getExpectedError("fixed VERSIONINFO statement type", true);
 
     if (RetType::VersionTypes.find(TypeResult->upper()) !=
         RetType::VersionTypes.end()) {
       // 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;
 }
 

llvm/tools/llvm-rc/ResourceScriptStmt.h

public:
   IntOrString(StringRef Value) : Data(Value), IsInt(0) {}
   IntOrString(const RCToken &Token)
       : Data(Token), IsInt(Token.kind() == RCToken::Kind::Int) {}
 
   bool equalsLower(const char *Str) {
     return !IsInt && Data.String.equals_lower(Str);
   }
 
+  bool isInt() const { return IsInt; }
+
+  uint32_t getInt() const {
+    assert(IsInt);
+    return Data.Int;
+  }
+
+  StringRef getString() const {
+    assert(!IsInt);
+    return Data.String;
+  }
+
   friend raw_ostream &operator<<(raw_ostream &, const IntOrString &);
 };
 
+class VisitorContext {
+public:
+  std::unique_ptr<raw_fd_ostream> FS;
+  uint16_t LanguageInfo;
+  uint32_t Characteristics;
+  uint32_t VersionInfo;
+
+  VisitorContext() : LanguageInfo(0), Characteristics(0), VersionInfo(0) {}
+
+  void setStream(std::unique_ptr<raw_fd_ostream> Stream) {
+    FS = std::move(Stream);
+  }
+};
+
+class OptionalStmtList;
+
 // Base resource. All the resources should derive from this base.
 class RCResource {
 protected:
   IntOrString ResName;
+  virtual Error dumpResource(VisitorContext &Ctx) const {
+    llvm_unreachable("This cannot dump to .res file.");
+  }
 
 public:
   RCResource() = default;
   RCResource(RCResource &&) = default;
   void setName(const IntOrString &Name) { ResName = Name; }
   virtual raw_ostream &log(raw_ostream &OS) const {
     return OS << "Base statement\n";
-  };
+  }
+
+  virtual Error visitResource(VisitorContext &Ctx);
+
+  virtual IntOrString getResourceType() const {
+    llvm_unreachable("This cannot be called on objects without IDs.");
+  }
+  // By default, memory flags are DISCARDABLE | PURE | MOVEABLE.
+  virtual uint16_t getMemoryFlags() const { return 0x1030; }
+  virtual const OptionalStmtList getOptionalStatements() const;
   virtual ~RCResource() {}
 };
 
+// An empty resource. It has no content, type 0, ID 0 and all of its
+// characteristics are equal to 0.
+class NullResource : public RCResource {
+public:
+  raw_ostream &log(raw_ostream &OS) const override {
+    return OS << "Null resource\n";
+  }
+  Error dumpResource(VisitorContext &Ctx) const override {
+    return Error::success();
+  }
+  IntOrString getResourceType() const override { return 0; }
+  uint16_t getMemoryFlags() const override { return 0; }
+};
+
 // Optional statement base. All such statements should derive from this base.
-class OptionalStmt : public RCResource {};
+class OptionalStmt : public RCResource {
+public:
+  virtual Error apply(VisitorContext &Ctx) const = 0;
+};
 
 class OptionalStmtList : public OptionalStmt {
   std::vector<std::unique_ptr<OptionalStmt>> Statements;
 
 public:
   OptionalStmtList() {}
-  virtual raw_ostream &log(raw_ostream &OS) const;
+  raw_ostream &log(raw_ostream &OS) const override;
 
   void addStmt(std::unique_ptr<OptionalStmt> Stmt) {
     Statements.push_back(std::move(Stmt));
   }
+
+  Error apply(VisitorContext &Ctx) const override;
 };
 
 // LANGUAGE statement. It can occur both as a top-level statement (in such
 // a situation, it changes the default language until the end of the file)
 // and as an optional resource statement (then it changes the language
 // of a single resource).
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381019(v=vs.85).aspx
 class LanguageResource : public OptionalStmt {
   uint32_t Lang, SubLang;
 
 public:
   LanguageResource(uint32_t LangId, uint32_t SubLangId)
       : Lang(LangId), SubLang(SubLangId) {}
   raw_ostream &log(raw_ostream &) const override;
+
+  // This is not a regular top-level statement; when it occurs, it just
+  // modifies the language context.
+  Error visitResource(VisitorContext &Ctx) override { return apply(Ctx); }
+
+  Error apply(VisitorContext &Ctx) const override;
 };
 
 // ACCELERATORS resource. Defines a named table of accelerators for the app.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa380610(v=vs.85).aspx
 class AcceleratorsResource : public RCResource {
 public:
   class Accelerator {
public:
     static StringRef OptionsStr[NumFlags];
   };
 
   AcceleratorsResource(OptionalStmtList &&OptStmts)
       : OptStatements(std::move(OptStmts)) {}
   void addAccelerator(IntOrString Event, uint32_t Id, uint8_t Flags) {
     Accelerators.push_back(Accelerator{Event, Id, Flags});
   }
+
   raw_ostream &log(raw_ostream &) const override;
+  IntOrString getResourceType() const override { return 9; }
 
 private:
   std::vector<Accelerator> Accelerators;
   OptionalStmtList OptStatements;
 };
 
 // CURSOR resource. Represents a single cursor (".cur") file.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa380920(v=vs.85).aspx
 class CursorResource : public RCResource {
   StringRef CursorLoc;
 
 public:
   CursorResource(StringRef Location) : CursorLoc(Location) {}
   raw_ostream &log(raw_ostream &) const override;
+  IntOrString getResourceType() const override { return 21; }
 };
 
 // ICON resource. Represents a single ".ico" file containing a group of icons.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381018(v=vs.85).aspx
 class IconResource : public RCResource {
   StringRef IconLoc;
 
 public:
   IconResource(StringRef Location) : IconLoc(Location) {}
   raw_ostream &log(raw_ostream &) const override;
+  IntOrString getResourceType() const override { return 22; }
 };
 
 // HTML resource. Represents a local webpage that is to be embedded into the
 // resulting resource file. It embeds a file only - no additional resources
 // (images etc.) are included with this resource.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa966018(v=vs.85).aspx
 class HTMLResource : public RCResource {
   StringRef HTMLLoc;
 
 public:
   HTMLResource(StringRef Location) : HTMLLoc(Location) {}
   raw_ostream &log(raw_ostream &) const override;
+  Error dumpResource(VisitorContext &Ctx) const override;
+  IntOrString getResourceType() const override { return 23; }
+  // Curiously, file resources don't have DISCARDABLE flag set.
+  uint16_t getMemoryFlags() const override { return 0x30; }
 };
 
 // -- MENU resource and its helper classes --
 // This resource describes the contents of an application menu
 // (usually located in the upper part of the dialog.)
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381025(v=vs.85).aspx
 

 class MenuResource : public RCResource {
   OptionalStmtList OptStatements;
   MenuDefinitionList Elements;
 
 public:
   MenuResource(OptionalStmtList &&OptStmts, MenuDefinitionList &&Items)
       : OptStatements(std::move(OptStmts)), Elements(std::move(Items)) {}
   raw_ostream &log(raw_ostream &) const override;
+  IntOrString getResourceType() const override { return 4; }
 };
 
 // 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 RCResource {
   OptionalStmtList OptStatements;
   std::vector<std::pair<uint32_t, StringRef>> Table;
 
 public:
   StringTableResource(OptionalStmtList &&OptStmts)
       : OptStatements(std::move(OptStmts)) {}
   void addString(uint32_t ID, StringRef String) {
     Table.emplace_back(ID, String);
   }
+
   raw_ostream &log(raw_ostream &) const override;
 };
 
 // -- DIALOG(EX) resource and its helper classes --
 //
 // This resource describes dialog boxes and controls residing inside them.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381003(v=vs.85).aspx
DialogResource(uint32_t PosX, uint32_t PosY, uint32_t DlgWidth,
                  uint32_t DlgHeight, uint32_t DlgHelpID,
                  OptionalStmtList &&OptStmts, bool IsDialogEx)
       : 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;
+  IntOrString getResourceType() const override { return 5; }
 };
 
 // User-defined resource. It is either:
 //   * a link to the file, e.g. NAME TYPE "filename",
 //   * or contains a list of integers and strings, e.g. NAME TYPE {1, "a", 2}.
 class UserDefinedResource : public RCResource {
   IntOrString Type;
   StringRef FileLoc;
   std::vector<IntOrString> Contents;
   bool IsFileResource;
 
 public:
   UserDefinedResource(IntOrString ResourceType, StringRef FileLocation)
       : Type(ResourceType), FileLoc(FileLocation), IsFileResource(true) {}
   UserDefinedResource(IntOrString ResourceType, std::vector<IntOrString> &&Data)
       : Type(ResourceType), Contents(std::move(Data)), IsFileResource(false) {}
 
   raw_ostream &log(raw_ostream &) const override;
+  IntOrString getResourceType() const override { return Type; }
 };
 
 // -- 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
private:
   VersionInfoFixed FixedData;
 
 public:
   VersionInfoResource(VersionInfoBlock &&TopLevelBlock,
                       VersionInfoFixed &&FixedInfo)
       : MainBlock(std::move(TopLevelBlock)), FixedData(std::move(FixedInfo)) {}
 
   raw_ostream &log(raw_ostream &) const override;
+  IntOrString getResourceType() const override { return 16; }
 };
 
 // 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) {}
   raw_ostream &log(raw_ostream &) const override;
+  Error apply(VisitorContext &Ctx) const override {
+    Ctx.Characteristics = Value;
+    return Error::success();
+  }
 };
 
 // VERSION optional statement.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381059(v=vs.85).aspx
 class VersionStmt : public OptionalStmt {
   uint32_t Value;
 
 public:
   VersionStmt(uint32_t Version) : Value(Version) {}
   raw_ostream &log(raw_ostream &) const override;
+  Error apply(VisitorContext &Ctx) const override {
+    Ctx.VersionInfo = Value;
+    return Error::success();
+  }
 };
 
 // CAPTION optional statement.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa380778(v=vs.85).aspx
 class CaptionStmt : public OptionalStmt {
   StringRef Value;
 
 public:
   CaptionStmt(StringRef Caption) : Value(Caption) {}
   raw_ostream &log(raw_ostream &) const override;
+  Error apply(VisitorContext &Ctx) const override {
+    llvm_unreachable("Not implemented yet");
+  }
 };
 
 // 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) {}
   raw_ostream &log(raw_ostream &) const override;
+  Error apply(VisitorContext &Ctx) const override {
+    llvm_unreachable("Not implemented yet");
+  }
 };
 
 // STYLE optional statement.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa381051(v=vs.85).aspx
 class StyleStmt : public OptionalStmt {
   uint32_t Value;
 
 public:
   StyleStmt(uint32_t Style) : Value(Style) {}
   raw_ostream &log(raw_ostream &) const override;
+  Error apply(VisitorContext &Ctx) const override {
+    llvm_unreachable("Not implemented yet");
+  }
 };
 
 } // namespace rc
 } // namespace llvm
 
 #endif

llvm/tools/llvm-rc/ResourceScriptStmt.cpp

 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 //
 // This implements methods defined in ResourceScriptStmt.h.
 //
 // Ref: msdn.microsoft.com/en-us/library/windows/desktop/aa380599(v=vs.85).aspx
 //
 //===---------------------------------------------------------------------===//
 
 #include "ResourceScriptStmt.h"
 
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/Error.h"
+
+#include <system_error>
+
+// Take an expression returning llvm::Error and forward the error if it exists.
+#define RETURN_IF_ERROR(Expr)                                                  \
+  if (auto Err = (Expr))                                                       \
+    return Err;
+
 namespace llvm {
 namespace rc {
 
+static Error checkNumberFits(uint32_t Number, size_t MaxBits, Twine FieldName) {
+  assert(1 <= MaxBits && MaxBits <= 32);
+  if (!(Number >> MaxBits))
+    return Error::success();
+  return make_error<StringError>(
+      FieldName + " (" + Twine(Number) + ") does not fit in " + Twine(MaxBits) +
+          " bits.",
+      std::make_error_code(std::errc::value_too_large));
+}
+
+template <typename FitType>
+static Error checkNumberFits(uint32_t Number, Twine FieldName) {
+  return checkNumberFits(Number, sizeof(FitType) * 8, FieldName);
+}
+
+static Error checkNumberFits(IntOrString Value, Twine FieldName) {
+  if (!Value.isInt())
+    return Error::success();
+  return checkNumberFits<uint16_t>(Value.getInt(), FieldName);
+}
+
+// Parses a string/identifier and returns a processed version of it.
+// For now, it only strips the string boundaries, but TODO:
+//   * Squash "" to a single ".
+//   * Replace the escape sequences with their processed version.
+// For identifiers, this is no-op.
+static std::string processString(StringRef Str) {
+  // Identifiers won't have " signs inside.
+  if (!Str.contains('"'))
+    return Str;
+
+  // Just take the contents of the string, checking if it's been marked long.
+  LLVM_ATTRIBUTE_UNUSED bool IsLongString = Str.startswith_lower("L");
+  if (IsLongString)
+    Str = Str.drop_front();
+
+  bool StripSuccess = Str.consume_front("\"") && Str.consume_back("\"");
+  (void)StripSuccess;
+  assert(StripSuccess && "Strings should be enclosed in quotes.");
+
+  return Str;
+}
+
+class RCWriter {
+  support::endian::Writer<support::little> Writer;
+  raw_fd_ostream &FS;
+
+  template <typename T> void writeImpl(T Value) {
+    padStream(sizeof(T));
+    Writer.write(Value);
+  }
+
+  void writeImpl(StringRef Str) {
+    for (char Ch : processString(Str))
+      Writer.write<uint16_t>(Ch);
+  }
+
+public:
+  RCWriter(raw_fd_ostream &Stream) : Writer(Stream), FS(Stream) {}
+
+  void padStream(uint64_t Length) {
+    assert(Length > 0);
+    uint64_t Location = tell();
+    Location %= Length;
+    uint64_t Pad = (Length - Location) % Length;
+    for (uint64_t i = 0; i < Pad; ++i)
+      writeImpl<uint8_t>(0);
+  }
+
+  template <typename T> uint64_t write(T Value) {
+    uint64_t Location = tell();
+    writeImpl(Value);
+    return Location;
+  }
+
+  template <typename T> void writeAt(T Value, uint64_t Loc) {
+    Value = support::endian::byte_swap<T, support::little>(Value);
+    FS.pwrite((const char *)&Value, sizeof(T), Loc);
+  }
+
+  void writeUppercase(StringRef Str) {
+    std::string Upper = Str.upper();
+    writeImpl(StringRef(Upper));
+  }
+
+  void writeUppercase(const IntOrString &Value) {
+    if (!Value.isInt())
+      return writeUppercase(Value.getString());
+
+    Writer.write<uint16_t>(0xFFFF);
+    Writer.write<uint16_t>(Value.getInt());
+  }
+
+  Error copyFile(std::string Filename) {
+    // Filename path should be relative to the current working directory.
+    ErrorOr<std::unique_ptr<MemoryBuffer>> File =
+        MemoryBuffer::getFile(Filename);
+    if (!File)
+      return make_error<StringError>("Error opening file '" + Filename +
+                                         "': " + File.getError().message(),
+                                     File.getError());
+    FS << (*File)->getBuffer();
+    return Error::success();
+  }
+
+  uint64_t tell() const { return FS.tell(); }
+};
+
 raw_ostream &operator<<(raw_ostream &OS, const IntOrString &Item) {
   if (Item.IsInt)
     return OS << Item.Data.Int;
   else
     return OS << Item.Data.String;
 }
 
+Error RCResource::visitResource(VisitorContext &Ctx) {
+  assert(Ctx.FS && "No output stream provided.");
+  RCWriter Writer(*Ctx.FS);
+  uint64_t ResSizeLoc = Writer.write<uint32_t>(0);
+  uint64_t HeaderSizeLoc = Writer.write<uint32_t>(0);
+  RETURN_IF_ERROR(checkNumberFits(ResName, "Resource ID"));
+  Writer.writeUppercase(getResourceType());
+  Writer.writeUppercase(ResName);
+  Writer.write<uint32_t>(0); // DataVersion
+  Writer.write<uint16_t>(getMemoryFlags());
+  Writer.write<uint16_t>(Ctx.LanguageInfo);
+  Writer.write<uint32_t>(Ctx.VersionInfo);
+  Writer.write<uint32_t>(Ctx.Characteristics);
+
+  uint64_t DataLoc = Writer.tell();
+  RETURN_IF_ERROR(dumpResource(Ctx));
+
+  Writer.writeAt<uint32_t>(Writer.tell() - DataLoc, ResSizeLoc);
+  Writer.writeAt<uint32_t>(DataLoc - ResSizeLoc, HeaderSizeLoc);
+  Writer.padStream(sizeof(uint32_t));
+
+  return Error::success();
+}
+
+const OptionalStmtList RCResource::getOptionalStatements() const {
+  return OptionalStmtList();
+}
+
 raw_ostream &OptionalStmtList::log(raw_ostream &OS) const {
   for (const auto &Stmt : Statements) {
     OS << "  Option: ";
     Stmt->log(OS);
   }
   return OS;
 }
 
+Error OptionalStmtList::apply(VisitorContext &Ctx) const {
+  for (auto &Stmt : Statements)
+    RETURN_IF_ERROR(Stmt->apply(Ctx));
+  return Error::success();
+}
+
 raw_ostream &LanguageResource::log(raw_ostream &OS) const {
   return OS << "Language: " << Lang << ", Sublanguage: " << SubLang << "\n";
 }
 
+Error LanguageResource::apply(VisitorContext &Ctx) const {
+  RETURN_IF_ERROR(checkNumberFits(Lang, 10, "Primary language ID"));
+  RETURN_IF_ERROR(checkNumberFits(SubLang, 6, "Sublanguage ID"));
+  Ctx.LanguageInfo = Lang | (SubLang << 10);
+  return Error::success();
+}
+
 StringRef AcceleratorsResource::Accelerator::OptionsStr
     [AcceleratorsResource::Accelerator::NumFlags] = {
         "ASCII", "VIRTKEY", "NOINVERT", "ALT", "SHIFT", "CONTROL"};
 
 raw_ostream &AcceleratorsResource::log(raw_ostream &OS) const {
   OS << "Accelerators (" << ResName << "): \n";
   OptStatements.log(OS);
   for (const auto &Acc : Accelerators) {

 raw_ostream &IconResource::log(raw_ostream &OS) const {
   return OS << "Icon (" << ResName << "): " << IconLoc << "\n";
 }
 
 raw_ostream &HTMLResource::log(raw_ostream &OS) const {
   return OS << "HTML (" << ResName << "): " << HTMLLoc << "\n";
 }
 
+Error HTMLResource::dumpResource(VisitorContext &Ctx) const {
+  RCWriter Writer(*Ctx.FS);
+  return Writer.copyFile(processString(HTMLLoc));
+}
+
 StringRef MenuDefinition::OptionsStr[MenuDefinition::NumFlags] = {
     "CHECKED", "GRAYED", "HELP", "INACTIVE", "MENUBARBREAK", "MENUBREAK"};
 
 raw_ostream &MenuDefinition::logFlags(raw_ostream &OS, uint8_t Flags) {
   for (size_t i = 0; i < NumFlags; ++i)
     if (Flags & (1U << i))
       OS << " " << OptionsStr[i];
   return OS;

llvm/tools/llvm-rc/llvm-rc.cpp

 //===-- llvm-rc.cpp - Compile .rc scripts into .res -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Compile .rc scripts into .res files. This is intended to be a
 // platform-independent port of Microsoft's rc.exe tool.
 //
 //===----------------------------------------------------------------------===//
 
-#include "ResourceScriptToken.h"
 #include "ResourceScriptParser.h"
+#include "ResourceScriptToken.h"
 
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <system_error>
 
 using namespace llvm;
+using namespace llvm::rc;
 
 namespace {
 
 // Input options tables.
 
 enum ID {
   OPT_INVALID = 0, // This is not a correct option ID.
 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
int main(int argc_, const char *argv_[]) {
   // The tool prints nothing when invoked with no command-line arguments.
   if (InputArgs.hasArg(OPT_HELP)) {
     T.PrintHelp(outs(), "rc", "Resource Converter", false);
     return 0;
   }
 
   const bool BeVerbose = InputArgs.hasArg(OPT_VERBOSE);
 
-  std::vector<std::string> InArgsInfo = InputArgs.getAllArgValues(OPT_INPUT);
-  if (InArgsInfo.size() != 1) {
+  auto InArgsInfo = InputArgs.getAllArgValues(OPT_INPUT);
+  if (InArgsInfo.size() != 1)
     fatalError("Exactly one input file should be provided.");
-  }
 
   // Read and tokenize the input file.
   const Twine &Filename = InArgsInfo[0];
   ErrorOr<std::unique_ptr<MemoryBuffer>> File = MemoryBuffer::getFile(Filename);
-  if (!File) {
-    fatalError("Error opening file '" + Filename +
+  if (!File)
+    fatalError("Error opening input file '" + Filename +
                "': " + File.getError().message());
-  }
 
   std::unique_ptr<MemoryBuffer> FileContents = std::move(*File);
   StringRef Contents = FileContents->getBuffer();
 
   std::vector<RCToken> Tokens = ExitOnErr(tokenizeRC(Contents));
 
   if (BeVerbose) {
     const Twine TokenNames[] = {
 #define TOKEN(Name) #Name,
 #define SHORT_TOKEN(Name, Ch) #Name,
 #include "ResourceScriptTokenList.h"
 #undef TOKEN
 #undef SHORT_TOKEN
     };
 
     for (const RCToken &Token : Tokens) {
       outs() << TokenNames[static_cast<int>(Token.kind())] << ": "
              << Token.value();
       if (Token.kind() == RCToken::Kind::Int)
         outs() << "; int value = " << Token.intValue();
 
       outs() << "\n";
     }
+    outs().flush();
+  }
+
+  bool IsDryRun = InputArgs.hasArg(OPT_DRY_RUN);
+
+  VisitorContext Ctx;
+
+  if (!IsDryRun) {
+    auto OutArgsInfo = InputArgs.getAllArgValues(OPT_FILEOUT);
+    if (OutArgsInfo.size() != 1)
+      fatalError(
+          "Exactly one output file should be provided (using /FO flag).");
+
+    std::error_code EC;
+    auto FOut = make_unique<raw_fd_ostream>(OutArgsInfo[0], EC, sys::fs::F_RW);
+    if (EC)
+      fatalError("Error opening output file '" + OutArgsInfo[0] +
+                 "': " + EC.message());
+    Ctx.setStream(std::move(FOut));
+
+    // Put an empty resource - .res file header.
+    ExitOnErr(NullResource().visitResource(Ctx));
+
+    // Set the default language; choose en-US arbitrarily.
+    ExitOnErr(LanguageResource(0x09, /* LANG_ENGLISH */
+                               0x01 /* SUBLANG_ENGLISH_US */)
+                  .visitResource(Ctx));
   }
 
-  rc::RCParser Parser{std::move(Tokens)};
+  RCParser Parser{std::move(Tokens)};
   while (!Parser.isEof()) {
     auto Resource = ExitOnErr(Parser.parseSingleResource());
     if (BeVerbose)
       Resource->log(outs());
+    if (!IsDryRun)
+      ExitOnErr(Resource->visitResource(Ctx));
   }
 
   return 0;
 }