void CmdLineParserTest() {
WStrVec args;
ParseCmdLine(L"test.exe -arg foo.pdf", args);
utassert(3 == args.size());
utassert(str::Eq(args.at(0), L"test.exe"));
utassert(str::Eq(args.at(1), L"-arg"));
utassert(str::Eq(args.at(2), L"foo.pdf"));
args.Reset();
ParseCmdLine(L"test.exe \"foo \\\" bar \\\\.pdf\" un\\\"quoted.pdf", args);
utassert(3 == args.size());
utassert(str::Eq(args.at(0), L"test.exe"));
utassert(str::Eq(args.at(1), L"foo \" bar \\\\.pdf"));
utassert(str::Eq(args.at(2), L"un\"quoted.pdf"));
args.Reset();
ParseCmdLine(L"test.exe \"foo\".pdf foo\" bar.pdf ", args);
utassert(3 == args.size());
utassert(str::Eq(args.at(0), L"test.exe"));
utassert(str::Eq(args.at(1), L"foo.pdf"));
utassert(str::Eq(args.at(2), L"foo bar.pdf "));
args.Reset();
ParseCmdLine(L"test.exe -arg \"%1\" -more", args, 2);
utassert(2 == args.size());
utassert(str::Eq(args.at(0), L"test.exe"));
utassert(str::Eq(args.at(1), L"-arg \"%1\" -more"));
args.Reset();
}
// Select random files to test. We want to test each file type equally, so
// we first group them by file extension and then select up to maxPerType
// for each extension, randomly, and inter-leave the files with different
// extensions, so their testing is evenly distributed.
// Returns result in <files>.
static void RandomizeFiles(WStrVec& files, int maxPerType)
{
WStrVec fileExts;
Vec<WStrVec *> filesPerType;
for (size_t i = 0; i < files.Count(); i++) {
const WCHAR *file = files.At(i);
const WCHAR *ext = path::GetExt(file);
CrashAlwaysIf(!ext);
int typeNo = fileExts.FindI(ext);
if (-1 == typeNo) {
fileExts.Append(str::Dup(ext));
filesPerType.Append(new WStrVec());
typeNo = (int)filesPerType.Count() - 1;
}
filesPerType.At(typeNo)->Append(str::Dup(file));
}
for (size_t j = 0; j < filesPerType.Count(); j++) {
WStrVec *all = filesPerType.At(j);
WStrVec *random = new WStrVec();
for (int n = 0; n < maxPerType && all->Count() > 0; n++) {
int idx = rand() % all->Count();
WCHAR *file = all->At(idx);
random->Append(file);
all->RemoveAtFast(idx);
}
filesPerType.At(j) = random;
delete all;
}
files.Reset();
bool gotAll = false;
while (!gotAll) {
gotAll = true;
for (size_t j = 0; j < filesPerType.Count(); j++) {
WStrVec *random = filesPerType.At(j);
if (random->Count() > 0) {
gotAll = false;
WCHAR *file = random->At(0);
files.Append(file);
random->RemoveAtFast(0);
}
}
}
for (size_t j = 0; j < filesPerType.Count(); j++) {
delete filesPerType.At(j);
}
}
bool CheckInstallUninstallPossible(bool silent) {
gProcessesToClose.Reset();
ProcessesUsingInstallation(gProcessesToClose);
bool possible = gProcessesToClose.size() == 0;
if (possible) {
SetDefaultMsg();
} else {
SetCloseProcessMsg();
if (!silent)
MessageBeep(MB_ICONEXCLAMATION);
}
InvalidateFrame();
return possible;
}
void DeleteAll() {
text.Reset();
}
// see http://itexmac.sourceforge.net/pdfsync.html for the specification
int Pdfsync::RebuildIndex()
{
size_t len;
ScopedMem<char> data(file::ReadAll(syncfilepath, &len));
if (!data)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
// convert the file data into a list of zero-terminated strings
str::TransChars(data, "\r\n", "\0\0");
// parse preamble (jobname and version marker)
char *line = data;
char *dataEnd = data + len;
// replace star by spaces (TeX uses stars instead of spaces in filenames)
str::TransChars(line, "*/", " \\");
ScopedMem<WCHAR> jobName(str::conv::FromAnsi(line));
jobName.Set(str::Join(jobName, L".tex"));
jobName.Set(PrependDir(jobName));
line = Advance0Line(line, dataEnd);
UINT versionNumber = 0;
if (!line || !str::Parse(line, "version %u", &versionNumber) || versionNumber != 1)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
// reset synchronizer database
srcfiles.Reset();
lines.Reset();
points.Reset();
fileIndex.Reset();
sheetIndex.Reset();
Vec<size_t> filestack;
UINT page = 1;
sheetIndex.Append(0);
// add the initial tex file to the source file stack
filestack.Push(srcfiles.Count());
srcfiles.Append(jobName.StealData());
PdfsyncFileIndex findex = { 0 };
fileIndex.Append(findex);
PdfsyncLine psline;
PdfsyncPoint pspoint;
// parse data
UINT maxPageNo = engine->PageCount();
while ((line = Advance0Line(line, dataEnd)) != NULL) {
if (!line)
break;
switch (*line) {
case 'l':
psline.file = filestack.Last();
if (str::Parse(line, "l %u %u %u", &psline.record, &psline.line, &psline.column))
lines.Append(psline);
else if (str::Parse(line, "l %u %u", &psline.record, &psline.line)) {
psline.column = 0;
lines.Append(psline);
}
// else dbg("Bad 'l' line in the pdfsync file");
break;
case 's':
if (str::Parse(line, "s %u", &page))
sheetIndex.Append(points.Count());
// else dbg("Bad 's' line in the pdfsync file");
// if (0 == page || page > maxPageNo)
// dbg("'s' line with invalid page number in the pdfsync file");
break;
case 'p':
pspoint.page = page;
if (0 == page || page > maxPageNo)
/* ignore point for invalid page number */;
else if (str::Parse(line, "p %u %u %u", &pspoint.record, &pspoint.x, &pspoint.y))
points.Append(pspoint);
else if (str::Parse(line, "p* %u %u %u", &pspoint.record, &pspoint.x, &pspoint.y))
points.Append(pspoint);
// else dbg("Bad 'p' line in the pdfsync file");
break;
case '(':
{
ScopedMem<WCHAR> filename(str::conv::FromAnsi(line + 1));
// if the filename contains quotes then remove them
// TODO: this should never happen!?
if (filename[0] == '"' && filename[str::Len(filename) - 1] == '"')
filename.Set(str::DupN(filename + 1, str::Len(filename) - 2));
// undecorate the filepath: replace * by space and / by \
str::TransChars(filename, L"*/", L" \\");
// if the file name extension is not specified then add the suffix '.tex'
if (str::IsEmpty(path::GetExt(filename)))
filename.Set(str::Join(filename, L".tex"));
// ensure that the path is absolute
if (PathIsRelative(filename))
filename.Set(PrependDir(filename));
filestack.Push(srcfiles.Count());
srcfiles.Append(filename.StealData());
findex.start = findex.end = lines.Count();
fileIndex.Append(findex);
}
break;
case ')':
if (filestack.Count() > 1)
fileIndex.At(filestack.Pop()).end = lines.Count();
// else dbg("Unbalanced ')' line in the pdfsync file");
break;
default:
// dbg("Ignoring invalid pdfsync line starting with '%c'", *line);
break;
}
}
fileIndex.At(0).end = lines.Count();
assert(filestack.Count() == 1);
return Synchronizer::RebuildIndex();
}