Portable Namespace Reference

Functions
int	system (const QCString &command, const QCString &args, bool commandHasConsole=true)
uint32_t	pid ()
QCString	getenv (const QCString &variable)
void	setenv (const QCString &variable, const QCString &value)
void	unsetenv (const QCString &variable)
FILE *	fopen (const QCString &fileName, const QCString &mode)
int	fclose (FILE *f)
void	unlink (const QCString &fileName)
QCString	pathSeparator ()
QCString	pathListSeparator ()
const char *	ghostScriptCommand ()
const char *	commandExtension ()
bool	fileSystemIsCaseSensitive ()
FILE *	popen (const QCString &name, const QCString &type)
int	pclose (FILE *stream)
double	getSysElapsedTime ()
bool	isAbsolutePath (const QCString &fileName)
void	correctPath (const StringVector &list)
	Correct a possible wrong PATH variable.
void	setShortDir ()
const char *	strnstr (const char *haystack, const char *needle, size_t haystack_len)
const char *	devNull ()
bool	checkForExecutable (const QCString &fileName)
size_t	recodeUtf8StringToW (const QCString &inputStr, uint16_t **buf)
std::ofstream	openOutputStream (const QCString &name, bool append=false)
std::ifstream	openInputStream (const QCString &name, bool binary=false, bool openAtEnd=false)

Function Documentation

checkForExecutable()

bool Portable::checkForExecutable

(

const QCString &

fileName

)

Definition at line 440 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  const char *extensions[] = {".bat",".com",".exe"};
  for (int i = 0; i < sizeof(extensions) / sizeof(*extensions); i++)
  {
    if (ExistsOnPath(fileName + extensions[i])) return true;
  }
  return false;
#else
  return ExistsOnPath(fileName);
#endif
}

References ExistsOnPath().

Referenced by generateFormula().

commandExtension()

const char * Portable::commandExtension

(

)

Definition at line 478 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
    return ".exe";
#else
    return "";
#endif
}

Referenced by Config::checkAndCorrect(), computeVerifiedDotPath(), and writeDiaGraphFromFile().

correctPath()

void Portable::correctPath

(

const StringVector &

extraPaths

)

Correct a possible wrong PATH variable.

This routine was inspired by the cause for bug 766059 was that in the Windows path there were forward slashes.

Definition at line 533 of file portable.cpp.

{
  QCString p = Portable::getenv("PATH");
  bool first=true;
  QCString result;
#if defined(_WIN32) && !defined(__CYGWIN__)
  for (const auto &path : extraPaths)
  {
    if (!first) result+=';';
    first=false;
    result += substitute(QCString(path),"/","\\");
  }
  if (!result.isEmpty() && !p.isEmpty()) result+=';';
  result += substitute(p,"/","\\");
#else
  for (const auto &path : extraPaths)
  {
    if (!first) result+=':';
    first=false;
    result += QCString(path);
  }
  if (!result.isEmpty() && !p.isEmpty()) result+=':';
  result += p;
#endif
  if (result!=p) Portable::setenv("PATH",result.data());
  //printf("settingPath(%s) #extraPaths=%zu\n",Portable::getenv("PATH").data(),extraPaths.size());
}

References QCString::data(), getenv(), QCString::isEmpty(), setenv(), and substitute().

Referenced by parseInput().

devNull()

const char * Portable::devNull

(

)

Definition at line 631 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  return "NUL";
#else
  return "/dev/null";
#endif
}

Referenced by createDVIFile(), createSVGFromPDFviaInkscape(), and determineInkscapeVersion().

fclose()

int Portable::fclose

(

FILE *

f

)

Definition at line 386 of file portable.cpp.

{
  return ::fclose(f);
}

Referenced by OutputGenerator::endPlainFile(), finishWarnExit(), and initWarningFormat().

fileSystemIsCaseSensitive()

bool Portable::fileSystemIsCaseSensitive

(

)

Definition at line 487 of file portable.cpp.

