eonc::pot Namespace Reference

Functions
std::string	commandFailure (int status)
	Describe how a command run through system() ended.
void	runOrThrow (const std::string &command)
	Run a shell command, throwing when it does not succeed.
std::string	shellQuote (const std::string &text)
	Wrap a path for the shell system() hands the command to, so spaces in it survive.
std::string	shebangInterpreter (const std::filesystem::path &path)
	Return the interpreter name from a #! line, or empty.
bool	isPythonInterpreterName (std::string name)
	True when name is python, python3, python3.12, python.exe, ...
std::string	wrapResolvedProgram (const std::string &command, const std::string &python)
	Quote a resolved program path, and on Windows prefix a script so cmd.exe can start it.

Function Documentation

commandFailure()

std::string eonc::pot::commandFailure ( int status )

inlinenodiscard

Describe how a command run through system() ended.

Parameters

status

The value system() returned.

Returns

An empty string when the command ran to completion with exit status 0, otherwise a human readable reason for the failure.

Definition at line 29 of file ExternalCommand.h.

                                                          {
  if (status == -1) {
    return "could not be started";
  }
#ifndef _WIN32
  if (WIFSIGNALED(status)) {
    return "died on signal " + std::to_string(WTERMSIG(status));
  }
  if (!WIFEXITED(status)) {
    return "terminated abnormally";
  }
  if (WEXITSTATUS(status) != 0) {
    return "exited with status " + std::to_string(WEXITSTATUS(status));
  }
#else
  if (status != 0) {
    return "exited with status " + std::to_string(status);
  }
#endif
  return {};
}

isPythonInterpreterName()

bool eonc::pot::isPythonInterpreterName ( std::string name )

inline

True when name is python, python3, python3.12, python.exe, ...

Definition at line 96 of file ExtPotCommand.h.

                                                    {
  for (char &c : name) {
    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
  }
  constexpr std::string_view exe{".exe"};
  if (name.size() > exe.size() &&
      name.compare(name.size() - exe.size(), exe.size(), exe.data()) == 0) {
    name.resize(name.size() - exe.size());
  }
  return name.rfind("python", 0) == 0;
}

runOrThrow()

void eonc::pot::runOrThrow ( const std::string & command )

inline

Run a shell command, throwing when it does not succeed.

External potentials feed whatever the command leaves behind straight into the optimizer, so a failed command has to stop the run rather than let the caller parse a stale or partial result file.

Definition at line 56 of file ExternalCommand.h.

                                                 {
  const std::string reason = commandFailure(std::system(command.c_str()));
  if (!reason.empty()) {
    throw std::runtime_error("Command \"" + command + "\" " + reason);
  }
}

shebangInterpreter()

std::string eonc::pot::shebangInterpreter ( const std::filesystem::path & path )

inline

Return the interpreter name from a #! line, or empty.

#!/usr/bin/env python3 and #!/usr/bin/python3 both yield python3. env flags (-S) are skipped. A file with no shebang yields empty.

Definition at line 48 of file ExtPotCommand.h.

                                                                   {
  std::ifstream in(path);
  std::string line;
  if (!in || !std::getline(in, line)) {
    return {};
  }
  if (!line.empty() && line.back() == '\r') {
    line.pop_back();
  }
  if (line.size() < 2 || line[0] != '#' || line[1] != '!') {
    return {};
  }
  std::string rest = line.substr(2);
  auto take = [](std::string &s) -> std::string {
    const auto begin = s.find_first_not_of(" \t");
    if (begin == std::string::npos) {
      s.clear();
      return {};
    }
    const auto end = s.find_first_of(" \t", begin);
    std::string tok = end == std::string::npos ? s.substr(begin)
                                               : s.substr(begin, end - begin);
    if (end == std::string::npos) {
      s.clear();
    } else {
      s.erase(0, end);
    }
    return tok;
  };
  const std::string first = take(rest);
  if (first.empty()) {
    return {};
  }
  std::string name = std::filesystem::path(first).filename().string();
  if (name == "env") {
    std::string tok = take(rest);
    while (!tok.empty() && tok.front() == '-') {
      tok = take(rest);
    }
    if (tok.empty()) {
      return {};
    }
    name = std::filesystem::path(tok).filename().string();
  }
  return name;
}

shellQuote()

std::string eonc::pot::shellQuote ( const std::string & text )

inline

Wrap a path for the shell system() hands the command to, so spaces in it survive.

Definition at line 25 of file ExtPotCommand.h.

                                                   {
#ifdef _WIN32
  // cmd.exe takes double quotes and offers no escape for an embedded one,
  // which a Windows path cannot hold anyway.
  return "\"" + text + "\"";
#else
  std::string quoted{"'"};
  for (const char c : text) {
    if (c == '\'') {
      quoted += "'\\''";
    } else {
      quoted += c;
    }
  }
  quoted += "'";
  return quoted;
#endif
}

wrapResolvedProgram()

std::string eonc::pot::wrapResolvedProgram ( const std::string & command, const std::string & python )

inline

Quote a resolved program path, and on Windows prefix a script so cmd.exe can start it.

cmd.exe will not execute an extensionless file, quoted or not. A Python shebang or a .py suffix becomes python "path". A native .exe / .bat / .cmd is quoted only. A command line that is not a single existing file is returned unchanged.

Definition at line 115 of file ExtPotCommand.h.

                                                                {
  std::error_code ec;
  if (!std::filesystem::is_regular_file(command, ec) || ec) {
    return command;
  }
#ifdef _WIN32
  const std::filesystem::path named{command};
  std::string ext = named.extension().string();
  for (char &c : ext) {
    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
  }
  if (ext == ".exe" || ext == ".com" || ext == ".bat" || ext == ".cmd") {
    return shellQuote(command);
  }
  const std::string interp = shebangInterpreter(named);
  if (isPythonInterpreterName(interp) || ext == ".py" || ext == ".pyw") {
    const std::string runner = python.empty() ? std::string{"python"} : python;
    return runner + " " + shellQuote(command);
  }
  if (!interp.empty()) {
    return interp + " " + shellQuote(command);
  }
  return shellQuote(command);
#else
  (void)python;
  return shellQuote(command);
#endif
}