/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp

Bug Summary

File:	tools/llvm-rc/ResourceFileWriter.cpp
Warning:	line 894, column 7 Called C++ object pointer is uninitialized

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ResourceFileWriter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/llvm-rc -I /build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/llvm-rc -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp

→

1//===-- ResourceFileWriter.cpp --------------------------------*- C++-*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===---------------------------------------------------------------------===//
9//
10// This implements the visitor serializing resources to a .res stream.
11//
12//===---------------------------------------------------------------------===//

14#include "ResourceFileWriter.h"

16#include "llvm/Object/WindowsResource.h"
17#include "llvm/Support/ConvertUTF.h"
18#include "llvm/Support/Endian.h"
19#include "llvm/Support/EndianStream.h"
20#include "llvm/Support/MemoryBuffer.h"
21#include "llvm/Support/Path.h"
22#include "llvm/Support/Process.h"

24using namespace llvm::support;

26// Take an expression returning llvm::Error and forward the error if it exists.
27#define RETURN_IF_ERROR(Expr)if (auto Err = (Expr)) return Err;                                                  \
if (auto Err = (Expr))                                                       \
  return Err;

31namespace llvm {
32namespace rc {

34// Class that employs RAII to save the current FileWriter object state
35// and revert to it as soon as we leave the scope. This is useful if resources
36// declare their own resource-local statements.
37class ContextKeeper {
ResourceFileWriter *FileWriter;
ResourceFileWriter::ObjectInfo SavedInfo;

41public:
ContextKeeper(ResourceFileWriter *V)
    : FileWriter(V), SavedInfo(V->ObjectData) {}
~ContextKeeper() { FileWriter->ObjectData = SavedInfo; }
45};

47static Error createError(const Twine &Message,
                       std::errc Type = std::errc::invalid_argument) {
return make_error<StringError>(Message, std::make_error_code(Type));
50}

52static Error checkNumberFits(uint32_t Number, size_t MaxBits,
                           const Twine &FieldName) {
assert(1 <= MaxBits && MaxBits <= 32)((1 <= MaxBits && MaxBits <= 32) ? static_cast<
void> (0) : __assert_fail ("1 <= MaxBits && MaxBits <= 32"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 54, __PRETTY_FUNCTION__));
if (!(Number >> MaxBits))
  return Error::success();
return createError(FieldName + " (" + Twine(Number) + ") does not fit in " +
                       Twine(MaxBits) + " bits.",
                   std::errc::value_too_large);
60}

62template <typename FitType>
63static Error checkNumberFits(uint32_t Number, const Twine &FieldName) {
return checkNumberFits(Number, sizeof(FitType) * 8, FieldName);
65}

67// A similar function for signed integers.
68template <typename FitType>
69static Error checkSignedNumberFits(uint32_t Number, const Twine &FieldName,
                                 bool CanBeNegative) {
int32_t SignedNum = Number;
if (SignedNum < std::numeric_limits<FitType>::min() ||
    SignedNum > std::numeric_limits<FitType>::max())
  return createError(FieldName + " (" + Twine(SignedNum) +
                         ") does not fit in " + Twine(sizeof(FitType) * 8) +
                         "-bit signed integer type.",
                     std::errc::value_too_large);

if (!CanBeNegative && SignedNum < 0)
  return createError(FieldName + " (" + Twine(SignedNum) +
                     ") cannot be negative.");

return Error::success();
84}

86static Error checkRCInt(RCInt Number, const Twine &FieldName) {
if (Number.isLong())
  return Error::success();
return checkNumberFits<uint16_t>(Number, FieldName);
90}

92static Error checkIntOrString(IntOrString Value, const Twine &FieldName) {
if (!Value.isInt())
  return Error::success();
return checkNumberFits<uint16_t>(Value.getInt(), FieldName);
96}

98static bool stripQuotes(StringRef &Str, bool &IsLongString) {
if (!Str.contains('"'))
  return false;

// Just take the contents of the string, checking if it's been marked long.
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.")((StripSuccess && "Strings should be enclosed in quotes."
) ? static_cast<void> (0) : __assert_fail ("StripSuccess && \"Strings should be enclosed in quotes.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 109, __PRETTY_FUNCTION__));
return true;
111}

113static UTF16 cp1252ToUnicode(unsigned char C) {
static const UTF16 Map80[] = {
    0x20ac, 0x0081, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
    0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008d, 0x017d, 0x008f,
    0x0090, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
    0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x009d, 0x017e, 0x0178,
};
if (C >= 0x80 && C <= 0x9F)
  return Map80[C - 0x80];
return C;
123}

125// Describes a way to handle '\0' characters when processing the string.
126// rc.exe tool sometimes behaves in a weird way in postprocessing.
127// If the string to be output is equivalent to a C-string (e.g. in MENU
128// titles), string is (predictably) truncated after first 0-byte.
129// When outputting a string table, the behavior is equivalent to appending
130// '\0\0' at the end of the string, and then stripping the string
131// before the first '\0\0' occurrence.
132// Finally, when handling strings in user-defined resources, 0-bytes
133// aren't stripped, nor do they terminate the string.

135enum class NullHandlingMethod {
UserResource,   // Don't terminate string on '\0'.
CutAtNull,      // Terminate string on '\0'.
CutAtDoubleNull // Terminate string on '\0\0'; strip final '\0'.
139};

141// Parses an identifier or string and returns a processed version of it:
142//   * String the string boundary quotes.
143//   * Squash "" to a single ".
144//   * Replace the escape sequences with their processed version.
145// For identifiers, this is no-op.
146static Error processString(StringRef Str, NullHandlingMethod NullHandler,
                         bool &IsLongString, SmallVectorImpl<UTF16> &Result,
                         int CodePage) {
bool IsString = stripQuotes(Str, IsLongString);
SmallVector<UTF16, 128> Chars;

// Convert the input bytes according to the chosen codepage.
if (CodePage == CpUtf8) {
  convertUTF8ToUTF16String(Str, Chars);
} else if (CodePage == CpWin1252) {
  for (char C : Str)
    Chars.push_back(cp1252ToUnicode((unsigned char)C));
} else {
  // For other, unknown codepages, only allow plain ASCII input.
  for (char C : Str) {
    if ((unsigned char)C > 0x7F)
      return createError("Non-ASCII 8-bit codepoint (" + Twine(C) +
                         ") can't be interpreted in the current codepage");
    Chars.push_back((unsigned char)C);
  }
}

if (!IsString) {
  // It's an identifier if it's not a string. Make all characters uppercase.
  for (UTF16 &Ch : Chars) {
    assert(Ch <= 0x7F && "We didn't allow identifiers to be non-ASCII")((Ch <= 0x7F && "We didn't allow identifiers to be non-ASCII"
) ? static_cast<void> (0) : __assert_fail ("Ch <= 0x7F && \"We didn't allow identifiers to be non-ASCII\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 171, __PRETTY_FUNCTION__));
    Ch = toupper(Ch);
  }
  Result.swap(Chars);
  return Error::success();
}
Result.reserve(Chars.size());
size_t Pos = 0;

auto AddRes = [&Result, NullHandler, IsLongString](UTF16 Char) -> Error {
  if (!IsLongString) {
    if (NullHandler == NullHandlingMethod::UserResource) {
      // Narrow strings in user-defined resources are *not* output in
      // UTF-16 format.
      if (Char > 0xFF)
        return createError("Non-8-bit codepoint (" + Twine(Char) +
                           ") can't occur in a user-defined narrow string");
    }
  }

  Result.push_back(Char);
  return Error::success();
};
auto AddEscapedChar = [AddRes, IsLongString, CodePage](UTF16 Char) -> Error {
  if (!IsLongString) {
    // Escaped chars in narrow strings have to be interpreted according to
    // the chosen code page.
    if (Char > 0xFF)
      return createError("Non-8-bit escaped char (" + Twine(Char) +
                         ") can't occur in narrow string");
    if (CodePage == CpUtf8) {
      if (Char >= 0x80)
        return createError("Unable to interpret single byte (" + Twine(Char) +
                           ") as UTF-8");
    } else if (CodePage == CpWin1252) {
      Char = cp1252ToUnicode(Char);
    } else {
      // Unknown/unsupported codepage, only allow ASCII input.
      if (Char > 0x7F)
        return createError("Non-ASCII 8-bit codepoint (" + Twine(Char) +
                           ") can't "
                           "occur in a non-Unicode string");
    }
  }

  return AddRes(Char);
};

while (Pos < Chars.size()) {
  UTF16 CurChar = Chars[Pos];
  ++Pos;

  // Strip double "".
  if (CurChar == '"') {
    if (Pos == Chars.size() || Chars[Pos] != '"')
      return createError("Expected \"\"");
    ++Pos;
    RETURN_IF_ERROR(AddRes('"'))if (auto Err = (AddRes('"'))) return Err;;
    continue;
  }

  if (CurChar == '\\') {
    UTF16 TypeChar = Chars[Pos];
    ++Pos;

    if (TypeChar == 'x' || TypeChar == 'X') {
      // Read a hex number. Max number of characters to read differs between
      // narrow and wide strings.
      UTF16 ReadInt = 0;
      size_t RemainingChars = IsLongString ? 4 : 2;
      // We don't want to read non-ASCII hex digits. std:: functions past
      // 0xFF invoke UB.
      //
      // FIXME: actually, Microsoft version probably doesn't check this
      // condition and uses their Unicode version of 'isxdigit'. However,
      // there are some hex-digit Unicode character outside of ASCII, and
      // some of these are actually accepted by rc.exe, the notable example
      // being fullwidth forms (U+FF10..U+FF19 etc.) These can be written
      // instead of ASCII digits in \x... escape sequence and get accepted.
      // However, the resulting hexcodes seem totally unpredictable.
      // We think it's infeasible to try to reproduce this behavior, nor to
      // put effort in order to detect it.
      while (RemainingChars && Pos < Chars.size() && Chars[Pos] < 0x80) {
        if (!isxdigit(Chars[Pos]))
          break;
        char Digit = tolower(Chars[Pos]);
        ++Pos;

        ReadInt <<= 4;
        if (isdigit(Digit))
          ReadInt |= Digit - '0';
        else
          ReadInt |= Digit - 'a' + 10;

        --RemainingChars;
      }

      RETURN_IF_ERROR(AddEscapedChar(ReadInt))if (auto Err = (AddEscapedChar(ReadInt))) return Err;;
      continue;
    }

    if (TypeChar >= '0' && TypeChar < '8') {
      // Read an octal number. Note that we've already read the first digit.
      UTF16 ReadInt = TypeChar - '0';
      size_t RemainingChars = IsLongString ? 6 : 2;

      while (RemainingChars && Pos < Chars.size() && Chars[Pos] >= '0' &&
             Chars[Pos] < '8') {
        ReadInt <<= 3;
        ReadInt |= Chars[Pos] - '0';
        --RemainingChars;
        ++Pos;
      }

      RETURN_IF_ERROR(AddEscapedChar(ReadInt))if (auto Err = (AddEscapedChar(ReadInt))) return Err;;

      continue;
    }

    switch (TypeChar) {
    case 'A':
    case 'a':
      // Windows '\a' translates into '\b' (Backspace).
      RETURN_IF_ERROR(AddRes('\b'))if (auto Err = (AddRes('\b'))) return Err;;
      break;

    case 'n': // Somehow, RC doesn't recognize '\N' and '\R'.
      RETURN_IF_ERROR(AddRes('\n'))if (auto Err = (AddRes('\n'))) return Err;;
      break;

    case 'r':
      RETURN_IF_ERROR(AddRes('\r'))if (auto Err = (AddRes('\r'))) return Err;;
      break;

    case 'T':
    case 't':
      RETURN_IF_ERROR(AddRes('\t'))if (auto Err = (AddRes('\t'))) return Err;;
      break;

    case '\\':
      RETURN_IF_ERROR(AddRes('\\'))if (auto Err = (AddRes('\\'))) return Err;;
      break;

    case '"':
      // RC accepts \" only if another " comes afterwards; then, \"" means
      // a single ".
      if (Pos == Chars.size() || Chars[Pos] != '"')
        return createError("Expected \\\"\"");
      ++Pos;
      RETURN_IF_ERROR(AddRes('"'))if (auto Err = (AddRes('"'))) return Err;;
      break;

    default:
      // If TypeChar means nothing, \ is should be output to stdout with
      // following char. However, rc.exe consumes these characters when
      // dealing with wide strings.
      if (!IsLongString) {
        RETURN_IF_ERROR(AddRes('\\'))if (auto Err = (AddRes('\\'))) return Err;;
        RETURN_IF_ERROR(AddRes(TypeChar))if (auto Err = (AddRes(TypeChar))) return Err;;
      }
      break;
    }

    continue;
  }

  // If nothing interesting happens, just output the character.
  RETURN_IF_ERROR(AddRes(CurChar))if (auto Err = (AddRes(CurChar))) return Err;;
}

switch (NullHandler) {
case NullHandlingMethod::CutAtNull:
  for (size_t Pos = 0; Pos < Result.size(); ++Pos)
    if (Result[Pos] == '\0')
      Result.resize(Pos);
  break;

case NullHandlingMethod::CutAtDoubleNull:
  for (size_t Pos = 0; Pos + 1 < Result.size(); ++Pos)
    if (Result[Pos] == '\0' && Result[Pos + 1] == '\0')
      Result.resize(Pos);
  if (Result.size() > 0 && Result.back() == '\0')
    Result.pop_back();
  break;

case NullHandlingMethod::UserResource:
  break;
}

return Error::success();
361}

363uint64_t ResourceFileWriter::writeObject(const ArrayRef<uint8_t> Data) {
uint64_t Result = tell();
FS->write((const char *)Data.begin(), Data.size());
return Result;
367}

369Error ResourceFileWriter::writeCString(StringRef Str, bool WriteTerminator) {
SmallVector<UTF16, 128> ProcessedString;
bool IsLongString;
RETURN_IF_ERROR(processString(Str, NullHandlingMethod::CutAtNull,if (auto Err = (processString(Str, NullHandlingMethod::CutAtNull
, IsLongString, ProcessedString, Params.CodePage))) return Err
;
                              IsLongString, ProcessedString,if (auto Err = (processString(Str, NullHandlingMethod::CutAtNull
, IsLongString, ProcessedString, Params.CodePage))) return Err
;
                              Params.CodePage))if (auto Err = (processString(Str, NullHandlingMethod::CutAtNull
, IsLongString, ProcessedString, Params.CodePage))) return Err
;;
for (auto Ch : ProcessedString)
  writeInt<uint16_t>(Ch);
if (WriteTerminator)
  writeInt<uint16_t>(0);
return Error::success();
380}

382Error ResourceFileWriter::writeIdentifier(const IntOrString &Ident) {
return writeIntOrString(Ident);
384}

386Error ResourceFileWriter::writeIntOrString(const IntOrString &Value) {
if (!Value.isInt())
  return writeCString(Value.getString());

writeInt<uint16_t>(0xFFFF);
writeInt<uint16_t>(Value.getInt());
return Error::success();
393}

395void ResourceFileWriter::writeRCInt(RCInt Value) {
if (Value.isLong())
  writeInt<uint32_t>(Value);
else
  writeInt<uint16_t>(Value);
400}

402Error ResourceFileWriter::appendFile(StringRef Filename) {
bool IsLong;
stripQuotes(Filename, IsLong);

auto File = loadFile(Filename);
if (!File)
  return File.takeError();

*FS << (*File)->getBuffer();
return Error::success();
412}

414void ResourceFileWriter::padStream(uint64_t Length) {
assert(Length > 0)((Length > 0) ? static_cast<void> (0) : __assert_fail
 ("Length > 0", "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 415, __PRETTY_FUNCTION__));
uint64_t Location = tell();
Location %= Length;
uint64_t Pad = (Length - Location) % Length;
for (uint64_t i = 0; i < Pad; ++i)
  writeInt<uint8_t>(0);
421}

423Error ResourceFileWriter::handleError(Error Err, const RCResource *Res) {
if (Err)
  return joinErrors(createError("Error in " + Res->getResourceTypeName() +
                                " statement (ID " + Twine(Res->ResName) +
                                "): "),
                    std::move(Err));
return Error::success();
430}

432Error ResourceFileWriter::visitNullResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeNullBody);
434}

436Error ResourceFileWriter::visitAcceleratorsResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeAcceleratorsBody);
438}

440Error ResourceFileWriter::visitBitmapResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeBitmapBody);
442}

