//读取一个单词
const char* CXML::ReadWord(const char* xml,char* word,int bufsize,TAG **ppTag)
{
assert(bufsize>0 && word);
char* tempWord = word;
*tempWord = '\0';
xml = SkipBlank(xml);
//名称可以以字母,数字,下划线,[,]开头, 中间可以夹杂 点, 冒号, 破折号,[].
if( xml && *xml
&& ( IsAlphaNum((unsigned char) *xml)
|| IsAlpha((unsigned char) *xml)
|| *xml == '_'
|| *xml == '['
|| *xml == ']') )
{
while( xml && *xml
&& ( IsAlphaNum( (unsigned char ) *xml )
|| *xml == '_'
|| *xml == '-'
|| *xml == '.'
|| *xml == ':'
|| *xml == '['
|| *xml == ']') )
{
*tempWord++ = *xml++;
}
*tempWord = '\0';
}
return SkipBlank(xml);
}
const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding )
{
*name = "";
assert( p );
// Names start with letters or underscores.
// Of course, in unicode, tinyxml has no idea what a letter *is*. The
// algorithm is generous.
//
// After that, they can be letters, underscores, numbers,
// hyphens, or colons. (Colons are valid ony for namespaces,
// but tinyxml can't tell namespaces from names.)
if ( p && *p
&& ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )
{
while( p && *p
&& ( IsAlphaNum( (unsigned char ) *p, encoding )
|| *p == '_'
|| *p == '-'
|| *p == '.'
|| *p == ':' ) )
{
(*name) += *p;
++p;
}
return p;
}
return 0;
}
// id - parses an id
bool opScanner::GetId(const inputtype& Input, int& current) {
char c = Input[current];
int size = Input.Size();
if (IsAlpha(c) || c == '_') {
opToken newToken(T_ID, c, CurrentLine);
++current;
while (current < size) {
c = Input[current];
if (!IsAlphaNum(c) && c != '_') break;
newToken.Value += c;
++current;
}
Tokens.push_back(newToken);
return true;
}
return false;
}
// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The
// "assign" optimization removes over 10% of the execution time.
//
const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding ) {
// Oddly, not supported on some comilers,
//name->clear();
// So use this:
*name = "";
assert( p );
// Names start with letters or underscores.
// Of course, in unicode, tinyxml has no idea what a letter *is*. The
// algorithm is generous.
//
// After that, they can be letters, underscores, numbers,
// hyphens, or colons. (Colons are valid ony for namespaces,
// but tinyxml can't tell namespaces from names.)
if ( p && *p
&& ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) ) {
const char* start = p;
while( p && *p
&& ( IsAlphaNum( (unsigned char ) *p, encoding )
|| *p == '_'
|| *p == '-'
|| *p == '.'
|| *p == ':' ) ) {
//(*name) += *p; // expensive
++p;
}
if ( p-start > 0 ) {
name->assign( start, p-start );
}
return p;
}
return 0;
}
int main()
{
int c;
int state;
int len;
state = 0;
len = 0;
do {
c = getchar();
switch (state) {
case 0:
if (IsAlphaNum(c)) {
buf[len] = c;
len++;
state = 1;
}
else {
if (c != EOF) putchar(c);
}
break;
case 1:
if (IsAlphaNum(c)) {
buf[len] = c;
len++;
}
else {
buf[len] = '\0';
PrintName(buf);
len = 0;
if (c != EOF) putchar(c);
state = 0;
}
break;
}
} while (c != EOF);
return 0;
}
gcc_unused
static bool
SetAssetNumber(const TCHAR *p)
{
size_t length = 0;
while (length < ARRAY_SIZE(asset_number) - 1 && *p != _T('\0')) {
if (IsAlphaNum(*p))
asset_number[length++] = *p;
++p;
}
if (length < 3) {
asset_number[0] = _T('\0');
return false;
}
return true;
}
void CppScanner::GetName()
{
char s[512];
int i = 0;
do
{
s[i++] = f.Get();
if (i > 511) throw CPError(CPError::NAME_TOO_LONG);
f.GetNext();
} while (IsAlphaNum(f.Get()));
s[i] = 0;
type = CToken::SYMBOL;
if (!strcmp(s, "void")) symbol = CToken::SYMB_VOID;
else if (!strcmp(s, "bool")) symbol = CToken::SYMB_BOOL;
else if (!strcmp(s, "int8_t")) symbol = CToken::SYMB_CHAR;
else if (!strcmp(s, "int16_t")) symbol = CToken::SYMB_SHORT;
else if (!strcmp(s, "int32_t")) symbol = CToken::SYMB_INT;
else if (!strcmp(s, "int64_t")) symbol = CToken::SYMB_LONG;
else if (!strcmp(s, "uint8_t")) symbol = CToken::SYMB_UCHAR;
else if (!strcmp(s, "uint16_t")) symbol = CToken::SYMB_USHORT;
else if (!strcmp(s, "uint32_t")) symbol = CToken::SYMB_UINT;
else if (!strcmp(s, "uint64_t")) symbol = CToken::SYMB_ULONG;
else if (!strcmp(s, "vector")) symbol = CToken::SYMB_VECTOR;
else if (!strcmp(s, "vectorR")) symbol = CToken::SYMB_VECTORR;
else if (!strcmp(s, "HWvectorR")) symbol = CToken::SYMB_HWVECTORR;
else if (!strcmp(s, "string")) symbol = CToken::SYMB_STRING;
else if (!strcmp(s, "stringR")) symbol = CToken::SYMB_STRINGR;
else if (!strcmp(s, "stringR")) symbol = CToken::SYMB_STRINGR;
else if (!strcmp(s, "false")) symbol = CToken::SYMB_FALSE;
else if (!strcmp(s, "true")) symbol = CToken::SYMB_TRUE;
else if (!strcmp(s, "static")) symbol = CToken::SYMB_STATIC;
else
{
type = CToken::NAME;
name = new char[i+1];
strcpy(name, s);
}
}
static TToken getToken()
{
oSrcString = sSrcString;
int ch = getNextChar();
bool verbStr=false;
switch (ch)
{
case EOFCH:
case 0: currTok = tEnd; break;
case L',': currTok = tComma; break;
case L'+': currTok = tPlus; break;
case L'-': currTok = tMinus; break;
case L'*': currTok = tMul; break;
case L'/': currTok = tDiv; break;
case L'(': currTok = tLp; break;
case L')': currTok = tRp; break;
case L'^':
if ((ch = getChar()) == L'^')
currTok = tBoolXor;
else
{
putBack(ch);
currTok = tBitXor;
}
break;
case L'~':
if ((ch = getChar()) != L' ')
{
putBack(ch);
currTok = tBitNot;
break;
}
putBack(ch); //????
currTok = tEnd;
break;
case L'|':
if ((ch = getChar()) == L'|')
currTok = tBoolOr;
else
{
putBack(ch);
currTok = tBitOr;
}
break;
case L'&':
if ((ch = getChar()) == L'&')
currTok = tBoolAnd;
else
{
putBack(ch);
currTok = tBitAnd;
}
break;
case L'=':
if ((ch = getChar()) == L'=')
currTok = tEq;
else
{
putBack(ch);
currTok = tLet;
}
break;
case L'>':
switch ((ch = getChar()))
{
case L'=': currTok = tGe; break;
case L'>': currTok = tBitShr; break;
default:
putBack(ch);
currTok = tGt;
break;
}
break;
case L'<':
switch (ch = getChar())
{
case L'=': currTok = tLe; break;
case L'<': currTok = tBitShl; break;
default:
putBack(ch);
currTok = tLt;
break;
}
break;
case L'!':
if ((ch = getChar()) != L'=')
{
putBack(ch);
currTok = tNot;
break;
}
else
currTok = tNe;
break;
case L'@':
ch = getChar();
if (ch != L'"')
{
putBack(ch);
break;
}
verbStr=true;
case L'\"':
{
TToken __currTok = tNo;
currVar = L"";
while (((ch = getChar()) != EOFCH))
{
if (ch == L'\"')
{
if (verbStr)
{
ch = getChar();
if (ch != L'\"')
{
putBack(ch);
break;
}
}
else
break;
}
if (ch == L'\\' && !verbStr)
{
switch (ch = getChar())
{
case L'a' : ch = L'\a'; break;
case L'b' : ch = L'\b'; break;
case L'f' : ch = L'\f'; break;
case L'n' : ch = L'\n'; break;
case L'r' : ch = L'\r'; break;
case L't' : ch = L'\t'; break;
case L'v' : ch = L'\v'; break;
case L'\'': ch = L'\''; break;
case L'\"': ch = L'\"'; break;
case L'\\': ch = L'\\'; break;
case L'0': case L'1': case L'2': case L'3': case L'4': case L'5': case L'6': case L'7': // octal: \d \dd \ddd
{
BYTE n = ch - L'0';
if ((unsigned int)(ch = getChar()) >= L'0' && (unsigned int)ch < L'8')
{
n = 8 * n + ch - L'0';
if ((unsigned int)(ch = getChar()) >= L'0' && (unsigned int)ch < L'8')
n = 8 * n + ch - L'0';
else
putBack(ch);
}
else
putBack(ch);
ch = n;
break;
}
case L'x':
{
if (iswxdigit(ch = getChar()))
{
wchar_t value=hex2ch(ch);
for (int ii=0; ii<3; ii++)
{
if (iswxdigit(ch = getChar()))
{
value=(value<<4)|hex2ch(ch);
}
else
{
putBack(ch);
break;
}
}
ch = value;
}
else
{
keyMacroParseError(err_Bad_Hex_Control_Char,--sSrcString,pSrcString);
__currTok = tEnd;
}
break;
}
default:
{
keyMacroParseError(err_Bad_Control_Char,--sSrcString,pSrcString);
__currTok = tEnd;
break;
}
}
}
if (__currTok != tNo)
break;
currVar.AppendStr((wchar_t)ch);
}
if (__currTok == tNo)
currTok = tStr;
else
currTok = __currTok;
break;
}
case L'.':
{
ch = getChar();
if (iswdigit(ch))
{
putBack(ch);
ch=L'.';
}
else
{
currTok = tEnd; //???
break;
}
}
case L'0': case L'1': case L'2': case L'3': case L'4':
case L'5': case L'6': case L'7': case L'8': case L'9':
{
static wchar_t buffer[256];
wchar_t *ptrbuffer=buffer;
bool isNum = false;
bool isHex = false;
bool isE = false;
bool isPoint = false;
int ch2;
for (;;)
{
*ptrbuffer++=(wchar_t)ch;
switch (ch)
{
case L'x':
case L'X':
if (ptrbuffer == buffer + 2)
{
ch = getChar();
if (iswxdigit(ch))
{
isHex=true;
putBack(ch);
}
else
{
putBack(ch);
isNum=true;
break;
}
}
break;
case L'.':
if (isPoint || isE)
{
isNum=true;
break;
}
isPoint=true;
break;
case L'e':
case L'E':
if (isHex)
break;
if (isE)
{
isNum=true;
break;
}
isE=true;
ch2 = getChar();
if (ch2 == L'-' || ch2 == L'+')
{
int ch3=getChar();
if (iswdigit(ch3))
{
*ptrbuffer++=(wchar_t)ch2;
*ptrbuffer++=(wchar_t)ch3;
}
else
{
putBack(ch3); // !iswdigit
putBack(ch2); // -+
putBack(ch); // eE
}
}
else if (!iswdigit(ch2))
{
putBack(ch2); // !iswdigit
putBack(ch); // eE
}
else
putBack(ch);
break;
case L'a': case L'A':
case L'b': case L'B':
case L'c': case L'C':
case L'd': case L'D':
case L'f': case L'F':
if (!isHex)
{
isNum=true;
break;
}
case L'0': case L'1': case L'2': case L'3': case L'4':
case L'5': case L'6': case L'7': case L'8': case L'9':
//isNum=true;
break;
default:
isNum=true;
break;
}
if (isNum)
break;
ch = getChar();
}
if (ch != EOFCH)
putBack(ch);
*ptrbuffer++=(wchar_t)0;
bool CheckIntNumber=true;
if (buffer[0])
{
if (!(buffer[1] == L'x' || buffer[1] == L'X'))
{
for (ptrbuffer=buffer; *ptrbuffer ; ptrbuffer++)
{
if (*ptrbuffer == L'e' || *ptrbuffer == L'E' || *ptrbuffer == L'.')
{
CheckIntNumber=false;
break;
}
else if (!iswdigit(*ptrbuffer))
break;
}
}
}
else
CheckIntNumber=false;
if (CheckIntNumber)
{
currVar = _wcstoi64(buffer,&ptrbuffer,0);
currTok = tInt;
}
else
{
currVar = wcstod(buffer,&ptrbuffer);
currTok = tFloat;
}
break;
}
case L'%':
ch = getChar();
if ((IsAlphaNum(ch) || ch == L'_') || (ch == L'%' && (IsAlphaNum(*sSrcString) || *sSrcString == L'_')))
{
getVarName(ch);
putBack(ch);
currTok = tVar;
}
else
keyMacroParseError(err_Var_Expected,L""); // BUG nameString
break;
default:
{
if (IsAlpha(ch)) // || ch == L'_' ????
{
TToken __currTok = tNo;
getFarName(ch);
if (ch == L' ')
{
while (ch == L' ')
ch = getNextChar();
}
if (ch == L'(') //!!!! а пробелы пропустить? ДА!
__currTok = tFunc;
else
{
putBack(ch);
for (int i = 0 ; i < MKeywordsSize ; i++)
if (!StrCmpI(nameString, MKeywords[i].Name))
{
FARVar = MKeywords[i].Value;
__currTok = tFARVar;
break;
}
if (__currTok == tNo)
{
if (IsProcessFunc || currTok == tFunc || currTok == tLt) // TODO: уточнить
{
if (KeyNameMacroToKey(nameString) == -1 && KeyNameToKey(nameString) == -1 && checkMacroConst(nameString))
__currTok = tConst;
else
{
DWORD k=KeyNameToKey(nameString);
if (k != (DWORD)-1)
{
currVar = (__int64)k;
__currTok = tInt; //??
}
else
{
keyMacroParseError(err_Var_Expected,oSrcString,pSrcString,nameString);
}
}
}
else
{
if (KeyNameMacroToKey(nameString) == -1)
{
if (KeyNameToKey(nameString) == -1)
{
if (checkMacroConst(nameString))
__currTok = tConst;
else
keyMacroParseError(err_Unrecognized_keyword,nameString);
}
else
{
currVar = (__int64)KeyNameToKey(nameString);
__currTok = tInt; //??
}
}
}
}
}
if (__currTok != tNo)
currTok=__currTok;
}
else
currTok = tEnd;
break;
}
}
return currTok;
}
//- AN ----------------------------------------------
// Компиляция строки BufPtr в байткод CurMacroBuffer
//- AN ----------------------------------------------
int __parseMacroString(DWORD *&CurMacroBuffer, int &CurMacroBufferSize, const wchar_t *BufPtr)
{
_KEYMACRO(CleverSysLog Clev(L"parseMacroString"));
//_KEYMACRO(SysLog(L"BufPtr[%p]='%s'", BufPtr,BufPtr));
_macro_nErr = 0;
_macro_nLine= 0;
_macro_nPos = 0;
pSrcString = emptyString;
inloop = 0;
/*pSrcString = */oSrcString = sSrcString = emptyString;
if (!BufPtr || !*BufPtr)
{
keyMacroParseError(err_ZeroLengthMacro);
return FALSE;
}
bool useUDL=true;
const wchar_t *NewBufPtr;
UserDefinedList MacroSrcList(ULF_NOTRIM|ULF_NOUNQUOTE, L"\r\n");
if(!MacroSrcList.Set(BufPtr))
useUDL=false; // все в одну строку
//{
// _SVS(SysLog(L"MacroSrcList.GetTotal()=%d",MacroSrcList.GetTotal()));
// while((NewBufPtr=MacroSrcList.GetNext()) )
// _SVS(SysLog(L"[%s]",NewBufPtr));
// MacroSrcList.Reset();
//}
size_t SizeCurKeyText = (StrLength(BufPtr)*2)*sizeof(wchar_t);
string strCurrKeyText;
//- AN ----------------------------------------------
// Буфер под парсинг выражений
//- AN ----------------------------------------------
DWORD *dwExprBuff = (DWORD*)xf_malloc(SizeCurKeyText*sizeof(DWORD));
if (!dwExprBuff)
return FALSE;
TExec exec;
wchar_t varName[256];
DWORD KeyCode, *CurMacro_Buffer = nullptr;
if(useUDL)
BufPtr=MacroSrcList.GetNext();
pSrcString=BufPtr;
for (;;)
{
int Size = 1;
int SizeVarName = 0;
const wchar_t *oldBufPtr = BufPtr;
if (!(BufPtr = __GetNextWord(BufPtr, strCurrKeyText, _macro_nLine)))
{
if(!useUDL)
break;
NewBufPtr=MacroSrcList.GetNext();
if(!NewBufPtr)
break;
_macro_nLine++;
pSrcString=BufPtr=NewBufPtr;
continue;
}
_SVS(SysLog(L"_macro_nLine = [%d]",_macro_nLine));
_SVS(SysLog(L"BufPtr = [%s]",BufPtr));
_SVS(SysLog(L"pSrcString = [%s]",pSrcString));
_SVS(SysLog(L"strCurrKeyText = [%s]",strCurrKeyText.CPtr()));
//- AN ----------------------------------------------
// Проверка на строковый литерал
// Сделаем $Text опциональным
//- AN ----------------------------------------------
if (strCurrKeyText.At(0) == L'\"' && strCurrKeyText.At(1))
{
KeyCode = MCODE_OP_PLAINTEXT;
BufPtr = oldBufPtr;
}
else if ((KeyCode = KeyNameMacroToKey(strCurrKeyText)) == (DWORD)-1 && (KeyCode = KeyNameToKey(strCurrKeyText)) == (DWORD)-1)
{
int ProcError=0;
if (strCurrKeyText.At(0) == L'%' &&
(
(IsAlphaNum(strCurrKeyText.At(1)) || strCurrKeyText.At(1) == L'_') ||
(
strCurrKeyText.At(1) == L'%' &&
(IsAlphaNum(strCurrKeyText.At(2)) || strCurrKeyText.At(2)==L'_')
)
)
)
{
BufPtr = oldBufPtr;
while (*BufPtr && (IsSpace(*BufPtr) || IsEol(*BufPtr)))
{
if (IsEol(*BufPtr))
{
_macro_nLine++;//TODO!!!
}
BufPtr++;
}
ClearArray(varName);
KeyCode = MCODE_OP_SAVE;
wchar_t* p = varName;
const wchar_t* s = strCurrKeyText.CPtr()+1;
if (*s == L'%')
*p++ = *s++;
wchar_t ch;
*p++ = *s++;
while ((iswalnum(ch = *s++) || (ch == L'_')))
*p++ = ch;
*p = 0;
size_t Length = (StrLength(varName)+1)*sizeof(wchar_t);
// строка должна быть выровнена на 4
SizeVarName = static_cast<int>(Length/sizeof(DWORD));
if (Length == sizeof(wchar_t) || (Length % sizeof(DWORD)) ) // дополнение до sizeof(DWORD) нулями.
SizeVarName++;
_SVS(SysLog(L"BufPtr=%s",BufPtr));
BufPtr += Length/sizeof(wchar_t);
_SVS(SysLog(L"BufPtr=%s",BufPtr));
Size += parseExpr(BufPtr, dwExprBuff, L'=', L';');
if (_macro_nErr)
{
ProcError++;
}
}
else
{
// проверим вариант, когда вызвали функцию, но результат не присвоили,
// например, вызвали MsgBox(), но результат неважен
// тогда SizeVarName=1 и varName=""
wchar_t *lpwszCurrKeyText = strCurrKeyText.GetBuffer();
wchar_t *Brack=(wchar_t *)wcspbrk(lpwszCurrKeyText,L"( "), Chr=0;
if (Brack)
{
Chr=*Brack;
*Brack=0;
}
if (funcLook(lpwszCurrKeyText) != MCODE_F_NOFUNC)
{
if (Brack) *Brack=Chr;
BufPtr = oldBufPtr;
while (*BufPtr && (IsSpace(*BufPtr) || IsEol(*BufPtr)))
{
if (IsEol(*BufPtr))
{
_macro_nLine++;//TODO!!!
}
BufPtr++;
}
Size += parseExpr(BufPtr, dwExprBuff, 0, 0);
/*
// этого пока ненадо, считаем, что ';' идет сразу за функцией, иначе это отдельный символ ';', который нужно поместить в поток
while ( *BufPtr && (IsSpace(*BufPtr) || IsEol(*BufPtr)) )
{
if (IsEol(*BufPtr))
{
_macro_nLine++;//TODO!!!
}
BufPtr++;
}
*/
if (*BufPtr == L';')
BufPtr++; // здесь Size не увеличиваем, т.к. мы прокидываем символ ';'
//Size--; //???
if (_macro_nErr)
{
ProcError++;
}
else
{
KeyCode=MCODE_OP_SAVE;
SizeVarName=1;
ClearArray(varName);
}
}
else
{
if (Brack) *Brack=Chr;
ProcError++;
}
strCurrKeyText.ReleaseBuffer();
}
if (ProcError)
{
if (!_macro_nErr)
//keyMacroParseError(err_Unrecognized_keyword, strCurrKeyText, strCurrKeyText,strCurrKeyText);
keyMacroParseError(err_Unrecognized_keyword, oldBufPtr, pSrcString, strCurrKeyText);
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
}
else if (!(strCurrKeyText.At(0) == L'$' && strCurrKeyText.At(1)))
{
Size=3;
KeyCode=MCODE_OP_KEYS;
}
switch (KeyCode)
{
// $Text
// -------------------------------------
// MCODE_OP_PLAINTEXT
// <expr>
case MCODE_OP_PLAINTEXT:
{
Size += parseExpr(BufPtr, dwExprBuff, 0, 0);
break;
}
// $If (expr) ... $End
// -------------------------------------
// <expr>
// MCODE_OP_JZ p1=*+0
// addr1 ------------+
// ... |
// MCODE_OP_JMP |
// +--------- addr2 |
// | ... <-----------+
// +--------> MCODE_OP_END
// или
// <expr>
// MCODE_OP_JZ p1=*+0
// addr1 ------------+
// ... |
// MCODE_OP_END <-----------+
case MCODE_OP_IF:
{
Size += parseExpr(BufPtr, dwExprBuff, L'(', L')');
if (!exec.add(emmThen, CurMacroBufferSize+Size))
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
Size++;
break;
}
case MCODE_OP_ELSE:
{
Size++;
break;
}
// $Rep (expr) ... $End
// -------------------------------------
// <expr>
// MCODE_OP_SAVEREPCOUNT 1
// +--------> MCODE_OP_REP p1=*
// | <counter> 3
// | <counter> 4
// | MCODE_OP_JZ 5 p2=*+2
// | addr1 ------------+
// | ... |
// | MCODE_OP_JMP |
// +--------- addr2 |
// MCODE_OP_END <-----------+
case MCODE_OP_REP:
{
inloop++;
Size += parseExpr(BufPtr, dwExprBuff, L'(', L')');
if (!exec.add(emmRep, CurMacroBufferSize+Size, CurMacroBufferSize+Size+4)) //??? 3
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
Size += 5; // естественно, размер будет больше = 4
break;
}
// $While (expr) ... $End
// -------------------------------------
// +--------> <expr>
// | MCODE_OP_JZ CurMacroBufferSize + Size - 2
// | addr1 ------------+ CurMacroBufferSize + Size - 1
// | ... | ...
// | MCODE_OP_JMP | CurMacroBufferSize + Size - 3
// +--------- addr2 | CurMacroBufferSize + Size - 2
// MCODE_OP_END <-----------+ CurMacroBufferSize + Size - 1
// CurMacroBufferSize + Size
case MCODE_OP_WHILE:
{
inloop++;
Size += parseExpr(BufPtr, dwExprBuff, L'(', L')');
if (!exec.add(emmWhile, CurMacroBufferSize, CurMacroBufferSize+Size))
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
Size++;
break;
}
// $continue
// -------------------------------------
// ^ MCODE_OP_CONTINUE
// | MCODE_OP_JMP
// +--------- addr
case MCODE_OP_CONTINUE:
{
Size++; // Место под адрес
break;
}
// $break
// -------------------------------------
// MCODE_OP_BREAK
// MCODE_OP_JMP
// addr -->
case MCODE_OP_BREAK:
{
Size++; // Место под адрес
break;
}
case MCODE_OP_END:
{
switch (exec().state)
{
case emmRep:
case emmWhile:
Size += 2; // Место под дополнительный JMP
break;
default:
break;
}
break;
}
}
if (_macro_nErr)
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
if (!BufPtr) // ???
break;
// код найден, добавим этот код в буфер последовательности.
CurMacro_Buffer = (DWORD *)xf_realloc(CurMacro_Buffer,sizeof(*CurMacro_Buffer)*(CurMacroBufferSize+Size+SizeVarName));
if (!CurMacro_Buffer)
{
CurMacroBuffer = nullptr;
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
switch (KeyCode)
{
case MCODE_OP_PLAINTEXT:
{
_SVS(SysLog(L"[%d] Size=%u",__LINE__,Size));
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
break;
}
case MCODE_OP_SAVE:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
memcpy(CurMacro_Buffer+CurMacroBufferSize+Size, varName, SizeVarName*sizeof(DWORD));
break;
}
case MCODE_OP_IF:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-2] = MCODE_OP_JZ;
break;
}
case MCODE_OP_REP:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-6] = MCODE_OP_SAVEREPCOUNT;
CurMacro_Buffer[CurMacroBufferSize+Size-5] = KeyCode;
CurMacro_Buffer[CurMacroBufferSize+Size-4] = 0; // Initilize 0
CurMacro_Buffer[CurMacroBufferSize+Size-3] = 0;
CurMacro_Buffer[CurMacroBufferSize+Size-2] = MCODE_OP_JZ;
break;
}
case MCODE_OP_WHILE:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-2] = MCODE_OP_JZ;
break;
}
case MCODE_OP_ELSE:
{
if (exec().state == emmThen)
{
exec().state = emmElse;
CurMacro_Buffer[exec().pos1] = CurMacroBufferSize+2;
exec().pos1 = CurMacroBufferSize;
CurMacro_Buffer[CurMacroBufferSize] = 0;
}
else // тут $else и не предвиделось :-/
{
keyMacroParseError(err_Not_expected_ELSE, BufPtr, pSrcString); // strCurrKeyText
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
break;
}
case MCODE_OP_BREAK:
case MCODE_OP_CONTINUE:
{
TExecItem *ei=nullptr;
if (!inloop || (KeyCode==MCODE_OP_CONTINUE && exec.findnearloop(&ei) == -1))
{
keyMacroParseError(KeyCode==MCODE_OP_CONTINUE?err_Continue_Outside_The_Loop:err_Break_Outside_The_Loop, oldBufPtr, pSrcString);//BufPtr, pSrcString); // strCurrKeyText
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
CurMacro_Buffer[CurMacroBufferSize+Size-2] = KeyCode==MCODE_OP_CONTINUE?MCODE_OP_JMP:MCODE_OP_BREAK;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode==MCODE_OP_CONTINUE?ei->pos1:0;
break;
}
case MCODE_OP_END:
{
switch (exec().state)
{
case emmMain:
// тут $end и не предвиделось :-/
keyMacroParseError(err_Not_expected_END, BufPtr, pSrcString); // strCurrKeyText
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
case emmThen:
CurMacro_Buffer[exec().pos1-1] = MCODE_OP_JZ;
CurMacro_Buffer[exec().pos1+0] = CurMacroBufferSize+Size-1;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
break;
case emmElse:
CurMacro_Buffer[exec().pos1-0] = MCODE_OP_JMP;
CurMacro_Buffer[exec().pos1+1] = CurMacroBufferSize+Size-1;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
break;
case emmRep:
case emmWhile:
inloop--;
CurMacro_Buffer[exec().pos2] = CurMacroBufferSize+Size-1;
CurMacro_Buffer[CurMacroBufferSize+Size-3] = MCODE_OP_JMP;
CurMacro_Buffer[CurMacroBufferSize+Size-2] = exec().pos1;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
CorrectBreakCode(CurMacro_Buffer,CurMacro_Buffer+exec().pos1,CurMacro_Buffer+(CurMacroBufferSize+Size-1));
break;
}
if (!exec.del()) // Вообще-то этого быть не должно, но подстрахуемся
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
break;
}
case MCODE_OP_KEYS:
{
CurMacro_Buffer[CurMacroBufferSize+Size-3]=MCODE_OP_KEYS;
CurMacro_Buffer[CurMacroBufferSize+Size-2]=KeyNameToKey(strCurrKeyText);
CurMacro_Buffer[CurMacroBufferSize+Size-1]=MCODE_OP_ENDKEYS;
break;
}
default:
CurMacro_Buffer[CurMacroBufferSize]=KeyCode;
} // end switch(KeyCode)
CurMacroBufferSize += Size+SizeVarName;
} // END for (;;)
if (CurMacroBufferSize == 1)
{
CurMacro_Buffer = (DWORD *)xf_realloc(CurMacro_Buffer,sizeof(*CurMacro_Buffer)*(CurMacroBufferSize+1));
if (!CurMacro_Buffer)
{
CurMacroBuffer = nullptr;
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
CurMacro_Buffer[CurMacroBufferSize]=MCODE_OP_NOP;
CurMacroBufferSize++;
}
#ifdef _DEBUG
#ifdef SYSLOG_KEYMACRO
SysLogDump(L"Macro Buffer",0,(LPBYTE)CurMacro_Buffer,CurMacroBufferSize*sizeof(DWORD),nullptr);
SysLog(L"<ByteCode>{");
if (CurMacro_Buffer)
{
int ii;
for (ii = 0 ; ii < CurMacroBufferSize ; ii++)
printKeyValue(CurMacro_Buffer, ii);
}
else
SysLog(L"??? is nullptr");
SysLog(L"}</ByteCode>");
#endif
#endif
if (CurMacroBufferSize > 1)
CurMacroBuffer = CurMacro_Buffer;
else if (CurMacro_Buffer)
{
CurMacroBuffer = reinterpret_cast<DWORD*>((intptr_t)(*CurMacro_Buffer));
xf_free(CurMacro_Buffer);
}
xf_free(dwExprBuff);
if (exec().state != emmMain)
{
keyMacroParseError(err_Unexpected_EOS, strCurrKeyText, strCurrKeyText);
return FALSE;
}
if (_macro_nErr)
{
return FALSE;
}
return TRUE;
}
//
// This is called by Calc/Task thread, after calling StartLogger
//
void LoggerHeader(void)
{
char datum[]= "HFDTM100GPSDATUM:WGS-84\r\n";
char temp[100];
// Flight recorder ID number MUST go first..
// Do one more check on %C because if one is 0 the string will not be closed by newline
// resulting in a wrong header!
strAssetNumber[0]= IsAlphaNum(strAssetNumber[0]) ? strAssetNumber[0] : _T('A');
strAssetNumber[1]= IsAlphaNum(strAssetNumber[1]) ? strAssetNumber[1] : _T('A');
strAssetNumber[2]= IsAlphaNum(strAssetNumber[0]) ? strAssetNumber[2] : _T('A');
sprintf(temp,
"A%s%C%C%C\r\n",
LOGGER_MANUFACTURER,
strAssetNumber[0],
strAssetNumber[1],
strAssetNumber[2]);
IGCWriteRecord(temp);
sprintf(temp,"HFDTE%02d%02d%02d\r\n",
GPS_INFO.Day,
GPS_INFO.Month,
GPS_INFO.Year % 100);
IGCWriteRecord(temp);
// Example: Hanna.Reitsch
sprintf(temp,"HFPLTPILOT:%S\r\n", PilotName_Config);
IGCWriteRecord(temp);
// Example: DG-300
sprintf(temp,"HFGTYGLIDERTYPE:%S\r\n", AircraftType_Config);
IGCWriteRecord(temp);
// Example: D-7176
sprintf(temp,"HFGIDGLIDERID:%S\r\n", AircraftRego_Config);
IGCWriteRecord(temp);
// 110117 TOCHECK: maybe a 8 char limit is needed.
sprintf(temp,"HFCCLCOMPETITIONCLASS:%S\r\n", CompetitionClass_Config);
IGCWriteRecord(temp);
sprintf(temp,"HFCIDCOMPETITIONID:%S\r\n", CompetitionID_Config);
IGCWriteRecord(temp);
#ifndef LKCOMPETITION
sprintf(temp,"HFFTYFRTYPE:%s\r\n", LKFORK); // default
#else
sprintf(temp,"HFFTYFRTYPE:%sC\r\n", LKFORK); // default
#endif
// PNAs are also PPC2003, so careful
#ifdef PNA
char pnamodel[MAX_PATH+1];
ConvertTToC(pnamodel,GlobalModelName);
pnamodel[_tcslen(GlobalModelName)]='\0';
#ifndef LKCOMPETITION
sprintf(temp,"HFFTYFRTYPE:%s PNA %s\r\n", LKFORK,pnamodel);
#else
sprintf(temp,"HFFTYFRTYPE:%sC PNA %s\r\n", LKFORK,pnamodel);
#endif
#else
#ifdef PPC2002
#ifndef LKCOMPETITION
sprintf(temp,"HFFTYFRTYPE:%s PPC2002\r\n", LKFORK);
#else
sprintf(temp,"HFFTYFRTYPE:%sC PPC2002\r\n", LKFORK);
#endif
#endif
// PNA is also PPC2003..
#ifdef PPC2003
#ifndef LKCOMPETITION
sprintf(temp,"HFFTYFRTYPE:%s PPC2003\r\n", LKFORK);
#else
sprintf(temp,"HFFTYFRTYPE:%sC PPC2003\r\n", LKFORK);
#endif
#endif
#endif
IGCWriteRecord(temp);
#ifndef LKCOMPETITION
sprintf(temp,"HFRFWFIRMWAREVERSION:%s.%s\r\n", LKVERSION, LKRELEASE);
#else
sprintf(temp,"HFRFWFIRMWAREVERSION:%s.%s.COMPETITION\r\n", LKVERSION, LKRELEASE);
#endif
IGCWriteRecord(temp);
IGCWriteRecord(datum);
}
void StartLogger()
{
HANDLE hFile;
int i;
TCHAR path[MAX_PATH+1];
TCHAR cAsset[3];
// strAsset is initialized with DUM.
if (_tcslen(PilotName_Config)>0) {
strAssetNumber[0]= IsAlphaNum(PilotName_Config[0]) ? PilotName_Config[0] : _T('A');
strAssetNumber[1]= IsAlphaNum(PilotName_Config[1]) ? PilotName_Config[1] : _T('A');
} else {
strAssetNumber[0]= _T('D');
strAssetNumber[1]= _T('U');
}
if (_tcslen(AircraftType_Config)>0) {
strAssetNumber[2]= IsAlphaNum(AircraftType_Config[0]) ? AircraftType_Config[0] : _T('A');
} else {
strAssetNumber[2]= _T('M');
}
strAssetNumber[0]= towupper(strAssetNumber[0]);
strAssetNumber[1]= towupper(strAssetNumber[1]);
strAssetNumber[2]= towupper(strAssetNumber[2]);
strAssetNumber[3]= _T('\0');
for (i=0; i < 3; i++) { // chars must be legal in file names
cAsset[i] = IsAlphaNum(strAssetNumber[i]) ? strAssetNumber[i] : _T('A');
}
LocalPath(path,TEXT(LKD_LOGS));
if (TaskModified) {
SaveDefaultTask();
}
wsprintf(szLoggerFileName, TEXT("%s\\LOGGER_TMP.IGC"), path);
wsprintf(szSLoggerFileName, TEXT("%s\\LOGGER_SIG.IGC"), path);
TCHAR newfile[MAX_PATH+20];
if (GetFileAttributes(szLoggerFileName) != 0xffffffff) {
StartupStore(_T("---- Logger recovery: Existing LOGGER_TMP.IGC found, renamed to LOST%s"),NEWLINE);
wsprintf(newfile, TEXT("%s\\LOST_%02d%02d%02d.IGC"), path, GPS_INFO.Hour, GPS_INFO.Minute, GPS_INFO.Second);
CopyFile(szLoggerFileName,newfile,TRUE);
DeleteFile(szLoggerFileName);
}
if (GetFileAttributes(szSLoggerFileName) != 0xffffffff) {
StartupStore(_T("---- Logger recovery (G): Existing LOGGER_SIG.IGC found, renamed to LOSTG%s"),NEWLINE);
wsprintf(newfile, TEXT("%s\\LOSTG_%02d%02d%02d.IGC"), path, GPS_INFO.Hour, GPS_INFO.Minute, GPS_INFO.Second);
CopyFile(szSLoggerFileName,newfile,TRUE);
DeleteFile(szSLoggerFileName);
}
for(i=1;i<99;i++)
{
// 2003-12-31-XXX-987-01.IGC
// long filename form of IGC file.
// XXX represents manufacturer code
if (!LoggerShortName) {
// Long file name
wsprintf(szFLoggerFileName,
TEXT("%s\\%04d-%02d-%02d-%s-%c%c%c-%02d.IGC"),
path,
GPS_INFO.Year,
GPS_INFO.Month,
GPS_INFO.Day,
_T(LOGGER_MANUFACTURER),
cAsset[0],
cAsset[1],
cAsset[2],
i);
wsprintf(szFLoggerFileNameRoot,
TEXT("%s\\%04d-%02d-%02d-%s-%c%c%c-%02d.IGC"),
TEXT(""), // this creates it in root if MoveFile() fails
GPS_INFO.Year,
GPS_INFO.Month,
GPS_INFO.Day,
_T(LOGGER_MANUFACTURER),
cAsset[0],
cAsset[1],
cAsset[2],
i);
} else {
// Short file name
TCHAR cyear, cmonth, cday, cflight;
cyear = NumToIGCChar((int)GPS_INFO.Year % 10);
cmonth = NumToIGCChar(GPS_INFO.Month);
cday = NumToIGCChar(GPS_INFO.Day);
cflight = NumToIGCChar(i);
wsprintf(szFLoggerFileName,
TEXT("%s\\%c%c%cX%c%c%c%c.IGC"),
path,
cyear,
cmonth,
cday,
cAsset[0],
cAsset[1],
cAsset[2],
cflight);
wsprintf(szFLoggerFileNameRoot,
TEXT("%s\\%c%c%cX%c%c%c%c.IGC"),
TEXT(""), // this creates it in root if MoveFile() fails
cyear,
cmonth,
cday,
cAsset[0],
cAsset[1],
cAsset[2],
cflight);
} // end if
hFile = CreateFile(szFLoggerFileName, GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL, 0);
if(hFile!=INVALID_HANDLE_VALUE )
{
// file already exists
CloseHandle(hFile);
DeleteFile(szFLoggerFileName);
break;
}
} // end while
StartupStore(_T(". Logger Started %s File <%s>%s"),
WhatTimeIsIt(), szFLoggerFileName,NEWLINE);
return;
}
bool FileFilter::FilterEdit()
{
if (bMenuOpen)
return false;
Changed = true;
bMenuOpen = true;
MenuItemEx ListItem;
int ExitCode;
bool bNeedUpdate=false;
VMenu FilterList(MSG(MFilterTitle),nullptr,0,ScrY-6);
FilterList.SetHelp(L"FiltersMenu");
FilterList.SetPosition(-1,-1,0,0);
FilterList.SetBottomTitle(MSG(MFilterBottom));
FilterList.SetFlags(/*VMENU_SHOWAMPERSAND|*/VMENU_WRAPMODE);
for (size_t i=0; i<FilterData.getCount(); i++)
{
ListItem.Clear();
MenuString(ListItem.strName,FilterData.getItem(i));
if (!i)
ListItem.Flags|=LIF_SELECTED;
int Check = GetCheck(FilterData.getItem(i));
if (Check)
ListItem.SetCheck(Check);
FilterList.AddItem(&ListItem);
}
ListItem.Clear();
if (!FilterData.getCount())
ListItem.Flags|=LIF_SELECTED;
FilterList.AddItem(&ListItem);
if (m_FilterType != FFT_CUSTOM)
{
wchar_t *ExtPtr=nullptr;
int ExtCount=0;
{
enumFileFilterFlagsType FFFT = GetFFFT();
for (size_t i=0; i<TempFilterData.getCount(); i++)
{
//AY: Будем показывать только те выбранные авто фильтры
//(для которых нету файлов на панели) которые выбраны в области данного меню
if (!TempFilterData.getItem(i)->GetFlags(FFFT))
continue;
const wchar_t *FMask;
TempFilterData.getItem(i)->GetMask(&FMask);
string strMask = FMask;
Unquote(strMask);
if (!ParseAndAddMasks(&ExtPtr,strMask,0,ExtCount,GetCheck(TempFilterData.getItem(i))))
break;
}
}
ListItem.Clear();
ListItem.Flags|=LIF_SEPARATOR;
FilterList.AddItem(&ListItem);
ListItem.Clear();
FoldersFilter.SetTitle(MSG(MFolderFileType));
MenuString(ListItem.strName,&FoldersFilter,false,L'0');
int Check = GetCheck(&FoldersFilter);
if (Check)
ListItem.SetCheck(Check);
FilterList.AddItem(&ListItem);
if (GetHostPanel()->GetMode()==NORMAL_PANEL)
{
string strCurDir, strFileName;
FAR_FIND_DATA_EX fdata;
GetHostPanel()->GetCurDir(strCurDir);
ScanTree ScTree(FALSE,FALSE);
ScTree.SetFindPath(strCurDir,L"*");
while (ScTree.GetNextName(&fdata,strFileName))
if (!ParseAndAddMasks(&ExtPtr,fdata.strFileName,fdata.dwFileAttributes,ExtCount,0))
break;
}
else
{
string strFileName;
DWORD FileAttr;
for (int i=0; GetHostPanel()->GetFileName(strFileName,i,FileAttr); i++)
if (!ParseAndAddMasks(&ExtPtr,strFileName,FileAttr,ExtCount,0))
break;
}
far_qsort((void *)ExtPtr,ExtCount,MAX_PATH*sizeof(wchar_t),ExtSort);
ListItem.Clear();
for (int i=0, h=L'1'; i<ExtCount; i++, (h==L'9'?h=L'A':(h==L'Z'||h?h++:h=0)))
{
wchar_t *CurExtPtr=ExtPtr+i*MAX_PATH;
MenuString(ListItem.strName,nullptr,false,h,true,CurExtPtr,MSG(MPanelFileType));
int Length = StrLength(CurExtPtr)+1;
ListItem.SetCheck(CurExtPtr[Length]);
FilterList.SetUserData(CurExtPtr, Length*sizeof(wchar_t), FilterList.AddItem(&ListItem));
}
xf_free(ExtPtr);
}
FilterList.Show();
while (!FilterList.Done())
{
int Key=FilterList.ReadInput();
if (Key==KEY_ADD)
Key=L'+';
else if (Key==KEY_SUBTRACT)
Key=L'-';
else if (Key==L'i')
Key=L'I';
else if (Key==L'x')
Key=L'X';
switch (Key)
{
case L'+':
case L'-':
case L'I':
case L'X':
case KEY_SPACE:
case KEY_BS:
{
int SelPos=FilterList.GetSelectPos();
if (SelPos<0 || SelPos==(int)FilterData.getCount())
break;
int Check=FilterList.GetCheck(SelPos);
int NewCheck;
if (Key==KEY_BS)
NewCheck = 0;
else if (Key==KEY_SPACE)
NewCheck = Check ? 0 : L'+';
else
NewCheck = (Check == Key) ? 0 : Key;
FilterList.SetCheck(NewCheck,SelPos);
FilterList.SetSelectPos(SelPos,1);
FilterList.SetUpdateRequired(TRUE);
FilterList.FastShow();
FilterList.ProcessKey(KEY_DOWN);
bNeedUpdate=true;
break;
}
case KEY_SHIFTBS:
{
for (int I=0; I < FilterList.GetItemCount(); I++)
{
FilterList.SetCheck(FALSE, I);
}
FilterList.SetUpdateRequired(TRUE);
FilterList.FastShow();
break;
}
case KEY_F4:
{
int SelPos=FilterList.GetSelectPos();
if (SelPos<0)
break;
if (SelPos<(int)FilterData.getCount())
{
if (FileFilterConfig(FilterData.getItem(SelPos)))
{
ListItem.Clear();
MenuString(ListItem.strName,FilterData.getItem(SelPos));
int Check = GetCheck(FilterData.getItem(SelPos));
if (Check)
ListItem.SetCheck(Check);
FilterList.DeleteItem(SelPos);
FilterList.AddItem(&ListItem,SelPos);
FilterList.SetSelectPos(SelPos,1);
FilterList.SetUpdateRequired(TRUE);
FilterList.FastShow();
bNeedUpdate=true;
}
}
else if (SelPos>(int)FilterData.getCount())
{
Message(MSG_WARNING,1,MSG(MFilterTitle),MSG(MCanEditCustomFilterOnly),MSG(MOk));
}
break;
}
case KEY_NUMPAD0:
case KEY_INS:
case KEY_F5:
{
int pos=FilterList.GetSelectPos();
if (pos<0)
break;
size_t SelPos=pos;
size_t SelPos2=pos+1;
SelPos = Min(FilterData.getCount(), SelPos);
FileFilterParams *NewFilter = FilterData.insertItem(SelPos);
if (!NewFilter)
break;
if (Key==KEY_F5)
{
if (SelPos2 < FilterData.getCount())
{
*NewFilter = *FilterData.getItem(SelPos2);
NewFilter->SetTitle(L"");
NewFilter->ClearAllFlags();
}
else if (SelPos2 == FilterData.getCount()+2)
{
*NewFilter = FoldersFilter;
NewFilter->SetTitle(L"");
NewFilter->ClearAllFlags();
}
else if (SelPos2 > FilterData.getCount()+2)
{
NewFilter->SetMask(1,static_cast<const wchar_t*>(FilterList.GetUserData(nullptr, 0, static_cast<int>(SelPos2-1))));
//Авто фильтры они только для файлов, папки не должны к ним подходить
NewFilter->SetAttr(1,0,FILE_ATTRIBUTE_DIRECTORY);
}
else
{
FilterData.deleteItem(SelPos);
break;
}
}
else
{
//AY: Раз создаём новый фильтр то думаю будет логично если он будет только для файлов
NewFilter->SetAttr(1,0,FILE_ATTRIBUTE_DIRECTORY);
}
if (FileFilterConfig(NewFilter))
{
ListItem.Clear();
MenuString(ListItem.strName,NewFilter);
FilterList.AddItem(&ListItem,static_cast<int>(SelPos));
FilterList.SetSelectPos(static_cast<int>(SelPos),1);
FilterList.SetPosition(-1,-1,0,0);
FilterList.Show();
bNeedUpdate=true;
}
else
FilterData.deleteItem(SelPos);
break;
}
case KEY_NUMDEL:
case KEY_DEL:
{
int SelPos=FilterList.GetSelectPos();
if (SelPos<0)
break;
if (SelPos<(int)FilterData.getCount())
{
string strQuotedTitle=FilterData.getItem(SelPos)->GetTitle();
InsertQuote(strQuotedTitle);
if (!Message(0,2,MSG(MFilterTitle),MSG(MAskDeleteFilter),
strQuotedTitle,MSG(MDelete),MSG(MCancel)))
{
FilterData.deleteItem(SelPos);
FilterList.DeleteItem(SelPos);
FilterList.SetSelectPos(SelPos,1);
FilterList.SetPosition(-1,-1,0,0);
FilterList.Show();
bNeedUpdate=true;
}
}
else if (SelPos>(int)FilterData.getCount())
{
Message(MSG_WARNING,1,MSG(MFilterTitle),MSG(MCanDeleteCustomFilterOnly),MSG(MOk));
}
break;
}
case KEY_CTRLUP:
case KEY_RCTRLUP:
case KEY_CTRLDOWN:
case KEY_RCTRLDOWN:
{
int SelPos=FilterList.GetSelectPos();
if (SelPos<0)
break;
if (SelPos<(int)FilterData.getCount() && !((Key==KEY_CTRLUP || Key==KEY_RCTRLUP) && !SelPos) &&
!((Key==KEY_CTRLDOWN || Key==KEY_RCTRLDOWN) && SelPos==(int)(FilterData.getCount()-1)))
{
int NewPos = SelPos + ((Key == KEY_CTRLDOWN || Key == KEY_RCTRLDOWN) ? 1 : -1);
MenuItemEx CurItem = *FilterList.GetItemPtr(SelPos);
MenuItemEx NextItem = *FilterList.GetItemPtr(NewPos);
FilterData.swapItems(NewPos,SelPos);
if (NewPos<SelPos)
{
FilterList.DeleteItem(NewPos,2);
FilterList.AddItem(&CurItem,NewPos);
FilterList.AddItem(&NextItem,SelPos);
}
else
{
FilterList.DeleteItem(SelPos,2);
FilterList.AddItem(&NextItem,SelPos);
FilterList.AddItem(&CurItem,NewPos);
}
FilterList.SetSelectPos(NewPos,1);
FilterList.SetUpdateRequired(TRUE);
FilterList.FastShow();
bNeedUpdate=true;
}
break;
}
default:
{
FilterList.ProcessInput();
//заставляем хоткеи позиционировать курсор на пункте но не закрывать меню
if (Key!=KEY_NUMENTER && Key!=KEY_ENTER && Key!=KEY_ESC && Key!=KEY_F10 && (IsAlphaNum(Key) || Key&(KEY_ALT|KEY_RALT)))
FilterList.ClearDone();
}
}
}
FilterList.Hide();
ExitCode=FilterList.Modal::GetExitCode();
if (ExitCode!=-1)
ProcessSelection(&FilterList);
if (Opt.AutoSaveSetup)
SaveFilters();
if (ExitCode!=-1 || bNeedUpdate)
{
if (m_FilterType == FFT_PANEL)
{
GetHostPanel()->Update(UPDATE_KEEP_SELECTION);
GetHostPanel()->Redraw();
}
}
bMenuOpen = false;
return (ExitCode!=-1);
}
void
LoggerImpl::StartLogger(const NMEA_INFO &gps_info,
const SETTINGS_COMPUTER &settings,
const TCHAR *astrAssetNumber)
{
HANDLE hFile;
int i;
TCHAR path[MAX_PATH];
TCHAR cAsset[3];
for (i=0; i < 3; i++) { // chars must be legal in file names
cAsset[i] = IsAlphaNum(strAssetNumber[i]) ? strAssetNumber[i] : _T('A');
}
// VENTA3 use logs subdirectory when not in main memory (true for FIVV and PNA)
#if defined(GNAV) || defined(FIVV) || defined(PNA)
LocalPath(path,TEXT("logs"));
#else
LocalPath(path);
#endif
if (task.isTaskModified()) {
task.SaveDefaultTask();
}
#ifdef WINDOWSPC
_stprintf(szLoggerFileName, TEXT("/tmp/tmp.IGC"));
#else
_stprintf(szLoggerFileName, TEXT("\\tmp.IGC"));
#endif
DeleteFile(szLoggerFileName);
LoggerGInit();
for(i=1;i<99;i++)
{
// 2003-12-31-XXX-987-01.IGC
// long filename form of IGC file.
// XXX represents manufacturer code
if (!settings.LoggerShortName) {
// Long file name
_stprintf(szFLoggerFileName,
TEXT("%s\\%04d-%02d-%02d-XCS-%c%c%c-%02d.IGC"),
path,
gps_info.Year,
gps_info.Month,
gps_info.Day,
cAsset[0],
cAsset[1],
cAsset[2],
i);
_stprintf(szFLoggerFileNameRoot,
TEXT("%s\\%04d-%02d-%02d-XCS-%c%c%c-%02d.IGC"),
TEXT(""), // this creates it in root if MoveFile() fails
gps_info.Year,
gps_info.Month,
gps_info.Day,
cAsset[0],
cAsset[1],
cAsset[2],
i);
} else {
// Short file name
TCHAR cyear, cmonth, cday, cflight;
cyear = NumToIGCChar((int)gps_info.Year % 10);
cmonth = NumToIGCChar(gps_info.Month);
cday = NumToIGCChar(gps_info.Day);
cflight = NumToIGCChar(i);
_stprintf(szFLoggerFileName,
TEXT("%s\\%c%c%cX%c%c%c%c.IGC"),
path,
cyear,
cmonth,
cday,
cAsset[0],
cAsset[1],
cAsset[2],
cflight);
_stprintf(szFLoggerFileNameRoot,
TEXT("%s\\%c%c%cX%c%c%c%c.IGC"),
TEXT(""), // this creates it in root if MoveFile() fails
cyear,
cmonth,
cday,
cAsset[0],
cAsset[1],
cAsset[2],
cflight);
} // end if
hFile = CreateFile(szFLoggerFileName, GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL, 0);
if(hFile!=INVALID_HANDLE_VALUE )
{
// file already exists
CloseHandle(hFile);
DeleteFile(szFLoggerFileName);
break;
}
} // end while
TCHAR szMessage[MAX_PATH] = TEXT("\0");
_tcsncpy(szMessage,TEXT("Logger Started: "),MAX_PATH);
_tcsncat(szMessage,szFLoggerFileName,MAX_PATH);
_tcsncat(szMessage,TEXT("\r\n"),MAX_PATH);
StartupStore(szMessage);
return;
}