{
#if defined(_WIN32) || defined(macintosh) || defined(__MACOSX__) || defined(__APPLE__) || defined(__CYGWIN__)
  return FALSE;
#else
  return TRUE;
#endif
}

References FALSE, and TRUE.

Referenced by findFileDef(), getCaseSenseNames(), and getFilterFromList().

fopen()

FILE * Portable::fopen	(	const QCString &	fileName,
		const QCString &	mode )

Definition at line 366 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  uint16_t *fn = nullptr;
  size_t fn_len = recodeUtf8StringToW(fileName,&fn);
  uint16_t *m  = nullptr;
  size_t m_len = recodeUtf8StringToW(mode,&m);
  FILE *result = nullptr;
  if (fn_len!=(size_t)-1 && m_len!=(size_t)-1)
  {
    result = _wfopen((wchar_t*)fn,(wchar_t*)m);
  }
  delete[] fn;
  delete[] m;
  return result;
#else
  return ::fopen(fileName.data(),mode.data());
#endif
}

References QCString::data(), and recodeUtf8StringToW().

Referenced by checkPngResult(), FilterCache::getFileContentsPipe(), initWarningFormat(), DotRunner::run(), OutputGenerator::startPlainFile(), and tryPath().

getenv()

QCString Portable::getenv

(

const QCString &

variable

)

Definition at line 338 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
    #define ENV_BUFSIZE 32768
    LPTSTR pszVal = (LPTSTR) malloc(ENV_BUFSIZE*sizeof(TCHAR));
    if (GetEnvironmentVariable(variable.data(),pszVal,ENV_BUFSIZE) == 0) return "";
    QCString out;
    out = pszVal;
    free(pszVal);
    return out;
    #undef ENV_BUFSIZE
#else
    if(!environmentLoaded) // if the environment variables are not loaded already...
    {                      // ...call loadEnvironment to store them in class
      loadEnvironment();
    }
 
    if (proc_env.find(variable.str()) != proc_env.end())
    {
      return QCString(proc_env[variable.str()]);
    }
    else
    {
      return QCString();
    }
#endif
}

References QCString::data(), environmentLoaded, loadEnvironment(), proc_env, and QCString::str().

Referenced by correctPath(), ExistsOnPath(), getCurrentDateTime(), initDoxygen(), parseInput(), setDotFontPath(), and substEnvVarsInString().

getSysElapsedTime()

double Portable::getSysElapsedTime

(

)

Definition at line 98 of file portable.cpp.

{
  return SysTimeKeeper::instance().elapsedTime();
}

References SysTimeKeeper::elapsedTime(), and SysTimeKeeper::instance().

Referenced by generateOutput().

ghostScriptCommand()

const char * Portable::ghostScriptCommand

(

)

Definition at line 454 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
    static const char *gsexe = nullptr;
    if (!gsexe)
    {
        const char *gsExec[] = {"gswin32c.exe","gswin64c.exe"};
        for (int i = 0; i < sizeof(gsExec) / sizeof(*gsExec); i++)
        {
            if (ExistsOnPath(gsExec[i]))
            {
                gsexe = gsExec[i];
                return gsexe;
            }
        }
        gsexe = gsExec[0];
        return gsexe;
    }
    return gsexe;
#else
    return "gs";
#endif
}

References ExistsOnPath().

Referenced by createCroppedEPS(), createCroppedPDF(), createEPSbboxFile(), createPNG(), and writeMakeBat().

isAbsolutePath()

bool Portable::isAbsolutePath

(

const QCString &

fileName

)

Definition at line 514 of file portable.cpp.

{
  const char *fn = fileName.data();
# ifdef _WIN32
  if (fileName.length()>1 && isalpha(fileName[0]) && fileName[1]==':') fn+=2;
# endif
  char const fst = fn[0];
  if (fst == '/') return true;
# ifdef _WIN32
  if (fst == '\\') return true;
# endif
  return false;
}

References QCString::data(), and QCString::length().

