portable.cpp File Reference

#include "portable.h"
#include "qcstring.h"
#include <stdlib.h>
#include <stdio.h>
#include <chrono>
#include <thread>
#include <mutex>
#include <map>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <assert.h>
#include <ctype.h>
#include <string>
#include "fileinfo.h"
#include "message.h"
#include "util.h"
#include "dir.h"
#include "debug.h"
#include "filesystem.hpp"

Include dependency graph for portable.cpp:

Go to the source code of this file.

Classes
class	SysTimeKeeper
struct	SysTimeKeeper::TimeData
class	AutoTimeKeeper

Functions
void	loadEnvironment ()
static bool	ExistsOnPath (const QCString &fileName)
static const char *	portable_memmem (const char *haystack, size_t haystack_len, const char *needle, size_t needle_len)

Variables
char **	environ
static bool	environmentLoaded = false
static std::map< std::string, std::string >	proc_env = std::map<std::string,std::string>()

Function Documentation

ExistsOnPath()

static bool ExistsOnPath ( const QCString & fileName )

static

Definition at line 409 of file portable.cpp.

{
  FileInfo fi1(fileName.str());
  if (fi1.exists()) return true;
 
  QCString paths = Portable::getenv("PATH");
  char listSep = Portable::pathListSeparator()[0];
  char pathSep = Portable::pathSeparator()[0];
  int strt = 0;
  int idx;
  while ((idx = paths.find(listSep,strt)) != -1)
  {
    QCString locFile(paths.mid(strt,idx-strt));
    locFile += pathSep;
    locFile += fileName;
    FileInfo fi(locFile.str());
    if (fi.exists()) return true;
    strt = idx + 1;
  }
  // to be sure the last path component is checked as well
  QCString locFile(paths.mid(strt));
  if (!locFile.isEmpty())
  {
    locFile += pathSep;
    locFile += fileName;
    FileInfo fi(locFile.str());
    if (fi.exists()) return true;
  }
  return false;
}

References FileInfo::exists(), QCString::find(), Portable::getenv(), QCString::isEmpty(), QCString::mid(), Portable::pathListSeparator(), Portable::pathSeparator(), and QCString::str().

Referenced by Portable::checkForExecutable(), and Portable::ghostScriptCommand().

loadEnvironment()

void loadEnvironment

(

)

Definition at line 277 of file portable.cpp.

{
  if(environ != nullptr)
  {
    unsigned int i = 0;
    char* current = environ[i];
 
    while(current != nullptr)                            // parse all strings contained by environ til the last element (nullptr)
    {
      std::string env_var(current);                   // load current environment variable string
      size_t pos = env_var.find("=");
      if(pos != std::string::npos)                    // only parse the variable, if it is a valid environment variable...
      {                                               // ...which has to contain an equal sign as delimiter by definition
        std::string name = env_var.substr(0,pos);     // the string til the equal sign contains the name
        std::string value = env_var.substr(pos + 1);  // the string from the equal sign contains the value
        proc_env[name] = std::move(value);            // save the value by the name as its key in the classes map
      }
      i++;
      current = environ[i];
    }
  }
 
  environmentLoaded = true;
}

References environ, environmentLoaded, and proc_env.

Referenced by Portable::getenv(), and Portable::setenv().

portable_memmem()

static const char * portable_memmem ( const char * haystack, size_t haystack_len, const char * needle, size_t needle_len )

static

Definition at line 589 of file portable.cpp.

{
  const char *const last_possible = haystack + haystack_len - needle_len;
 
  if (needle_len == 0)
    // The first occurrence of the empty string should to occur at the beginning of the string.
  {
    return haystack;
  }
 
  // Sanity check
  if (haystack_len < needle_len)
  {
    return nullptr;
  }
 
  for (const char *begin = haystack; begin <= last_possible; ++begin)
  {
    if (begin[0] == needle[0] && !memcmp(&begin[1], needle + 1, needle_len - 1))
    {
      return begin;
    }
  }
 
  return nullptr;
}

References begin().

Referenced by Portable::strnstr().

Variable Documentation

environ

char** environ

extern

Referenced by loadEnvironment(), and Portable::system().

environmentLoaded

bool environmentLoaded = false

static

Definition at line 38 of file portable.cpp.

Referenced by Portable::getenv(), loadEnvironment(), and Portable::setenv().

proc_env

std::map<std::string,std::string> proc_env = std::map<std::string,std::string>()

static

Definition at line 39 of file portable.cpp.

Referenced by Portable::getenv(), loadEnvironment(), Portable::setenv(), and Portable::unsetenv().