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

• Show log

  Commit

• Hash : f0dd087e
  Author :
  Date : 2019-08-23T15:45:34
  

  Move timer functionality from util/ to common/
  
  The main timer functionality (get absolute time) is moved to common/ for
  use in ANGLE itself (in upcoming overlay change).  util/Timer.h is no
  longer an abstract class and uses this functionality to implement the
  timer.
  
  Bug: angleproject:3757
  Change-Id: I3fe418778d80d1089c9bfe43a9e8098e43236f18
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1769061
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@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 ";";
  }
  
  double GetCurrentTime()
  {
      LARGE_INTEGER frequency = {};
      QueryPerformanceFrequency(&frequency);
  
      LARGE_INTEGER curTime;
      QueryPerformanceCounter(&curTime);
  
      return static_cast<double>(curTime.QuadPart) / frequency.QuadPart;
  }
  
  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