Referenced by findFile(), findFile(), generateOutput(), Markdown::Private::processLink(), and readTextFileByName().

openInputStream()

std::ifstream Portable::openInputStream	(	const QCString &	name,
		bool	binary = false,
		bool	openAtEnd = false )

Definition at line 676 of file portable.cpp.

{
  std::ios_base::openmode mode = std::ifstream::in | std::ifstream::binary;
  if (binary)     mode |= std::ios::binary;
  if (openAtEnd)  mode |= std::ios::ate;
#if defined(__clang__) && defined(__MINGW32__)
  return std::ifstream(fs::path(fileName.str()).wstring(), mode);
#else
  return std::ifstream(fs::path(fileName.str()), mode);
#endif
}

References QCString::str().

Referenced by configFileToString(), convertMapFile(), DotFilePatcher::convertMapFile(), determineInkscapeVersion(), finishWarnExit(), CitationManager::generatePage(), FormulaManager::initFromRepository(), CitationManager::insertCrossReferencesForBibFile(), Htags::loadFilemap(), preProcessFile(), DotRunner::readBoundingBox(), FilterCache::readFragmentFromFile(), readInputFile(), readSVGSize(), resetPDFSize(), DotFilePatcher::run(), sameMd5Signature(), testRTFOutput(), and updateEPSBoundingBox().

openOutputStream()

std::ofstream Portable::openOutputStream	(	const QCString &	name,
		bool	append = false )

Definition at line 665 of file portable.cpp.

{
  std::ios_base::openmode mode = std::ofstream::out | std::ofstream::binary;
  if (append) mode |= std::ofstream::app;
#if defined(__clang__) && defined(__MINGW32__)
  return std::ofstream(fs::path(fileName.str()).wstring(), mode);
#else
  return std::ofstream(fs::path(fileName.str()), mode);
#endif
}

References QCString::str().

Referenced by Qhp::addContentsItem(), ResourceMgr::copyResourceAs(), FormulaManager::createFormulasTexFile(), FormulaManager::createLatexFile(), PerlModGenerator::createOutputFile(), HtmlHelp::Private::createProjectFile(), dumpSymbolMap(), EclipseHelp::finalize(), generateDEF(), generateJSNavTree(), generateJSTreeFiles(), CitationManager::generatePage(), generateXML(), generateXMLForClass(), generateXMLForConcept(), generateXMLForDir(), generateXMLForFile(), generateXMLForGroup(), generateXMLForModule(), generateXMLForNamespace(), generateXMLForPage(), HtmlGenerator::init(), Crawlmap::initialize(), DocSets::initialize(), EclipseHelp::initialize(), HtmlHelp::initialize(), Qhp::initialize(), Sitemap::initialize(), openOutputFile(), DocbookDocVisitor::operator()(), HtmlDocVisitor::operator()(), LatexDocVisitor::operator()(), RTFDocVisitor::operator()(), DotGraph::prepareDotFile(), RTFGenerator::preProcessFileInplace(), resetPDFSize(), DotFilePatcher::run(), runPlantumlContent(), ManGenerator::startDoxyAnchor(), updateEPSBoundingBox(), SearchIndex::write(), SearchIndexExternal::write(), ResourceMgr::writeCategory(), writeCombineScript(), HtmlGenerator::writeExternalSearchPage(), ClassDiagram::writeFigure(), FlowChart::writeFlowChart(), writeJavascriptSearchData(), writeJavaScriptSearchIndex(), writeJavasScriptSearchDataPage(), writeLatexMakefile(), writeMakeBat(), writeMenuData(), HtmlGenerator::writeSearchData(), HtmlGenerator::writeSearchPage(), and writeTagFile().

pathListSeparator()

QCString Portable::pathListSeparator

(

)

Definition at line 400 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  return ";";
#else
  return ":";
#endif
}

Referenced by ExistsOnPath(), parseInput(), runPlantumlContent(), and setDotFontPath().

