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

portable.cpp 的引用(Include)关系图:

函数
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)

变量
char **	environ

static bool	environmentLoaded = false

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

static double	g_sysElapsedTime

static std::chrono::steady_clock::time_point	g_startTime

函数说明

◆ ExistsOnPath()

static bool ExistsOnPath ( const QCString & fileName )

static

在文件 portable.cpp 第 365 行定义.

 {
   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;
 }

引用了 FileInfo::exists(), QCString::find(), Portable::getenv(), QCString::isEmpty(), QCString::mid(), Portable::pathListSeparator(), Portable::pathSeparator() , 以及 QCString::str().

被这些函数引用 Portable::checkForExecutable() , 以及 Portable::ghostScriptCommand().

◆ loadEnvironment()

void loadEnvironment ( )

在文件 portable.cpp 第 219 行定义.

 {
   if(environ != NULL)
   {
     unsigned int i = 0;
     char* current = environ[i];
  
     while(current != NULL)                            // parse all strings contained by environ til the last element (NULL)
     {
       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] = value;                       // save the value by the name as its key in the classes map
       }
       i++;
       current = environ[i];
     }
   }
  
   environmentLoaded = true;
 }

引用了 environ, environmentLoaded , 以及 proc_env.

被这些函数引用 Portable::getenv() , 以及 Portable::setenv().

◆ portable_memmem()

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

static

在文件 portable.cpp 第 553 行定义.

 {
   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 0;
   }
  
   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 0;
 }