444Error ResourceFileWriter::visitCursorResource(const RCResource *Res) {
return handleError(visitIconOrCursorResource(Res), Res);
446}

448Error ResourceFileWriter::visitDialogResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeDialogBody);
450}

452Error ResourceFileWriter::visitIconResource(const RCResource *Res) {
return handleError(visitIconOrCursorResource(Res), Res);
1
Calling 'ResourceFileWriter::visitIconOrCursorResource'→
454}

456Error ResourceFileWriter::visitCaptionStmt(const CaptionStmt *Stmt) {
ObjectData.Caption = Stmt->Value;
return Error::success();
459}

461Error ResourceFileWriter::visitClassStmt(const ClassStmt *Stmt) {
ObjectData.Class = Stmt->Value;
return Error::success();
464}

466Error ResourceFileWriter::visitHTMLResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeHTMLBody);
468}

470Error ResourceFileWriter::visitMenuResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeMenuBody);
472}

474Error ResourceFileWriter::visitStringTableResource(const RCResource *Base) {
const auto *Res = cast<StringTableResource>(Base);

ContextKeeper RAII(this);
RETURN_IF_ERROR(Res->applyStmts(this))if (auto Err = (Res->applyStmts(this))) return Err;;

for (auto &String : Res->Table) {
  RETURN_IF_ERROR(checkNumberFits<uint16_t>(String.first, "String ID"))if (auto Err = (checkNumberFits<uint16_t>(String.first,
 "String ID"))) return Err;;
  uint16_t BundleID = String.first >> 4;
  StringTableInfo::BundleKey Key(BundleID, ObjectData.LanguageInfo);
  auto &BundleData = StringTableData.BundleData;
  auto Iter = BundleData.find(Key);

  if (Iter == BundleData.end()) {
    // Need to create a bundle.
    StringTableData.BundleList.push_back(Key);
    auto EmplaceResult = BundleData.emplace(
        Key, StringTableInfo::Bundle(ObjectData, Res->MemoryFlags));
    assert(EmplaceResult.second && "Could not create a bundle")((EmplaceResult.second && "Could not create a bundle"
) ? static_cast<void> (0) : __assert_fail ("EmplaceResult.second && \"Could not create a bundle\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 492, __PRETTY_FUNCTION__));
    Iter = EmplaceResult.first;
  }

  RETURN_IF_ERROR(if (auto Err = (insertStringIntoBundle(Iter->second, String
.first, String.second))) return Err;
      insertStringIntoBundle(Iter->second, String.first, String.second))if (auto Err = (insertStringIntoBundle(Iter->second, String
.first, String.second))) return Err;;
}

return Error::success();
501}

503Error ResourceFileWriter::visitUserDefinedResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeUserDefinedBody);
505}