pathSeparator()

QCString Portable::pathSeparator

(

)

Definition at line 391 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  return "\\";
#else
  return "/";
#endif
}

Referenced by Config::checkAndCorrect(), ExistsOnPath(), findFilePath(), readTextFileByName(), writeDiaGraphFromFile(), and writeMscGraphFromFile().

pclose()

int Portable::pclose

(

FILE *

stream

)

Definition at line 505 of file portable.cpp.

{
  #if defined(_MSC_VER) || defined(__BORLANDC__)
  return ::_pclose(stream);
  #else
  return ::pclose(stream);
  #endif
}

Referenced by FileDefImpl::acquireFileVersion(), FilterCache::getFileContentsPipe(), readInputFile(), runQHelpGenerator(), and stackTrace().

pid()

uint32_t Portable::pid

(

)

Definition at line 265 of file portable.cpp.

{
  uint32_t pid;
#if !defined(_WIN32) || defined(__CYGWIN__)
  pid = static_cast<uint32_t>(getpid());
#else
  pid = static_cast<uint32_t>(GetCurrentProcessId());
#endif
  return pid;
}

References pid().

Referenced by initWarningFormat(), parseInput(), pid(), and system().

popen()

FILE * Portable::popen	(	const QCString &	name,
		const QCString &	type )

Definition at line 496 of file portable.cpp.

{
  #if defined(_MSC_VER) || defined(__BORLANDC__)
  return ::_popen(name.data(),type.data());
  #else
  return ::popen(name.data(),type.data());
  #endif
}

References QCString::data().

Referenced by FileDefImpl::acquireFileVersion(), FilterCache::getFileContentsPipe(), readInputFile(), runQHelpGenerator(), and stackTrace().

recodeUtf8StringToW()

size_t Portable::recodeUtf8StringToW	(	const QCString &	inputStr,
		uint16_t **	buf )

Definition at line 640 of file portable.cpp.

{
  if (inputStr.isEmpty() || outBuf==nullptr) return 0; // empty input or invalid output
  void *handle = portable_iconv_open("UTF-16LE","UTF-8");
  if (handle==reinterpret_cast<void *>(-1)) return 0; // invalid encoding
  size_t len = inputStr.length();
  uint16_t *buf = new uint16_t[len+1];
  *outBuf = buf;
  size_t inRemains  = len;
  size_t outRemains = len*sizeof(uint16_t)+2; // chars + \0
  const char *p = inputStr.data();
  portable_iconv(handle,&p,&inRemains,reinterpret_cast<char **>(&buf),&outRemains);
  *buf=0;
  portable_iconv_close(handle);
  return len;
}

References QCString::data(), QCString::isEmpty(), QCString::length(), portable_iconv(), portable_iconv_close(), and portable_iconv_open().

Referenced by fopen(), and system().

setenv()

void Portable::setenv	(	const QCString &	variable,
		const QCString &	value )

Definition at line 303 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
    SetEnvironmentVariable(name.data(),!value.isEmpty() ? value.data() : "");
#else
    if(!environmentLoaded) // if the environment variables are not loaded already...
    {                                 // ...call loadEnvironment to store them in class
      loadEnvironment();
    }
 
    proc_env[name.str()] = value.str(); // create or replace existing value
    ::setenv(name.data(),value.data(),1);
#endif
}

References QCString::data(), environmentLoaded, QCString::isEmpty(), loadEnvironment(), proc_env, setenv(), and QCString::str().

Referenced by correctPath(), initDoxygen(), parseInput(), setDotFontPath(), setenv(), and unsetDotFontPath().

setShortDir()

void Portable::setShortDir

(

)

Definition at line 570 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  long     length = 0;
  TCHAR*   buffer = nullptr;
  // First obtain the size needed by passing nullptr and 0.
  length = GetShortPathName(Dir::currentDirPath().c_str(), nullptr, 0);
  // Dynamically allocate the correct size
  // (terminating null char was included in length)
  buffer = new TCHAR[length];
  // Now simply call again using same (long) path.
  length = GetShortPathName(Dir::currentDirPath().c_str(), buffer, length);
  // Set the correct directory (short name)
  Dir::setCurrent(buffer);
  delete [] buffer;
