// Parses the keys in m_sKeys string and puts them into m_KeyList
void CKeystrokeEngine::ParseKeys()
{
KeyStruct tempKey, keyAltHold, keyCtrlHold, keyShiftHold,
keyAltRelease, keyCtrlRelease, keyShiftRelease;
keyAltHold.nAction = Action_KeyDown;
keyAltHold.nOptional = 0;
keyAltHold.nSpecial = SK_None;
keyAltHold.Vk = VK_MENU;
keyAltHold.nScan = MapVirtualKey (VK_MENU, 0);
keyCtrlHold.nAction = Action_KeyDown;
keyCtrlHold.nOptional = 0;
keyCtrlHold.nSpecial = SK_None;
keyCtrlHold.Vk = VK_CONTROL;
keyCtrlHold.nScan = MapVirtualKey (VK_CONTROL, 0);
keyShiftHold.nAction = Action_KeyDown;
keyShiftHold.nOptional = 0;
keyShiftHold.nSpecial = SK_None;
keyShiftHold.Vk = VK_SHIFT;
keyShiftHold.nScan = MapVirtualKey (VK_SHIFT, 0);
keyAltRelease.nAction = Action_KeyUp;
keyAltRelease.nOptional = 0;
keyAltRelease.nSpecial = SK_None;
keyAltRelease.Vk = VK_MENU;
keyAltRelease.nScan = MapVirtualKey (VK_MENU, 0);
keyCtrlRelease.nAction = Action_KeyUp;
keyCtrlRelease.nOptional = 0;
keyCtrlRelease.nSpecial = SK_None;
keyCtrlRelease.Vk = VK_CONTROL;
keyCtrlRelease.nScan = MapVirtualKey (VK_CONTROL, 0);
keyShiftRelease.nAction = Action_KeyUp;
keyShiftRelease.nOptional = 0;
keyShiftRelease.nSpecial = SK_None;
keyShiftRelease.Vk = VK_SHIFT;
keyShiftRelease.nScan = MapVirtualKey (VK_SHIFT, 0);
m_KeyList.clear ();
int idx = 0;
int nKeyLength = m_sKeys.size ();
char c = 0;
char szTemp [MAX_SK_LEN];
SHORT nTemp;
bool bNotASpecialKey = false;
bool bPushAltRelease = false, bPushCtrlRelease = false, bPushShiftRelease = false;
while (idx < nKeyLength)
{
c = m_sKeys[idx];
// if a normal key
if (bNotASpecialKey ||
((c != '<') || ((c == '<') && (idx == nKeyLength - 1)))
)
{
bNotASpecialKey = false;
tempKey.nAction = Action_KeyPress;
tempKey.nSpecial = SK_None;
nTemp = VkKeyScan (c);
tempKey.Vk = LOBYTE (nTemp);
int nTempState = HIBYTE(nTemp);
if (nTempState & 0x0001)
m_KeyList.push_back (keyShiftHold);
if (nTempState & 0x0002)
m_KeyList.push_back (keyCtrlHold);
if (nTempState & 0x0004)
m_KeyList.push_back (keyAltHold);
tempKey.nScan = MapVirtualKey (tempKey.Vk, 0);
m_KeyList.push_back (tempKey);
if (nTempState & 0x0004)
m_KeyList.push_back (keyAltRelease);
if (nTempState & 0x0002)
m_KeyList.push_back (keyCtrlRelease);
if (nTempState & 0x0001)
m_KeyList.push_back (keyShiftRelease);
if (bPushAltRelease)
m_KeyList.push_back (keyAltRelease);
if (bPushCtrlRelease)
m_KeyList.push_back (keyCtrlRelease);
if (bPushShiftRelease)
m_KeyList.push_back (keyShiftRelease);
bPushAltRelease = false;
bPushCtrlRelease = false;
bPushShiftRelease = false;
++ idx;
}
// if a special key
else
{
bNotASpecialKey = false;
int nTempIdx = idx + 1;
int nOffset = 0;
while (nTempIdx < nKeyLength && (nTempIdx < nTempIdx + MAX_SK_LEN - 1))
{
c = m_sKeys[nTempIdx];
// found the first token
if (c == ' ' || c == '>')
{
++nTempIdx;
szTemp [nOffset] = '\0';
KeyType nType = GetNextSpecialKey (szTemp, tempKey);
if (nType != Key_StartRepeat && nType != Key_Delay)
{
if (c == ' ')
{
string sDest;
int i = GetKeyParam (m_sKeys.c_str(), sDest, nTempIdx);
if (i > 0)
nTempIdx += i;
else
{
bNotASpecialKey = true;
break;
}
}
}
if (nType != Key_NotFound && nType != Key_Normal)
{
if (bPushAltRelease)
m_KeyList.push_back (keyAltRelease);
if (bPushCtrlRelease)
m_KeyList.push_back (keyCtrlRelease);
if (bPushShiftRelease)
m_KeyList.push_back (keyShiftRelease);
}
switch (nType)
{
case Key_NotFound:
bNotASpecialKey = true;
break;
case Key_Ignore:
bPushAltRelease = false;
bPushCtrlRelease = false;
bPushShiftRelease = false;
break;
case Key_Normal:
m_KeyList.push_back (tempKey);
if (bPushAltRelease)
m_KeyList.push_back (keyAltRelease);
if (bPushCtrlRelease)
m_KeyList.push_back (keyCtrlRelease);
if (bPushShiftRelease)
m_KeyList.push_back (keyShiftRelease);
bPushAltRelease = false;
bPushCtrlRelease = false;
bPushShiftRelease = false;
break;
case Key_Alt:
m_KeyList.push_back (keyAltHold);
bPushAltRelease = true;
bPushCtrlRelease = false;
bPushShiftRelease = false;
break;
case Key_Ctrl:
m_KeyList.push_back (keyCtrlHold);
bPushCtrlRelease = true;
bPushAltRelease = false;
bPushShiftRelease = false;
break;
case Key_Shift:
m_KeyList.push_back (keyShiftHold);
bPushShiftRelease = true;
bPushAltRelease = false;
bPushCtrlRelease = false;
break;
case Key_CtrlAlt:
m_KeyList.push_back (keyCtrlHold);
m_KeyList.push_back (keyAltHold);
bPushShiftRelease = false;
bPushAltRelease = true;
bPushCtrlRelease = true;
break;
case Key_CtrlShift:
m_KeyList.push_back (keyCtrlHold);
m_KeyList.push_back (keyShiftHold);
bPushShiftRelease = true;
bPushAltRelease = false;
bPushCtrlRelease = true;
break;
case Key_AltShift:
m_KeyList.push_back (keyShiftHold);
m_KeyList.push_back (keyAltHold);
bPushShiftRelease = true;
bPushAltRelease = true;
bPushCtrlRelease = false;
break;
case Key_CtrlAltShift:
m_KeyList.push_back (keyCtrlHold);
m_KeyList.push_back (keyAltHold);
m_KeyList.push_back (keyShiftHold);
bPushShiftRelease = true;
bPushAltRelease = true;
bPushCtrlRelease = true;
break;
case Key_StartRepeat:
if (c == '>')
tempKey.nOptional = 0;
else
{
string sDest;
nTempIdx += GetKeyParam (m_sKeys.c_str(), sDest, nTempIdx);
tempKey.nOptional = atoi (sDest.c_str());
m_KeyList.push_back (tempKey);
}
bPushShiftRelease = false;
bPushAltRelease = false;
bPushCtrlRelease = false;
break;
case Key_Delay:
if (c == '>')
tempKey.nOptional = 0;
else
{
string sDest;
nTempIdx += GetKeyParam (m_sKeys.c_str(), sDest, nTempIdx);
tempKey.nOptional = atoi (sDest.c_str());
m_KeyList.push_back (tempKey);
}
bPushShiftRelease = false;
bPushAltRelease = false;
bPushCtrlRelease = false;
break;
}
if (nType != Key_NotFound)
idx = nTempIdx;
break;
}
else
{
szTemp [nOffset] = c;
++nTempIdx;
++nOffset;
}
}
// Not found!
if (nTempIdx >= nKeyLength || (nTempIdx >= nTempIdx + MAX_SK_LEN - 1))
bNotASpecialKey = true;
}
}
}
int ParseInputFile()
{
char pszKeyWord[MAX]; // input token
char pszParam[MAX]; // parameter for keyword
CODEPAGE CP; // codepage structure
LANGUAGE Lang; // language structure
LANG_EXCEPT LangExcept; // language exception structure
LOCALE_HEADER LocHdr; // header locale structure
LOCALE_STATIC LocStat; // static length locale structure
LOCALE_VARIABLE LocVar; // variable length locale structure
UNICODE Unic; // unicode structure
CTYPES CTypes; // ctypes structure
SORTKEY Sortkey; // sortkey structure - sorting
SORT_TABLES SortTbls; // sort tables structure - sorting
IDEOGRAPH_EXCEPT IdeographExcept; // ideograph exception structure - sorting
while (fscanf(pInputFile, "%s", pszKeyWord) == 1)
{
if (_strcmpi(pszKeyWord, "CODEPAGE") == 0)
{
if (Verbose)
printf("\n\nFound CODEPAGE keyword.\n");
//
// Initialize CodePage structure.
//
memset(&CP, 0, sizeof(CODEPAGE));
memset(pszParam, 0, MAX * sizeof(char));
CP.pszName = pszParam;
//
// Get CODEPAGE parameter string.
//
if (GetKeyParam(pszParam))
{
return (1);
}
//
// Get the valid keywords for CODEPAGE.
//
if (ParseCodePage(&CP, pszKeyWord))
{
return (1);
}
//
// Write the CODEPAGE tables to an output file.
//
if (WriteCodePage(&CP))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "LANGUAGE") == 0)
{
if (Verbose)
printf("\n\nFound LANGUAGE keyword.\n");
//
// Initialize Language structure.
//
memset(&Lang, 0, sizeof(LANGUAGE));
//
// Get LANGUAGE parameter string.
//
if (GetKeyParam(pszParam))
{
return (1);
}
//
// Get the valid keywords for LANGUAGE.
//
if (ParseLanguage(&Lang, pszKeyWord))
{
return (1);
}
//
// Write the LANGUAGE tables to an output file.
//
if (WriteLanguage(&Lang))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "LANGUAGE_EXCEPTION") == 0)
{
if (Verbose)
printf("\n\nFound LANGUAGE_EXCEPTION keyword.\n");
//
// Initialize Language structure.
//
memset(&LangExcept, 0, sizeof(LANG_EXCEPT));
//
// Get the valid keywords for LANGUAGE_EXCEPTION.
//
if (ParseLangException(&LangExcept, pszKeyWord))
{
return (1);
}
//
// Write the LANGUAGE_EXCEPTION tables to an output file.
//
if (WriteLangException(&LangExcept))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "LOCALE") == 0)
{
if (Verbose)
printf("\n\nFound LOCALE keyword.\n");
//
// Get the valid keywords for LOCALE.
// Write the LOCALE information to an output file.
//
if (ParseWriteLocale( &LocHdr,
&LocStat,
&LocVar,
pszKeyWord ))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "UNICODE") == 0)
{
if (Verbose)
printf("\n\nFound UNICODE keyword.\n");
//
// Initialize Unicode structure.
//
memset(&Unic, 0, sizeof(UNICODE));
//
// Get the valid keywords for UNICODE.
//
if (ParseUnicode(&Unic, pszKeyWord))
{
return (1);
}
//
// Write the UNICODE tables to an output file.
//
if (WriteUnicode(&Unic))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "CTYPES") == 0)
{
if (Verbose)
printf("\n\nFound CTYPES keyword.\n");
//
// Initialize CTypes structure.
//
memset(&CTypes, 0, sizeof(CTYPES));
//
// Get the valid keywords for CTYPES.
//
if (ParseCTypes(&CTypes))
{
return (1);
}
//
// Write the CTYPES tables to different output files.
//
if (WriteCTypes(&CTypes))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "SORTKEY") == 0)
{
if (Verbose)
printf("\n\nFound SORTKEY keyword.\n");
//
// Initialize Sortkey structure.
//
memset(&Sortkey, 0, sizeof(SORTKEY));
//
// Get the valid keywords for SORTKEY.
//
if (ParseSortkey(&Sortkey, pszKeyWord))
{
return (1);
}
//
// Write the SORTKEY tables to an output file.
//
if (WriteSortkey(&Sortkey))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "SORTTABLES") == 0)
{
if (Verbose)
printf("\n\nFound SORTTABLES keyword.\n");
//
// Initialize Sort Tables structure.
//
memset(&SortTbls, 0, sizeof(SORT_TABLES));
//
// Get the valid keywords for SORTTABLES.
//
if (ParseSortTables(&SortTbls, pszKeyWord))
{
return (1);
}
//
// Write the Sort Tables to an output file.
//
if (WriteSortTables(&SortTbls))
{
return (1);
}
}
else if (_strcmpi(pszKeyWord, "IDEOGRAPH_EXCEPTION") == 0)
{
if (Verbose)
printf("\n\nFound IDEOGRAPH_EXCEPTION keyword.\n");
//
// Initialize Ideograph Exception structure.
//
memset(&IdeographExcept, 0, sizeof(IDEOGRAPH_EXCEPT));
//
// Get the valid keywords for IDEOGRAPH_EXCEPTION.
//
if (ParseIdeographExceptions(&IdeographExcept))
{
return (1);
}
//
// Write the Ideograph Exceptions to the given output file.
//
if (WriteIdeographExceptions(&IdeographExcept))
{
return (1);
}
}
else
{
printf("Parse Error: Invalid Instruction '%s'.\n", pszKeyWord);
return (1);
}
}
//
// Return success.
//
return (0);
}
