// -----------------------------------------------------------------------
int main(int Argc_, char *Argv_[])
{
struct THelper {
static void normalizeFolderName(QString &Value_) {
QDir Folder(Value_);
Value_ = QDir::toNativeSeparators(Folder.absolutePath());
Q_ASSERT(!Value_.endsWith(QDir::separator()));
Value_ += QDir::separator();
}
};
QCoreApplication HPro(Argc_, Argv_);
//
TParameters Parameters;
if(!ParseParameters(Argc_, Argv_, Parameters)) {
std::cerr << '\n' << std::endl;
Usage();
return RETCODE_INVALID_PARAMETERS;
}
//
THelper::normalizeFolderName(Parameters.InputFolder);
THelper::normalizeFolderName(Parameters.OutputFolder);
TProcessor Processor(Parameters);
if(!ProcessFolder(Parameters.InputFolder, Parameters.OutputFolder, Processor))
return RETCODE_PROCESS_ERROR;
return RETCODE_OK;
}
int main(int argc, _TCHAR* argv[])
{
if(argc<3){
printf("usage:\nSwitchBom path a[r]\n");
return -1;
}
ProcessFolder(argv[1],argv[2][0]=='a');
return 0;
}
// -----------------------------------------------------------------------
bool ProcessFolder(const QString &Input_, const QString &Output_, TProcessor &Processor_)
{
QDir InputFolder(Input_);
if(!InputFolder.exists()) {
std::cerr << "Error accessing folder '" << (const char*)Input_.toLocal8Bit() << "'.";
return false;
}
//
QDir OutputFolder(Output_);
if(!OutputFolder.exists()) {
if(!OutputFolder.mkpath(Output_)) {
std::cerr << "Can't create folder '" << (const char*)Output_.toLocal8Bit() << "'.";
return false;
}
}
// Processing files
QStringList FilesList = InputFolder.entryList(QDir::Files | QDir::Hidden | QDir::System);
for(QStringList::iterator it = FilesList.begin(); it != FilesList.end(); ++it) {
QString InputFile(Input_ + *it), OutputFile(Output_ + *it);
if(QFile::exists(OutputFile)) {
if(!QFile::remove(OutputFile)) {
std::cerr << "Can't write file '" << (const char*)OutputFile.toLocal8Bit() << "'.";
return false;
}
}
bool Result = Processor_.isExcluded(*it)?
QFile::copy(InputFile, OutputFile):
Processor_.processFile(InputFile, OutputFile);
//
if(!Result) {
std::cerr << "Can't write file '" << (const char*)OutputFile.toLocal8Bit() << "'.";
return false;
}
}
// Processing folders
FilesList = InputFolder.entryList(QDir::Dirs | QDir::Hidden | QDir::System |
QDir::NoDotAndDotDot | QDir::NoSymLinks);
for(QStringList::iterator it = FilesList.begin(); it != FilesList.end(); ++it) {
if(!ProcessFolder(Input_ + *it + QDir::separator(), Output_ + *it + QDir::separator(),
Processor_))
return false;
}
return true;
}
void ProcessFolder(const char *folder,bool isAddBom)
{
WIN32_FIND_DATA find;
memset(&find, 0, sizeof(find));
char* filePath=new char[1024];
sprintf(filePath, "%s\\*.*", folder);
HANDLE file = FindFirstFile(filePath, &find);
while (FindNextFile(file, &find))
{
if (find.cFileName[0] == '.')
{
continue;
}
if (find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
char* newPath=new char[1024];
sprintf(newPath, "%s\\%s", folder, find.cFileName);
ProcessFolder(newPath,isAddBom);
continue;
}
std::string fileStr = find.cFileName;
if (std::string::npos == fileStr.find(".cpp")
&& std::string::npos == fileStr.find(".h")
&& std::string::npos == fileStr.find(".inl")
&& std::string::npos == fileStr.find(".inc"))
{
continue;
}
sprintf(filePath, "%s\\%s", folder, find.cFileName);
if(isAddBom)
{
ProcessFileAddBom(filePath, find.nFileSizeLow);
}
else
{
ProcessFileRemoveBom(filePath, find.nFileSizeLow);
}
}
delete []filePath;
}
bool
FndbManager::Create (/*[in]*/ const char * lpszFndbPath,
/*[in]*/ const char * lpszRootPath,
/*[in]*/ ICreateFndbCallback * pCallback,
/*[in]*/ bool enableStringPooling,
/*[in]*/ bool storeFileNameInfo)
{
traceStream->WriteFormattedLine ("core",
T_("creating fndb file %s..."),
Q_(lpszFndbPath));
unsigned rootIdx = SessionImpl::GetSession()->DeriveTEXMFRoot(lpszRootPath);
this->enableStringPooling = enableStringPooling;
this->storeFileNameInfo = storeFileNameInfo;
byteArray.reserve (2 * 1024 * 1024);
try
{
ReserveMem (sizeof(FileNameDatabaseHeader));
FileNameDatabaseHeader fndb;
fndb.Init ();
if (pCallback == 0 && FileIsOnROMedia(lpszRootPath))
{
fndb.flags |= FileNameDatabaseHeader::FndbFlags::Frozen;
}
if (storeFileNameInfo)
{
fndb.flags |= FileNameDatabaseHeader::FndbFlags::FileNameInfo;
}
AlignMem ();
fndb.foPath = PushBack(lpszRootPath);
numDirectories = 0;
numFiles = 0;
deepestLevel = 0;
currentLevel = 0;
this->pCallback = pCallback;
#if 0 // <new>this will break prev MiKTeX</new>
fndb.foTopDir = ProcessFolder(0, lpszRootPath, CURRENT_DIRECTORY, 0);
#else
fndb.foTopDir =
ProcessFolder(0,
lpszRootPath,
CURRENT_DIRECTORY,
fndb.foPath);
#endif
fndb.numDirs = numDirectories;
fndb.numFiles = numFiles;
fndb.depth = deepestLevel;
fndb.timeStamp = static_cast<unsigned long>(time(0)); // <sixtyfourbit/>
fndb.size = GetMemTop();
if ((fndb.flags & FileNameDatabaseHeader::FndbFlags::Frozen) == 0)
{
size_t n = ((GetMemTop() + FNDB_EXTRA + 1) / FNDB_GRAN * FNDB_GRAN) - GetMemTop();
ReserveMem (n);
}
AlignMem (FNDB_PAGESIZE);
SetMem (0, &fndb, sizeof(fndb));
// <fixme>
bool unloaded = false;
for (size_t i = 0; ! unloaded && i < 100; ++ i)
{
unloaded =
SessionImpl::GetSession()->UnloadFilenameDatabaseInternal(rootIdx,
true);
if (! unloaded)
{
traceStream->WriteFormattedLine ("core", "Sleep(1)");
Thread::Sleep (1);
}
}
if (! unloaded)
{
TraceError (T_("fndb cannot be unloaded"));
}
// </fixme>
PathName directory = PathName(lpszFndbPath).RemoveFileSpec();
if (! Directory::Exists(directory))
{
Directory::Create (directory);
}
FileStream streamFndb (File::Open(lpszFndbPath,
FileMode::Create,
FileAccess::Write,
false));
streamFndb.Write (GetMemPointer(), GetMemTop());
traceStream->WriteFormattedLine ("core",
T_("fndb creation completed"));
time_t now = time(0);
string nowStr = NUMTOSTR(now);
if (SessionImpl::GetSession()->IsAdminMode())
{
SessionImpl::GetSession()->SetConfigValue (MIKTEX_REGKEY_CORE, MIKTEX_REGVAL_LAST_ADMIN_MAINTENANCE, nowStr.c_str());
}
else
{
SessionImpl::GetSession()->SetConfigValue (MIKTEX_REGKEY_CORE, MIKTEX_REGVAL_LAST_USER_MAINTENANCE, nowStr.c_str());
}
return (true);
}
catch (const OperationCancelledException &)
{
traceStream->WriteFormattedLine ("core",
T_("fndb creation cancelled"));
return (false);
}
}
FileNameDatabaseHeader::FndbOffset
FndbManager::ProcessFolder
(/*[in]*/ FileNameDatabaseHeader::FndbOffset foParent,
/*[in]*/ const char * lpszParentPath,
/*[in]*/ const char * lpszFolderName,
/*[in]*/ FileNameDatabaseHeader::FndbOffset foFolderName)
{
const size_t cReservedEntries = 0;
if (currentLevel > deepestLevel)
{
deepestLevel = currentLevel;
}
vector<string> subDirectoryNames;
subDirectoryNames.reserve (40);
vector<FILENAMEINFO> fileNames;
fileNames.reserve (100);
bool done = false;
PathName path (lpszParentPath, lpszFolderName);
path.MakeAbsolute ();
if (pCallback != 0)
{
if (! pCallback->OnProgress(currentLevel, path.Get()))
{
throw OperationCancelledException ();
}
char * lpszSubDirNames = 0;
char * lpszFileNames = 0;
char * lpszFileNameInfos = 0;
done =
pCallback->ReadDirectory(path.Get(),
&lpszSubDirNames,
&lpszFileNames,
&lpszFileNameInfos);
if (done)
{
AutoMemoryPointer xxx (lpszSubDirNames);
AutoMemoryPointer xxy (lpszFileNames);
AutoMemoryPointer xxz (lpszFileNameInfos);
const char * lpsz = lpszSubDirNames;
while (*lpsz != 0)
{
subDirectoryNames.push_back (lpsz);
lpsz += strlen(lpsz) + 1;
}
lpsz = lpszFileNames;
const char * lpsz2 = lpszFileNameInfos;
while (*lpsz != 0)
{
FILENAMEINFO filenameinfo;
filenameinfo.FileName = lpsz;
lpsz += strlen(lpsz) + 1;
if (lpsz2 != 0)
{
filenameinfo.Info = lpsz2;
lpsz2 += strlen(lpsz2) + 1;
}
fileNames.push_back (filenameinfo);
}
}
}
if (! done)
{
ReadDirectory (path.Get(), subDirectoryNames, fileNames);
}
numDirectories += static_cast<unsigned long>(subDirectoryNames.size());
numFiles += static_cast<unsigned long>(fileNames.size());
sort (subDirectoryNames.begin(),
subDirectoryNames.end(),
StringComparerIgnoringCase());
sort (fileNames.begin(), fileNames.end(), COMPAREFILENAMEINFO());
// store all names; build offset table
vector<FileNameDatabaseHeader::FndbOffset> vecfndboff;
vecfndboff.reserve ((storeFileNameInfo ? 2 : 1) * fileNames.size()
+ 2 * subDirectoryNames.size()
+ cReservedEntries);
vector<FILENAMEINFO>::iterator it;
vector<string>::iterator it2;
for (it = fileNames.begin(); it != fileNames.end(); ++ it)
{
vecfndboff.push_back (PushBack((*it).FileName.c_str()));
}
for (it2 = subDirectoryNames.begin(); it2 != subDirectoryNames.end(); ++ it2)
{
vecfndboff.push_back (PushBack((*it2).c_str()));
}
for (it2 = subDirectoryNames.begin(); it2 != subDirectoryNames.end(); ++ it2)
{
vecfndboff.push_back (null_byte);
}
if (storeFileNameInfo)
{
for (it = fileNames.begin(); it != fileNames.end(); ++ it)
{
vecfndboff.push_back (PushBack((*it).Info.c_str()));
}
}
vecfndboff.insert (vecfndboff.end(), cReservedEntries, 0);
// store directory data (excluding offsets)
FileNameDatabaseDirectory dirdata;
dirdata.Init ();
dirdata.foName = foFolderName;
dirdata.foParent = foParent;
dirdata.numSubDirs = static_cast<unsigned long>(subDirectoryNames.size());
dirdata.numFiles = static_cast<unsigned long>(fileNames.size());
dirdata.capacity = static_cast<unsigned long>(vecfndboff.size());
AlignMem (AlignmentDirectory);
FileNameDatabaseHeader::FndbOffset foThis =
PushBack(&dirdata, offsetof(FileNameDatabaseDirectory, table));
if (vecfndboff.size() == 0)
{
return (foThis);
}
// reserve memory for offset table
FileNameDatabaseHeader::FndbOffset foOffsetTable =
ReserveMem(vecfndboff.size() * sizeof(FileNameDatabaseHeader::FndbOffset));
// recurse into sub-directories and remember offsets
PathName pathFolder (lpszParentPath, lpszFolderName, 0);
size_t i = 0;
++ currentLevel;
for (it2 = subDirectoryNames.begin();
it2 != subDirectoryNames.end();
++ it2, ++ i)
{
vecfndboff[dirdata.numFiles + dirdata.numSubDirs + i]
// <recursivecall>
= ProcessFolder(foThis,
pathFolder.Get(),
it2->c_str(),
vecfndboff[dirdata.numFiles + i]);
// </recursivecall>
}
-- currentLevel;
// store offset table
SetMem (foOffsetTable,
&vecfndboff[0],
vecfndboff.size() * sizeof(FileNameDatabaseHeader::FndbOffset));
return (foThis);
}
void ProcessLTX(LPCSTR tgt_name, LPCSTR params, BOOL bFast)
{
xr_string ltx_name;
LPCSTR ltx_nm = strstr(params,".ltx"); VERIFY(ltx_nm!=0);
string_path ltx_fn;
string_path tmp;
strncpy (tmp,params,ltx_nm-params); tmp[ltx_nm-params]=0;
_Trim (tmp);
strcat (tmp,".ltx");
strcpy (ltx_fn,tmp);
// append ltx path (if exist)
string_path fn,dr,di;
_splitpath (ltx_fn,dr,di,0,0);
strconcat (sizeof(fn),fn,dr,di);
if (0!=fn[0])
FS.append_path ("ltx_path",fn,0,false);
if (!FS.exist(ltx_fn)&&!FS.exist(ltx_fn,"$app_root$",tmp))
Debug.fatal (DEBUG_INFO,"ERROR: Can't find ltx file: '%s'",ltx_fn);
CInifile ltx (ltx_fn);
printf ("Processing LTX...\n");
BOOL make_pack = ltx.line_exist("options","make_pack") ? ltx.r_bool("options","make_pack") : true;
LPCSTR copy_path= ltx.line_exist("options","copy_path") ? ltx.r_string("options","copy_path") : 0;
if (ltx.line_exist("options","exclude_exts"))
_SequenceToList(exclude_exts,ltx.r_string("options","exclude_exts"));
xr_vector<char*> list;
xr_vector<char*> fl_list;
if(ltx.section_exist("include_folders"))
{
CInifile::Sect& if_sect = ltx.r_section("include_folders");
for (CInifile::SectCIt if_it=if_sect.Data.begin(); if_it!=if_sect.Data.end(); if_it++)
{
BOOL ifRecurse = CInifile::IsBOOL(if_it->second.c_str());
u32 folder_mask = FS_ListFolders | (ifRecurse?0:FS_RootOnly);
string_path path;
LPCSTR _path = 0==xr_strcmp(if_it->first.c_str(),".\\")?"":if_it->first.c_str();
strcpy (path,_path);
u32 path_len = xr_strlen(path);
if ((0!=path_len)&&(path[path_len-1]!='\\')) strcat(path,"\\");
Log ("");
OUT_LOG ("Processing folder: '%s'",path);
BOOL efRecurse;
BOOL val = IsFolderAccepted(ltx,path,efRecurse);
if (val || (!val&&!efRecurse))
{
if (val) ProcessFolder (list,path);
xr_vector<char*>* i_fl_list = FS.file_list_open ("$target_folder$",path,folder_mask);
if (!i_fl_list)
{
Log ("ERROR: Unable to open folder list:", path);
continue;
}
xr_vector<char*>::iterator it = i_fl_list->begin();
xr_vector<char*>::iterator itE = i_fl_list->end();
for (;it!=itE;++it){
xr_string tmp_path = xr_string(path)+xr_string(*it);
bool val = IsFolderAccepted(ltx,tmp_path.c_str(),efRecurse);
if (val)
{
fl_list.push_back(xr_strdup(tmp_path.c_str()));
Msg ("+F: %s",tmp_path.c_str());
// collect files
if (ifRecurse)
ProcessFolder (list,tmp_path.c_str());
}else
{
Msg ("-F: %s",tmp_path.c_str());
}
}
FS.file_list_close (i_fl_list);
}else
{
Msg ("-F: %s",path);
}
}
}//if(ltx.section_exist("include_folders"))
// compress
{
if(ltx.section_exist("include_files"))
{
CInifile::Sect& if_sect = ltx.r_section("include_files");
for (CInifile::SectCIt if_it=if_sect.Data.begin(); if_it!=if_sect.Data.end(); if_it++)
{
list.push_back (xr_strdup(if_it->first.c_str()));
}
}
}
CompressList (tgt_name,&list,&fl_list,bFast,make_pack,copy_path);
// free
xr_vector<char*>::iterator it = list.begin();
xr_vector<char*>::iterator itE = list.end();
for (;it!=itE;++it) xr_free(*it);
it = fl_list.begin();
itE = fl_list.end();
for (;it!=itE;++it) xr_free(*it);
exclude_exts.clear_and_free();
}
