bool
Fndb::Create (/*[in]*/ const char * lpszFndbPath,
/*[in]*/ const char * lpszRootPath,
/*[in]*/ ICreateFndbCallback * pCallback,
/*[in]*/ bool enableStringPooling,
/*[in]*/ bool storeFileNameInfo)
{
MIKTEX_ASSERT_STRING (lpszFndbPath);
MIKTEX_ASSERT_STRING (lpszRootPath);
FndbManager fndbmngr;
if (! fndbmngr.Create(lpszFndbPath,
lpszRootPath,
pCallback,
enableStringPooling,
storeFileNameInfo))
{
return (false);
}
#if defined(MIKTEX_WINDOWS)
ReportMiKTeXEvent (EVENTLOG_INFORMATION_TYPE,
MIKTEX_EVENT_FNDB_CREATED,
lpszFndbPath,
lpszRootPath,
0);
#endif
return (true);
}
bool
SessionImpl::FindFile (/*[in]*/ const char * lpszFileName,
/*[in]*/ const char * lpszPathList,
/*[in]*/ FindFileFlags flags,
/*[out]*/ PathNameArray & result)
{
MIKTEX_ASSERT_STRING (lpszFileName);
MIKTEX_ASSERT_STRING (lpszPathList);
bool found = FindFileInternal(
lpszFileName,
SplitSearchPath(lpszPathList),
(flags & FindFileFlags::All) == 0,
true,
false,
result);
if (! found && (flags & FindFileFlags::TryHard) != 0)
{
found = FindFileInternal(
lpszFileName,
SplitSearchPath(lpszPathList),
(flags & FindFileFlags::All) == 0,
false,
true,
result);
}
return (found);
}
bool
Fndb::Create (/*[in]*/ const char * lpszFndbPath,
/*[in]*/ const char * lpszRootPath,
/*[in]*/ ICreateFndbCallback * pCallback)
{
MIKTEX_ASSERT_STRING (lpszFndbPath);
MIKTEX_ASSERT_STRING (lpszRootPath);
return (Fndb::Create(lpszFndbPath,
lpszRootPath,
pCallback,
false,
false));
}
PathName WebAppInputLine::MangleNameOfFile(const char* lpszFrom)
{
PathName ret;
char* lpszTo = ret.GetData();
MIKTEX_ASSERT_STRING(lpszFrom);
size_t len = StrLen(lpszFrom);
if (len >= ret.GetCapacity())
{
MIKTEX_UNEXPECTED();
}
size_t idx;
for (idx = 0; idx < len; ++idx)
{
if (lpszFrom[idx] == ' ')
{
lpszTo[idx] = '*';
}
else if (lpszFrom[idx] == '~')
{
lpszTo[idx] = '?';
}
else if (lpszFrom[idx] == '\\')
{
lpszTo[idx] = '/';
}
else
{
lpszTo[idx] = lpszFrom[idx];
}
}
lpszTo[idx] = 0;
return ret;
}
FileType
SessionImpl::DeriveFileType (/*[in]*/ const char * lpszPath)
{
MIKTEX_ASSERT_STRING (lpszPath);
RegisterFileTypes ();
const char * lpszExt = GetFileNameExtension(lpszPath);
for (int idx = 1; idx < fileTypes.size(); ++ idx)
{
if (lpszExt == 0)
{
if (StringCompare(fileTypes[idx].fileTypeString.c_str(), lpszPath) == 0)
{
return (fileTypes[idx].fileType);
}
}
else
{
for (CSVList ext (fileTypes[idx].fileNameExtensions.c_str(), PATH_DELIMITER);
ext.GetCurrent() != 0;
++ ext)
{
if (PathName::Compare(ext.GetCurrent(), lpszExt) == 0)
{
return (fileTypes[idx].fileType);
}
}
}
}
return (FileType::None);
}
void
SessionImpl::SetTheNameOfTheGame (/*[in]*/ const char * lpszTheNameOfTheGame)
{
MIKTEX_ASSERT_STRING (lpszTheNameOfTheGame);
fileTypes.clear ();
theNameOfTheGame = lpszTheNameOfTheGame;
}
void
SessionImpl::AddInputDirectory (/*[in]*/ const char * lpszPath,
/*[in]*/ bool atEnd)
{
MIKTEX_ASSERT_STRING (lpszPath);
if (! Utils::IsAbsolutePath(lpszPath))
{
INVALID_ARGUMENT ("SessionImpl::AddInputDirectory", lpszPath);
}
// clear the search path cache
ClearSearchVectors ();
if (atEnd)
{
inputDirectories.push_back (lpszPath);
}
else
{
inputDirectories.push_front (lpszPath);
}
#if 1
SetCWDEnv ();
#endif
}
miktex_find_input_file (/*[in]*/ const char * lpszApplicationName,
/*[in]*/ const char * lpszFileName,
/*[out]*/ char * lpszPath)
{
C_FUNC_BEGIN ();
MIKTEX_ASSERT_STRING_OR_NIL (lpszApplicationName);
MIKTEX_ASSERT_STRING (lpszFileName);
MIKTEX_ASSERT_PATH_BUFFER (lpszPath);
PathName temp;
if (! SessionImpl::GetSession()->FindFile(lpszFileName,
FileType::None,
temp))
{
if (lpszApplicationName == 0)
{
return (0);
}
string searchPath = CURRENT_DIRECTORY;
searchPath += PATH_DELIMITER;
searchPath += TEXMF_PLACEHOLDER;
searchPath += MIKTEX_PATH_DIRECTORY_DELIMITER_STRING;
searchPath += lpszApplicationName;
searchPath += RECURSION_INDICATOR;
if (! SessionImpl::GetSession()->FindFile(lpszFileName,
searchPath.c_str(),
temp))
{
return (0);
}
}
Utils::CopyString (lpszPath, BufferSizes::MaxPath, temp.Get());
return (1);
C_FUNC_END ();
}
template<typename CharType> static PathName UnmangleNameOfFile_(const CharType* lpszFrom)
{
PathName ret;
char* lpszTo = ret.GetData();
MIKTEX_ASSERT_STRING(lpszFrom);
size_t len = StrLen(lpszFrom);
if (len >= ret.GetCapacity())
{
MIKTEX_UNEXPECTED();
}
size_t idx;
for (idx = 0; idx < len; ++idx)
{
if (lpszFrom[idx] == '*')
{
lpszTo[idx] = ' ';
}
else if (lpszFrom[idx] == '?')
{
lpszTo[idx] = '~';
}
else
{
lpszTo[idx] = lpszFrom[idx];
}
}
lpszTo[idx] = 0;
return ret;
}
miktex_find_file (/*[in]*/ const char * lpszFileName,
/*[in]*/ const char * lpszPathList,
/*[out]*/ char * lpszPath)
{
C_FUNC_BEGIN ();
MIKTEX_ASSERT_STRING (lpszFileName);
MIKTEX_ASSERT_STRING (lpszPathList);
MIKTEX_ASSERT_PATH_BUFFER (lpszPath);
PathName temp;
if (! SessionImpl::GetSession()->FindFile(lpszFileName,
lpszPathList,
temp))
{
return (0);
}
Utils::CopyString (lpszPath, BufferSizes::MaxPath, temp.Get());
return (1);
C_FUNC_END ();
}
void
Process::Start (/*[in]*/ const char * lpszFileName,
/*[in]*/ const char * lpszArguments,
/*[in]*/ FILE * pFileStandardInput,
/*[out]*/ FILE ** ppFileStandardInput,
/*[out]*/ FILE ** ppFileStandardOutput,
/*[out]*/ FILE ** ppFileStandardError,
/*[in]*/ const char * lpszWorkingDirectory)
{
MIKTEX_ASSERT_STRING (lpszFileName);
MIKTEX_ASSERT_STRING_OR_NIL (lpszArguments);
MIKTEX_ASSERT_STRING_OR_NIL (lpszWorkingDirectory);
MIKTEX_ASSERT (pFileStandardInput == 0 || ppFileStandardInput == 0);
ProcessStartInfo startinfo;
startinfo.FileName = lpszFileName;
if (lpszArguments != 0)
{
startinfo.Arguments = lpszArguments;
}
startinfo.StandardInput = pFileStandardInput;
startinfo.RedirectStandardInput =
(pFileStandardInput == 0 && ppFileStandardInput != 0);
startinfo.RedirectStandardOutput = (ppFileStandardOutput != 0);
startinfo.RedirectStandardError = (ppFileStandardError != 0);
if (lpszWorkingDirectory != 0)
{
startinfo.WorkingDirectory = lpszWorkingDirectory;
}
auto_ptr<Process> pProcess (Process::Start(startinfo));
if (ppFileStandardInput != 0)
{
*ppFileStandardInput = pProcess->get_StandardInput();
}
if (ppFileStandardOutput != 0)
{
*ppFileStandardOutput = pProcess->get_StandardOutput();
}
if (ppFileStandardError != 0)
{
*ppFileStandardError = pProcess->get_StandardError();
}
pProcess->Close ();
}
FILE *
SessionImpl::OpenFile (/*[in]*/ const char * lpszPath,
/*[in]*/ FileMode mode,
/*[in]*/ FileAccess access,
/*[in]*/ bool text,
/*[in]*/ FileShare share)
{
MIKTEX_ASSERT_STRING (lpszPath);
trace_files->WriteFormattedLine
("core",
"OpenFile(\"%s\", %d, 0x%x, %d, %d)",
lpszPath,
static_cast<int>(mode.Get()),
static_cast<int>(access.Get()),
static_cast<int>(text),
static_cast<int>(share.Get()));
FILE * pFile = 0;
if (mode.Get() == FileMode::Command)
{
MIKTEX_ASSERT (access.Get() == FileAccess::Read
|| access.Get() == FileAccess::Write);
MIKTEX_ASSERT (! text);
pFile = InitiateProcessPipe(lpszPath, access, mode);
}
else
{
pFile = File::Open(lpszPath, mode, access, text, share);
}
try
{
OpenFileInfo info;
info.pFile = pFile;
info.fileName = lpszPath;
info.mode = mode;
info.access = access;
openFilesMap.insert (pair<FILE *, OpenFileInfo>(pFile, info));
if (setvbuf(pFile, 0, _IOFBF, 1024 * 4) != 0)
{
TraceError (T_("setvbuf() failed for some reason"));
}
RecordFileInfo (lpszPath, access);
trace_files->WriteFormattedLine ("core", " => %p", pFile);
return (pFile);
}
catch (const exception &)
{
fclose (pFile);
throw;
}
}
bool
SessionImpl::FindFile (/*[in]*/ const char * lpszFileName,
/*[in]*/ const char * lpszPathList,
/*[in]*/ FindFileFlags flags,
/*[out]*/ PathName & result)
{
MIKTEX_ASSERT_STRING (lpszFileName);
MIKTEX_ASSERT_STRING (lpszPathList);
MIKTEX_ASSERT ((flags & FindFileFlags::All) == 0);
PathNameArray paths;
bool found = FindFile(lpszFileName, lpszPathList, flags, paths);
if (found)
{
result = paths[0];
}
return (found);
}
void
Fndb::Add (/*[in]*/ const char * lpszPath,
/*[in]*/ const char * lpszFileNameInfo)
{
MIKTEX_ASSERT_STRING (lpszPath);
#if 0
MIKTEX_ASSERT (File::Exists(lpszPath));
#endif
unsigned root = SessionImpl::GetSession()->DeriveTEXMFRoot(lpszPath);
PathName pathFqFndbFileName;
if (SessionImpl::GetSession()->FindFilenameDatabase(root, pathFqFndbFileName))
{
FileNameDatabase * pFndb =
SessionImpl::GetSession()->GetFileNameDatabase(root, TriState::False);
if (pFndb == 0)
{
UNEXPECTED_CONDITION ("Fndb::Add");
}
AutoFndbRelease autoRelease (pFndb);
pFndb->AddFile (lpszPath, lpszFileNameInfo);
}
else
{
// create the fndb file
// <fixme>the file name info hasn't been added, if the file
// exists</fixme>
PathName pathFndbFile
= SessionImpl::GetSession()->GetFilenameDatabasePathName(root);
if (! Fndb::Create(pathFndbFile.Get(),
SessionImpl::GetSession()->GetRootDirectory(root).Get(),
0))
{
UNEXPECTED_CONDITION ("Fndb::Add");
}
if (! File::Exists(lpszPath))
{
// the file hasn't been added yet
// <recursivecall>
Add (lpszPath, lpszFileNameInfo);
// </recursivecall>
}
}
}
void
Fndb::Remove (/*[in]*/ const char * lpszPath)
{
MIKTEX_ASSERT_STRING (lpszPath);
unsigned root = SessionImpl::GetSession()->DeriveTEXMFRoot(lpszPath);
FileNameDatabase * pFndb =
SessionImpl::GetSession()->GetFileNameDatabase(root, TriState::False);
if (pFndb == 0)
{
UNEXPECTED_CONDITION ("Fndb::Remove");
}
AutoFndbRelease autoRelease (pFndb);
pFndb->RemoveFile (lpszPath);
}
bool
Fndb::Enumerate (/*[in]*/ const char * lpszPath,
/*[in]*/ IEnumerateFndbCallback * pCallback)
{
MIKTEX_ASSERT_STRING (lpszPath);
FileNameDatabase * pFndb =
SessionImpl::GetSession()->GetFileNameDatabase(lpszPath);
if (pFndb == 0)
{
FATAL_MIKTEX_ERROR
("Fndb::Enumerate",
T_("The path is not covered by the file name database."),
lpszPath);
}
AutoFndbRelease autoRelease (pFndb);
return (pFndb->Enumerate(lpszPath, pCallback));
}
void
SessionImpl::RegisterFileType (/*[in]*/ FileType fileType,
/*[in]*/ const char * lpszFileType,
/*[in]*/ const char * lpszApplication,
/*[in]*/ const char * lpszFileNameExtensions,
/*[in]*/ const char * lpszAlternateExtensions,
/*[in]*/ const char * lpszDefaultSearchPath,
/*[in]*/ const char * lpszEnvVarNames)
{
MIKTEX_ASSERT_STRING (lpszFileType);
MIKTEX_ASSERT_STRING_OR_NIL (lpszApplication);
InternalFileTypeInfo fti;
fti.fileType = fileType;
fti.fileTypeString = lpszFileType;
if (lpszApplication != 0)
{
fti.applicationName = lpszApplication;
}
string section = "ft.";
section += lpszFileType;
fti.fileNameExtensions =
GetConfigValue(section.c_str(),
"extensions",
lpszFileNameExtensions );
fti.alternateExtensions = GetConfigValue(section.c_str(),
"alternate_extensions",
lpszAlternateExtensions == 0 ? "" : lpszAlternateExtensions);
fti.searchPath =
GetConfigValue(section.c_str(),
"path",
lpszDefaultSearchPath);
fti.envVarNames =
GetConfigValue(section.c_str(),
"env",
lpszEnvVarNames);
fileTypes.resize (FileType::E_N_D);
fileTypes[fileType.Get()] = fti;
}
void
SessionImpl::MakeMakePkCommandLine (/*[in]*/ const char * lpszFontName,
/*[in]*/ int dpi,
/*[in]*/ int baseDpi,
/*[in]*/ const char * lpszMfMode,
/*[out]*/ PathName & fileName,
/*[out]*/ char * lpszArguments,
/*[in]*/ size_t maxArguments)
{
MIKTEX_ASSERT_STRING (lpszFontName);
MIKTEX_ASSERT_STRING_OR_NIL (lpszMfMode);
MIKTEX_ASSERT_CHAR_BUFFER (lpszArguments, maxArguments);
MIKTEX_ASSERT (baseDpi != 0);
if (! FindFile(MIKTEX_MAKEPK_EXE, FileType::EXE, fileName))
{
FATAL_MIKTEX_ERROR ("SessionImpl::MakeMakePkCommandLine",
T_("The MakePk utility could not be found."),
MIKTEX_MAKEPK_EXE);
}
int m = 0;
int n;
if (dpi < baseDpi)
{
for (;;)
{
-- m;
n = magstep(m, baseDpi);
if (n == dpi)
{
break;
}
if (n < dpi || m < -40)
{
m = 9999;
break;
}
}
}
else if (dpi > baseDpi)
{
for (;;)
{
++ m;
n = magstep(m, baseDpi);
if (n == dpi)
{
break;
}
if (n > dpi || m > 40)
{
m = 9999;
break;
}
}
}
string strMagStep;
if (m == 9999)
{
// a+b/c
strMagStep = NUMTOSTR(dpi / baseDpi);
strMagStep += '+';
strMagStep += NUMTOSTR(dpi % baseDpi);
strMagStep += '/';
strMagStep += NUMTOSTR(baseDpi);
}
else if (m >= 0)
{
// magstep(a.b)
strMagStep = "magstep(";
strMagStep += NUMTOSTR( m / 2);
strMagStep += '.';
strMagStep += NUMTOSTR((m & 1) * 5);
strMagStep += ')';
}
else
{
// magstep(-a.b)
strMagStep = "magstep(-";
strMagStep += NUMTOSTR((-m) / 2);
strMagStep += '.';
strMagStep += NUMTOSTR((m & 1) * 5);
strMagStep += ')';
}
string cmdline;
cmdline.reserve (256);
cmdline += " --verbose";
cmdline += ' '; cmdline += lpszFontName;
cmdline += ' '; cmdline += NUMTOSTR(dpi);
cmdline += ' '; cmdline += NUMTOSTR(baseDpi);
cmdline += ' '; cmdline += strMagStep;
if (lpszMfMode != 0)
{
cmdline += ' '; cmdline += lpszMfMode;
}
Utils::CopyString (lpszArguments, maxArguments, cmdline.c_str());
}
bool
SessionImpl::FindPkFile (/*[in]*/ const char * lpszFontName,
/*[in]*/ const char * lpszMode,
/*[in]*/ int dpi,
/*[out]*/ PathName & result)
{
MIKTEX_ASSERT_STRING (lpszFontName);
MIKTEX_ASSERT_STRING_OR_NIL (lpszMode);
PathName pkFileName;
if (! MakePkFileName (pkFileName, lpszFontName, dpi))
{
return (false);
}
string searchPathTemplate;
if (! GetSessionValue(MIKTEX_REGKEY_CORE,
"PKPath",
searchPathTemplate,
DEFAULT_PK_SEARCH_PATH))
{
UNEXPECTED_CONDITION ("SessionImpl::FindPkFile");
}
string searchPath;
for (const char * q = searchPathTemplate.c_str(); *q != 0; ++ q)
{
if (*q == '%')
{
++ q;
if (*q == 0)
{
FATAL_MIKTEX_ERROR ("SessionImpl::FindPkFile",
T_("Invalid search path template."),
searchPathTemplate.c_str());
}
switch (*q)
{
case 'R':
searchPath += '%';
searchPath += 'R';
break;
case '%':
searchPath += '%';
break;
case 'm':
if (lpszMode != 0)
{
searchPath += lpszMode;
}
else
{
// <fixme>hardcoded METAFONT mode
searchPath += "ljfour";
// </fixme>
}
break;
case 'd':
searchPath += NUMTOSTR(dpi);
break;
default:
FATAL_MIKTEX_ERROR ("SessionImpl::FindPkFile",
T_("Invalid search path template."),
searchPathTemplate.c_str());
}
}
else
{
searchPath += *q;
}
}
bool found = FindFile(pkFileName.Get(), searchPath.c_str(), result);
if (! found
&& (lpszMode == 0 || StringCompare(lpszMode, "modeless", true) != 0))
{
// <recursivecall>
found = FindPkFile(lpszFontName, "modeless", dpi, result);
// </recursivecall>
}
return (found);
}