507Error ResourceFileWriter::visitVersionInfoResource(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeVersionInfoBody);
509}

511Error ResourceFileWriter::visitCharacteristicsStmt(
  const CharacteristicsStmt *Stmt) {
ObjectData.Characteristics = Stmt->Value;
return Error::success();
515}

517Error ResourceFileWriter::visitFontStmt(const FontStmt *Stmt) {
RETURN_IF_ERROR(checkNumberFits<uint16_t>(Stmt->Size, "Font size"))if (auto Err = (checkNumberFits<uint16_t>(Stmt->Size
, "Font size"))) return Err;;
RETURN_IF_ERROR(checkNumberFits<uint16_t>(Stmt->Weight, "Font weight"))if (auto Err = (checkNumberFits<uint16_t>(Stmt->Weight
, "Font weight"))) return Err;;
RETURN_IF_ERROR(checkNumberFits<uint8_t>(Stmt->Charset, "Font charset"))if (auto Err = (checkNumberFits<uint8_t>(Stmt->Charset
, "Font charset"))) return Err;;
ObjectInfo::FontInfo Font{Stmt->Size, Stmt->Name, Stmt->Weight, Stmt->Italic,
                          Stmt->Charset};
ObjectData.Font.emplace(Font);
return Error::success();
525}

527Error ResourceFileWriter::visitLanguageStmt(const LanguageResource *Stmt) {
RETURN_IF_ERROR(checkNumberFits(Stmt->Lang, 10, "Primary language ID"))if (auto Err = (checkNumberFits(Stmt->Lang, 10, "Primary language ID"
))) return Err;;
RETURN_IF_ERROR(checkNumberFits(Stmt->SubLang, 6, "Sublanguage ID"))if (auto Err = (checkNumberFits(Stmt->SubLang, 6, "Sublanguage ID"
))) return Err;;
ObjectData.LanguageInfo = Stmt->Lang | (Stmt->SubLang << 10);
return Error::success();
532}

534Error ResourceFileWriter::visitStyleStmt(const StyleStmt *Stmt) {
ObjectData.Style = Stmt->Value;
return Error::success();
537}

539Error ResourceFileWriter::visitVersionStmt(const VersionStmt *Stmt) {
ObjectData.VersionInfo = Stmt->Value;
return Error::success();
542}

544Error ResourceFileWriter::writeResource(
  const RCResource *Res,
  Error (ResourceFileWriter::*BodyWriter)(const RCResource *)) {
// We don't know the sizes yet.
object::WinResHeaderPrefix HeaderPrefix{ulittle32_t(0U), ulittle32_t(0U)};
uint64_t HeaderLoc = writeObject(HeaderPrefix);

auto ResType = Res->getResourceType();
RETURN_IF_ERROR(checkIntOrString(ResType, "Resource type"))if (auto Err = (checkIntOrString(ResType, "Resource type"))) return
 Err;;
RETURN_IF_ERROR(checkIntOrString(Res->ResName, "Resource ID"))if (auto Err = (checkIntOrString(Res->ResName, "Resource ID"
))) return Err;;
RETURN_IF_ERROR(handleError(writeIdentifier(ResType), Res))if (auto Err = (handleError(writeIdentifier(ResType), Res))) return
 Err;;
RETURN_IF_ERROR(handleError(writeIdentifier(Res->ResName), Res))if (auto Err = (handleError(writeIdentifier(Res->ResName),
 Res))) return Err;;

// Apply the resource-local optional statements.
ContextKeeper RAII(this);
RETURN_IF_ERROR(handleError(Res->applyStmts(this), Res))if (auto Err = (handleError(Res->applyStmts(this), Res))) return
 Err;;

padStream(sizeof(uint32_t));
object::WinResHeaderSuffix HeaderSuffix{
    ulittle32_t(0), // DataVersion; seems to always be 0
    ulittle16_t(Res->MemoryFlags), ulittle16_t(ObjectData.LanguageInfo),
    ulittle32_t(ObjectData.VersionInfo),
    ulittle32_t(ObjectData.Characteristics)};
writeObject(HeaderSuffix);

uint64_t DataLoc = tell();
RETURN_IF_ERROR(handleError((this->*BodyWriter)(Res), Res))if (auto Err = (handleError((this->*BodyWriter)(Res), Res)
)) return Err;;
// RETURN_IF_ERROR(handleError(dumpResource(Ctx)));

// Update the sizes.
HeaderPrefix.DataSize = tell() - DataLoc;
HeaderPrefix.HeaderSize = DataLoc - HeaderLoc;
writeObjectAt(HeaderPrefix, HeaderLoc);
padStream(sizeof(uint32_t));

return Error::success();
580}

582// --- NullResource helpers. --- //

584Error ResourceFileWriter::writeNullBody(const RCResource *) {
return Error::success();
586}

588// --- AcceleratorsResource helpers. --- //

590Error ResourceFileWriter::writeSingleAccelerator(
  const AcceleratorsResource::Accelerator &Obj, bool IsLastItem) {
using Accelerator = AcceleratorsResource::Accelerator;
using Opt = Accelerator::Options;

struct AccelTableEntry {
  ulittle16_t Flags;
  ulittle16_t ANSICode;
  ulittle16_t Id;
  uint16_t Padding;
} Entry{ulittle16_t(0), ulittle16_t(0), ulittle16_t(0), 0};

bool IsASCII = Obj.Flags & Opt::ASCII, IsVirtKey = Obj.Flags & Opt::VIRTKEY;

// Remove ASCII flags (which doesn't occur in .res files).
Entry.Flags = Obj.Flags & ~Opt::ASCII;

if (IsLastItem)
  Entry.Flags |= 0x80;

RETURN_IF_ERROR(checkNumberFits<uint16_t>(Obj.Id, "ACCELERATORS entry ID"))if (auto Err = (checkNumberFits<uint16_t>(Obj.Id, "ACCELERATORS entry ID"
))) return Err;;
Entry.Id = ulittle16_t(Obj.Id);

auto createAccError = [&Obj](const char *Msg) {
  return createError("Accelerator ID " + Twine(Obj.Id) + ": " + Msg);
};

if (IsASCII && IsVirtKey)
  return createAccError("Accelerator can't be both ASCII and VIRTKEY");

if (!IsVirtKey && (Obj.Flags & (Opt::ALT | Opt::SHIFT | Opt::CONTROL)))
  return createAccError("Can only apply ALT, SHIFT or CONTROL to VIRTKEY"
                        " accelerators");

if (Obj.Event.isInt()) {
  if (!IsASCII && !IsVirtKey)
    return createAccError(
        "Accelerator with a numeric event must be either ASCII"
        " or VIRTKEY");

  uint32_t EventVal = Obj.Event.getInt();
  RETURN_IF_ERROR(if (auto Err = (checkNumberFits<uint16_t>(EventVal, "Numeric event key ID"
))) return Err;
      checkNumberFits<uint16_t>(EventVal, "Numeric event key ID"))if (auto Err = (checkNumberFits<uint16_t>(EventVal, "Numeric event key ID"
))) return Err;;
  Entry.ANSICode = ulittle16_t(EventVal);
  writeObject(Entry);
  return Error::success();
}

StringRef Str = Obj.Event.getString();
bool IsWide;
stripQuotes(Str, IsWide);

if (Str.size() == 0 || Str.size() > 2)
  return createAccError(
      "Accelerator string events should have length 1 or 2");

if (Str[0] == '^') {
  if (Str.size() == 1)
    return createAccError("No character following '^' in accelerator event");
  if (IsVirtKey)
    return createAccError(
        "VIRTKEY accelerator events can't be preceded by '^'");

  char Ch = Str[1];
  if (Ch >= 'a' && Ch <= 'z')
    Entry.ANSICode = ulittle16_t(Ch - 'a' + 1);
  else if (Ch >= 'A' && Ch <= 'Z')
    Entry.ANSICode = ulittle16_t(Ch - 'A' + 1);
  else
    return createAccError("Control character accelerator event should be"
                          " alphabetic");

  writeObject(Entry);
  return Error::success();
}

if (Str.size() == 2)
  return createAccError("Event string should be one-character, possibly"
                        " preceded by '^'");

uint8_t EventCh = Str[0];
// The original tool just warns in this situation. We chose to fail.
if (IsVirtKey && !isalnum(EventCh))
  return createAccError("Non-alphanumeric characters cannot describe virtual"
                        " keys");
if (EventCh > 0x7F)
  return createAccError("Non-ASCII description of accelerator");

if (IsVirtKey)
  EventCh = toupper(EventCh);
Entry.ANSICode = ulittle16_t(EventCh);
writeObject(Entry);
return Error::success();
683}

685Error ResourceFileWriter::writeAcceleratorsBody(const RCResource *Base) {
auto *Res = cast<AcceleratorsResource>(Base);
size_t AcceleratorId = 0;
for (auto &Acc : Res->Accelerators) {
  ++AcceleratorId;
  RETURN_IF_ERROR(if (auto Err = (writeSingleAccelerator(Acc, AcceleratorId == Res
->Accelerators.size()))) return Err;
      writeSingleAccelerator(Acc, AcceleratorId == Res->Accelerators.size()))if (auto Err = (writeSingleAccelerator(Acc, AcceleratorId == Res
->Accelerators.size()))) return Err;;
}
return Error::success();
694}

696// --- BitmapResource helpers. --- //

