Session.h

/* miktex/Core/Session.h: MiKTeX session
 
   Copyright (C) 1996-2022 Christian Schenk
 
   This file is part of the MiKTeX Core Library.
 
   The MiKTeX Core Library is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.
 
   The MiKTeX Core Library is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with the MiKTeX Core Library; if not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA. */
 
#pragma once
 
#if !defined(B4CE13E8A2514CC8B46D9F6D49EEDC60)
#define B4CE13E8A2514CC8B46D9F6D49EEDC60
 
#include <miktex/Core/config.h>
 
#if defined(MIKTEX_WINDOWS)
#  include <Windows.h>
#endif
 
#include <cstddef>
 
#include <chrono>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
#include <miktex/Configuration/ConfigurationProvider>
#include <miktex/Configuration/HasNamedValues>
#include <miktex/Configuration/TriState>
#include <miktex/Core/Text>
#include <miktex/Util/OptionSet>
#include <miktex/Util/PathName>
#include <miktex/Trace/TraceCallback>
#include <miktex/Util/DateUtil>
 
#include "Exceptions.h"
#include "File.h"
#include "FileType.h"
#include "Process.h"
#include "RootDirectoryInfo.h"
#include "VersionNumber.h"
 
#define MIKTEX_SESSION() ([]()                      \
{                                                   \
    auto session = MiKTeX::Core::Session::TryGet(); \
    if (session == nullptr)                         \
    {                                               \
        MIKTEX_UNEXPECTED();                        \
    }                                               \
    return session;                                 \
}                                                   \
())
 
MIKTEX_CORE_BEGIN_NAMESPACE;
 
constexpr unsigned INVALID_ROOT_INDEX = static_cast<unsigned>(-1);
 
enum class MiKTeXConfiguration
{
  None,
  Regular,
  Direct,
  Portable,
};
 
inline std::ostream& operator<<(std::ostream& os, const MiKTeXConfiguration& miktexConfiguration)
{
  switch (miktexConfiguration)
  {
  case MiKTeXConfiguration::None: os << "None"; break;
  case MiKTeXConfiguration::Regular: os << "Regular"; break;
  case MiKTeXConfiguration::Direct: os << "Direct"; break;
  case MiKTeXConfiguration::Portable: os << "Portable"; break;
  }
  return os;
}
 
enum class ConfigurationScope
{
  None,
  User,
  Common
};
 
inline std::ostream& operator<<(std::ostream& os, const ConfigurationScope& scope)
{
  switch (scope)
  {
  case ConfigurationScope::None: os << "None"; break;
  case ConfigurationScope::User: os << "User"; break;
  case ConfigurationScope::Common: os << "Common"; break;
  }
  return os;
}
 
struct StartupConfig
{
  MiKTeX::Util::PathName userConfigRoot;
 
  MiKTeX::Util::PathName userDataRoot;
 
  MiKTeX::Util::PathName userInstallRoot;
 
  std::string userRoots;
 
  std::string otherUserRoots;
 
  MiKTeX::Util::PathName commonConfigRoot;
 
  MiKTeX::Util::PathName commonDataRoot;
 
  MiKTeX::Util::PathName commonInstallRoot;
 
  std::string commonRoots;
 
  std::string otherCommonRoots;
 
  MiKTeXConfiguration config = MiKTeXConfiguration::None;
};
 
inline std::ostream& operator<<(std::ostream& os, const StartupConfig& startupConfig)
{
  if (!startupConfig.userConfigRoot.Empty())
  {
    os << "UserConfig=" << startupConfig.userConfigRoot << ",";
  }
  if (!startupConfig.userDataRoot.Empty())
  {
    os << "UserData=" << startupConfig.userDataRoot << ",";
  }
  if (!startupConfig.userInstallRoot.Empty())
  {
    os << "UserInstall=" << startupConfig.userInstallRoot << ",";
  }
  if (!startupConfig.userRoots.empty())
  {
    os << "UserRoots=" << startupConfig.userRoots << ",";
  }
  if (!startupConfig.otherUserRoots.empty())
  {
    os << "OtherUserRoots=" << startupConfig.otherUserRoots << ",";
  }
  if (!startupConfig.commonConfigRoot.Empty())
  {
    os << "CommonConfig=" << startupConfig.commonConfigRoot << ",";
  }
  if (!startupConfig.commonDataRoot.Empty())
  {
    os << "CommonData=" << startupConfig.commonDataRoot << ",";
  }
  if (!startupConfig.commonInstallRoot.Empty())
  {
    os << "CommonInstall=" << startupConfig.commonInstallRoot << ",";
  }
  if (!startupConfig.commonRoots.empty())
  {
    os << "CommonRoots=" << startupConfig.commonRoots << ",";
  }
  if (!startupConfig.otherCommonRoots.empty())
  {
    os << "OtherCommonRoots=" << startupConfig.otherCommonRoots << ",";
  }
  os << "MiKTeXConfiguration=" << startupConfig.config;
  return os;
}
 
