kc3-lang/angle/src/common/system_utils_win.cpp

• Show log

  Commit

• Hash : 9d737966
  Author :
  Date : 2019-08-14T12:25:12
  

  Standardize copyright notices to project style
  
  For all "ANGLE Project" copyrights, standardize to the format specified
  by the style guide. Changes:
  - "Copyright (c)" and "Copyright(c)" changed to just "Copyright".
  - Removed the second half of date ranges ("Y1Y1-Y2Y2"->"Y1Y1").
  - Fixed a small number of files that had no copyright date using the
    initial commit year from the version control history.
  - Fixed one instance of copyright being "The ANGLE Project" rather than
    "The ANGLE Project Authors"
  
  These changes are applied both to the copyright of source file, and
  where applicable to copyright statements that are generated by
  templates.
  
  BUG=angleproject:3811
  
  Change-Id: I973dd65e4ef9deeba232d5be74c768256a0eb2e5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1754397
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/common/system_utils_win.cpp

• //
  // Copyright 2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // system_utils_win.cpp: Implementation of OS-specific functions for Windows
  
  #include "system_utils.h"
  
  #include <stdarg.h>
  #include <windows.h>
  #include <array>
  #include <vector>
  
  namespace angle
  {
  namespace
  {
  struct ScopedPipe
  {
      ~ScopedPipe()
      {
          closeReadHandle();
          closeWriteHandle();
      }
      void closeReadHandle()
      {
          if (readHandle)
          {
              CloseHandle(readHandle);
              readHandle = nullptr;
          }
      }
      void closeWriteHandle()
      {
          if (writeHandle)
          {
              CloseHandle(writeHandle);
              writeHandle = nullptr;
          }
      }
      HANDLE readHandle  = nullptr;
      HANDLE writeHandle = nullptr;
  };
  
  void ReadEntireFile(HANDLE handle, std::string *out)
  {
      out->clear();
  
      while (true)
      {
          char buffer[256];
          DWORD bytesRead;
  
          BOOL success = ReadFile(handle, buffer, sizeof(buffer), &bytesRead, nullptr);
  
          if (!success || bytesRead == 0)
          {
              break;
          }
  
          out->append(buffer, bytesRead);
      }
  }
  }  // anonymous namespace
  
  std::string GetExecutablePath()
  {
      std::array<char, MAX_PATH> executableFileBuf;
      DWORD executablePathLen = GetModuleFileNameA(nullptr, executableFileBuf.data(),
                                                   static_cast<DWORD>(executableFileBuf.size()));
      return (executablePathLen > 0 ? std::string(executableFileBuf.data()) : "");
  }
  
  std::string GetExecutableDirectory()
  {
      std::string executablePath = GetExecutablePath();
      size_t lastPathSepLoc      = executablePath.find_last_of("\\/");
      return (lastPathSepLoc != std::string::npos) ? executablePath.substr(0, lastPathSepLoc) : "";
  }
  
  const char *GetSharedLibraryExtension()
  {
      return "dll";
  }
  
  Optional<std::string> GetCWD()
  {
      std::array<char, MAX_PATH> pathBuf;
      DWORD result = GetCurrentDirectoryA(static_cast<DWORD>(pathBuf.size()), pathBuf.data());
      if (result == 0)
      {
          return Optional<std::string>::Invalid();
      }
      return std::string(pathBuf.data());
  }
  
  bool SetCWD(const char *dirName)
  {
      return (SetCurrentDirectoryA(dirName) == TRUE);
  }
  
  bool UnsetEnvironmentVar(const char *variableName)
  {
      return (SetEnvironmentVariableA(variableName, nullptr) == TRUE);
  }
  
  bool SetEnvironmentVar(const char *variableName, const char *value)
  {
      return (SetEnvironmentVariableA(variableName, value) == TRUE);
  }
  
  std::string GetEnvironmentVar(const char *variableName)
  {
      std::array<char, MAX_PATH> oldValue;
      DWORD result =
          GetEnvironmentVariableA(variableName, oldValue.data(), static_cast<DWORD>(oldValue.size()));
      if (result == 0)
      {
          return std::string();
      }
      else
      {
          return std::string(oldValue.data());
      }
  }
  
  const char *GetPathSeparator()
  {
      return ";";
  }
  
  bool RunApp(const std::vector<const char *> &args,
              std::string *stdoutOut,
              std::string *stderrOut,
              int *exitCodeOut)
  {
      ScopedPipe stdoutPipe;
      ScopedPipe stderrPipe;
  
      SECURITY_ATTRIBUTES sa_attr;
      // Set the bInheritHandle flag so pipe handles are inherited.
      sa_attr.nLength              = sizeof(SECURITY_ATTRIBUTES);
      sa_attr.bInheritHandle       = TRUE;
      sa_attr.lpSecurityDescriptor = nullptr;
  
      // Create pipes for stdout and stderr.  Ensure the read handles to the pipes are not inherited.
      if (stdoutOut && !CreatePipe(&stdoutPipe.readHandle, &stdoutPipe.writeHandle, &sa_attr, 0) &&
          !SetHandleInformation(stdoutPipe.readHandle, HANDLE_FLAG_INHERIT, 0))
      {
          return false;
      }
      if (stderrOut && !CreatePipe(&stderrPipe.readHandle, &stderrPipe.writeHandle, &sa_attr, 0) &&
          !SetHandleInformation(stderrPipe.readHandle, HANDLE_FLAG_INHERIT, 0))
      {
          return false;
      }
  
      // Concat the nicely separated arguments into one string so the application has to reparse it.
      // We don't support quotation and spaces in arguments currently.
      std::vector<char> commandLineString;
      for (const char *arg : args)
      {
          if (arg)
          {
              if (!commandLineString.empty())
              {
                  commandLineString.push_back(' ');
              }
              commandLineString.insert(commandLineString.end(), arg, arg + strlen(arg));
          }
      }
      commandLineString.push_back('\0');
  
      STARTUPINFOA startInfo = {};
  
      startInfo.cb        = sizeof(STARTUPINFOA);
      startInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
      if (stdoutOut)
      {
          startInfo.hStdOutput = stdoutPipe.writeHandle;
      }
      else
      {
          startInfo.hStdError = GetStdHandle(STD_OUTPUT_HANDLE);
      }
      if (stderrOut)
      {
          startInfo.hStdError = stderrPipe.writeHandle;
      }
      else
      {
          startInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
      }
  
      if (stderrOut || stdoutOut)
      {
          startInfo.dwFlags |= STARTF_USESTDHANDLES;
      }
  
      // Create the child process.
      PROCESS_INFORMATION processInfo = {};
      if (!CreateProcessA(nullptr, commandLineString.data(), nullptr, nullptr,
                          TRUE,  // Handles are inherited.
                          0, nullptr, nullptr, &startInfo, &processInfo))
      {
          return false;
      }
  
      // Close the write end of the pipes, so EOF can be generated when child exits.
      stdoutPipe.closeWriteHandle();
      stderrPipe.closeWriteHandle();
  
      // Read back the output of the child.
      if (stdoutOut)
      {
          ReadEntireFile(stdoutPipe.readHandle, stdoutOut);
      }
      if (stderrOut)
      {
          ReadEntireFile(stderrPipe.readHandle, stderrOut);
      }
  
      // Cleanup the child.
      bool success = WaitForSingleObject(processInfo.hProcess, INFINITE) == WAIT_OBJECT_0;
  
      if (success)
      {
          DWORD exitCode = 0;
          success        = GetExitCodeProcess(processInfo.hProcess, &exitCode);
  
          if (success)
          {
              *exitCodeOut = static_cast<int>(exitCode);
          }
      }
  
      CloseHandle(processInfo.hProcess);
      CloseHandle(processInfo.hThread);
  
      return success;
  }
  
  class Win32Library : public Library
  {
    public:
      Win32Library(const char *libraryName, SearchType searchType)
      {
          char buffer[MAX_PATH];
          int ret = snprintf(buffer, MAX_PATH, "%s.%s", libraryName, GetSharedLibraryExtension());
          if (ret > 0 && ret < MAX_PATH)
          {
              switch (searchType)
              {
                  case SearchType::ApplicationDir:
                      mModule = LoadLibraryA(buffer);
                      break;
                  case SearchType::SystemDir:
                      mModule = LoadLibraryExA(buffer, nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
                      break;
              }
          }
      }
  
      ~Win32Library() override
      {
          if (mModule)
          {
              FreeLibrary(mModule);
          }
      }
  
      void *getSymbol(const char *symbolName) override
      {
          if (!mModule)
          {
              return nullptr;
          }
  
          return reinterpret_cast<void *>(GetProcAddress(mModule, symbolName));
      }
  
      void *getNative() const override { return reinterpret_cast<void *>(mModule); }
  
    private:
      HMODULE mModule = nullptr;
  };
  
  Library *OpenSharedLibrary(const char *libraryName, SearchType searchType)
  {
      return new Win32Library(libraryName, searchType);
  }
  
  bool IsDirectory(const char *filename)
  {
      WIN32_FILE_ATTRIBUTE_DATA fileInformation;
  
      BOOL result = GetFileAttributesExA(filename, GetFileExInfoStandard, &fileInformation);
      if (result)
      {
          DWORD attribs = fileInformation.dwFileAttributes;
          return (attribs != INVALID_FILE_ATTRIBUTES) && ((attribs & FILE_ATTRIBUTE_DIRECTORY) > 0);
      }
  
      return false;
  }
  
  bool IsDebuggerAttached()
  {
      return !!::IsDebuggerPresent();
  }
  
  void BreakDebugger()
  {
      __debugbreak();
  }
  }  // namespace angle
  

Download