698Error ResourceFileWriter::writeBitmapBody(const RCResource *Base) {
StringRef Filename = cast<BitmapResource>(Base)->BitmapLoc;
bool IsLong;
stripQuotes(Filename, IsLong);

auto File = loadFile(Filename);
if (!File)
  return File.takeError();

StringRef Buffer = (*File)->getBuffer();

// Skip the 14 byte BITMAPFILEHEADER.
constexpr size_t BITMAPFILEHEADER_size = 14;
if (Buffer.size() < BITMAPFILEHEADER_size || Buffer[0] != 'B' ||
    Buffer[1] != 'M')
  return createError("Incorrect bitmap file.");

*FS << Buffer.substr(BITMAPFILEHEADER_size);
return Error::success();
717}

719// --- CursorResource and IconResource helpers. --- //

721// ICONRESDIR structure. Describes a single icon in resouce group.
722//
723// Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648016.aspx
724struct IconResDir {
uint8_t Width;
uint8_t Height;
uint8_t ColorCount;
uint8_t Reserved;
729};

731// CURSORDIR structure. Describes a single cursor in resource group.
732//
733// Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648011(v=vs.85).aspx
734struct CursorDir {
ulittle16_t Width;
ulittle16_t Height;
737};

739// RESDIRENTRY structure, stripped from the last item. Stripping made
740// for compatibility with RESDIR.
741//
742// Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648026(v=vs.85).aspx
743struct ResourceDirEntryStart {
union {
  CursorDir Cursor; // Used in CURSOR resources.
  IconResDir Icon;  // Used in .ico and .cur files, and ICON resources.
};
ulittle16_t Planes;   // HotspotX (.cur files but not CURSOR resource).
ulittle16_t BitCount; // HotspotY (.cur files but not CURSOR resource).
ulittle32_t Size;
// ulittle32_t ImageOffset;  // Offset to image data (ICONDIRENTRY only).
// ulittle16_t IconID;       // Resource icon ID (RESDIR only).
753};

755// BITMAPINFOHEADER structure. Describes basic information about the bitmap
756// being read.
757//
758// Ref: msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
759struct BitmapInfoHeader {
ulittle32_t Size;
ulittle32_t Width;
ulittle32_t Height;
ulittle16_t Planes;
ulittle16_t BitCount;
ulittle32_t Compression;
ulittle32_t SizeImage;
ulittle32_t XPelsPerMeter;
ulittle32_t YPelsPerMeter;
ulittle32_t ClrUsed;
ulittle32_t ClrImportant;
771};

773// Group icon directory header. Called ICONDIR in .ico/.cur files and
774// NEWHEADER in .res files.
775//
776// Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648023(v=vs.85).aspx
777struct GroupIconDir {
ulittle16_t Reserved; // Always 0.
ulittle16_t ResType;  // 1 for icons, 2 for cursors.
ulittle16_t ResCount; // Number of items.
781};

783enum class IconCursorGroupType { Icon, Cursor };

785class SingleIconCursorResource : public RCResource {
786public:
IconCursorGroupType Type;
const ResourceDirEntryStart &Header;
ArrayRef<uint8_t> Image;

SingleIconCursorResource(IconCursorGroupType ResourceType,
                         const ResourceDirEntryStart &HeaderEntry,
                         ArrayRef<uint8_t> ImageData, uint16_t Flags)
    : RCResource(Flags), Type(ResourceType), Header(HeaderEntry),
      Image(ImageData) {}

Twine getResourceTypeName() const override { return "Icon/cursor image"; }
IntOrString getResourceType() const override {
  return Type == IconCursorGroupType::Icon ? RkSingleIcon : RkSingleCursor;
}
ResourceKind getKind() const override { return RkSingleCursorOrIconRes; }
static bool classof(const RCResource *Res) {
  return Res->getKind() == RkSingleCursorOrIconRes;
}
805};

807class IconCursorGroupResource : public RCResource {
808public:
IconCursorGroupType Type;
GroupIconDir Header;
std::vector<ResourceDirEntryStart> ItemEntries;

IconCursorGroupResource(IconCursorGroupType ResourceType,
                        const GroupIconDir &HeaderData,
                        std::vector<ResourceDirEntryStart> &&Entries)
    : Type(ResourceType), Header(HeaderData),
      ItemEntries(std::move(Entries)) {}

Twine getResourceTypeName() const override { return "Icon/cursor group"; }
IntOrString getResourceType() const override {
  return Type == IconCursorGroupType::Icon ? RkIconGroup : RkCursorGroup;
}
ResourceKind getKind() const override { return RkCursorOrIconGroupRes; }
static bool classof(const RCResource *Res) {
  return Res->getKind() == RkCursorOrIconGroupRes;
}
827};

829Error ResourceFileWriter::writeSingleIconOrCursorBody(const RCResource *Base) {
auto *Res = cast<SingleIconCursorResource>(Base);
if (Res->Type == IconCursorGroupType::Cursor) {
  // In case of cursors, two WORDS are appended to the beginning
  // of the resource: HotspotX (Planes in RESDIRENTRY),
  // and HotspotY (BitCount).
  //
  // Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648026.aspx
  //  (Remarks section).
  writeObject(Res->Header.Planes);
  writeObject(Res->Header.BitCount);
}

writeObject(Res->Image);
return Error::success();
844}

846Error ResourceFileWriter::writeIconOrCursorGroupBody(const RCResource *Base) {
auto *Res = cast<IconCursorGroupResource>(Base);
writeObject(Res->Header);
for (auto Item : Res->ItemEntries) {
  writeObject(Item);
  writeInt(IconCursorID++);
}
return Error::success();
854}

856Error ResourceFileWriter::visitSingleIconOrCursor(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeSingleIconOrCursorBody);
858}

860Error ResourceFileWriter::visitIconOrCursorGroup(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeIconOrCursorGroupBody);
862}

864Error ResourceFileWriter::visitIconOrCursorResource(const RCResource *Base) {
IconCursorGroupType Type;
StringRef FileStr;
IntOrString ResName = Base->ResName;

if (auto *IconRes = dyn_cast<IconResource>(Base)) {
2
←
Taking true branch→
  FileStr = IconRes->IconLoc;
  Type = IconCursorGroupType::Icon;
} else {
  auto *CursorRes = dyn_cast<CursorResource>(Base);
  FileStr = CursorRes->CursorLoc;
  Type = IconCursorGroupType::Cursor;
}

bool IsLong;
stripQuotes(FileStr, IsLong);
auto File = loadFile(FileStr);

if (!File)
3
←
Taking false branch→
  return File.takeError();

BinaryStreamReader Reader((*File)->getBuffer(), support::little);

// Read the file headers.
//   - At the beginning, ICONDIR/NEWHEADER header.
//   - Then, a number of RESDIR headers follow. These contain offsets
//       to data.
const GroupIconDir *Header;
4
←
'Header' declared without an initial value→

RETURN_IF_ERROR(Reader.readObject(Header))if (auto Err = (Reader.readObject(Header))) return Err;;
5
←
Within the expansion of the macro 'RETURN_IF_ERROR':
→
a
Calling 'BinaryStreamReader::readObject'
b
Returning from 'BinaryStreamReader::readObject'
if (Header->Reserved != 0)
8
←
Called C++ object pointer is uninitialized
  return createError("Incorrect icon/cursor Reserved field; should be 0.");
uint16_t NeededType = Type == IconCursorGroupType::Icon ? 1 : 2;
if (Header->ResType != NeededType)
  return createError("Incorrect icon/cursor ResType field; should be " +
                     Twine(NeededType) + ".");

uint16_t NumItems = Header->ResCount;

// Read single ico/cur headers.
std::vector<ResourceDirEntryStart> ItemEntries;
ItemEntries.reserve(NumItems);
std::vector<uint32_t> ItemOffsets(NumItems);
for (size_t ID = 0; ID < NumItems; ++ID) {
  const ResourceDirEntryStart *Object;
  RETURN_IF_ERROR(Reader.readObject(Object))if (auto Err = (Reader.readObject(Object))) return Err;;
  ItemEntries.push_back(*Object);
  RETURN_IF_ERROR(Reader.readInteger(ItemOffsets[ID]))if (auto Err = (Reader.readInteger(ItemOffsets[ID]))) return Err
;;
}

// Now write each icon/cursors one by one. At first, all the contents
// without ICO/CUR header. This is described by SingleIconCursorResource.
for (size_t ID = 0; ID < NumItems; ++ID) {
  // Load the fragment of file.
  Reader.setOffset(ItemOffsets[ID]);
  ArrayRef<uint8_t> Image;
  RETURN_IF_ERROR(Reader.readArray(Image, ItemEntries[ID].Size))if (auto Err = (Reader.readArray(Image, ItemEntries[ID].Size)
)) return Err;;
  SingleIconCursorResource SingleRes(Type, ItemEntries[ID], Image,
                                     Base->MemoryFlags);
  SingleRes.setName(IconCursorID + ID);
  RETURN_IF_ERROR(visitSingleIconOrCursor(&SingleRes))if (auto Err = (visitSingleIconOrCursor(&SingleRes))) return
 Err;;
}

// Now, write all the headers concatenated into a separate resource.
for (size_t ID = 0; ID < NumItems; ++ID) {
  // We need to rewrite the cursor headers, and fetch actual values
  // for Planes/BitCount.
  const auto &OldHeader = ItemEntries[ID];
  ResourceDirEntryStart NewHeader = OldHeader;

  if (Type == IconCursorGroupType::Cursor) {
    NewHeader.Cursor.Width = OldHeader.Icon.Width;
    // Each cursor in fact stores two bitmaps, one under another.
    // Height provided in cursor definition describes the height of the
    // cursor, whereas the value existing in resource definition describes
    // the height of the bitmap. Therefore, we need to double this height.
    NewHeader.Cursor.Height = OldHeader.Icon.Height * 2;

    // Two WORDs were written at the beginning of the resource (hotspot
    // location). This is reflected in Size field.
    NewHeader.Size += 2 * sizeof(uint16_t);
  }

  // Now, we actually need to read the bitmap header to find
  // the number of planes and the number of bits per pixel.
  Reader.setOffset(ItemOffsets[ID]);
  const BitmapInfoHeader *BMPHeader;
  RETURN_IF_ERROR(Reader.readObject(BMPHeader))if (auto Err = (Reader.readObject(BMPHeader))) return Err;;
  if (BMPHeader->Size == sizeof(BitmapInfoHeader)) {
    NewHeader.Planes = BMPHeader->Planes;
    NewHeader.BitCount = BMPHeader->BitCount;
  } else {
    // A PNG .ico file.
    // https://blogs.msdn.microsoft.com/oldnewthing/20101022-00/?p=12473
    // "The image must be in 32bpp"
    NewHeader.Planes = 1;
    NewHeader.BitCount = 32;
  }

  ItemEntries[ID] = NewHeader;
}

IconCursorGroupResource HeaderRes(Type, *Header, std::move(ItemEntries));
HeaderRes.setName(ResName);
if (Base->MemoryFlags & MfPreload) {
  HeaderRes.MemoryFlags |= MfPreload;
  HeaderRes.MemoryFlags &= ~MfPure;
}
RETURN_IF_ERROR(visitIconOrCursorGroup(&HeaderRes))if (auto Err = (visitIconOrCursorGroup(&HeaderRes))) return
 Err;;

return Error::success();
975}

