Beispiel #1
0
int pkg_config(int argc, char **argv, Target &target) {
  (void)argc;

  std::vector<envvar> envvars;
  std::vector<envvar> unset;
  envvar evar;

  if (!getenv("OSXCROSS_PKG_CONFIG_NO_MP_INC")) {
    std::string MacPortsSysRoot;

    if (target.getMacPortsSysRootDir(MacPortsSysRoot)) {
      concatEnvVariable("OSXCROSS_PKG_CONFIG_SYSROOT_DIR", MacPortsSysRoot);
      std::string MacPortsPkgConfigPath;

      if (target.getMacPortsPkgConfigDir(MacPortsPkgConfigPath))
        concatEnvVariable("OSXCROSS_PKG_CONFIG_PATH", MacPortsPkgConfigPath);
    }
  } else {
    unsetenv("OSXCROSS_PKG_CONFIG_NO_MP_INC");
  }

  // Map OSXCROSS_PKG_* to PKG_*.
  for (char **env = environ; *env; ++env) {
    char *p = *env;

    if (!strncmp(p, "OSXCROSS_PKG_CONFIG", 19)) {
      p += 9; // skip OSXCROSS_
      envvars.push_back(var(p, evar));
    } else if (!strncmp(p, "PKG_CONFIG", 10)) {
      // Unset native pkg-config vars.
      unset.push_back(var(p, evar, true));
    }
  }

  if (!envvars.empty()) {
    for (const envvar &evar : unset)
      unsetenv(evar.name.c_str());

    for (const envvar &evar : envvars)
      setenv(evar.name.c_str(), evar.value.c_str(), 1);

    // Prevent pkg-config from looking for *.pc files
    // in pre-defined search paths, such as /usr.
    if (!getenv("PKG_CONFIG_LIBDIR"))
      setenv("PKG_CONFIG_LIBDIR", "", 1);

    if (execvp("pkg-config", argv))
      err << "cannot find or execute pkg-config" << err.endl();
  }

  return 1;
}
Beispiel #2
0
int man(int argc, char **argv, Target &target) {
  std::string SDKPath;

  if (!target.getSDKPath(SDKPath))
    return 1;

  std::vector<std::string> manpaths;

  manpaths.push_back(SDKPath + "/usr/share/man");
  manpaths.push_back(std::string(target.execpath) + "/../share/man");

  unsetenv("MANPATH");

  for (const std::string &manpath : manpaths)
    if (dirExists(manpath))
      concatEnvVariable("MANPATH", manpath);

  if (!getenv("MANPATH")) {
    err << "cannot find man pages!" << err.endl();
    return 1;
  }

  std::vector<char *> args;

  // All the const violation here doesn't matter,
  // the arguments won't be modified

  args.push_back(const_cast<char *>("man"));

  for (int i = 1; i < argc; ++i) {
    char *arg = argv[i];

    // Rewrite gcc to <triple>-gcc for compatibility
    // with other man pages

    constexpr const char *GCCManPages[] = { "gcc", "g++", "cpp", "gcov" };

    for (const char *mp : GCCManPages) {
      if (!strcmp(mp, arg)) {
        std::string *str = new std::string; // Intentionally "leaked"
        target.getDefaultTriple(*str);
        str->append("-");
        str->append(arg);
        arg = const_cast<char *>(str->c_str());
        break;
      }
    }

    args.push_back(arg);
  }

  args.push_back(nullptr);

  execvp(args[0], args.data());
  err << "cannot execute '" << args[0] << "'" << err.endl();
  return 1;
}