bool
NEWSArticle::StoreHeader(const string &line)
{
// First we simply store the raw header string
fHeader = line;
// Now we try to disassemble the header and store it as such
// Separate the lines
vector<string> headerLines = GetTokens(fHeader,'\n');
string fieldName = "";
string fieldValue = "";
for(vector<string>::const_iterator
itemIter = headerLines.begin();
itemIter != headerLines.end();
itemIter ++)
{
string thisLine = (*itemIter);
RemoveTrailingSpaces(thisLine);
if (thisLine[0] != ' ' && thisLine[0] != '\t')
{ // This means that this line is a new field
int position = thisLine.find(":");
fieldName.assign(thisLine,0,position);
fieldValue.assign(thisLine.begin()+position+1,thisLine.end());
RemoveLeadingSpaces(fieldName);
RemoveTrailingSpaces(fieldName);
RemoveLeadingSpaces(fieldValue);
RemoveTrailingSpaces(fieldValue);
// Store the field
fParsedHeaderFields.push_back(fieldName);
fParsedHeaders[fieldName] = fieldValue;
}
else
{ // This means that this line is a continuation of the previous line
// Just append the extra data with a newline
fParsedHeaders[fieldName] += "\n" + thisLine;
}
}
string groupsField;
if (GetHeaderField("Newsgroups",groupsField))
{
fNewsGroups = GetTokens(groupsField,',');
fNrOfNewsGroups = fNewsGroups.size();
}
fState = NA_ONLY_HEADER;
return true;
}
int GetLangParam(api::File& LangFile,const string& ParamName,string *strParam1, string *strParam2, UINT nCodePage)
{
string strFullParamName = L".";
strFullParamName += ParamName;
int Length=(int)strFullParamName.size();
/* $ 29.11.2001 DJ
не поганим позицию в файле; дальше @Contents не читаем
*/
BOOL Found = FALSE;
auto OldPos = LangFile.GetPointer();
string ReadStr;
GetFileString GetStr(LangFile, nCodePage);
while (GetStr.GetString(ReadStr))
{
if (!StrCmpNI(ReadStr.data(), strFullParamName.data(), Length))
{
size_t Pos = ReadStr.find(L'=');
if (Pos != string::npos)
{
*strParam1 = ReadStr.substr(Pos + 1);
if (strParam2)
strParam2->clear();
size_t pos = strParam1->find(L',');
if (pos != string::npos)
{
if (strParam2)
{
*strParam2 = *strParam1;
strParam2->erase(0, pos+1);
RemoveTrailingSpaces(*strParam2);
}
strParam1->resize(pos);
}
RemoveTrailingSpaces(*strParam1);
Found = TRUE;
break;
}
}
else if (!StrCmpNI(ReadStr.data(), L"@Contents", 9))
break;
}
LangFile.SetPointer(OldPos, nullptr, FILE_BEGIN);
return Found;
}
void vmsCommandLine::setArgs(LPCTSTR ptsz)
{
while (*ptsz == ' ')
ptsz++;
m_tstrArgs = ptsz;
RemoveTrailingSpaces ();
}
static const FARString& GetFarTitleAddons()
{
// " - Far%Ver%Admin"
/*
%Ver - 2.0
%Build - 1259
%Platform - x86
%Admin - MFarTitleAddonsAdmin
*/
static FormatString strVer, strBuild;
static bool bFirstRun = true;
static FARString strTitleAddons;
strTitleAddons.Copy(L" - Far ",7);
strTitleAddons += Opt.strTitleAddons;
if (bFirstRun)
{
bFirstRun = false;
strVer << HIWORD(FAR_VERSION) << L"." << LOWORD(FAR_VERSION);
strBuild << MB2Wide(FAR_BUILD).c_str();
}
ReplaceStrings(strTitleAddons,L"%Ver",strVer,-1,true);
ReplaceStrings(strTitleAddons,L"%Build",strBuild,-1,true);
ReplaceStrings(strTitleAddons,L"%Platform",
#if defined(__x86_64__)
L"x64",
#elif defined(__ppc64__)
L"ppc64",
#elif defined(__arm64__) || defined(__aarch64__)
L"arm64",
#elif defined(__arm__)
L"arm",
#else
L"x86",
#endif
-1,true);
ReplaceStrings(strTitleAddons,L"%Admin",Opt.IsUserAdmin?MSG(MFarTitleAddonsAdmin):L"",-1,true);
char hn[0x100] = {};
if (gethostname(hn, sizeof(hn) - 1) >= 0) {
ReplaceStrings(strTitleAddons,L"%Host", StrMB2Wide(hn).c_str(),-1,true);
}
const char *user = getenv("USER");
ReplaceStrings(strTitleAddons,L"%User", StrMB2Wide(user ? user : "").c_str(),-1,true);
RemoveTrailingSpaces(strTitleAddons);
return strTitleAddons;
}
double ConvertToDegrees (char *direction)
{
StrToUpper(direction);
RemoveTrailingSpaces(direction);
// JLM 11/12/99 allow the string to contain a value in digits
//if(isdigit(direction[0]))
if (direction[0]>='0' && direction[0]<='9') // for code warrior
{
float val;
long count = sscanf(direction, "%f", &val);
if (count == 1) {
// make sure it is in the range 0-360
double completeCircle = 360.0;
long numCompleteCircles = val/completeCircle; // truncate
val -= numCompleteCircles*completeCircle;
while (val < 0.0) { val += completeCircle;}
while (val > completeCircle) { val -= completeCircle;}
return val;
}
}
else
{
if (!strcmp(direction, "N")) return 0;
if (!strcmp(direction, "E")) return 90;
if (!strcmp(direction, "S")) return 180;
if (!strcmp(direction, "W")) return 270;
if (!strcmp(direction, "NE")) return 45;
if (!strcmp(direction, "SE")) return 135;
if (!strcmp(direction, "SW")) return 225;
if (!strcmp(direction, "NW")) return 315;
if (!strcmp(direction, "NNE")) return 22.5;
if (!strcmp(direction, "ENE")) return 67.5;
if (!strcmp(direction, "ESE")) return 112.5;
if (!strcmp(direction, "SSE")) return 157.5;
if (!strcmp(direction, "SSW")) return 202.5;
if (!strcmp(direction, "WSW")) return 247.5;
if (!strcmp(direction, "WNW")) return 292.5;
if (!strcmp(direction, "NNW")) return 337.5;
}
return 0;
}
static const string& GetFarTitleAddons()
{
// " - Far%Ver%Admin"
/*
%Ver - 2.0
%Build - 1259
%Platform - x86
%Admin - MFarTitleAddonsAdmin
%PID - current PID
*/
static FormatString strVer, strBuild, strPID;
static bool bFirstRun = true;
static string strTitleAddons;
strTitleAddons.Copy(L" - Far ",7);
strTitleAddons += Opt.strTitleAddons;
if (bFirstRun)
{
bFirstRun = false;
strVer<<FAR_VERSION.Major<<L"."<<FAR_VERSION.Minor;
strBuild<<FAR_VERSION.Build;
strPID<<GetCurrentProcessId();
}
ReplaceStrings(strTitleAddons,L"%PID",strPID,-1,true);
ReplaceStrings(strTitleAddons,L"%Ver",strVer,-1,true);
ReplaceStrings(strTitleAddons,L"%Build",strBuild,-1,true);
ReplaceStrings(strTitleAddons,L"%Platform",
#ifdef _WIN64
#ifdef _M_IA64
L"IA64",
#else
L"x64",
#endif
#else
L"x86",
#endif
-1,true);
ReplaceStrings(strTitleAddons,L"%Admin",Opt.IsUserAdmin?MSG(MFarTitleAddonsAdmin):L"",-1,true);
RemoveTrailingSpaces(strTitleAddons);
return strTitleAddons;
}
static const string& GetFarTitleAddons()
{
// " - Far%Ver%Admin"
/*
%Ver - 2.0
%Build - 1259
%Platform - x86
%Admin - MFarTitleAddonsAdmin
%PID - current PID
*/
static string strTitleAddons;
strTitleAddons.assign(L" - Far ",7);
strTitleAddons += Global->Opt->strTitleAddons.Get();
static const string strVer = std::to_wstring(FAR_VERSION.Major) + L"." + std::to_wstring(FAR_VERSION.Minor);
static const string strBuild = std::to_wstring(FAR_VERSION.Build);
static const string strPID = std::to_wstring(GetCurrentProcessId());
ReplaceStrings(strTitleAddons,L"%PID",strPID,-1,true);
ReplaceStrings(strTitleAddons,L"%Ver",strVer,-1,true);
ReplaceStrings(strTitleAddons,L"%Build",strBuild,-1,true);
ReplaceStrings(strTitleAddons,L"%Platform",
#ifdef _WIN64
#ifdef _M_IA64
L"IA64",
#else
L"x64",
#endif
#else
L"x86",
#endif
-1,true);
ReplaceStrings(strTitleAddons,L"%Admin",Global->IsUserAdmin()?MSG(MFarTitleAddonsAdmin):L"",-1,true);
RemoveTrailingSpaces(strTitleAddons);
return strTitleAddons;
}
bool cdgFile::ParseFile(std::ifstream & input, const std::string & filename)
{
Filename = filename;
bool errorFound = false; // any error found, stop parsing and return false
std::string errorMessage;
std::stringstream parsedOutput; // for debug
int parsedOutputIndentCounter = 0;
std::string parsedOutputIndent;
size_t lineNumber = 1; // counter for debug messages
char currentChar, previousChar = ' '; // we read character by character, used to detect //
std::string word, temp; // each word is created by concatenating characters
bool wordFinished, lineFinished; // start real processing or upgrade line count
bool semiColumn, curlyOpen, curlyClose; // special characters
std::string keyword, value; // parses "keyword <value .....>;"
bool curlyOpenExpected = false;
size_t curlyCounter = 0; // for inline code, need to balance {};
// global initialization
cdgScope::Stack scopes; // scope being parsed
this->Global = new cdgGlobal(lineNumber);
scopes.push_back(this->Global);
keyword.clear();
value.clear();
// parsing character by character
while (input.get(currentChar) && !errorFound) {
semiColumn = false;
curlyOpen = false;
curlyClose = false;
lineFinished = false;
// find curly brackets
switch (currentChar) {
case '/':
if (previousChar == '/') {
word.resize(word.size() - 1); // we had added previous '/' to a word
wordFinished = true;
getline(input, temp); // read and ignore comments until end of line
lineFinished = true;
} else {
word = word + currentChar;
wordFinished = false;
}
break;
case '\n':
lineFinished = true;
wordFinished = true;
break;
case ' ':
case '\t':
wordFinished = true;
break;
case ';':
semiColumn = true;
wordFinished = true;
break;
case '{':
curlyOpen = true;
wordFinished = true;
break;
case '}':
curlyClose = true;
wordFinished = true;
break;
default:
word = word + currentChar;
wordFinished = false;
}
// parsed output for debug
if (wordFinished && !word.empty()) {
parsedOutput << '\'' << word << '\'';
}
if (curlyOpen) {
parsedOutput << '[';
parsedOutputIndentCounter++;
parsedOutputIndent.resize(parsedOutputIndentCounter * 4, ' ');
}
if (curlyClose) {
parsedOutput << ']';
parsedOutputIndentCounter--;
if (parsedOutputIndentCounter < 0) {
parsedOutputIndentCounter = 0;
}
parsedOutputIndent.resize(parsedOutputIndentCounter * 4, ' ');
}
if (semiColumn) {
parsedOutput << '|';
}
// process based on flags and scope if there is anything to do
if (curlyOpen || curlyClose || semiColumn || (wordFinished && !word.empty())) {
if (curlyOpenExpected) {
if (!curlyOpen) {
std::cerr << filename << ":" << lineNumber << ": error: \"{\" expected, not \""
<< word << "\"" << std::endl;
errorFound = true;
} else {
curlyOpenExpected = false;
}
} else {
switch (scopes.back()->GetScope()) {
case cdgScope::CDG_GLOBAL:
case cdgScope::CDG_CLASS:
case cdgScope::CDG_BASECLASS:
case cdgScope::CDG_MEMBER:
case cdgScope::CDG_ENUM:
case cdgScope::CDG_ENUMVALUE:
case cdgScope::CDG_TYPEDEF:
// first define the current step, either find new keyword or new scope
if (keyword.empty()) {
value.clear();
if (scopes.back()->HasField(word)) {
keyword = word;
} else if (scopes.back()->HasSubScope(word, scopes, lineNumber)) {
keyword.clear();
if (!curlyOpen) {
curlyOpenExpected = true;
}
} else if (!word.empty()) {
std::cerr << filename << ":" << lineNumber << ": error: unexpected keyword \""
<< word << "\" in " << std::endl;
scopes.back()->DisplaySyntax(std::cerr, 0, false);
std::cerr << std::endl;
errorFound = true;
}
if (curlyClose) {
if (!scopes.back()->IsValid(errorMessage)) {
std::cerr << filename << ":" << lineNumber << ": error: " << errorMessage
<< " in scope \"" << scopes.back()->GetScopeName() << "\"" << std::endl;
errorFound = true;
}
scopes.pop_back();
if (!scopes.back()) {
std::cerr << filename << ":" << lineNumber << ": error: found one too many closing \"}\""
<< std::endl;
errorFound = true;
}
}
} else {
value += word + " ";
if (semiColumn) {
// we are done for this set keyword/value
RemoveTrailingSpaces(value);
errorMessage.clear();
if (!scopes.back()->SetFieldValue(keyword, value, errorMessage)) {
std::cerr << filename << ":" << lineNumber << ": error: " << errorMessage
<< " in scope \"" << scopes.back()->GetScopeName() << "\"" << std::endl;
errorFound = true;
}
keyword.clear();
}
}
word.clear();
break;
case cdgScope::CDG_CODE:
default:
std::cerr << filename << ":" << lineNumber << ": error: invalid scope ("
<< scopes.back()->GetScopeName() << ")" << std::endl;
errorFound = true;
break;
} // end of switch scope
// if we found some code to be parsed
if (scopes.back()->GetScope() == cdgScope::CDG_CODE) {
if (curlyOpenExpected) {
lineNumber++;
curlyCounter = 0;
} else {
curlyCounter = 1;
}
value.clear();
while (input.get(currentChar) && (curlyOpenExpected || (curlyCounter > 0))) {
switch (currentChar) {
case '\n':
lineNumber++;
value += currentChar;
break;
case '{':
curlyCounter++;
if (curlyOpenExpected) {
curlyOpenExpected = false;
} else {
value += currentChar;
}
break;
case '}':
curlyCounter--;
if (curlyCounter == 0) {
errorMessage.clear();
if (!scopes.back()->SetFieldValue(keyword, value, errorMessage)) {
std::cerr << filename << ":" << lineNumber << ": error: " << errorMessage
<< " in scope \"" << scopes.back()->GetScopeName() << "\"" << std::endl;
errorFound = true;
}
scopes.pop_back();
keyword.clear();
}
value += currentChar;
break;
default:
value += currentChar;
break;
}
parsedOutput << currentChar;
}
if (curlyOpenExpected) {
std::cerr << filename << ":" << lineNumber << ": error: missing opening \"}\""
<< " for \"" << keyword << "\" in scope \""
<< scopes.back()->GetScopeName() << "\"" << std::endl;
errorFound = true;
}
} // end of inline code parsing
}
}
// general settings for next iteration
if (wordFinished) {
previousChar = ' ';
} else {
previousChar = currentChar;
}
if (lineFinished) {
lineNumber++;
lineFinished = false;
parsedOutput << '\n' << lineNumber << ": " << parsedOutputIndent;
}
} // while loop for character
// some sanity checks
if (scopes.back()->GetScope() != cdgScope::CDG_GLOBAL) {
std::cerr << filename << ":" << lineNumber << ": error: invalid scope ("
<< scopes.back()->GetScopeName() << ")" << std::endl;
errorFound = true;
}
if (curlyCounter != 0) {
std::cerr << filename << ":" << lineNumber << ": error: missing closing \"}\"" << std::endl;
errorFound = true;
}
// provides a parsed view which might help debug
if (errorFound) {
std::cerr << parsedOutput.str() << std::endl;
} else {
// fill in default values
scopes.back()->FillInDefaults();
}
return !errorFound;
}
string& WINAPI RemoveExternalSpaces(string &strStr)
{
return RemoveTrailingSpaces(RemoveLeadingSpaces(strStr));
}
wchar_t* WINAPI RemoveExternalSpaces(wchar_t *Str)
{
return RemoveTrailingSpaces(RemoveLeadingSpaces(Str));
}
void MenuFileToList(DList<UserMenuItem> *Menu, File& MenuFile, GetFileString& GetStr, uintptr_t MenuCP = CP_UNICODE)
{
INT64 Pos = MenuFile.GetPointer();
if (!Pos)
{
if (!GetFileFormat(MenuFile,MenuCP))
MenuCP = CP_OEMCP;
}
LPWSTR MenuStr = nullptr;
int MenuStrLength = 0;
UserMenuItem *MenuItem = nullptr;
while (GetStr.GetString(&MenuStr, MenuCP, MenuStrLength))
{
RemoveTrailingSpaces(MenuStr);
if (!*MenuStr)
continue;
if (*MenuStr==L'{' && MenuItem && MenuItem->Menu)
{
MenuFileToList(MenuItem->Menu, MenuFile, GetStr, MenuCP);
MenuItem = nullptr;
continue;
}
if (*MenuStr==L'}')
break;
if (!IsSpace(*MenuStr))
{
wchar_t *ChPtr = nullptr;
if (!(ChPtr=wcschr(MenuStr,L':')))
continue;
MenuItem = Menu->Push();
*ChPtr = 0;
MenuItem->strHotKey = MenuStr;
MenuItem->strLabel = ChPtr+1;
RemoveLeadingSpaces(MenuItem->strLabel);
MenuItem->Submenu = (GetStr.PeekString(&MenuStr, MenuCP, MenuStrLength) && *MenuStr==L'{');
if (MenuItem->Submenu)
MenuItem->Menu = new DList<UserMenuItem>();
// Support for old 1.x separator format
if (MenuCP==CP_OEMCP && MenuItem->strHotKey==L"-" && MenuItem->strLabel.IsEmpty())
{
MenuItem->strHotKey += L"-";
}
}
else if (MenuItem)
{
RemoveLeadingSpaces(MenuStr);
string *str = MenuItem->Commands.Push();
*str = MenuStr;
}
}
}
void DizList::Read(const string& Path, const string* DizName)
{
Reset();
TPreRedrawFuncGuard preRedrawFuncGuard(DizList::PR_ReadingMsg);
const wchar_t *NamePtr=Opt.Diz.strListNames;
for (;;)
{
if (DizName)
{
strDizFileName = *DizName;
}
else
{
strDizFileName = Path;
if (!PathCanHoldRegularFile(strDizFileName))
break;
string strArgName;
if (!(NamePtr=GetCommaWord(NamePtr,strArgName)))
break;
AddEndSlash(strDizFileName);
strDizFileName += strArgName;
}
File DizFile;
if (DizFile.Open(strDizFileName,GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING))
{
GetFileString GetStr(DizFile);
wchar_t *DizText;
int DizLength;
clock_t StartTime=clock();
uintptr_t CodePage=CP_DEFAULT;
bool bSigFound=false;
if (!GetFileFormat(DizFile,CodePage,&bSigFound,false) || !bSigFound)
CodePage = Opt.Diz.AnsiByDefault ? CP_ACP : CP_OEMCP;
while (GetStr.GetString(&DizText, CodePage, DizLength) > 0)
{
if (!(DizCount & 127) && clock()-StartTime>1000)
{
SetCursorType(FALSE,0);
PR_ReadingMsg();
if (CheckForEsc())
break;
}
RemoveTrailingSpaces(DizText);
if (*DizText)
AddRecord(DizText);
}
OrigCodePage=CodePage;
Modified=false;
DizFile.Close();
return;
}
if (DizName)
break;
}
Modified=false;
strDizFileName.Clear();
}
//Централизованная функция для создания строк меню различных фильтров.
void MenuString(string &strDest, FileFilterParams *FF, bool bHighlightType, int Hotkey, bool bPanelType, const wchar_t *FMask, const wchar_t *Title)
{
const wchar_t AttrC[] = L"RAHSDCEI$TLOV";
const DWORD AttrF[] =
{
FILE_ATTRIBUTE_READONLY,
FILE_ATTRIBUTE_ARCHIVE,
FILE_ATTRIBUTE_HIDDEN,
FILE_ATTRIBUTE_SYSTEM,
FILE_ATTRIBUTE_DIRECTORY,
FILE_ATTRIBUTE_COMPRESSED,
FILE_ATTRIBUTE_ENCRYPTED,
FILE_ATTRIBUTE_NOT_CONTENT_INDEXED,
FILE_ATTRIBUTE_SPARSE_FILE,
FILE_ATTRIBUTE_TEMPORARY,
FILE_ATTRIBUTE_REPARSE_POINT,
FILE_ATTRIBUTE_OFFLINE,
FILE_ATTRIBUTE_VIRTUAL,
};
const wchar_t Format1a[] = L"%-21.21s %c %-26.26s %-3.3s %c %s";
const wchar_t Format1b[] = L"%-22.22s %c %-26.26s %-3.3s %c %s";
const wchar_t Format1c[] = L"&%c. %-18.18s %c %-26.26s %-3.3s %c %s";
const wchar_t Format1d[] = L" %-18.18s %c %-26.26s %-3.3s %c %s";
const wchar_t Format2[] = L"%-3.3s %c %-26.26s %-4.4s %c %s";
const wchar_t DownArrow=0x2193;
const wchar_t *Name, *Mask;
wchar_t MarkChar[]=L"\" \"";
DWORD IncludeAttr, ExcludeAttr;
bool UseMask, UseSize, UseHardLinks, UseDate, RelativeDate;
if (bPanelType)
{
Name=Title;
UseMask=true;
Mask=FMask;
IncludeAttr=0;
ExcludeAttr=FILE_ATTRIBUTE_DIRECTORY;
RelativeDate=UseDate=UseSize=UseHardLinks=false;
}
else
{
MarkChar[1]=(wchar_t)FF->GetMarkChar();
if (!MarkChar[1])
*MarkChar=0;
Name=FF->GetTitle();
UseMask=FF->GetMask(&Mask);
if (!FF->GetAttr(&IncludeAttr,&ExcludeAttr))
IncludeAttr=ExcludeAttr=0;
UseSize=FF->GetSize(nullptr,nullptr);
UseDate=FF->GetDate(nullptr,nullptr,nullptr,&RelativeDate);
UseHardLinks=FF->GetHardLinks(nullptr,nullptr);
}
wchar_t Attr[ARRAYSIZE(AttrC)*2] = {};
for (size_t i=0; i<ARRAYSIZE(AttrF); i++)
{
wchar_t *Ptr=Attr+i*2;
*Ptr=AttrC[i];
if (IncludeAttr&AttrF[i])
*(Ptr+1)=L'+';
else if (ExcludeAttr&AttrF[i])
*(Ptr+1)=L'-';
else
*Ptr=*(Ptr+1)=L'.';
}
wchar_t SizeDate[5] = L"....";
if (UseSize)
{
SizeDate[0]=L'S';
}
if (UseDate)
{
if (RelativeDate)
SizeDate[1]=L'R';
else
SizeDate[1]=L'D';
}
if (UseHardLinks)
{
SizeDate[2]=L'H';
}
if (bHighlightType)
{
if (FF->GetContinueProcessing())
SizeDate[3]=DownArrow;
strDest.Format(Format2, MarkChar, BoxSymbols[BS_V1], Attr, SizeDate, BoxSymbols[BS_V1], UseMask ? Mask : L"");
}
else
{
SizeDate[3]=0;
if (!Hotkey && !bPanelType)
{
strDest.Format(wcschr(Name, L'&') ? Format1b : Format1a, Name, BoxSymbols[BS_V1], Attr, SizeDate, BoxSymbols[BS_V1], UseMask ? Mask : L"");
}
else
{
if (Hotkey)
strDest.Format(Format1c, Hotkey, Name, BoxSymbols[BS_V1], Attr, SizeDate, BoxSymbols[BS_V1], UseMask ? Mask : L"");
else
strDest.Format(Format1d, Name, BoxSymbols[BS_V1], Attr, SizeDate, BoxSymbols[BS_V1], UseMask ? Mask : L"");
}
}
RemoveTrailingSpaces(strDest);
}
HeaderMatcher::HeaderMatcher(
IniFile *settings,
const string sectionName,
const string valueName)
: Printable("HeaderMatcher")
, ArticleImpactChecker(settings)
{
fObjectIsValid = true;
fRegExpression = NULL;
// Copy the parameters
fIniSectionName = sectionName;
fIniValueName = valueName;
// Initialize the Cooked values
fHeaderName = "";
fHeaderValue = "";
fLastMatchDate = fNow;
fMatchCount = 0;
fImpactValue = 100; // Default Impact value
fSearchCaseINSensitive = false;
// Quick check of the parameters
if (fSettings == NULL ||
fIniSectionName == "" ||
fIniValueName == "")
{
fObjectIsValid = false;
return;
}
// ----------
// Split the fIniValueName into the required parts
// There should be two possibilities:
// Casesensitive matching
// fieldname:valuetomatch
// Case INsensitive matching
// ~fieldname:valuetomatch
// First check if searching case insensitive.
string parseValueName = fIniValueName;
if (parseValueName[0] == '~')
{
fSearchCaseINSensitive = true;
// Remove "~"
parseValueName.erase(parseValueName.begin());
}
// Now split at the first ':'
unsigned long colonPosition = parseValueName.find(":");
if (colonPosition == parseValueName.npos)
{ // The header doesn't include a ':' --> Not a header !!
fObjectIsValid = false;
Lerror << "Invalid \"" << sectionName
<< "\" header matching line : \""
<< valueName << "\"." << endl << flush;
return;
}
fHeaderName.assign (parseValueName,0,colonPosition);
fHeaderValue.assign(parseValueName.begin() + colonPosition + 1,parseValueName.end());
// ----------
// Try to compile the header value that should be matched
regbase::flag_type cflags = regbase::normal;
if (fSearchCaseINSensitive)
cflags |= regbase::icase;
try
{
fRegExpression = new regex(fHeaderValue, cflags);
}
catch (bad_expression)
{
fObjectIsValid = false;
Lerror << "Invalid regular expression \"" << fHeaderValue
<< "\". Check the suckmt config file" << endl << flush;
char inistr[100];
std::sprintf(inistr,"%s ; %5ld ; %5ld ; INVALID REGULAR EXPRESSION !!",fLastMatchDate.c_str(),fMatchCount,fImpactValue);
fSettings->SetValue(fIniSectionName, fIniValueName, inistr);
return;
}
// ----------
// Now get the statistics parameters for the matching process
if (fSettings->GetValue(fIniSectionName,fIniValueName,fIniValue))
{
// ----------
// Split the value into the required parts
vector<string> iniValueList = GetTokens(fIniValue,';');
switch (iniValueList.size())
{
case 3: StringToLong(iniValueList[2],fImpactValue);
case 2: StringToLong(iniValueList[1],fMatchCount);
case 1: RemoveLeadingSpaces(iniValueList[0]);
RemoveTrailingSpaces(iniValueList[0]);
fLastMatchDate = iniValueList[0];
}
}
char inistr[100];
std::sprintf(inistr,"%s ; %5ld ; %5ld",fLastMatchDate.c_str(),fMatchCount,fImpactValue);
fSettings->SetValue(fIniSectionName, fIniValueName, inistr);
}
void vmsCommandLine::fromString(LPCTSTR ptsz, bool bConvertToLongPath)
{
Clear ();
if (ptsz == NULL || *ptsz == 0)
return;
TCHAR tszTmp [MAX_PATH] = _T ("");
if (_tcschr (ptsz, '%'))
{
ExpandEnvironmentStrings (ptsz, tszTmp, MAX_PATH);
ptsz = tszTmp;
}
if (*ptsz == '"')
{
ptsz++;
while (*ptsz && *ptsz != '"')
m_tstrExe += *ptsz++;
if (*ptsz == 0)
{
m_tstrExe = _T ("");
return;
}
ptsz++;
}
else
{
while (*ptsz == ' ')
ptsz++;
do
{
while (*ptsz && *ptsz != ' ')
m_tstrExe += *ptsz++;
if (m_tstrExe.length () > 1 && m_tstrExe [1] != ':')
{
if (SearchPath (m_tstrExe.c_str (), _T (".exe"), &m_tstrExe))
{
bConvertToLongPath = false;
break;
}
}
if (*ptsz)
{
DWORD dw = GetFileAttributes (m_tstrExe.c_str ());
if (dw != DWORD (-1) && (dw & FILE_ATTRIBUTE_DIRECTORY) == 0)
break;
tstring tstr = m_tstrExe;
tstr += _T (".exe");
dw = GetFileAttributes (tstr.c_str ());
if (dw != DWORD (-1) && (dw & FILE_ATTRIBUTE_DIRECTORY) == 0)
break;
if (m_tstrExe.length () > 4 &&
_tcsicmp (m_tstrExe.c_str ()+m_tstrExe.length ()-4, _T (".exe")) == 0)
break;
while (*ptsz == ' ')
m_tstrExe += *ptsz++;
}
} while (*ptsz);
}
if (bConvertToLongPath)
m_tstrExe = getLongPathName (m_tstrExe.c_str ());
while (*ptsz == ' ')
ptsz++;
m_tstrArgs = ptsz ? ptsz : _T ("");
RemoveTrailingSpaces ();
}
void DizList::Read(const string& Path, const string* DizName)
{
Reset();
struct DizPreRedrawItem : public PreRedrawItem
{
DizPreRedrawItem() : PreRedrawItem(PR_ReadingMsg) {}
};
SCOPED_ACTION(TPreRedrawFuncGuard)(std::make_unique<DizPreRedrawItem>());
const wchar_t *NamePtr=Global->Opt->Diz.strListNames.data();
for (;;)
{
if (DizName)
{
strDizFileName = *DizName;
}
else
{
strDizFileName = Path;
if (!PathCanHoldRegularFile(strDizFileName))
break;
string strArgName;
NamePtr = GetCommaWord(NamePtr, strArgName);
if (!NamePtr)
break;
AddEndSlash(strDizFileName);
strDizFileName += strArgName;
}
os::fs::file DizFile;
if (DizFile.Open(strDizFileName,GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING))
{
clock_t StartTime=clock();
uintptr_t CodePage=CP_DEFAULT;
bool bSigFound=false;
if (!GetFileFormat(DizFile,CodePage,&bSigFound,false) || !bSigFound)
CodePage = Global->Opt->Diz.AnsiByDefault ? CP_ACP : CP_OEMCP;
GetFileString GetStr(DizFile, CodePage);
auto LastAdded = DizData.end();
string DizText;
while (GetStr.GetString(DizText))
{
if (!(DizData.size() & 127) && clock() - StartTime > CLOCKS_PER_SEC)
{
SetCursorType(false, 0);
PR_ReadingMsg();
if (CheckForEsc())
break;
}
RemoveTrailingSpaces(DizText);
if (!DizText.empty())
{
if(!IsSpace(DizText.front()))
{
LastAdded = AddRecord(DizText);
}
else
{
if (LastAdded != DizData.end())
{
LastAdded->second.emplace_back(DizText);
}
}
}
}
OrigCodePage=CodePage;
Modified=false;
DizFile.Close();
return;
}
if (DizName)
break;
}
Modified=false;
strDizFileName.clear();
}