977// --- DialogResource helpers. --- //

979Error ResourceFileWriter::writeSingleDialogControl(const Control &Ctl,
                                                 bool IsExtended) {
// Each control should be aligned to DWORD.
padStream(sizeof(uint32_t));

auto TypeInfo = Control::SupportedCtls.lookup(Ctl.Type);
uint32_t CtlStyle = TypeInfo.Style | Ctl.Style.getValueOr(0);
uint32_t CtlExtStyle = Ctl.ExtStyle.getValueOr(0);

// DIALOG(EX) item header prefix.
if (!IsExtended) {
  struct {
    ulittle32_t Style;
    ulittle32_t ExtStyle;
  } Prefix{ulittle32_t(CtlStyle), ulittle32_t(CtlExtStyle)};
  writeObject(Prefix);
} else {
  struct {
    ulittle32_t HelpID;
    ulittle32_t ExtStyle;
    ulittle32_t Style;
  } Prefix{ulittle32_t(Ctl.HelpID.getValueOr(0)), ulittle32_t(CtlExtStyle),
           ulittle32_t(CtlStyle)};
  writeObject(Prefix);
}

// Common fixed-length part.
RETURN_IF_ERROR(checkSignedNumberFits<int16_t>(if (auto Err = (checkSignedNumberFits<int16_t>( Ctl.X, "Dialog control x-coordinate"
, true))) return Err;
    Ctl.X, "Dialog control x-coordinate", true))if (auto Err = (checkSignedNumberFits<int16_t>( Ctl.X, "Dialog control x-coordinate"
, true))) return Err;;
RETURN_IF_ERROR(checkSignedNumberFits<int16_t>(if (auto Err = (checkSignedNumberFits<int16_t>( Ctl.Y, "Dialog control y-coordinate"
, true))) return Err;
    Ctl.Y, "Dialog control y-coordinate", true))if (auto Err = (checkSignedNumberFits<int16_t>( Ctl.Y, "Dialog control y-coordinate"
, true))) return Err;;
RETURN_IF_ERROR(if (auto Err = (checkSignedNumberFits<int16_t>(Ctl.Width
, "Dialog control width", false))) return Err;
    checkSignedNumberFits<int16_t>(Ctl.Width, "Dialog control width", false))if (auto Err = (checkSignedNumberFits<int16_t>(Ctl.Width
, "Dialog control width", false))) return Err;;
RETURN_IF_ERROR(checkSignedNumberFits<int16_t>(if (auto Err = (checkSignedNumberFits<int16_t>( Ctl.Height
, "Dialog control height", false))) return Err;
    Ctl.Height, "Dialog control height", false))if (auto Err = (checkSignedNumberFits<int16_t>( Ctl.Height
, "Dialog control height", false))) return Err;;
struct {
  ulittle16_t X;
  ulittle16_t Y;
  ulittle16_t Width;
  ulittle16_t Height;
} Middle{ulittle16_t(Ctl.X), ulittle16_t(Ctl.Y), ulittle16_t(Ctl.Width),
         ulittle16_t(Ctl.Height)};
writeObject(Middle);

// ID; it's 16-bit in DIALOG and 32-bit in DIALOGEX.
if (!IsExtended) {
  // It's common to use -1, i.e. UINT32_MAX, for controls one doesn't
  // want to refer to later.
  if (Ctl.ID != static_cast<uint32_t>(-1))
    RETURN_IF_ERROR(checkNumberFits<uint16_t>(if (auto Err = (checkNumberFits<uint16_t>( Ctl.ID, "Control ID in simple DIALOG resource"
))) return Err;
        Ctl.ID, "Control ID in simple DIALOG resource"))if (auto Err = (checkNumberFits<uint16_t>( Ctl.ID, "Control ID in simple DIALOG resource"
))) return Err;;
  writeInt<uint16_t>(Ctl.ID);
} else {
  writeInt<uint32_t>(Ctl.ID);
}

// Window class - either 0xFFFF + 16-bit integer or a string.
RETURN_IF_ERROR(writeIntOrString(Ctl.Class))if (auto Err = (writeIntOrString(Ctl.Class))) return Err;;

// Element caption/reference ID. ID is preceded by 0xFFFF.
RETURN_IF_ERROR(checkIntOrString(Ctl.Title, "Control reference ID"))if (auto Err = (checkIntOrString(Ctl.Title, "Control reference ID"
))) return Err;;
RETURN_IF_ERROR(writeIntOrString(Ctl.Title))if (auto Err = (writeIntOrString(Ctl.Title))) return Err;;

// # bytes of extra creation data count. Don't pass any.
writeInt<uint16_t>(0);

return Error::success();
1046}

1048Error ResourceFileWriter::writeDialogBody(const RCResource *Base) {
auto *Res = cast<DialogResource>(Base);

// Default style: WS_POPUP | WS_BORDER | WS_SYSMENU.
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 {
  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)};

  writeObject(Prefix);
}

// Now, a common part. First, fixed-length fields.
RETURN_IF_ERROR(checkNumberFits<uint16_t>(Res->Controls.size(),if (auto Err = (checkNumberFits<uint16_t>(Res->Controls
.size(), "Number of dialog controls"))) return Err;
                                          "Number of dialog controls"))if (auto Err = (checkNumberFits<uint16_t>(Res->Controls
.size(), "Number of dialog controls"))) return Err;;
RETURN_IF_ERROR(if (auto Err = (checkSignedNumberFits<int16_t>(Res->
X, "Dialog x-coordinate", true))) return Err;
    checkSignedNumberFits<int16_t>(Res->X, "Dialog x-coordinate", true))if (auto Err = (checkSignedNumberFits<int16_t>(Res->
X, "Dialog x-coordinate", true))) return Err;;
RETURN_IF_ERROR(if (auto Err = (checkSignedNumberFits<int16_t>(Res->
Y, "Dialog y-coordinate", true))) return Err;
    checkSignedNumberFits<int16_t>(Res->Y, "Dialog y-coordinate", true))if (auto Err = (checkSignedNumberFits<int16_t>(Res->
Y, "Dialog y-coordinate", true))) return Err;;
RETURN_IF_ERROR(if (auto Err = (checkSignedNumberFits<int16_t>(Res->
Width, "Dialog width", false))) return Err;
    checkSignedNumberFits<int16_t>(Res->Width, "Dialog width", false))if (auto Err = (checkSignedNumberFits<int16_t>(Res->
Width, "Dialog width", false))) return Err;;
RETURN_IF_ERROR(if (auto Err = (checkSignedNumberFits<int16_t>(Res->
Height, "Dialog height", false))) return Err;
    checkSignedNumberFits<int16_t>(Res->Height, "Dialog height", false))if (auto Err = (checkSignedNumberFits<int16_t>(Res->
Height, "Dialog height", false))) return Err;;
struct {
  ulittle16_t Count;
  ulittle16_t PosX;
  ulittle16_t PosY;
  ulittle16_t DialogWidth;
  ulittle16_t DialogHeight;
} Middle{ulittle16_t(Res->Controls.size()), ulittle16_t(Res->X),
         ulittle16_t(Res->Y), ulittle16_t(Res->Width),
         ulittle16_t(Res->Height)};
writeObject(Middle);

// 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.
writeInt<uint16_t>(0);

// Window CLASS field.
RETURN_IF_ERROR(writeIntOrString(ObjectData.Class))if (auto Err = (writeIntOrString(ObjectData.Class))) return Err
;;

// Window title or a single word equal to 0.
RETURN_IF_ERROR(writeCString(ObjectData.Caption))if (auto Err = (writeCString(ObjectData.Caption))) return Err
;;