#endif
}

References Dir::currentDirPath(), and Dir::setCurrent().

Referenced by runHtmlHelpCompiler().

strnstr()

const char * Portable::strnstr	(	const char *	haystack,
		const char *	needle,
		size_t	haystack_len )

Definition at line 617 of file portable.cpp.

{
  size_t needle_len = strnlen(needle, haystack_len);
  if (needle_len < haystack_len || !needle[needle_len])
  {
    const char *x = portable_memmem(haystack, haystack_len, needle, needle_len);
    if (x && !memchr(haystack, 0, x - haystack))
    {
      return x;
    }
  }
  return nullptr;
}

References portable_memmem().

Referenced by Markdown::Private::addStrEscapeUtf8Nbsp().

system()

int Portable::system	(	const QCString &	command,
		const QCString &	args,
		bool	commandHasConsole = true )

taken from the system() manpage on my Linux box

Definition at line 106 of file portable.cpp.

{
  if (command.isEmpty()) return 1;
  AutoTimeKeeper timeKeeper;
 
#if defined(_WIN32) && !defined(__CYGWIN__)
  QCString commandCorrectedPath = substitute(command,'/','\\');
  QCString fullCmd=commandCorrectedPath;
#else
  QCString fullCmd=command;
#endif
  fullCmd=fullCmd.stripWhiteSpace();
  if (fullCmd.at(0)!='"' && fullCmd.find(' ')!=-1)
  {
    // add quotes around command as it contains spaces and is not quoted already
    fullCmd="\""+fullCmd+"\"";
  }
  fullCmd += " ";
  fullCmd += args;
#ifndef NODEBUG
  Debug::print(Debug::ExtCmd,0,"Executing external command `{}`\n",fullCmd);
#endif
 
#if !defined(_WIN32) || defined(__CYGWIN__)
  (void)commandHasConsole;
  /*! taken from the system() manpage on my Linux box */
  int pid,status=0;
 
#ifdef _OS_SOLARIS // for Solaris we use vfork since it is more memory efficient
 
  // on Solaris fork() duplicates the memory usage
  // so we use vfork instead
 
  // spawn shell
  if ((pid=vfork())<0)
  {
    status=-1;
  }
  else if (pid==0)
  {
     execl("/bin/sh","sh","-c",fullCmd.data(),(char*)0);
     _exit(127);
  }
  else
  {
    while (waitpid(pid,&status,0 )<0)
    {
      if (errno!=EINTR)
      {
        status=-1;
        break;
      }
    }
  }
  return status;
 
#else  // Other Unices just use fork
 
  pid = fork();
  if (pid==-1)
  {
    perror("fork error");
          return -1;
  }
  if (pid==0)
  {
    const char * const argv[4] = { "sh", "-c", fullCmd.data(), 0 };
    execve("/bin/sh",const_cast<char * const*>(argv),environ);
    exit(127);
  }
  for (;;)
  {
    if (waitpid(pid,&status,0)==-1)
    {
      if (errno!=EINTR) return -1;
    }
    else
    {
      if (WIFEXITED(status))
      {
        return WEXITSTATUS(status);
      }
      else
      {
        return status;
      }
    }
  }
#endif // !_OS_SOLARIS
 
#else // Win32 specific
  if (commandHasConsole)
  {
    return ::system(fullCmd.data());
  }
  else
  {
    // Because ShellExecuteEx can delegate execution to Shell extensions
    // (data sources, context menu handlers, verb implementations) that
    // are activated using Component Object Model (COM), COM should be
    // initialized before ShellExecuteEx is called. Some Shell extensions
    // require the COM single-threaded apartment (STA) type.
    // For that case COM is initialized as follows
    CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
 
    uint16_t *commandw = nullptr;
    recodeUtf8StringToW( commandCorrectedPath, &commandw );
    uint16_t *argsw = nullptr;
    recodeUtf8StringToW( args, &argsw );
 
    // gswin32 is a GUI api which will pop up a window and run
    // asynchronously. To prevent both, we use ShellExecuteEx and
    // WaitForSingleObject (thanks to Robert Golias for the code)
 
    SHELLEXECUTEINFOW sInfo = {
      sizeof(SHELLEXECUTEINFOW),   /* structure size */
      SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI,  /* tell us the process
                                                       *  handle so we can wait till it's done |
                                                       *  do not display msg box if error
                                                       */
      nullptr,                       /* window handle */
      nullptr,                       /* action to perform: open */
      (LPCWSTR)commandw,          /* file to execute */
      (LPCWSTR)argsw,             /* argument list */
      nullptr,                       /* use current working dir */
      SW_HIDE,                    /* minimize on start-up */
      nullptr,                          /* application instance handle */
      nullptr,                       /* ignored: id list */
      nullptr,                       /* ignored: class name */
      nullptr,                       /* ignored: key class */
      0,                          /* ignored: hot key */
      nullptr,                       /* ignored: icon */
      nullptr                        /* resulting application handle */
    };
 
    if (!ShellExecuteExW(&sInfo))
    {
      delete[] commandw;
      delete[] argsw;
      return -1;
    }
    else if (sInfo.hProcess)      /* executable was launched, wait for it to finish */
    {
      WaitForSingleObject(sInfo.hProcess,INFINITE);
      /* get process exit code */
      DWORD exitCode;
      bool retval = GetExitCodeProcess(sInfo.hProcess,&exitCode);
      CloseHandle(sInfo.hProcess);
      delete[] commandw;
      delete[] argsw;
      if (!retval) return -1;
      return exitCode;
    }
  }
#endif
  return 1; // we should never get here
 
}