struct SetupConfig
{
  std::time_t setupDate = MiKTeX::Util::DateUtil::UNDEFINED_TIME_T_VALUE;
  VersionNumber setupVersion;
  bool isNew = false;
};
 
struct PaperSizeInfo
{
  static MIKTEXCORECEEAPI(PaperSizeInfo) Parse(const std::string &spec);
 
  std::string name;
 
  std::string dvipsName;
 
  int width;
 
  int height;
};
 
struct MIKTEXMFMODE
{
  std::string mnemonic;
  std::string description;
  int horizontalResolution;
  int verticalResolution;
};
 
struct FileTypeInfo
{
  FileType fileType = FileType::None;
  std::string fileTypeString;
  std::vector<std::string> fileNameExtensions;
  std::vector<std::string> alternateExtensions;
  std::vector<std::string> searchPath;
  std::vector<std::string> envVarNames;
};
 
struct FileInfoRecord
{
  std::string fileName;
  std::string packageName;
  FileAccess access = FileAccess::None;
};
 
struct MiKTeXUserInfo
{
  enum { Developer = 1, Contributor = 2, Sponsor = 4, KnownUser = 8 };
  enum { Individual = 100 };
  std::string userid;
  std::string name;
  std::string organization;
  std::string email;
  int role = 0;
  int level = 0;
  std::time_t expirationDate = MiKTeX::Util::DateUtil::UNDEFINED_TIME_T_VALUE;
  bool IsMember () const
  {
    return level >= Individual && (!MiKTeX::Util::DateUtil::IsDefined(expirationDate) || expirationDate >= std::time(nullptr));
  }
  bool IsDeveloper () const { return IsMember() && (role & Developer) != 0; }
  bool IsContributor () const { return IsMember() && (role & Contributor) != 0; }
  bool IsSponsor () const { return IsMember() && (role & Sponsor) != 0; }
  bool IsKnownUser () const { return IsMember() && (role & KnownUser) != 0; }
};
 
struct FormatInfo
{
  std::string key;
  std::string name;
  std::string description;
  std::string compiler;
  std::string inputFile;
  std::string outputFile;
  std::string preloaded;
  bool exclude = false;
  bool noExecutable = false;
  bool custom = false;
  std::vector<std::string> arguments;
};
 
struct LanguageInfo
{
  std::string key;
  std::string synonyms;
  std::string loader;
  std::string patterns;
  std::string hyphenation;
  std::string luaspecial;
  int lefthyphenmin = -1;
  int righthyphenmin = -1;
  bool exclude = false;
  bool custom = false;
};
 
enum class ExpandOption
{
  Values,
  Braces,
  PathPatterns
};
 
typedef MiKTeX::Util::OptionSet<ExpandOption> ExpandOptionSet;
 
enum class RegisterRootDirectoriesOption
{
#if defined(MIKTEX_WINDOWS)
  NoRegistry,
#endif
  Temporary,
  Review
};
 
typedef MiKTeX::Util::OptionSet<RegisterRootDirectoriesOption> RegisterRootDirectoriesOptionSet;
 
enum class ShellCommandMode
{
  Forbidden,
  Restricted,
  Query,
  Unrestricted
};
 
class MIKTEXNOVTABLE IFindFileCallback
{
public:
  virtual bool MIKTEXTHISCALL InstallPackage(const std::string& packageId, const MiKTeX::Util::PathName& trigger, MiKTeX::Util::PathName& installRoot) = 0;
 
  virtual bool MIKTEXTHISCALL TryCreateFile(const MiKTeX::Util::PathName& fileName, FileType fileType) = 0;
};
 