// If there *is* a window font declared, output its data.
auto &Font = ObjectData.Font;
if (Font) {
  writeInt<uint16_t>(Font->Size);
  // Additional description occurs only in DIALOGEX.
  if (Res->IsExtended) {
    writeInt<uint16_t>(Font->Weight);
    writeInt<uint8_t>(Font->IsItalic);
    writeInt<uint8_t>(Font->Charset);
  }
  RETURN_IF_ERROR(writeCString(Font->Typeface))if (auto Err = (writeCString(Font->Typeface))) return Err;;
}

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));
};

for (auto &Ctl : Res->Controls)
  RETURN_IF_ERROR(if (auto Err = (handleCtlError(writeSingleDialogControl(Ctl, Res
->IsExtended), Ctl))) return Err;
      handleCtlError(writeSingleDialogControl(Ctl, Res->IsExtended), Ctl))if (auto Err = (handleCtlError(writeSingleDialogControl(Ctl, Res
->IsExtended), Ctl))) return Err;;

return Error::success();
1160}

1162// --- HTMLResource helpers. --- //

1164Error ResourceFileWriter::writeHTMLBody(const RCResource *Base) {
return appendFile(cast<HTMLResource>(Base)->HTMLLoc);
1166}

1168// --- MenuResource helpers. --- //