References QCString::at(), QCString::data(), environ, Debug::ExtCmd, QCString::find(), QCString::isEmpty(), pid(), Debug::print(), recodeUtf8StringToW(), QCString::stripWhiteSpace(), and substitute().

Referenced by createCroppedEPS(), createCroppedPDF(), createDVIFile(), createEPSbboxFile(), createPNG(), createPostscriptFile(), FlowChart::createSVG(), createSVGFromPDF(), createSVGFromPDFviaInkscape(), determineInkscapeVersion(), do_mscgen_generate(), Htags::execute(), DocParser::findAndCopyImage(), CitationManager::generatePage(), DotRunner::run(), runHtmlHelpCompiler(), runPlantumlContent(), runQHelpGenerator(), writeDiaGraphFromFile(), ClassDiagram::writeFigure(), and writeMscGraphFromFile().

unlink()

void Portable::unlink

(

const QCString &

fileName

)

Definition at line 561 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
  _unlink(fileName.data());
#else
  ::unlink(fileName.data());
#endif
}

References QCString::data(), and unlink().

Referenced by finishWarnExit(), RTFGenerator::preProcessFileInplace(), DotRunner::run(), and unlink().

unsetenv()

void Portable::unsetenv

(

const QCString &

variable

)

Definition at line 318 of file portable.cpp.

{
#if defined(_WIN32) && !defined(__CYGWIN__)
    SetEnvironmentVariable(variable.data(),nullptr);
#else
    /* Some systems don't have unsetenv(), so we do it ourselves */
    if (variable.isEmpty() || variable.find('=')!=-1)
    {
      return; // not properly formatted
    }
 
    auto it = proc_env.find(variable.str());
    if (it != proc_env.end())
    {
      proc_env.erase(it);
      ::unsetenv(variable.data());
    }
#endif
}

References QCString::data(), QCString::find(), QCString::isEmpty(), proc_env, QCString::str(), and unsetenv().

Referenced by setDotFontPath(), unsetDotFontPath(), and unsetenv().