From: Alexander Kornienko Date: Wed, 6 Sep 2017 16:28:33 +0000 (+0000) Subject: Minor style fixes in lib/Support/**/Program.(inc|cpp). X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=3274c0d73fedd6f3450bba65fe35fc13bf6fb659;p=llvm Minor style fixes in lib/Support/**/Program.(inc|cpp). No functional changes intended. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@312646 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Support/Program.h b/include/llvm/Support/Program.h index 055f016d824..2e9b75a082f 100644 --- a/include/llvm/Support/Program.h +++ b/include/llvm/Support/Program.h @@ -91,13 +91,13 @@ struct ProcessInfo { int ExecuteAndWait( StringRef Program, ///< Path of the program to be executed. It is ///< presumed this is the result of the findProgramByName method. - const char **args, ///< A vector of strings that are passed to the + const char **Args, ///< A vector of strings that are passed to the ///< program. The first element should be the name of the program. ///< The list *must* be terminated by a null char* entry. - const char **env = nullptr, ///< An optional vector of strings to use for + const char **Env = nullptr, ///< An optional vector of strings to use for ///< the program's environment. If not provided, the current program's ///< environment will be used. - const StringRef **redirects = nullptr, ///< An optional array of pointers + const StringRef **Redirects = nullptr, ///< An optional array of pointers ///< to paths. If the array is null, no redirection is done. The array ///< should have a size of at least three. The inferior process's ///< stdin(0), stdout(1), and stderr(2) will be redirected to the @@ -105,12 +105,12 @@ struct ProcessInfo { ///< When an empty path is passed in, the corresponding file ///< descriptor will be disconnected (ie, /dev/null'd) in a portable ///< way. - unsigned secondsToWait = 0, ///< If non-zero, this specifies the amount + unsigned SecondsToWait = 0, ///< If non-zero, this specifies the amount ///< of time to wait for the child process to exit. If the time ///< expires, the child is killed and this call returns. If zero, ///< this function will wait until the child finishes or forever if ///< it doesn't. - unsigned memoryLimit = 0, ///< If non-zero, this specifies max. amount + unsigned MemoryLimit = 0, ///< If non-zero, this specifies max. amount ///< of memory can be allocated by process. If memory usage will be ///< higher limit, the child is killed and this call returns. If zero ///< - no memory limit. @@ -125,14 +125,17 @@ struct ProcessInfo { /// \note On Microsoft Windows systems, users will need to either call \see /// Wait until the process finished execution or win32 CloseHandle() API on /// ProcessInfo.ProcessHandle to avoid memory leaks. - ProcessInfo - ExecuteNoWait(StringRef Program, const char **args, const char **env = nullptr, - const StringRef **redirects = nullptr, unsigned memoryLimit = 0, - std::string *ErrMsg = nullptr, bool *ExecutionFailed = nullptr); + ProcessInfo ExecuteNoWait(StringRef Program, const char **Args, + const char **Env = nullptr, + const StringRef **Redirects = nullptr, + unsigned MemoryLimit = 0, + std::string *ErrMsg = nullptr, + bool *ExecutionFailed = nullptr); /// Return true if the given arguments fit within system-specific /// argument length limits. - bool commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef Args); + bool commandLineFitsWithinSystemLimits(StringRef Program, + ArrayRef Args); /// File encoding options when writing contents that a non-UTF8 tool will /// read (on Windows systems). For UNIX, we always use UTF-8. diff --git a/lib/Support/Program.cpp b/lib/Support/Program.cpp index 34e336b354d..f9f64cca7c9 100644 --- a/lib/Support/Program.cpp +++ b/lib/Support/Program.cpp @@ -23,20 +23,20 @@ using namespace sys; //=== independent code. //===----------------------------------------------------------------------===// -static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, - const char **env, const StringRef **Redirects, - unsigned memoryLimit, std::string *ErrMsg); +static bool Execute(ProcessInfo &PI, StringRef Program, const char **Args, + const char **Env, const StringRef **Redirects, + unsigned MemoryLimit, std::string *ErrMsg); -int sys::ExecuteAndWait(StringRef Program, const char **args, const char **envp, - const StringRef **redirects, unsigned secondsToWait, - unsigned memoryLimit, std::string *ErrMsg, +int sys::ExecuteAndWait(StringRef Program, const char **Args, const char **Envp, + const StringRef **Redirects, unsigned SecondsToWait, + unsigned MemoryLimit, std::string *ErrMsg, bool *ExecutionFailed) { ProcessInfo PI; - if (Execute(PI, Program, args, envp, redirects, memoryLimit, ErrMsg)) { + if (Execute(PI, Program, Args, Envp, Redirects, MemoryLimit, ErrMsg)) { if (ExecutionFailed) *ExecutionFailed = false; ProcessInfo Result = Wait( - PI, secondsToWait, /*WaitUntilTerminates=*/secondsToWait == 0, ErrMsg); + PI, SecondsToWait, /*WaitUntilTerminates=*/SecondsToWait == 0, ErrMsg); return Result.ReturnCode; } @@ -46,14 +46,14 @@ int sys::ExecuteAndWait(StringRef Program, const char **args, const char **envp, return -1; } -ProcessInfo sys::ExecuteNoWait(StringRef Program, const char **args, - const char **envp, const StringRef **redirects, - unsigned memoryLimit, std::string *ErrMsg, +ProcessInfo sys::ExecuteNoWait(StringRef Program, const char **Args, + const char **Envp, const StringRef **Redirects, + unsigned MemoryLimit, std::string *ErrMsg, bool *ExecutionFailed) { ProcessInfo PI; if (ExecutionFailed) *ExecutionFailed = false; - if (!Execute(PI, Program, args, envp, redirects, memoryLimit, ErrMsg)) + if (!Execute(PI, Program, Args, Envp, Redirects, MemoryLimit, ErrMsg)) if (ExecutionFailed) *ExecutionFailed = true; diff --git a/lib/Support/Unix/Program.inc b/lib/Support/Unix/Program.inc index c866d5b5a84..db7f16aae97 100644 --- a/lib/Support/Unix/Program.inc +++ b/lib/Support/Unix/Program.inc @@ -144,8 +144,7 @@ static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg, static void TimeOutHandler(int Sig) { } -static void SetMemoryLimits (unsigned size) -{ +static void SetMemoryLimits(unsigned size) { #if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT struct rlimit r; __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576; @@ -165,9 +164,9 @@ static void SetMemoryLimits (unsigned size) } -static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, - const char **envp, const StringRef **redirects, - unsigned memoryLimit, std::string *ErrMsg) { +static bool Execute(ProcessInfo &PI, StringRef Program, const char **Args, + const char **Envp, const StringRef **Redirects, + unsigned MemoryLimit, std::string *ErrMsg) { if (!llvm::sys::fs::exists(Program)) { if (ErrMsg) *ErrMsg = std::string("Executable \"") + Program.str() + @@ -178,7 +177,7 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, // If this OS has posix_spawn and there is no memory limit being implied, use // posix_spawn. It is more efficient than fork/exec. #ifdef HAVE_POSIX_SPAWN - if (memoryLimit == 0) { + if (MemoryLimit == 0) { posix_spawn_file_actions_t FileActionsStore; posix_spawn_file_actions_t *FileActions = nullptr; @@ -187,11 +186,11 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, // so we copy any StringRefs into this variable. std::string RedirectsStorage[3]; - if (redirects) { + if (Redirects) { std::string *RedirectsStr[3] = {nullptr, nullptr, nullptr}; for (int I = 0; I < 3; ++I) { - if (redirects[I]) { - RedirectsStorage[I] = *redirects[I]; + if (Redirects[I]) { + RedirectsStorage[I] = *Redirects[I]; RedirectsStr[I] = &RedirectsStorage[I]; } } @@ -203,8 +202,8 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, if (RedirectIO_PS(RedirectsStr[0], 0, ErrMsg, FileActions) || RedirectIO_PS(RedirectsStr[1], 1, ErrMsg, FileActions)) return false; - if (redirects[1] == nullptr || redirects[2] == nullptr || - *redirects[1] != *redirects[2]) { + if (Redirects[1] == nullptr || Redirects[2] == nullptr || + *Redirects[1] != *Redirects[2]) { // Just redirect stderr if (RedirectIO_PS(RedirectsStr[2], 2, ErrMsg, FileActions)) return false; @@ -216,20 +215,20 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, } } - if (!envp) + if (!Envp) #if !USE_NSGETENVIRON - envp = const_cast(environ); + Envp = const_cast(environ); #else // environ is missing in dylibs. - envp = const_cast(*_NSGetEnviron()); + Envp = const_cast(*_NSGetEnviron()); #endif // Explicitly initialized to prevent what appears to be a valgrind false // positive. pid_t PID = 0; int Err = posix_spawn(&PID, Program.str().c_str(), FileActions, - /*attrp*/nullptr, const_cast(args), - const_cast(envp)); + /*attrp*/nullptr, const_cast(Args), + const_cast(Envp)); if (FileActions) posix_spawn_file_actions_destroy(FileActions); @@ -254,13 +253,12 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, // Child process: Execute the program. case 0: { // Redirect file descriptors... - if (redirects) { + if (Redirects) { // Redirect stdin - if (RedirectIO(redirects[0], 0, ErrMsg)) { return false; } + if (RedirectIO(Redirects[0], 0, ErrMsg)) { return false; } // Redirect stdout - if (RedirectIO(redirects[1], 1, ErrMsg)) { return false; } - if (redirects[1] && redirects[2] && - *(redirects[1]) == *(redirects[2])) { + if (RedirectIO(Redirects[1], 1, ErrMsg)) { return false; } + if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) { // If stdout and stderr should go to the same place, redirect stderr // to the FD already open for stdout. if (-1 == dup2(1,2)) { @@ -269,24 +267,24 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, } } else { // Just redirect stderr - if (RedirectIO(redirects[2], 2, ErrMsg)) { return false; } + if (RedirectIO(Redirects[2], 2, ErrMsg)) { return false; } } } // Set memory limits - if (memoryLimit!=0) { - SetMemoryLimits(memoryLimit); + if (MemoryLimit!=0) { + SetMemoryLimits(MemoryLimit); } // Execute! std::string PathStr = Program; - if (envp != nullptr) + if (Envp != nullptr) execve(PathStr.c_str(), - const_cast(args), - const_cast(envp)); + const_cast(Args), + const_cast(Envp)); else execv(PathStr.c_str(), - const_cast(args)); + const_cast(Args)); // If the execve() failed, we should exit. Follow Unix protocol and // return 127 if the executable was not found, and 126 otherwise. // Use _exit rather than exit so that atexit functions and static @@ -433,7 +431,8 @@ llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents, return EC; } -bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef Args) { +bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, + ArrayRef Args) { static long ArgMax = sysconf(_SC_ARG_MAX); // System says no practical limit. @@ -444,9 +443,8 @@ bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef::iterator I = Args.begin(), E = Args.end(); - I != E; ++I) { - size_t length = strlen(*I); + for (const char* Arg : Args) { + size_t length = strlen(Arg); // Ensure that we do not exceed the MAX_ARG_STRLEN constant on Linux, which // does not have a constant unlike what the man pages would have you diff --git a/lib/Support/Windows/Program.inc b/lib/Support/Windows/Program.inc index 721167da5b1..f9000d2d741 100644 --- a/lib/Support/Windows/Program.inc +++ b/lib/Support/Windows/Program.inc @@ -103,9 +103,9 @@ ErrorOr sys::findProgramByName(StringRef Name, return std::string(U8Result.begin(), U8Result.end()); } -static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) { +static HANDLE RedirectIO(const StringRef *Path, int fd, std::string* ErrMsg) { HANDLE h; - if (path == 0) { + if (Path == 0) { if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd), GetCurrentProcess(), &h, 0, TRUE, DUPLICATE_SAME_ACCESS)) @@ -114,10 +114,10 @@ static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) { } std::string fname; - if (path->empty()) + if (Path->empty()) fname = "NUL"; else - fname = *path; + fname = *Path; SECURITY_ATTRIBUTES sa; sa.nLength = sizeof(sa); @@ -125,7 +125,7 @@ static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) { sa.bInheritHandle = TRUE; SmallVector fnameUnicode; - if (path->empty()) { + if (Path->empty()) { // Don't play long-path tricks on "NUL". if (windows::UTF8ToUTF16(fname, fnameUnicode)) return INVALID_HANDLE_VALUE; @@ -207,19 +207,19 @@ static unsigned int ArgLenWithQuotes(const char *Str) { } -static std::unique_ptr flattenArgs(const char **args) { +static std::unique_ptr flattenArgs(const char **Args) { // First, determine the length of the command line. unsigned len = 0; - for (unsigned i = 0; args[i]; i++) { - len += ArgLenWithQuotes(args[i]) + 1; + for (unsigned i = 0; Args[i]; i++) { + len += ArgLenWithQuotes(Args[i]) + 1; } // Now build the command line. std::unique_ptr command(new char[len+1]); char *p = command.get(); - for (unsigned i = 0; args[i]; i++) { - const char *arg = args[i]; + for (unsigned i = 0; Args[i]; i++) { + const char *arg = Args[i]; const char *start = arg; bool needsQuoting = ArgNeedsQuotes(arg); @@ -248,9 +248,9 @@ static std::unique_ptr flattenArgs(const char **args) { return command; } -static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, - const char **envp, const StringRef **redirects, - unsigned memoryLimit, std::string *ErrMsg) { +static bool Execute(ProcessInfo &PI, StringRef Program, const char **Args, + const char **Envp, const StringRef **Redirects, + unsigned MemoryLimit, std::string *ErrMsg) { if (!sys::fs::can_execute(Program)) { if (ErrMsg) *ErrMsg = "program not executable"; @@ -268,18 +268,18 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, // Windows wants a command line, not an array of args, to pass to the new // process. We have to concatenate them all, while quoting the args that // have embedded spaces (or are empty). - std::unique_ptr command = flattenArgs(args); + std::unique_ptr command = flattenArgs(Args); // The pointer to the environment block for the new process. std::vector EnvBlock; - if (envp) { + if (Envp) { // An environment block consists of a null-terminated block of // null-terminated strings. Convert the array of environment variables to // an environment block by concatenating them. - for (unsigned i = 0; envp[i]; ++i) { + for (unsigned i = 0; Envp[i]; ++i) { SmallVector EnvString; - if (std::error_code ec = windows::UTF8ToUTF16(envp[i], EnvString)) { + if (std::error_code ec = windows::UTF8ToUTF16(Envp[i], EnvString)) { SetLastError(ec.value()); MakeErrMsg(ErrMsg, "Unable to convert environment variable to UTF-16"); return false; @@ -299,21 +299,21 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, si.hStdOutput = INVALID_HANDLE_VALUE; si.hStdError = INVALID_HANDLE_VALUE; - if (redirects) { + if (Redirects) { si.dwFlags = STARTF_USESTDHANDLES; - si.hStdInput = RedirectIO(redirects[0], 0, ErrMsg); + si.hStdInput = RedirectIO(Redirects[0], 0, ErrMsg); if (si.hStdInput == INVALID_HANDLE_VALUE) { MakeErrMsg(ErrMsg, "can't redirect stdin"); return false; } - si.hStdOutput = RedirectIO(redirects[1], 1, ErrMsg); + si.hStdOutput = RedirectIO(Redirects[1], 1, ErrMsg); if (si.hStdOutput == INVALID_HANDLE_VALUE) { CloseHandle(si.hStdInput); MakeErrMsg(ErrMsg, "can't redirect stdout"); return false; } - if (redirects[1] && redirects[2] && *(redirects[1]) == *(redirects[2])) { + if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) { // If stdout and stderr should go to the same place, redirect stderr // to the handle already open for stdout. if (!DuplicateHandle(GetCurrentProcess(), si.hStdOutput, @@ -326,7 +326,7 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, } } else { // Just redirect stderr - si.hStdError = RedirectIO(redirects[2], 2, ErrMsg); + si.hStdError = RedirectIO(Redirects[2], 2, ErrMsg); if (si.hStdError == INVALID_HANDLE_VALUE) { CloseHandle(si.hStdInput); CloseHandle(si.hStdOutput); @@ -386,14 +386,14 @@ static bool Execute(ProcessInfo &PI, StringRef Program, const char **args, // Assign the process to a job if a memory limit is defined. ScopedJobHandle hJob; - if (memoryLimit != 0) { + if (MemoryLimit != 0) { hJob = CreateJobObjectW(0, 0); bool success = false; if (hJob) { JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli; memset(&jeli, 0, sizeof(jeli)); jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_MEMORY; - jeli.ProcessMemoryLimit = uintptr_t(memoryLimit) * 1048576; + jeli.ProcessMemoryLimit = uintptr_t(MemoryLimit) * 1048576; if (SetInformationJobObject(hJob, JobObjectExtendedLimitInformation, &jeli, sizeof(jeli))) { if (AssignProcessToJobObject(hJob, pi.hProcess)) @@ -534,16 +534,16 @@ llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents, return EC; } -bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef Args) { +bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, + ArrayRef Args) { // The documented max length of the command line passed to CreateProcess. static const size_t MaxCommandStringLength = 32768; // Account for the trailing space for the program path and the // trailing NULL of the last argument. size_t ArgLength = ArgLenWithQuotes(Program.str().c_str()) + 2; - for (ArrayRef::iterator I = Args.begin(), E = Args.end(); - I != E; ++I) { + for (const char* Arg : Args) { // Account for the trailing space for every arg - ArgLength += ArgLenWithQuotes(*I) + 1; + ArgLength += ArgLenWithQuotes(Arg) + 1; if (ArgLength > MaxCommandStringLength) { return false; }