1170Error ResourceFileWriter::writeMenuDefinition(
  const std::unique_ptr<MenuDefinition> &Def, uint16_t Flags) {
assert(Def)((Def) ? static_cast<void> (0) : __assert_fail ("Def", "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 1172, __PRETTY_FUNCTION__));
const MenuDefinition *DefPtr = Def.get();

if (auto *MenuItemPtr = dyn_cast<MenuItem>(DefPtr)) {
  writeInt<uint16_t>(Flags);
  RETURN_IF_ERROR(if (auto Err = (checkNumberFits<uint16_t>(MenuItemPtr->
Id, "MENUITEM action ID"))) return Err;
      checkNumberFits<uint16_t>(MenuItemPtr->Id, "MENUITEM action ID"))if (auto Err = (checkNumberFits<uint16_t>(MenuItemPtr->
Id, "MENUITEM action ID"))) return Err;;
  writeInt<uint16_t>(MenuItemPtr->Id);
  RETURN_IF_ERROR(writeCString(MenuItemPtr->Name))if (auto Err = (writeCString(MenuItemPtr->Name))) return Err
;;
  return Error::success();
}

if (isa<MenuSeparator>(DefPtr)) {
  writeInt<uint16_t>(Flags);
  writeInt<uint32_t>(0);
  return Error::success();
}

auto *PopupPtr = cast<PopupItem>(DefPtr);
writeInt<uint16_t>(Flags);
RETURN_IF_ERROR(writeCString(PopupPtr->Name))if (auto Err = (writeCString(PopupPtr->Name))) return Err;;
return writeMenuDefinitionList(PopupPtr->SubItems);
1194}

1196Error ResourceFileWriter::writeMenuDefinitionList(
  const MenuDefinitionList &List) {
for (auto &Def : List.Definitions) {
  uint16_t Flags = Def->getResFlags();
  // Last element receives an additional 0x80 flag.
  const uint16_t LastElementFlag = 0x0080;
  if (&Def == &List.Definitions.back())
    Flags |= LastElementFlag;

  RETURN_IF_ERROR(writeMenuDefinition(Def, Flags))if (auto Err = (writeMenuDefinition(Def, Flags))) return Err;;
}
return Error::success();
1208}

1210Error ResourceFileWriter::writeMenuBody(const RCResource *Base) {
// At first, MENUHEADER structure. In fact, these are two WORDs equal to 0.
// Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms648018.aspx
writeInt<uint32_t>(0);

return writeMenuDefinitionList(cast<MenuResource>(Base)->Elements);
1216}

1218// --- StringTableResource helpers. --- //

1220class BundleResource : public RCResource {
1221public:
using BundleType = ResourceFileWriter::StringTableInfo::Bundle;
BundleType Bundle;

BundleResource(const BundleType &StrBundle)
    : RCResource(StrBundle.MemoryFlags), Bundle(StrBundle) {}
IntOrString getResourceType() const override { return 6; }

ResourceKind getKind() const override { return RkStringTableBundle; }
static bool classof(const RCResource *Res) {
  return Res->getKind() == RkStringTableBundle;
}
Twine getResourceTypeName() const override { return "STRINGTABLE"; }
1234};

1236Error ResourceFileWriter::visitStringTableBundle(const RCResource *Res) {
return writeResource(Res, &ResourceFileWriter::writeStringTableBundleBody);
1238}

1240Error ResourceFileWriter::insertStringIntoBundle(
  StringTableInfo::Bundle &Bundle, uint16_t StringID, StringRef String) {
uint16_t StringLoc = StringID & 15;
if (Bundle.Data[StringLoc])
  return createError("Multiple STRINGTABLE strings located under ID " +
                     Twine(StringID));
Bundle.Data[StringLoc] = String;
return Error::success();
1248}

1250Error ResourceFileWriter::writeStringTableBundleBody(const RCResource *Base) {
auto *Res = cast<BundleResource>(Base);
for (size_t ID = 0; ID < Res->Bundle.Data.size(); ++ID) {
  // The string format is a tiny bit different here. We
  // first output the size of the string, and then the string itself
  // (which is not null-terminated).
  bool IsLongString;
  SmallVector<UTF16, 128> Data;
  RETURN_IF_ERROR(processString(Res->Bundle.Data[ID].getValueOr(StringRef()),if (auto Err = (processString(Res->Bundle.Data[ID].getValueOr
(StringRef()), NullHandlingMethod::CutAtDoubleNull, IsLongString
, Data, Params.CodePage))) return Err;
                                NullHandlingMethod::CutAtDoubleNull,if (auto Err = (processString(Res->Bundle.Data[ID].getValueOr
(StringRef()), NullHandlingMethod::CutAtDoubleNull, IsLongString
, Data, Params.CodePage))) return Err;
                                IsLongString, Data, Params.CodePage))if (auto Err = (processString(Res->Bundle.Data[ID].getValueOr
(StringRef()), NullHandlingMethod::CutAtDoubleNull, IsLongString
, Data, Params.CodePage))) return Err;;
  if (AppendNull && Res->Bundle.Data[ID])
    Data.push_back('\0');
  RETURN_IF_ERROR(if (auto Err = (checkNumberFits<uint16_t>(Data.size(), "STRINGTABLE string size"
))) return Err;
      checkNumberFits<uint16_t>(Data.size(), "STRINGTABLE string size"))if (auto Err = (checkNumberFits<uint16_t>(Data.size(), "STRINGTABLE string size"
))) return Err;;
  writeInt<uint16_t>(Data.size());
  for (auto Char : Data)
    writeInt(Char);
}
return Error::success();
1270}

1272Error ResourceFileWriter::dumpAllStringTables() {
for (auto Key : StringTableData.BundleList) {
  auto Iter = StringTableData.BundleData.find(Key);
  assert(Iter != StringTableData.BundleData.end())((Iter != StringTableData.BundleData.end()) ? static_cast<
void> (0) : __assert_fail ("Iter != StringTableData.BundleData.end()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 1275, __PRETTY_FUNCTION__));

  // For a moment, revert the context info to moment of bundle declaration.
  ContextKeeper RAII(this);
  ObjectData = Iter->second.DeclTimeInfo;

  BundleResource Res(Iter->second);
  // Bundle #(k+1) contains keys [16k, 16k + 15].
  Res.setName(Key.first + 1);
  RETURN_IF_ERROR(visitStringTableBundle(&Res))if (auto Err = (visitStringTableBundle(&Res))) return Err
;;
}
return Error::success();
1287}

1289// --- UserDefinedResource helpers. --- //

1291Error ResourceFileWriter::writeUserDefinedBody(const RCResource *Base) {
auto *Res = cast<UserDefinedResource>(Base);

if (Res->IsFileResource)
  return appendFile(Res->FileLoc);

for (auto &Elem : Res->Contents) {
  if (Elem.isInt()) {
    RETURN_IF_ERROR(if (auto Err = (checkRCInt(Elem.getInt(), "Number in user-defined resource"
))) return Err;
        checkRCInt(Elem.getInt(), "Number in user-defined resource"))if (auto Err = (checkRCInt(Elem.getInt(), "Number in user-defined resource"
))) return Err;;
    writeRCInt(Elem.getInt());
    continue;
  }

  SmallVector<UTF16, 128> ProcessedString;
  bool IsLongString;
  RETURN_IF_ERROR(if (auto Err = (processString(Elem.getString(), NullHandlingMethod
::UserResource, IsLongString, ProcessedString, Params.CodePage
))) return Err;
      processString(Elem.getString(), NullHandlingMethod::UserResource,if (auto Err = (processString(Elem.getString(), NullHandlingMethod
::UserResource, IsLongString, ProcessedString, Params.CodePage
))) return Err;
                    IsLongString, ProcessedString, Params.CodePage))if (auto Err = (processString(Elem.getString(), NullHandlingMethod
::UserResource, IsLongString, ProcessedString, Params.CodePage
))) return Err;;

  for (auto Ch : ProcessedString) {
    if (IsLongString) {
      writeInt(Ch);
      continue;
    }

    RETURN_IF_ERROR(checkNumberFits<uint8_t>(if (auto Err = (checkNumberFits<uint8_t>( Ch, "Character in narrow string in user-defined resource"
))) return Err;
        Ch, "Character in narrow string in user-defined resource"))if (auto Err = (checkNumberFits<uint8_t>( Ch, "Character in narrow string in user-defined resource"
))) return Err;;
    writeInt<uint8_t>(Ch);
  }
}

return Error::success();
1324}

1326// --- VersionInfoResourceResource helpers. --- //

1328Error ResourceFileWriter::writeVersionInfoBlock(const VersionInfoBlock &Blk) {
// Output the header if the block has name.
bool OutputHeader = Blk.Name != "";
uint64_t LengthLoc;

padStream(sizeof(uint32_t));
if (OutputHeader) {
  LengthLoc = writeInt<uint16_t>(0);
  writeInt<uint16_t>(0);
  writeInt<uint16_t>(1); // true
  RETURN_IF_ERROR(writeCString(Blk.Name))if (auto Err = (writeCString(Blk.Name))) return Err;;
  padStream(sizeof(uint32_t));
}

for (const std::unique_ptr<VersionInfoStmt> &Item : Blk.Stmts) {
  VersionInfoStmt *ItemPtr = Item.get();

  if (auto *BlockPtr = dyn_cast<VersionInfoBlock>(ItemPtr)) {
    RETURN_IF_ERROR(writeVersionInfoBlock(*BlockPtr))if (auto Err = (writeVersionInfoBlock(*BlockPtr))) return Err
;;
    continue;
  }

  auto *ValuePtr = cast<VersionInfoValue>(ItemPtr);
  RETURN_IF_ERROR(writeVersionInfoValue(*ValuePtr))if (auto Err = (writeVersionInfoValue(*ValuePtr))) return Err
;;
}

if (OutputHeader) {
  uint64_t CurLoc = tell();
  writeObjectAt(ulittle16_t(CurLoc - LengthLoc), LengthLoc);
}

return Error::success();
1360}

1362Error ResourceFileWriter::writeVersionInfoValue(const VersionInfoValue &Val) {
// rc has a peculiar algorithm to output VERSIONINFO VALUEs. Each VALUE
// is a mapping from the key (string) to the value (a sequence of ints or
// a sequence of strings).
//
// If integers are to be written: width of each integer written depends on
// whether it's been declared 'long' (it's DWORD then) or not (it's WORD).
// ValueLength defined in structure referenced below is then the total
// number of bytes taken by these integers.
//
// If strings are to be written: characters are always WORDs.
// Moreover, '\0' character is written after the last string, and between
// every two strings separated by comma (if strings are not comma-separated,
// they're simply concatenated). ValueLength is equal to the number of WORDs
// written (that is, half of the bytes written).
//
// Ref: msdn.microsoft.com/en-us/library/windows/desktop/ms646994.aspx
bool HasStrings = false, HasInts = false;
for (auto &Item : Val.Values)
  (Item.isInt() ? HasInts : HasStrings) = true;

assert((HasStrings || HasInts) && "VALUE must have at least one argument")(((HasStrings || HasInts) && "VALUE must have at least one argument"
) ? static_cast<void> (0) : __assert_fail ("(HasStrings || HasInts) && \"VALUE must have at least one argument\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 1383, __PRETTY_FUNCTION__));
if (HasStrings && HasInts)
  return createError(Twine("VALUE ") + Val.Key +
                     " cannot contain both strings and integers");

padStream(sizeof(uint32_t));
auto LengthLoc = writeInt<uint16_t>(0);
auto ValLengthLoc = writeInt<uint16_t>(0);
writeInt<uint16_t>(HasStrings);
RETURN_IF_ERROR(writeCString(Val.Key))if (auto Err = (writeCString(Val.Key))) return Err;;
padStream(sizeof(uint32_t));

auto DataLoc = tell();
for (size_t Id = 0; Id < Val.Values.size(); ++Id) {
  auto &Item = Val.Values[Id];
  if (Item.isInt()) {
    auto Value = Item.getInt();
    RETURN_IF_ERROR(checkRCInt(Value, "VERSIONINFO integer value"))if (auto Err = (checkRCInt(Value, "VERSIONINFO integer value"
))) return Err;;
    writeRCInt(Value);
    continue;
  }

  bool WriteTerminator =
      Id == Val.Values.size() - 1 || Val.HasPrecedingComma[Id + 1];
  RETURN_IF_ERROR(writeCString(Item.getString(), WriteTerminator))if (auto Err = (writeCString(Item.getString(), WriteTerminator
))) return Err;;
}

auto CurLoc = tell();
auto ValueLength = CurLoc - DataLoc;
if (HasStrings) {
  assert(ValueLength % 2 == 0)((ValueLength % 2 == 0) ? static_cast<void> (0) : __assert_fail
 ("ValueLength % 2 == 0", "/build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-rc/ResourceFileWriter.cpp"
, 1413, __PRETTY_FUNCTION__));
  ValueLength /= 2;
}
writeObjectAt(ulittle16_t(CurLoc - LengthLoc), LengthLoc);
writeObjectAt(ulittle16_t(ValueLength), ValLengthLoc);
return Error::success();
1419}

1421template <typename Ty>
1422static Ty getWithDefault(const StringMap<Ty> &Map, StringRef Key,
                       const Ty &Default) {
auto Iter = Map.find(Key);
if (Iter != Map.end())
  return Iter->getValue();
return Default;
1428}

1430Error ResourceFileWriter::writeVersionInfoBody(const RCResource *Base) {
auto *Res = cast<VersionInfoResource>(Base);

const auto &FixedData = Res->FixedData;

struct /* VS_FIXEDFILEINFO */ {
  ulittle32_t Signature = ulittle32_t(0xFEEF04BD);
  ulittle32_t StructVersion = ulittle32_t(0x10000);
  // It's weird to have most-significant DWORD first on the little-endian
  // machines, but let it be this way.
  ulittle32_t FileVersionMS;
  ulittle32_t FileVersionLS;
  ulittle32_t ProductVersionMS;
  ulittle32_t ProductVersionLS;
  ulittle32_t FileFlagsMask;
  ulittle32_t FileFlags;
  ulittle32_t FileOS;
  ulittle32_t FileType;
  ulittle32_t FileSubtype;
  // MS implementation seems to always set these fields to 0.
  ulittle32_t FileDateMS = ulittle32_t(0);
  ulittle32_t FileDateLS = ulittle32_t(0);
} FixedInfo;

// First, VS_VERSIONINFO.
auto LengthLoc = writeInt<uint16_t>(0);
writeInt<uint16_t>(sizeof(FixedInfo));
writeInt<uint16_t>(0);
cantFail(writeCString("VS_VERSION_INFO"));
padStream(sizeof(uint32_t));

using VersionInfoFixed = VersionInfoResource::VersionInfoFixed;
auto GetField = [&](VersionInfoFixed::VersionInfoFixedType Type) {
  static const SmallVector<uint32_t, 4> DefaultOut{0, 0, 0, 0};
  if (!FixedData.IsTypePresent[(int)Type])
    return DefaultOut;
  return FixedData.FixedInfo[(int)Type];
};

auto FileVer = GetField(VersionInfoFixed::FtFileVersion);
RETURN_IF_ERROR(checkNumberFits<uint16_t>(if (auto Err = (checkNumberFits<uint16_t>( *std::max_element
(FileVer.begin(), FileVer.end()), "FILEVERSION fields"))) return
 Err;
    *std::max_element(FileVer.begin(), FileVer.end()), "FILEVERSION fields"))if (auto Err = (checkNumberFits<uint16_t>( *std::max_element
(FileVer.begin(), FileVer.end()), "FILEVERSION fields"))) return
 Err;;
FixedInfo.FileVersionMS = (FileVer[0] << 16) | FileVer[1];
FixedInfo.FileVersionLS = (FileVer[2] << 16) | FileVer[3];

auto ProdVer = GetField(VersionInfoFixed::FtProductVersion);
RETURN_IF_ERROR(checkNumberFits<uint16_t>(if (auto Err = (checkNumberFits<uint16_t>( *std::max_element
(ProdVer.begin(), ProdVer.end()), "PRODUCTVERSION fields"))) return
 Err;
    *std::max_element(ProdVer.begin(), ProdVer.end()),if (auto Err = (checkNumberFits<uint16_t>( *std::max_element
(ProdVer.begin(), ProdVer.end()), "PRODUCTVERSION fields"))) return
 Err;
    "PRODUCTVERSION fields"))if (auto Err = (checkNumberFits<uint16_t>( *std::max_element
(ProdVer.begin(), ProdVer.end()), "PRODUCTVERSION fields"))) return
 Err;;
FixedInfo.ProductVersionMS = (ProdVer[0] << 16) | ProdVer[1];
FixedInfo.ProductVersionLS = (ProdVer[2] << 16) | ProdVer[3];

FixedInfo.FileFlagsMask = GetField(VersionInfoFixed::FtFileFlagsMask)[0];
FixedInfo.FileFlags = GetField(VersionInfoFixed::FtFileFlags)[0];
FixedInfo.FileOS = GetField(VersionInfoFixed::FtFileOS)[0];
FixedInfo.FileType = GetField(VersionInfoFixed::FtFileType)[0];
FixedInfo.FileSubtype = GetField(VersionInfoFixed::FtFileSubtype)[0];

writeObject(FixedInfo);
padStream(sizeof(uint32_t));

RETURN_IF_ERROR(writeVersionInfoBlock(Res->MainBlock))if (auto Err = (writeVersionInfoBlock(Res->MainBlock))) return
 Err;;

// FIXME: check overflow?
writeObjectAt(ulittle16_t(tell() - LengthLoc), LengthLoc);

return Error::success();
1497}

1499Expected<std::unique_ptr<MemoryBuffer>>
1500ResourceFileWriter::loadFile(StringRef File) const {
SmallString<128> Path;
SmallString<128> Cwd;
std::unique_ptr<MemoryBuffer> Result;

// 1. The current working directory.
sys::fs::current_path(Cwd);
Path.assign(Cwd.begin(), Cwd.end());
sys::path::append(Path, File);
if (sys::fs::exists(Path))
  return errorOrToExpected(MemoryBuffer::getFile(Path, -1, false));

// 2. The directory of the input resource file, if it is different from the
// current
//    working directory.
StringRef InputFileDir = sys::path::parent_path(Params.InputFilePath);
Path.assign(InputFileDir.begin(), InputFileDir.end());
sys::path::append(Path, File);
if (sys::fs::exists(Path))
  return errorOrToExpected(MemoryBuffer::getFile(Path, -1, false));

// 3. All of the include directories specified on the command line.
for (StringRef ForceInclude : Params.Include) {
  Path.assign(ForceInclude.begin(), ForceInclude.end());
  sys::path::append(Path, File);
  if (sys::fs::exists(Path))
    return errorOrToExpected(MemoryBuffer::getFile(Path, -1, false));
}

if (auto Result =
        llvm::sys::Process::FindInEnvPath("INCLUDE", File, Params.NoInclude))
  return errorOrToExpected(MemoryBuffer::getFile(*Result, -1, false));

return make_error<StringError>("error : file not found : " + Twine(File),
                               inconvertibleErrorCode());
1535}

1537} // namespace rc
1538} // namespace llvm

←

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/BinaryStreamReader.h

1//===- BinaryStreamReader.h - Reads objects from a binary stream *- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H
11#define LLVM_SUPPORT_BINARYSTREAMREADER_H

13#include "llvm/ADT/ArrayRef.h"
14#include "llvm/ADT/STLExtras.h"
15#include "llvm/Support/BinaryStreamArray.h"
16#include "llvm/Support/BinaryStreamRef.h"
17#include "llvm/Support/ConvertUTF.h"
18#include "llvm/Support/Endian.h"
19#include "llvm/Support/Error.h"
20#include "llvm/Support/type_traits.h"

22#include <string>
23#include <type_traits>

25namespace llvm {

27/// Provides read only access to a subclass of `BinaryStream`.  Provides
28/// bounds checking and helpers for writing certain common data types such as
29/// null-terminated strings, integers in various flavors of endianness, etc.
30/// Can be subclassed to provide reading of custom datatypes, although no
31/// are overridable.
32class BinaryStreamReader {
33public:
BinaryStreamReader() = default;
explicit BinaryStreamReader(BinaryStreamRef Ref);
explicit BinaryStreamReader(BinaryStream &Stream);
explicit BinaryStreamReader(ArrayRef<uint8_t> Data,
                            llvm::support::endianness Endian);
explicit BinaryStreamReader(StringRef Data, llvm::support::endianness Endian);

BinaryStreamReader(const BinaryStreamReader &Other)
    : Stream(Other.Stream), Offset(Other.Offset) {}

BinaryStreamReader &operator=(const BinaryStreamReader &Other) {
  Stream = Other.Stream;
  Offset = Other.Offset;
  return *this;
}

virtual ~BinaryStreamReader() {}

/// Read as much as possible from the underlying string at the current offset
/// without invoking a copy, and set \p Buffer to the resulting data slice.
/// 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 readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer);

/// Read \p Size bytes from the underlying stream at the current offset and
/// and set \p Buffer to the resulting data slice.  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 readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);

/// Read an integer of the specified endianness into \p Dest and update the
/// stream's offset.  The data is always copied from the stream's underlying
/// buffer into \p Dest. 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.
template <typename T> Error readInteger(T &Dest) {
  static_assert(std::is_integral<T>::value,
                "Cannot call readInteger with non-integral value!");

  ArrayRef<uint8_t> Bytes;
  if (auto EC = readBytes(Bytes, sizeof(T)))
    return EC;

  Dest = llvm::support::endian::read<T, llvm::support::unaligned>(
      Bytes.data(), Stream.getEndian());
  return Error::success();
}

/// Similar to readInteger.
template <typename T> Error readEnum(T &Dest) {
  static_assert(std::is_enum<T>::value,
                "Cannot call readEnum with non-enum value!");
  typename std::underlying_type<T>::type N;
  if (auto EC = readInteger(N))
    return EC;
  Dest = static_cast<T>(N);
  return Error::success();
}

/// 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);

/// Read the entire remainder of the underlying stream into \p Ref.  This is
/// equivalent to calling getUnderlyingStream().slice(Offset).  Updates the
/// stream's offset to point to the end of the stream.  Never causes a copy.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readStreamRef(BinaryStreamRef &Ref);

/// Read \p Length bytes from the underlying stream into \p Ref.  This is
/// equivalent to calling getUnderlyingStream().slice(Offset, Length).
/// Updates the stream's offset to point after the newly read object.  Never
/// causes a copy.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readStreamRef(BinaryStreamRef &Ref, uint32_t Length);

/// Read \p Length bytes from the underlying stream into \p Stream.  This is
/// equivalent to calling getUnderlyingStream().slice(Offset, Length).
/// Updates the stream's offset to point after the newly read object.  Never
/// causes a copy.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readSubstream(BinarySubstreamRef &Stream, uint32_t Size);

/// Get a pointer to an object of type T from the underlying stream, as if by
/// memcpy, and store the result into \p Dest.  It is up to the caller to
/// ensure that objects of type T can be safely treated in this manner.
/// Updates the stream's offset to point after the newly read object.  Whether
/// a copy occurs depends upon the implementation of the underlying
/// stream.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T> Error readObject(const T *&Dest) {
  ArrayRef<uint8_t> Buffer;
  if (auto EC = readBytes(Buffer, sizeof(T)))
6
←
Taking true branch→
    return EC;
7
←
Returning without writing to 'Dest'→
  Dest = reinterpret_cast<const T *>(Buffer.data());
  return Error::success();
}

/// Get a reference to a \p NumElements element array of objects of type T
/// from the underlying stream as if by memcpy, and store the resulting array
/// slice into \p array.  It is up to the caller to ensure that objects of
/// type T can be safely treated in this manner.  Updates the stream's offset
/// to point after the newly read object.  Whether a copy occurs depends upon
/// the implementation of the underlying stream.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T>
Error readArray(ArrayRef<T> &Array, uint32_t NumElements) {
  ArrayRef<uint8_t> Bytes;
  if (NumElements == 0) {
    Array = ArrayRef<T>();
    return Error::success();
  }

  if (NumElements > UINT32_MAX(4294967295U) / sizeof(T))
    return make_error<BinaryStreamError>(
        stream_error_code::invalid_array_size);

  if (auto EC = readBytes(Bytes, NumElements * sizeof(T)))
    return EC;

  assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&((alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&
 "Reading at invalid alignment!") ? static_cast<void> (
0) : __assert_fail ("alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && \"Reading at invalid alignment!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/BinaryStreamReader.h"
, 191, __PRETTY_FUNCTION__))
         "Reading at invalid alignment!")((alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&
 "Reading at invalid alignment!") ? static_cast<void> (
0) : __assert_fail ("alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && \"Reading at invalid alignment!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/BinaryStreamReader.h"
, 191, __PRETTY_FUNCTION__));

  Array = ArrayRef<T>(reinterpret_cast<const T *>(Bytes.data()), NumElements);
  return Error::success();
}

/// Read a VarStreamArray of size \p Size bytes and store the result into
/// \p Array.  Updates the stream's offset to point after the newly read
/// array.  Never causes a copy (although iterating the elements of the
/// VarStreamArray may, depending upon the implementation of the underlying
/// stream).
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T, typename U>
Error readArray(VarStreamArray<T, U> &Array, uint32_t Size) {
  BinaryStreamRef S;
  if (auto EC = readStreamRef(S, Size))
    return EC;
  Array.setUnderlyingStream(S);
  return Error::success();
}

/// Read a FixedStreamArray of \p NumItems elements and store the result into
/// \p Array.  Updates the stream's offset to point after the newly read
/// array.  Never causes a copy (although iterating the elements of the
/// FixedStreamArray may, depending upon the implementation of the underlying
/// stream).
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T>
Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
  if (NumItems == 0) {
    Array = FixedStreamArray<T>();
    return Error::success();
  }

  if (NumItems > UINT32_MAX(4294967295U) / sizeof(T))
    return make_error<BinaryStreamError>(
        stream_error_code::invalid_array_size);

  BinaryStreamRef View;
  if (auto EC = readStreamRef(View, NumItems * sizeof(T)))
    return EC;

  Array = FixedStreamArray<T>(View);
  return Error::success();
}

bool empty() const { return bytesRemaining() == 0; }
void setOffset(uint32_t Off) { Offset = Off; }
uint32_t getOffset() const { return Offset; }
uint32_t getLength() const { return Stream.getLength(); }
uint32_t bytesRemaining() const { return getLength() - getOffset(); }

/// Advance the stream's offset by \p Amount bytes.
///
/// \returns a success error code if at least \p Amount bytes remain in the
/// stream, otherwise returns an appropriate error code.
Error skip(uint32_t Amount);

/// Examine the next byte of the underlying stream without advancing the
/// stream's offset.  If the stream is empty the behavior is undefined.
///
/// \returns the next byte in the stream.
uint8_t peek() const;

Error padToAlignment(uint32_t Align);

std::pair<BinaryStreamReader, BinaryStreamReader>
split(uint32_t Offset) const;

264private:
BinaryStreamRef Stream;
uint32_t Offset = 0;
267};
268} // namespace llvm

270#endif // LLVM_SUPPORT_BINARYSTREAMREADER_H