Mostly automatic incremental link enabling

tools/win/supalink/supalink.cpp

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+
+using namespace std;
+
+// Don't use stderr for errors because VS has large buffers on them, leading
+// to confusing error output.
+static void Fatal(const wchar_t* msg) {
+  wprintf(L"supalink fatal error: %s\n", msg);
+  exit(1);
+}
+
+static wstring ErrorMessageToString(DWORD err) {
+  wchar_t* msg_buf = NULL;
+  DWORD rc = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                               FORMAT_MESSAGE_FROM_SYSTEM,
+                           NULL,
+                           err,
+                           MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                           reinterpret_cast<LPTSTR>(&msg_buf),
+                           0,
+                           NULL);
+  if (!rc)
+    return L"unknown error";
+  wstring ret(msg_buf);
+  LocalFree(msg_buf);
+  return ret;
+}
+
+static const wchar_t* const g_search_for[] = {
+  L"link.exe\" ",
+  L"LINK.EXE\" ",
+  L"link.EXE\" ",
+  L"link\" ",
+  L"LINK\" ",
+  L"link.exe ",
+  L"LINK.EXE ",
+  L"link.EXE ",
+  L"link ",
+  L"LINK ",
+};
+
+static void Fallback(const wchar_t* msg = NULL) {
+  if (msg) {
+    wprintf(L"supalink failed (%s), trying to fallback to standard link.\n",
+            msg);
+    wprintf(L"Original command line: %s\n", GetCommandLine());
+    fflush(stdout);
+  }
+
+  STARTUPINFO startup_info = { sizeof(STARTUPINFO) };
+  PROCESS_INFORMATION process_info;
+  DWORD exit_code;
+
+  wstring orig_cmd(GetCommandLine());
+  wstring cmd;
+  wstring replace_with = L"link.exe.supalink_orig.exe";
+  for (size_t i = 0; i < sizeof(g_search_for) / sizeof(g_search_for[0]); ++i) {
+    wstring linkexe = g_search_for[i];
+    wstring::size_type at = orig_cmd.find(linkexe, 0);
+    if (at == wstring::npos)
+      continue;
+    if (linkexe[linkexe.size() - 2] == L'"')
+      replace_with += L"\" ";
+    else
+      replace_with += L" ";
+    cmd = orig_cmd.replace(at, linkexe.size(), replace_with);
+    break;
+  }
+  if (cmd == L"") {
+    wprintf(L"Original run '%s'\n", orig_cmd.c_str());
+    Fatal(L"Couldn't find link.exe (or similar) in command line");
+  }
+
+  if (getenv("SUPALINK_DEBUG")) {
+    wprintf(L"  running '%s'\n", cmd.c_str());
+    fflush(stdout);
+  }
+  if (!CreateProcess(NULL,
+                     reinterpret_cast<LPWSTR>(const_cast<wchar_t *>(
+                             cmd.c_str())),
+                     NULL,
+                     NULL,
+                     TRUE,
+                     0,
+                     NULL,
+                     NULL,
+                     &startup_info, &process_info)) {
+    wstring error = ErrorMessageToString(GetLastError());
+    Fatal(error.c_str());
+  }
+  CloseHandle(process_info.hThread);
+  WaitForSingleObject(process_info.hProcess, INFINITE);
+  GetExitCodeProcess(process_info.hProcess, &exit_code);
+  CloseHandle(process_info.hProcess);
+  exit(exit_code);
+}
+
+wstring SlurpFile(const wchar_t* path) {
+  FILE* f = _wfopen(path, L"rb, ccs=UNICODE");
+  if (!f) Fallback(L"couldn't read file");
+  fseek(f, 0, SEEK_END);
+  long len = ftell(f);
+  rewind(f);
+  wchar_t* data = reinterpret_cast<wchar_t*>(malloc(len));
+  fread(data, 1, len, f);
+  fclose(f);
+  wstring ret(data, len/sizeof(wchar_t));
+  free(data);
+  return ret;
+}
+
+void DumpFile(const wchar_t* path, wstring& contents) {
+  FILE* f = _wfopen(path, L"wb, ccs=UTF-16LE");
+  if (!f) Fallback(L"couldn't write file");
+
+  fwrite(contents.c_str(), sizeof(wchar_t), contents.size(), f);
+  if (ferror(f))
+      Fatal(L"failed during response rewrite");

[M-A Ruel, 2011/09/28 18:17:14]

alignment

[scottmg, 2011/09/28 21:47:56]

Done.

+  fclose(f);
+}
+
+// Input command line is assumed to be of the form:
+//
+// link.exe @C:\src\...\RSP00003045884740.rsp /NOLOGO /ERRORREPORT:PROMPT
+//
+// Specifically, we parse & hack the contents of argv[1] and pass the rest
+// onwards.
+int main(int argc, wchar_t** argv) {
+  ULONGLONG start_time = 0, end_time;
+
+  int rsp_file_index = -1;
+
+  if (argc < 2)
+    Fallback(L"too few commmand line args");
+
+  for (int i = 1; i < argc; ++i) {
+    if (argv[i][0] == '@') {
+      rsp_file_index = i;
+      break;
+    }
+  }
+
+  if (rsp_file_index == -1)
+    Fallback(L"couldn't find a response file in argv");
+
+  if (getenv("SUPALINK_DEBUG"))
+    start_time = GetTickCount64();
+
+  wstring rsp = SlurpFile(&argv[rsp_file_index][1]);
+
+  // The first line of this file is all we try to fix. It's a bunch of
+  // quoted space separated items. Simplest thing seems to be replacing " "
+  // with "\n". So, just slurp the file, replace, spit it out to the same
+  // file and continue on our way.
+
+  // Took about .5s when using the naive .replace loop to replace " " with
+  // "\r\n" so write the silly loop instead.
+  wstring fixed;
+  fixed.reserve(rsp.size() * 2);
+
+  for (const wchar_t* s = rsp.c_str(); *s;) {
+    if (*s == '"' && *(s + 1) == ' ' && *(s + 2) == '"') {
+      fixed += L"\"\r\n\"";
+      s += 3;
+    } else {
+      fixed += *s++;
+    }
+  }
+
+  DumpFile(&argv[rsp_file_index][1], fixed);
+
+  if (getenv("SUPALINK_DEBUG")) {
+    wstring backup_copy(&argv[rsp_file_index][1]);
+    backup_copy += L".copy";
+    DumpFile(backup_copy.c_str(), fixed);
+
+    end_time = GetTickCount64();
+
+    wprintf(L"  took %.2fs to modify @rsp file\n",
+            (end_time - start_time) / 1000.0);
+  }
+
+  Fallback();
+}