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