src/msvc_helper-win32.cc

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "msvc_helper.h"
  16
  17 #include <algorithm>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <windows.h>
  21
  22 #include "includes_normalize.h"
  23 #include "util.h"
  24
  25 namespace {
  26
  27 /// Return true if \a input ends with \a needle.
  28 bool EndsWith(const string& input, const string& needle) {
  29   return (input.size() >= needle.size() &&
  30           input.substr(input.size() - needle.size()) == needle);
  31 }
  32
  33 string Replace(const string& input, const string& find, const string& replace) {
  34   string result = input;
  35   size_t start_pos = 0;
  36   while ((start_pos = result.find(find, start_pos)) != string::npos) {
  37     result.replace(start_pos, find.length(), replace);
  38     start_pos += replace.length();
  39   }
  40   return result;
  41 }
  42
  43 }  // anonymous namespace
  44
  45 string EscapeForDepfile(const string& path) {
  46   // Depfiles don't escape single \.
  47   return Replace(path, " ", "\\ ");
  48 }
  49
  50 // static
  51 string CLParser::FilterShowIncludes(const string& line,
  52                                     const string& deps_prefix) {
  53   const string kDepsPrefixEnglish = "Note: including file: ";
  54   const char* in = line.c_str();
  55   const char* end = in + line.size();
  56   const string& prefix = deps_prefix.empty() ? kDepsPrefixEnglish : deps_prefix;
  57   if (end - in > (int)prefix.size() &&
  58       memcmp(in, prefix.c_str(), (int)prefix.size()) == 0) {
  59     in += prefix.size();
  60     while (*in == ' ')
  61       ++in;
  62     return line.substr(in - line.c_str());
  63   }
  64   return "";
  65 }
  66
  67 // static
  68 bool CLParser::IsSystemInclude(string path) {
  69   transform(path.begin(), path.end(), path.begin(), ::tolower);
  70   // TODO: this is a heuristic, perhaps there's a better way?
  71   return (path.find("program files") != string::npos ||
  72           path.find("microsoft visual studio") != string::npos);
  73 }
  74
  75 // static
  76 bool CLParser::FilterInputFilename(string line) {
  77   transform(line.begin(), line.end(), line.begin(), ::tolower);
  78   // TODO: other extensions, like .asm?
  79   return EndsWith(line, ".c") ||
  80       EndsWith(line, ".cc") ||
  81       EndsWith(line, ".cxx") ||
  82       EndsWith(line, ".cpp");
  83 }
  84
  85 bool CLParser::Parse(const string& output, const string& deps_prefix,
  86                      string* filtered_output, string* err) {
  87   // Loop over all lines in the output to process them.
  88   size_t start = 0;
  89   while (start < output.size()) {
  90     size_t end = output.find_first_of("\r\n", start);
  91     if (end == string::npos)
  92       end = output.size();
  93     string line = output.substr(start, end - start);
  94
  95     string include = FilterShowIncludes(line, deps_prefix);
  96     if (!include.empty()) {
  97       string normalized;
  98       if (!IncludesNormalize::Normalize(include, NULL, &normalized, err))
  99         return false;
 100       if (!IsSystemInclude(normalized))
 101         includes_.insert(normalized);
 102     } else if (FilterInputFilename(line)) {
 103       // Drop it.
 104       // TODO: if we support compiling multiple output files in a single
 105       // cl.exe invocation, we should stash the filename.
 106     } else {
 107       filtered_output->append(line);
 108       filtered_output->append("\n");
 109     }
 110
 111     if (end < output.size() && output[end] == '\r')
 112       ++end;
 113     if (end < output.size() && output[end] == '\n')
 114       ++end;
 115     start = end;
 116   }
 117
 118   return true;
 119 }
 120
 121 int CLWrapper::Run(const string& command, string* output) {
 122   SECURITY_ATTRIBUTES security_attributes = {};
 123   security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
 124   security_attributes.bInheritHandle = TRUE;
 125
 126   // Must be inheritable so subprocesses can dup to children.
 127   HANDLE nul = CreateFile("NUL", GENERIC_READ,
 128                           FILE_SHARE_READ | FILE_SHARE_WRITE |
 129                           FILE_SHARE_DELETE,
 130                           &security_attributes, OPEN_EXISTING, 0, NULL);
 131   if (nul == INVALID_HANDLE_VALUE)
 132     Fatal("couldn't open nul");
 133
 134   HANDLE stdout_read, stdout_write;
 135   if (!CreatePipe(&stdout_read, &stdout_write, &security_attributes, 0))
 136     Win32Fatal("CreatePipe");
 137
 138   if (!SetHandleInformation(stdout_read, HANDLE_FLAG_INHERIT, 0))
 139     Win32Fatal("SetHandleInformation");
 140
 141   PROCESS_INFORMATION process_info = {};
 142   STARTUPINFO startup_info = {};
 143   startup_info.cb = sizeof(STARTUPINFO);
 144   startup_info.hStdInput = nul;
 145   startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
 146   startup_info.hStdOutput = stdout_write;
 147   startup_info.dwFlags |= STARTF_USESTDHANDLES;
 148
 149   if (!CreateProcessA(NULL, (char*)command.c_str(), NULL, NULL,
 150                       /* inherit handles */ TRUE, 0,
 151                       env_block_, NULL,
 152                       &startup_info, &process_info)) {
 153     Win32Fatal("CreateProcess");
 154   }
 155
 156   if (!CloseHandle(nul) ||
 157       !CloseHandle(stdout_write)) {
 158     Win32Fatal("CloseHandle");
 159   }
 160
 161   // Read all output of the subprocess.
 162   DWORD read_len = 1;
 163   while (read_len) {
 164     char buf[64 << 10];
 165     read_len = 0;
 166     if (!::ReadFile(stdout_read, buf, sizeof(buf), &read_len, NULL) &&
 167         GetLastError() != ERROR_BROKEN_PIPE) {
 168       Win32Fatal("ReadFile");
 169     }
 170     output->append(buf, read_len);
 171   }
 172
 173   // Wait for it to exit and grab its exit code.
 174   if (WaitForSingleObject(process_info.hProcess, INFINITE) == WAIT_FAILED)
 175     Win32Fatal("WaitForSingleObject");
 176   DWORD exit_code = 0;
 177   if (!GetExitCodeProcess(process_info.hProcess, &exit_code))
 178     Win32Fatal("GetExitCodeProcess");
 179
 180   if (!CloseHandle(stdout_read) ||
 181       !CloseHandle(process_info.hProcess) ||
 182       !CloseHandle(process_info.hThread)) {
 183     Win32Fatal("CloseHandle");
 184   }
 185
 186   return exit_code;
 187 }