struct LocateOptions {
  bool all = false;
  IFindFileCallback* callback = nullptr;
  FileType fileType = FileType::None;
  bool create = false;
  bool renew = false;
  bool searchFileSystem = false;
  std::string searchPath;
};
 
struct LocateResult {
  std::vector<MiKTeX::Util::PathName> pathNames;
};
 
class MIKTEXNOVTABLE Session :
  public MiKTeX::Configuration::ConfigurationProvider
{
public:
  enum class FindFileOption
  {
    Create,
    Renew,
    All,
    SearchFileSystem
  };
 
  typedef MiKTeX::Util::OptionSet<FindFileOption> FindFileOptionSet;
 
  enum class InitOption
  {
    SettingUp,
    NoFixPath,
    AdminMode,
  };
 
  typedef MiKTeX::Util::OptionSet<InitOption> InitOptionSet;
 
  class InitInfo
  {
  public:
    InitInfo() = default;
    InitInfo(const InitInfo& other) = default;
    InitInfo& operator=(const InitInfo& other) = default;
    InitInfo(InitInfo&& other) = default;
    InitInfo& operator=(InitInfo&& other) = default;
    ~InitInfo() = default;
 
    InitInfo(const std::string& programInvocationName) :
      programInvocationName(programInvocationName)
    {
    }
 
    InitInfo(const std::string& programInvocationName, InitOptionSet options) :
      options(options),
      programInvocationName(programInvocationName)
    {
    }
 
    void SetOptions(InitOptionSet options)
    {
      this->options = options;
    }
 
    InitOptionSet GetOptions() const
    {
      return options;
    }
 
    void AddOption(InitOption option)
    {
      this->options += option;
    }
 
    void SetProgramInvocationName(const std::string& programInvocationName)
    {
      this->programInvocationName = programInvocationName;
    }
 
    std::string GetProgramInvocationName() const
    {
      return programInvocationName;
    }
 
    void SetTheNameOfTheGame(const std::string& theNameOfTheGame)
    {
      this->theNameOfTheGame = theNameOfTheGame;
    }
 
    std::string GetTheNameOfTheGame() const
    {
      return theNameOfTheGame;
    }
 
    void SetStartupConfig(const StartupConfig& startupConfig)
    {
      this->startupConfig = startupConfig;
    }
 
    StartupConfig GetStartupConfig() const
    {
      return startupConfig;
    }
 
    void SetTraceFlags(const std::string& traceFlags)
    {
      this->traceFlags = traceFlags;
    }
 
    std::string GetTraceFlags() const
    {
      return traceFlags;
    }
 
    void SetTraceCallback(MiKTeX::Trace::TraceCallback* callback)
    {
      traceCallback = callback;
    }
 
    MiKTeX::Trace::TraceCallback* GetTraceCallback()
    {
      return traceCallback;
    }
 
  private:
    InitOptionSet options;
    std::string programInvocationName;
    std::string theNameOfTheGame;
    StartupConfig startupConfig;
    std::string traceFlags;
    MiKTeX::Trace::TraceCallback* traceCallback = nullptr;
  };
 
  struct OpenFileInfo
  {
    const FILE* file = nullptr;
    std::string fileName;
    FileMode mode = FileMode::Open;
    FileAccess access = FileAccess::None;
  };
 
  static MIKTEXCORECEEAPI(std::shared_ptr<Session>) TryGet();
 
  static MIKTEXCORECEEAPI(std::shared_ptr<Session>) Create(const InitInfo& initInfo);
 
  virtual MIKTEXTHISCALL ~Session() noexcept = 0;
 
  virtual void MIKTEXTHISCALL Close() = 0;
 
  virtual void MIKTEXTHISCALL Reset() = 0;
 
  virtual void MIKTEXTHISCALL PushAppName(const std::string& name) = 0;
 
  virtual void MIKTEXTHISCALL PushBackAppName(const std::string& name) = 0;
 
  virtual void MIKTEXTHISCALL AddInputDirectory(const MiKTeX::Util::PathName& path, bool atEnd) = 0;
 
  virtual std::vector<RootDirectoryInfo> GetRootDirectories() = 0;
 
  virtual unsigned MIKTEXTHISCALL GetNumberOfTEXMFRoots() = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetRootDirectoryPath(unsigned r) = 0;
 
  virtual bool MIKTEXTHISCALL IsCommonRootDirectory(unsigned r) = 0;
 
  virtual bool MIKTEXTHISCALL IsOtherRootDirectory(unsigned r) = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetMpmRootPath() = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetMpmDatabasePathName() = 0;
 
  virtual unsigned MIKTEXTHISCALL TryDeriveTEXMFRoot(const MiKTeX::Util::PathName& path) = 0;
 
  virtual unsigned MIKTEXTHISCALL DeriveTEXMFRoot(const MiKTeX::Util::PathName& path) = 0;
 
  virtual bool MIKTEXTHISCALL FindFilenameDatabase(unsigned r, MiKTeX::Util::PathName& path) = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetFilenameDatabasePathName(unsigned r) = 0;
 
  virtual bool MIKTEXTHISCALL UnloadFilenameDatabase() = 0;
 
  virtual bool MIKTEXTHISCALL UnloadFilenameDatabase(std::chrono::duration<double> minIdleTime) = 0;
 
  virtual unsigned MIKTEXTHISCALL SplitTEXMFPath(const MiKTeX::Util::PathName& path, MiKTeX::Util::PathName& root, MiKTeX::Util::PathName& relative) = 0;
 
  virtual void MIKTEXTHISCALL RegisterRootDirectories(const StartupConfig& startupConfig, RegisterRootDirectoriesOptionSet options) = 0;
 
  virtual void MIKTEXTHISCALL RegisterRootDirectory(const MiKTeX::Util::PathName& path, bool other) = 0;
 
  virtual void MIKTEXTHISCALL UnregisterRootDirectory(const MiKTeX::Util::PathName& path, bool other) = 0;
 
  virtual void MIKTEXTHISCALL MoveRootDirectoryUp(unsigned r) = 0;
 
  virtual void MIKTEXTHISCALL MoveRootDirectoryDown(unsigned r) = 0;
 
  virtual bool MIKTEXTHISCALL IsMiKTeXDirect() = 0;
 
  virtual bool MIKTEXTHISCALL IsMiKTeXPortable() = 0;
 
  virtual bool MIKTEXTHISCALL GetMETAFONTMode(unsigned idx, MIKTEXMFMODE& mode) = 0;
 
  virtual bool MIKTEXTHISCALL DetermineMETAFONTMode(unsigned dpi, MIKTEXMFMODE& Mode) = 0;
 
  virtual std::string MIKTEXTHISCALL GetEngineName() = 0;
 
  virtual FILE* MIKTEXTHISCALL OpenFile(const MiKTeX::Util::PathName& path, FileMode mode, FileAccess access, bool isTextFile) = 0;
 
  virtual FILE* MIKTEXTHISCALL TryOpenFile(const MiKTeX::Util::PathName& path, FileMode mode, FileAccess access, bool isTextFile) = 0;
 
  virtual std::pair<bool, OpenFileInfo> MIKTEXTHISCALL TryGetOpenFileInfo(FILE* file) = 0;
 
  virtual void MIKTEXTHISCALL CloseFile(FILE* file, int& exitCode) = 0;
 
  virtual void MIKTEXTHISCALL CloseFile(FILE* file) = 0;
 
  virtual bool MIKTEXTHISCALL IsOutputFile(const FILE* file) = 0;
 
#if defined(MIKTEX_WINDOWS)
  virtual bool MIKTEXTHISCALL IsFileAlreadyOpen(const MiKTeX::Util::PathName& fileName) = 0;
#endif
 
  virtual void MIKTEXTHISCALL ScheduleSystemCommand(const std::string& commandLine) = 0;
 
#if defined(MIKTEX_WINDOWS)
  virtual void MIKTEXTHISCALL ScheduleFileRemoval(const MiKTeX::Util::PathName& path) = 0;
#endif
 
  virtual bool MIKTEXTHISCALL StartFileInfoRecorder() = 0;
 
  virtual bool MIKTEXTHISCALL StartFileInfoRecorder(bool recordPackageNames) = 0;
 
  virtual void MIKTEXTHISCALL SetRecorderPath(const MiKTeX::Util::PathName& path) = 0;
 
  virtual void MIKTEXTHISCALL RecordFileInfo(const MiKTeX::Util::PathName& path, FileAccess access) = 0;
 
  virtual std::vector<FileInfoRecord> MIKTEXTHISCALL GetFileInfoRecords() = 0;
 
  virtual FileType MIKTEXTHISCALL DeriveFileType(const MiKTeX::Util::PathName& fileName) = 0;
 
  virtual LocateResult MIKTEXTHISCALL Locate(const std::string& fileName, const LocateOptions& options) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, const std::string& searchPath, FindFileOptionSet options, std::vector<MiKTeX::Util::PathName>& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, const std::string& searchPath, std::vector<MiKTeX::Util::PathName>& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, const std::string& searchPath, FindFileOptionSet options, MiKTeX::Util::PathName& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, const std::string& searchPath, MiKTeX::Util::PathName& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, FileType fileType, FindFileOptionSet options, std::vector<MiKTeX::Util::PathName>& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, FileType fileType, std::vector<MiKTeX::Util::PathName>& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, FileType fileType, FindFileOptionSet options, MiKTeX::Util::PathName& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindFile(const std::string& fileName, FileType fileType, MiKTeX::Util::PathName& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindPkFile(const std::string& fontName, const std::string& mfMode, int dpi, MiKTeX::Util::PathName& result) = 0;
 
  virtual bool MIKTEXTHISCALL FindTfmFile(const std::string& fontName, MiKTeX::Util::PathName& result, bool create) = 0;
 
  virtual void MIKTEXTHISCALL SetFindFileCallback(IFindFileCallback* callback) = 0;
 
  virtual void MIKTEXTHISCALL SplitFontPath(const MiKTeX::Util::PathName& fontPath, std::string* fontType, std::string* supplier, std::string* typeface, std::string* fontName, std::string* pointSize) = 0;
 
  virtual bool MIKTEXTHISCALL GetFontInfo(const std::string& fontName, std::string& supplier, std::string& typeface, double* genSize) = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetGhostscript(unsigned long* versionNumber) = 0;
 
  virtual std::string MIKTEXTHISCALL GetExpandedSearchPath(FileType fileType) = 0;
 
  virtual bool MIKTEXTHISCALL ConvertToBitmapFile(const MiKTeX::Util::PathName& sourceFileName, MiKTeX::Util::PathName& destFileName, IRunProcessCallback* callback) = 0;
 
  virtual bool MIKTEXTHISCALL EnableFontMaker(bool enable) = 0;
 
  virtual bool MIKTEXTHISCALL GetMakeFontsFlag() = 0;
 
  virtual std::vector<std::string> MIKTEXTHISCALL MakeMakePkCommandLine(const std::string& fontName, int dpi, int baseDpi, const std::string& mfMode, MiKTeX::Util::PathName& fileName, MiKTeX::Configuration::TriState enableInstaller) = 0;
 
#if defined(MIKTEX_WINDOWS)
  virtual int MIKTEXTHISCALL RunBatch(int argc, const char** argv) = 0;
#endif
 
  virtual int MIKTEXTHISCALL RunExe(int argc, const char** argv) = 0;
 
  virtual int MIKTEXTHISCALL RunGhostscript(int argc, const char** argv) = 0;
 
#if !defined(MIKTEX_WINDOWS)
  virtual int MIKTEXTHISCALL RunSh(int argc, const char** argv) = 0;
#endif
 
  virtual int MIKTEXTHISCALL RunPerl(int argc, const char** argv) = 0;
 
  virtual int MIKTEXTHISCALL RunPython(int argc, const char** argv) = 0;
 
  virtual int MIKTEXTHISCALL RunJava(int argc, const char** argv) = 0;
 
#if defined(MIKTEX_WINDOWS)
  virtual bool MIKTEXTHISCALL ShowManualPageAndWait(HWND hWnd, unsigned long topic) = 0;
#endif
 
  virtual std::vector<FileTypeInfo> MIKTEXTHISCALL GetFileTypes() = 0;
 
  virtual std::vector<FormatInfo> MIKTEXTHISCALL GetFormats() = 0;
 
  virtual FormatInfo MIKTEXTHISCALL GetFormatInfo(const std::string& key) = 0;
 
  virtual bool MIKTEXTHISCALL TryGetFormatInfo(const std::string& key, FormatInfo& formatInfo) = 0;
 
  virtual void MIKTEXTHISCALL DeleteFormatInfo(const std::string& key) = 0;
 
  virtual void MIKTEXTHISCALL SetFormatInfo(const FormatInfo& formatInfo) = 0;
 
  virtual std::vector<LanguageInfo> MIKTEXTHISCALL GetLanguages() = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetMyProgramFile(bool canonicalized) = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetMyLocation(bool canonicalized) = 0;
 
  virtual MiKTeX::Util::PathName MIKTEXTHISCALL GetMyPrefix(bool canonicalized) = 0;
 
  virtual bool MIKTEXTHISCALL RunningAsAdministrator() = 0;
 
  virtual void MIKTEXTHISCALL SetAdminMode(bool adminMode, bool force = false) = 0;
 
  virtual bool MIKTEXTHISCALL IsAdminMode() = 0;
 
  virtual bool MIKTEXTHISCALL IsSharedSetup() = 0;
 
  virtual SetupConfig MIKTEXTHISCALL GetSetupConfig() = 0;
 
  virtual bool MIKTEXTHISCALL GetPaperSizeInfo(int idx, PaperSizeInfo& paperSize) = 0;
 
  virtual PaperSizeInfo MIKTEXTHISCALL GetPaperSizeInfo(const std::string& dvipsName) = 0;
 
  virtual void MIKTEXTHISCALL SetDefaultPaperSize(const std::string& dvipsName) = 0;
 
  virtual bool MIKTEXTHISCALL TryCreateFromTemplate(const MiKTeX::Util::PathName& path) = 0;
 
  virtual bool MIKTEXTHISCALL IsUserAnAdministrator() = 0;
 
  virtual void MIKTEXTHISCALL ConfigureFile(const MiKTeX::Util::PathName& pathIn, const MiKTeX::Util::PathName& pathOut, MiKTeX::Configuration::HasNamedValues* callback = nullptr) = 0;
 
  virtual void MIKTEXTHISCALL ConfigureFile(const MiKTeX::Util::PathName& pathRel, MiKTeX::Configuration::HasNamedValues* callback = nullptr) = 0;
 
  virtual void MIKTEXTHISCALL SetTheNameOfTheGame(const std::string& name) = 0;
 
  virtual std::vector<std::string> MIKTEXTHISCALL GetFontDirectories() = 0;
 
  virtual FileTypeInfo MIKTEXTHISCALL GetFileTypeInfo(FileType fileType) = 0;
 
  virtual std::string Expand(const std::string& toBeExpanded) = 0;
 
  virtual std::string Expand(const std::string& toBeExpanded, MiKTeX::Configuration::HasNamedValues* callback) = 0;
 
  virtual std::string Expand(const std::string& toBeExpanded, ExpandOptionSet options, MiKTeX::Configuration::HasNamedValues* callback) = 0;
 
  virtual void MIKTEXTHISCALL SetLanguageInfo(const LanguageInfo& languageInfo) = 0;
 
#if HAVE_MIKTEX_USER_INFO
  virtual MiKTeXUserInfo RegisterMiKTeXUser(const MiKTeXUserInfo& info) = 0;
#endif
 
#if HAVE_MIKTEX_USER_INFO
  virtual bool TryGetMiKTeXUserInfo(MiKTeXUserInfo& info) = 0;
#endif
 
  virtual ShellCommandMode GetShellCommandMode() = 0;
 
  virtual std::vector<std::string> GetAllowedShellCommands() = 0;
 
  enum class ExamineCommandLineResult
  {
    ProbablySafe,
    MaybeSafe,
    NotSafe,
    SyntaxError
  };
 
  virtual std::tuple<ExamineCommandLineResult, std::string, std::string> ExamineCommandLine(const std::string& commandLine) = 0;
 
  static MIKTEXCOREEXPORT MIKTEXNORETURN void MIKTEXCEECALL FatalCrtError(const std::string& functionName, int errorCode, const MiKTeXException::KVMAP& info, const SourceLocation& sourceLocation);
 
  static MIKTEXCOREEXPORT MIKTEXNORETURN void MIKTEXCEECALL FatalMiKTeXError(const std::string& message, const std::string& description, const std::string& remedy, const std::string& tag, const MiKTeXException::KVMAP& info, const SourceLocation& sourceLocation);
 
#if defined(MIKTEX_WINDOWS)
  static MIKTEXCOREEXPORT MIKTEXNORETURN void MIKTEXCEECALL FatalWindowsError(const std::string& functionName, unsigned long errorCode, const std::string& description, const std::string& remedy, const std::string& tag, const MiKTeXException::KVMAP& info, const SourceLocation& sourceLocation);
#endif
};
 
MIKTEX_CORE_END_NAMESPACE;
 
#define MIKTEX_FATAL_ERROR(message) \
  MiKTeX::Core::Session::FatalMiKTeXError(message, "", "", "", MiKTeX::Core::MiKTeXException::KVMAP(), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_ERROR_2(message, ...) \
  MiKTeX::Core::Session::FatalMiKTeXError(message, "", "", "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_ERROR_3(message, description, ...) \
  MiKTeX::Core::Session::FatalMiKTeXError(message, description, "", "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_ERROR_4(message, description, remedy, ...) \
  MiKTeX::Core::Session::FatalMiKTeXError(message, description, remedy, "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_ERROR_5(message, description, remedy, tag, ...) \
  MiKTeX::Core::Session::FatalMiKTeXError(message, description, remedy, tag, MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_STRINGIFY_(x) #x
#define MIKTEX_STRINGIFY(x) MIKTEX_STRINGIFY_(x)
 
#define MIKTEX_INTERNAL_ERROR() MIKTEX_FATAL_ERROR("internal error")
 
#define MIKTEX_UNEXPECTED() MIKTEX_INTERNAL_ERROR()
 
#define MIKTEX_EXPECT(p) if (!(p)) { MIKTEX_UNEXPECTED(); }
 
#define MIKTEX_FATAL_CRT_ERROR(functionName)                                                                                         \
  {                                                                                                                                  \
    int errorCode = errno;                                                                                                           \
    MiKTeX::Core::Session::FatalCrtError(functionName, errorCode, MiKTeX::Core::MiKTeXException::KVMAP(), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_CRT_ERROR_2(functionName, ...)                                                                                             \
  {                                                                                                                                             \
    int errorCode = errno;                                                                                                                      \
    MiKTeX::Core::Session::FatalCrtError(functionName, errorCode, MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_CRT_RESULT(functionName, errorCode) \
  MiKTeX::Core::Session::FatalCrtError(functionName, errorCode, MiKTeX::Core::MiKTeXException::KVMAP(), MIKTEX_SOURCE_LOCATION());
 
#define MIKTEX_FATAL_CRT_RESULT_2(functionName, errorCode, ...) \
  MiKTeX::Core::Session::FatalCrtError(functionName, errorCode, MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION());
 
#if defined(MIKTEX_WINDOWS)
 
#define MIKTEX_FATAL_WINDOWS_ERROR(functionName)                                                                                                     \
  {                                                                                                                                                  \
    unsigned long errorCode = GetLastError();                                                                                                        \
    MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, "", "", "", MiKTeX::Core::MiKTeXException::KVMAP(), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_WINDOWS_ERROR_2(functionName, ...)                                                                                                         \
  {                                                                                                                                                             \
    unsigned long errorCode = GetLastError();                                                                                                                   \
    MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, "", "", "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_WINDOWS_ERROR_3(functionName, description, ...)                                                                                                     \
  {                                                                                                                                                                      \
    unsigned long errorCode = GetLastError();                                                                                                                            \
    MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, description, "", "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_WINDOWS_ERROR_4(functionName, description, remedy, ...)                                                                                                 \
  {                                                                                                                                                                          \
    unsigned long errorCode = GetLastError();                                                                                                                                \
    MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, description, remedy, "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_WINDOWS_ERROR_5(functionName, description, remedy, tag, ...)                                                                                             \
  {                                                                                                                                                                           \
    unsigned long errorCode = GetLastError();                                                                                                                                 \
    MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, description, remedy, tag, MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION()); \
  }
 
#define MIKTEX_FATAL_WINDOWS_RESULT(functionName, errorCode) \
  MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, "", "", "", MiKTeX::Core::MiKTeXException::KVMAP(), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_WINDOWS_RESULT_2(functionName, errorCode, ...) \
  MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, "", "", "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_WINDOWS_RESULT_3(functionName, errorCode, description, ...) \
  MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, description, "", "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_WINDOWS_RESULT_4(functionName, errorCode, description, remedy, ...) \
  MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, description, remedy, "", MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#define MIKTEX_FATAL_WINDOWS_RESULT_5(functionName, errorCode, description, remedy, tag, ...) \
  MiKTeX::Core::Session::FatalWindowsError(functionName, errorCode, description, remedy, tag, MiKTeX::Core::MiKTeXException::KVMAP(__VA_ARGS__), MIKTEX_SOURCE_LOCATION())
 
#endif
 
#endif