/*
* PROJECT: ReactOS Build Tools [Keyboard Layout Compiler]
* LICENSE: BSD - See COPYING.BSD in the top level directory
* FILE: tools/kbdtool/parser.c
* PURPOSE: Parsing Logic
* PROGRAMMERS: ReactOS Foundation
*/
/* INCLUDES *******************************************************************/
#include "kbdtool.h"
/* GLOBALS ********************************************************************/
/* Internal parser data about everything that was parsed */
CHAR gBuf[256];
CHAR gKBDName[10];
CHAR gCopyright[256];
CHAR gDescription[256];
CHAR gCompany[256];
CHAR gLocaleName[256];
CHAR gVKeyName[32];
ULONG gID = 0;
ULONG gKbdLayoutVersion;
LAYOUT g_Layout;
ULONG gLineCount;
/* Table of keywords the parser recognizes */
PCHAR KeyWordList[KEYWORD_COUNT] =
{
"KBD",
"VERSION",
"COPYRIGHT",
"COMPANY",
"LOCALENAME",
"MODIIFERS",
"SHIFTSTATE",
"ATTRIBUTES",
"LAYOUT",
"DEADKEY",
"LIGATURE",
"KEYNAME",
"KEYNAME_EXT",
"KEYNAME_DEAD",
"DESCRIPTIONS",
"LANGUAGENAMES",
"ENDKBD",
};
/* FUNCTIONS ******************************************************************/
ULONG
isKeyWord(PCHAR p)
{
ULONG i;
/* Check if we know this keyword */
for (i = 0; i < KEYWORD_COUNT; i++) if (strcmp(KeyWordList[i], p) == 0) break;
/* If we didn't find anything, i will be KEYWORD_COUNT, which is invalid */
return i;
}
PCHAR
getVKName(IN ULONG VirtualKey,
IN BOOLEAN Prefix)
{
ULONG i;
/* Loop for standard virtual key */
if (((VirtualKey >= 'A') && (VirtualKey <= 'Z')) ||
((VirtualKey >= '0') && (VirtualKey <= '9')))
{
/* Fill out the name */
gVKeyName[0] = '\'';
gVKeyName[1] = VirtualKey;
gVKeyName[2] = '\'';
gVKeyName[3] = '\0';
return gVKeyName;
}
/* Check if a prefix is required */
if (Prefix)
{
/* Add it */
strcpy(gVKeyName, "VK_");
}
else
{
/* Otherwise, don't add anything */
strcpy(gVKeyName, "");
}
/* Loop all virtual keys */
for (i = 0; i < 36; i++)
{
/* Check if this key matches */
if (VKName[i].VirtualKey == VirtualKey)
{
/* Copy the key's name into the buffer */
strcat(gVKeyName, VKName[i].Name);
return gVKeyName;
}
}
/* If we got here, then we failed, so print out an error name */
strcpy(gVKeyName, "#ERROR#");
return gVKeyName;
}
ULONG
getVKNum(IN PCHAR p)
{
ULONG Length;
ULONG i;
ULONG KeyNumber;
/* Compute the length of the string */
Length = strlen(p);
if (!Length) return -1;
/* Check if this is is a simple key */
if (Length == 1)
{
/* If it's a number, return it now */
if ((*p >= '0') && (*p <= '9')) return *p;
/* Otherwise, convert the letter to upper case */
*p = toupper(*p);
/* And make sure it's a valid letter */
if ((*p >= 'A') && (*p <='Z')) return *p;
/* Otherwise, fail */
return -1;
}
/* Otherwise, scan our virtual key names */
for (i = 0; i < 36; i++)
{
/* Check if we have a match */
if (!strcmp(VKName[i].Name, p)) return VKName[i].VirtualKey;
}
/* Check if this is a hex string */
if ((*p == '0') && ((*(p + 1) == 'x') || (*(p + 1) == 'X')))
{
/* Get the key number from the hex string */
*(p + 1) = 'x';
if (sscanf(p, "0x%x", &KeyNumber) == 1) return KeyNumber;
}
/* No hope: fail */
return -1;
}
UCHAR
getCharacterInfo(IN PCHAR State,
OUT PULONG EntryChar,
OUT PCHAR LigatureChar)
{
ULONG Length;
ULONG CharInfo = CHAR_NORMAL_KEY;
UCHAR StateChar;
ULONG CharCode;
/* Calculate the length of the state */
Length = strlen(State);
/* Check if this is at least a simple key state */
if (Length > 1)
{
/* Read the first character and check if it's a dead key */
StateChar = State[Length - 1];
if (StateChar == '@')
{
/* This is a dead key */
CharInfo = CHAR_DEAD_KEY;
}
else if (StateChar == '%')
{
/* This is another key */
CharInfo = CHAR_OTHER_KEY;
}
}
/* Check if this is a numerical key state */
if ((Length - 1) >= 2)
{
/* Scan for extended character code entry */
if ((sscanf(State, "%6x", &CharCode) == 1) &&
(((Length == 5) && (State[0] == '0')) ||
((Length == 6) && ((State[0] == '0') && (State[1] == '0')))))
{
/* Handle a ligature key */
CharInfo = CHAR_LIGATURE_KEY;
/* Not yet handled */
printf("Ligatured character entries not yet supported!\n");
exit(1);
}
else
{
/* Get the normal character entry */
if (sscanf(State, "%4x", &CharCode) == 1)
{
/* Does the caller want the key? */
if (EntryChar) *EntryChar = CharCode;
}
else
{
/* The entry is totally invalid */
if (Verbose) printf("An unparseable character entry '%s' was found.\n", State);
if (EntryChar) *EntryChar = 0;
CharInfo = CHAR_INVALID_KEY;
}
}
}
else
{
/* Save the key if the caller requested it */
if (EntryChar) *EntryChar = *State;
}
/* Return the type of character this is */
return CharInfo;
}
BOOLEAN
NextLine(PCHAR LineBuffer,
ULONG BufferSize,
FILE *File)
{
PCHAR p, pp;
/* Scan each line */
while (fgets(LineBuffer, BufferSize, File))
{
/* Remember it */
gLineCount++;
/* Reset the pointer at the beginning of the line */
p = LineBuffer;
/* Now bypass all whitespace (and tabspace) */
while ((*p) && ((*p == ' ') || (*p == '\t'))) p++;
/* If this is an old-style comment, skip the line */
if (*p == ';') continue;
/* Otherwise, check for new-style comment */
pp = strstr(p, "//");
if (pp)
{
/* We have a comment, so terminate there (unless the whole line is one) */
if (pp == p) continue;
*pp = '\0';
}
else
{
/* No comment, so find the new line and terminate there */
p = strchr(p, '\n');
if (p) *p = '\0';
}
/* We have a line! */
return TRUE;
}
/* No line found */
return FALSE;
}
ULONG
SkipLines(VOID)
{
ULONG KeyWord;
CHAR KeyWordChars[32];
/* Scan each line, skipping it if it's not a keyword */
while (NextLine(gBuf, sizeof(gBuf), gfpInput))
{
/* Read a single word */
if (sscanf(gBuf, "%s", KeyWordChars) == 1)
{
/* If the word is a keyword, stop skipping lines */
KeyWord = isKeyWord(KeyWordChars);
if (KeyWord < KEYWORD_COUNT) return KeyWord;
}
}
/* We skipped all the possible lines, not finding anything */
return KEYWORD_COUNT;
}
ULONG
DoKBD(VOID)
{
/* On Unicode files, we need to find the Unicode marker (FEEF) */
ASSERT(UnicodeFile == FALSE);
/* Initial values */
*gKBDName = '\0';
*gDescription = '\0';
/* Scan for the values */
if (sscanf(gBuf, "KBD %8s \"%40[^\"]\" %d", gKBDName, gDescription, &gID) < 2)
{
/* Couldn't find them */
printf("Unable to read keyboard name or description.\n");
exit(1);
}
/* Debug only */
DPRINT1("KBD Name: [%8s] Description: [%40s] ID: [%d]\n", gKBDName, gDescription, gID);
return SkipLines();
}
ULONG
DoVERSION(VOID)
{
/* Scan for the value */
if (sscanf(gBuf, "VERSION %d", &gKbdLayoutVersion) < 1)
{
/* Couldn't find them */
printf("Unable to read keyboard version information.\n");
}
/* Debug only */
DPRINT1("VERSION [%d]\n", gKbdLayoutVersion);
return SkipLines();
}
ULONG
DoCOPYRIGHT(VOID)
{
/* Initial values */
*gCopyright = '\0';
/* Scan for the value */
if (sscanf(gBuf, "COPYRIGHT \"%40[^\"]\"", gCopyright) < 1)
{
/* Couldn't find them */
printf("Unable to read the specified COPYRIGHT string.\n");
}
/* Debug only */
DPRINT1("COPYRIGHT [%40s]\n", gCopyright);
return SkipLines();
}
ULONG
DoCOMPANY(VOID)
{
/* Initial values */
*gCompany = '\0';
/* Scan for the value */
if (sscanf(gBuf, "COMPANY \"%85[^\"]\"", gCompany) < 1)
{
/* Couldn't find them */
printf("Unable to read the specified COMPANY name.\n");
}
/* Debug only */
DPRINT1("COMPANY [%85s]\n", gCompany);
return SkipLines();
}
ULONG
DoLOCALENAME(VOID)
{
/* Initial values */
*gLocaleName = '\0';
/* Scan for the value */
if (sscanf(gBuf, "LOCALENAME \"%40[^\"]\"", gLocaleName) < 1)
{
/* Couldn't find them */
printf("Unable to read the specified COPYRIGHT string.\n");
}
/* Debug only */
DPRINT1("LOCALENAME [%40s]\n", gLocaleName);
return SkipLines();
}
ULONG
DoDESCRIPTIONS(IN PKEYNAME* DescriptionData)
{
ULONG KeyWord = 0;
CHAR Token[32];
ULONG LanguageCode;
PCHAR p, pp;
PKEYNAME Description;
/* Assume nothing */
*DescriptionData = 0;
/* Start scanning */
while (NextLine(gBuf, 256, gfpInput))
{
/* Search for token */
if (sscanf(gBuf, "%s", Token) != 1) continue;
/* Make sure it's not just a comment */
if (*Token == ';') continue;
/* Make sure it's not a keyword */
KeyWord = isKeyWord(Token);
if (KeyWord < KEYWORD_COUNT) break;
/* Now scan for the language code */
if (sscanf(Token, " %4x", &LanguageCode) != 1)
{
/* Skip */
printf("An invalid LANGID was specified.\n");
continue;
}
/* Now get the actual description */
if (sscanf(gBuf, " %*4x %s[^\n]", Token) != 1)
{
/* Skip */
printf("A language description is missing.\n");
continue;
}
/* Get the description string and find the ending */
p = strstr(gBuf, Token);
pp = strchr(p, '\n');
if (!pp) pp = strchr(p, '\r');
/* Terminate the description string here */
if (pp) *pp = 0;
/* Now allocate the description */
Description = malloc(sizeof(KEYNAME));
if (!Description)
{
/* Fail */
printf("Unable to allocate the KEYNAME struct (out of memory?).\n");
exit(1);
}
/* Fill out the structure */
Description->Code = LanguageCode;
Description->Name = strdup(p);
Description->Next = NULL;
/* Debug only */
DPRINT1("LANGID: [%4x] Description: [%s]\n", Description->Code, Description->Name);
/* Point to it and advance the pointer */
*DescriptionData = Description;
DescriptionData = &Description->Next;
}
/* We are done */
return KeyWord;
}
ULONG
DoLANGUAGENAMES(IN PKEYNAME* LanguageData)
{
ULONG KeyWord = 0;
CHAR Token[32];
ULONG LanguageCode;
PCHAR p, pp;
PKEYNAME Language;
/* Assume nothing */
*LanguageData = 0;
/* Start scanning */
while (NextLine(gBuf, 256, gfpInput))
{
/* Search for token */
if (sscanf(gBuf, "%s", Token) != 1) continue;
/* Make sure it's not just a comment */
if (*Token == ';') continue;
/* Make sure it's not a keyword */
KeyWord = isKeyWord(Token);
if (KeyWord < KEYWORD_COUNT) break;
/* Now scan for the language code */
if (sscanf(Token, " %4x", &LanguageCode) != 1)
{
/* Skip */
printf("An invalid LANGID was specified.\n");
continue;
}
/* Now get the actual language */
if (sscanf(gBuf, " %*4x %s[^\n]", Token) != 1)
{
/* Skip */
printf("A language name is missing\n");
continue;
}
/* Get the language string and find the ending */
p = strstr(gBuf, Token);
pp = strchr(p, '\n');
if (!pp) pp = strchr(p, '\r');
/* Terminate the language string here */
if (pp) *pp = 0;
/* Now allocate the language */
Language = malloc(sizeof(KEYNAME));
if (!Language)
{
/* Fail */
printf("Unable to allocate the KEYNAME struct (out of memory?).\n");
exit(1);
}
/* Fill out the structure */
Language->Code = LanguageCode;
Language->Name = strdup(p);
Language->Next = NULL;
/* Debug only */
DPRINT1("LANGID: [%4x] Name: [%s]\n", Language->Code, Language->Name);
/* Point to it and advance the pointer */
*LanguageData = Language;
LanguageData = &Language->Next;
}
/* We are done */
return KeyWord;
}
ULONG
DoKEYNAME(IN PKEYNAME* KeyNameData)
{
ULONG KeyWord = 0;
CHAR Token[32];
ULONG CharacterCode;
PCHAR p, pp;
PKEYNAME KeyName;
/* Assume nothing */
*KeyNameData = 0;
/* Start scanning */
while (NextLine(gBuf, 256, gfpInput))
{
/* Search for token */
if (sscanf(gBuf, "%s", Token) != 1) continue;
/* Make sure it's not just a comment */
if (*Token == ';') continue;
/* Make sure it's not a keyword */
KeyWord = isKeyWord(Token);
if (KeyWord < KEYWORD_COUNT) break;
/* Now scan for the character code */
if (sscanf(Token, " %4x", &CharacterCode) != 1)
{
/* Skip */
printf("An invalid character code was specified.\n");
continue;
}
/* Now get the actual key name */
if (sscanf(gBuf, " %*4x %s[^\n]", Token) != 1)
{
/* Skip */
printf("A key name is missing\n");
continue;
}
/* Get the key name string and find the ending */
p = strstr(gBuf, Token);
pp = strchr(p, '\n');
if (!pp) pp = strchr(p, '\r');
/* Terminate the key name string here */
if (pp) *pp = 0;
/* Now allocate the language */
KeyName = malloc(sizeof(KEYNAME));
if (!KeyName)
{
/* Fail */
printf("Unable to allocate the KEYNAME struct (out of memory?).\n");
exit(1);
}
/* Fill out the structure */
KeyName->Code = CharacterCode;
KeyName->Name = strdup(p);
KeyName->Next = NULL;
/* Debug only */
DPRINT1("CHARCODE: [%4x] Name: [%s]\n", KeyName->Code, KeyName->Name);
/* Point to it and advance the pointer */
*KeyNameData = KeyName;
KeyNameData = &KeyName->Next;
}
/* We are done */
return KeyWord;
}
ULONG
DoSHIFTSTATE(IN PULONG StateCount,
IN OUT PULONG ShiftStates)
{
ULONG KeyWord;
ULONG i;
ULONG ShiftState;
CHAR Token[32];
/* Reset the shift states */
for (i = 0; i < 8; i++) ShiftStates[i] = -1;
/* Start with no states */
*StateCount = 0;
/* Scan for shift states */
while (NextLine(gBuf, 256, gfpInput))
{
/* Search for token */
if (sscanf(gBuf, "%s", Token) != 1) continue;
/* Make sure it's not a keyword */
KeyWord = isKeyWord(Token);
if (KeyWord < KEYWORD_COUNT) break;
/* Now scan for the shift state */
if (sscanf(gBuf, " %1s[012367]", Token) != 1)
{
/* We failed -- should we warn? */
if (Verbose) printf("An invalid shift state '%s' was found (use 0, 1, 2, 3, 6, or 7.)\n", Token);
continue;
}
/* Now read the state */
ShiftState = atoi(Token);
/* Scan existing states */
for (i = 0; i < *StateCount; i++)
{
/* Check for duplicate */
if ((ShiftStates[i] == ShiftState) && (Verbose))
{
/* Warn user */
printf("The state '%d' was duplicated for this Virtual Key.\n", ShiftStates[i]);
break;
}
}
/* Make sure we won't overflow */
if (*StateCount < 8)
{
/* Save this state */
ShiftStates[(*StateCount)++] = ShiftState;
}
else
{
/* Too many states -- should we warn? */
if (Verbose) printf("There were too many states (you defined %d).\n", *StateCount);
}
}
/* Debug only */
DPRINT1("Found %d Shift States: [", *StateCount);
for (i = 0; i < *StateCount; i++) DPRINT1("%d ", ShiftStates[i]);
DPRINT1("]\n");
/* We are done */
return KeyWord;
}
ULONG
DoLIGATURE(PVOID LigatureData)
{
printf("LIGATURE support is not yet implemented. Please bug Arch to fix it\n");
return SkipLines();
}
ULONG
DoATTRIBUTES(PVOID AttributeData)
{
printf("ATTRIBUTES support is not yet implemented. Please bug Arch to fix it\n");
return SkipLines();
}
ULONG
DoMODIFIERS(VOID)
{
printf("MODIFIERS support is not yet implemented. Please bug Arch to fix it\n");
return SkipLines();
}
ULONG
DoDEADKEY(PVOID DeadKeyData)
{
printf("DEADKEY support is not yet implemented. Please bug Arch to fix it\n");
return SkipLines();
}
ULONG
DoLAYOUT(IN PLAYOUT LayoutData,
IN PVOID LigatureData,
IN PULONG ShiftStates,
IN ULONG StateCount)
{
CHAR Token[32];
CHAR Cap[8];
ULONG KeyWord;
ULONG ScanCode, CurrentCode;
ULONG TokenCount;
ULONG VirtualKey;
ULONG i;
ULONG Count;
BOOLEAN FullEntry;
CHAR State[8][8];
ULONG ScanCodeCount = -1;
PLAYOUTENTRY Entry;
UCHAR CharacterType;
CHAR LigatureChar;
/* Zero out the layout */
memset(LayoutData, 0, sizeof(LAYOUT));
/* Read each line */
Entry = &LayoutData->Entry[0];
while (NextLine(gBuf, 256, gfpInput))
{
/* Search for token */
if (sscanf(gBuf, "%s", Token) != 1) continue;
/* Make sure it's not just a comment */
if (*Token == ';') continue;
/* Make sure it's not a keyword */
KeyWord = isKeyWord(Token);
if (KeyWord < KEYWORD_COUNT) break;
/* Now read the entry */
TokenCount = sscanf(gBuf, " %x %s %s", &ScanCode, Token, Cap);
if (TokenCount == 3)
{
/* Full entry with cap */
FullEntry = TRUE;
}
else if (TokenCount != 2)
{
/* Fail, invalid LAYOUT entry */
printf("There are not enough columns in the layout list.\n");
exit(1);
}
else
{
/* Simplified layout with no cap */
FullEntry = FALSE;
}
/* One more */
DPRINT1("RAW ENTRY: [%x %s %s]\n", ScanCode, Token, Cap);
Entry++;
if (++ScanCodeCount >= 110)
{
/* Too many! */
printf("ScanCode %02x - too many scancodes here to parse.\n", ScanCode);
exit(1);
}
/* Fill out this entry */
Entry->ScanCode = ScanCode;
Entry->LineCount = gLineCount;
/* Loop scancode table */
for (i = 0; i < 110; i++)
{
/* Get the current code */
CurrentCode = ScVk[i].ScanCode;
if (CurrentCode == 0xFFFF)
{
/* New code */
if (Verbose) printf("A new scancode is being defined: 0x%2X, %s\n", Entry->ScanCode, Token);
/* Fill out the entry */
Entry->VirtualKey = getVKNum(Token);
break;
}
else if (ScanCode == CurrentCode)
{
/* Make sure we didn't already process it */
if (ScVk[i].Processed)
{
/* Fail */
printf("Scancode %X was previously defined.\n", ScanCode);
exit(1);
}
/* Check if there is a valid virtual key */
if (ScVk[i].VirtualKey == 0xFFFF)
{
/* Fail */
printf("The Scancode you tried to use (%X) is reserved.\n", ScanCode);
exit(1);
}
/* Fill out the entry */
Entry->OriginalVirtualKey = ScVk[i].VirtualKey;
Entry->Name = ScVk[i].Name;
break;
}
}
/* The entry is now processed */
Entry->Processed = TRUE;
ScVk[i].Processed = TRUE;
/* Get the virtual key from the entry */
VirtualKey = getVKNum(Token);
Entry->VirtualKey = VirtualKey;
DPRINT1("ENTRY: [%x %x %x %s] with ",
Entry->VirtualKey, Entry->OriginalVirtualKey, Entry->ScanCode, Entry->Name);
/* Make sure it's valid */
if (VirtualKey == 0xFFFF)
{
/* Warn the user */
if (Verbose) printf("An invalid Virtual Key '%s' was defined.\n", Token);
continue;
}
/* Is this a full entry */
if (FullEntry)
{
/* Do we have SGCAP data? Set cap mode to 2 */
if (!strcmp(Cap, "SGCAP")) *Cap = '2';
/* Read the cap mode */
if (sscanf(Cap, "%1d[012]", &Entry->Cap) != 1)
{
/* Invalid cap mode */
printf("invalid Cap specified (%s). Must be 0, 1, or 2.\n", Cap);
exit(1);
}
}
/* Read the states */
Count = sscanf(gBuf,
" %*s %*s %*s %s %s %s %s %s %s %s %s",
State[0],
State[1],
State[2],
State[3],
State[4],
State[5],
State[6],
State[7]);
Entry->StateCount = Count;
DPRINT1("%d STATES: [", Count);
/* Check if there are less than 2 states */
if ((Count < 2) && (FullEntry))
{
/* Fail */
printf("You must have at least 2 characters.\n");
exit(1);
}
/* Loop all states */
for (i = 0; i < Count; i++)
{
/* Check if this is an undefined state */
DPRINT1("%s ", State[i]);
if (!strcmp(State[i], "-1"))
{
/* No data for this state */
Entry->CharData[i] = -1;
continue;
}
/* Otherwise, check what kind of character this is */
CharacterType = getCharacterInfo(State[i],
&Entry->CharData[i],
&LigatureChar);
if (CharacterType == CHAR_DEAD_KEY)
{
/* Save it as such */
Entry->DeadCharData[i] = 1;
}
else if (CharacterType == CHAR_OTHER_KEY)
{
/* Save it as such */
Entry->OtherCharData[i] = 1;
}
}
/* Check for sanity checks */
DPRINT1("]\n");
if (SanityCheck)
{
/* Not yet handled... */
printf("Sanity checks not yet handled!\n");
exit(1);
}
/* Check if we had SGCAP data */
if (Entry->Cap & 2)
{
/* Not yet handled... */
printf("SGCAP state not yet handled!\n");
exit(1);
}
}
/* Check if we have found any ScanCode in the file */
if (ScanCodeCount == -1)
{
printf("No ScanCode found!\n");
exit(1);
}
/* Process the scan code table */
Entry = &LayoutData->Entry[ScanCodeCount];
for (i = 0; i < 110; i++)
{
/* Get the scan code */
CurrentCode = ScVk[i].ScanCode;
if (CurrentCode == 0xFFFF) break;
/* Check if this entry had been processed */
if (ScVk[i].Processed)
{
/* Skip it */
ScVk[i].Processed = FALSE;
}
else
{
/* Do we have too many? */
if (++ScanCodeCount >= 110)
{
/* Fail */
printf("ScanCode %02x - too many scancodes here to parse.\n", CurrentCode);
exit(1);
}
/* Build an entry for it */
Entry++;
Entry->ScanCode = CurrentCode;
Entry->VirtualKey = ScVk[i].VirtualKey;
Entry->OriginalVirtualKey = ScVk[i].VirtualKey;
Entry->Name = ScVk[i].Name;
Entry->Processed = TRUE;
Entry->LineCount = 0;
DPRINT1("AUTOMATIC ENTRY: [%x %x %s]\n",
Entry->VirtualKey, Entry->ScanCode, Entry->Name);
}
}
/* Skip what's left */
return KeyWord;
}
ULONG
DoParsing(VOID)
{
ULONG KeyWords[KEYWORD_COUNT];
ULONG KeyWord;
ULONG StateCount;
ULONG ShiftStates[8];
PKEYNAME DescriptionData = NULL, LanguageData = NULL;
PKEYNAME KeyNameData = NULL, KeyNameExtData = NULL, KeyNameDeadData = NULL;
PVOID AttributeData = NULL, LigatureData = NULL, DeadKeyData = NULL;
/* Parse keywords */
gLineCount = 0;
KeyWord = SkipLines();
if (KeyWord >= KEYWORD_COUNT)
{
/* Invalid keyword count, fail */
fclose(gfpInput);
printf("No keywords were found in '%s'.\n", gpszFileName);
exit(1);
}
/* Now parse the keywords */
memset(KeyWords, 0, sizeof(KeyWords));
while (KeyWord < (KEYWORD_COUNT - 1))
{
/* Save this keyword */
KeyWords[KeyWord]++;
/* Check for duplicate entires, other than DEADKEY, which is okay */
if ((KeyWord != 9) && (KeyWords[KeyWord] > 1) && (Verbose))
{
/* On a verbose run, warn the user */
printf("The '%s' keyword appeared multiple times.\n",
KeyWordList[KeyWord]);
}
/* Now parse this keyword */
switch (KeyWord)
{
/* KBD */
case 0:
DPRINT1("Found KBD section\n");
KeyWord = DoKBD();
break;
/* VERSION */
case 1:
DPRINT1("Found VERSION section\n");
KeyWord = DoVERSION();
break;
/* COPYRIGHT */
case 2:
DPRINT1("Found COPYRIGHT section\n");
KeyWord = DoCOPYRIGHT();
break;
/* COMPANY */
case 3:
DPRINT1("Found COMPANY section\n");
KeyWord = DoCOMPANY();
break;
/* LOCALENAME */
case 4:
DPRINT1("Found LOCALENAME section\n");
KeyWord = DoLOCALENAME();
break;
/* MODIFIERS */
case 5:
DPRINT1("Found MODIFIERS section\n");
KeyWord = DoMODIFIERS();
break;
/* SHIFTSTATE */
case 6:
DPRINT1("Found SHIFTSTATE section\n");
KeyWord = DoSHIFTSTATE(&StateCount, ShiftStates);
if (StateCount < 2)
{
/* Fail */
fclose(gfpInput);
printf("ERROR");
exit(1);
}
break;
/* ATTRIBUTES */
case 7:
DPRINT1("Found ATTRIBUTES section\n");
KeyWord = DoATTRIBUTES(&AttributeData);
break;
/* LAYOUT */
case 8:
DPRINT1("Found LAYOUT section\n");
KeyWord = DoLAYOUT(&g_Layout,
&LigatureData,
ShiftStates,
StateCount);
break;
/* DEADKEY */
case 9:
DPRINT1("Found DEADKEY section\n");
KeyWord = DoDEADKEY(&DeadKeyData);
break;
/* LIGATURE */
case 10:
DPRINT1("Found LIGATURE section\n");
KeyWord = DoLIGATURE(&LigatureData);
break;
/* KEYNAME */
case 11:
DPRINT1("Found KEYNAME section\n");
KeyWord = DoKEYNAME(&KeyNameData);
break;
/* KEYNAME_EXT */
case 12:
DPRINT1("Found KEYNAME_EXT section\n");
KeyWord = DoKEYNAME(&KeyNameExtData);
break;
/* KEYNAME_DEAD */
case 13:
DPRINT1("Found KEYNAME_DEAD section\n");
KeyWord = DoKEYNAME(&KeyNameDeadData);
break;
/* DESCRIPTIONS */
case 14:
DPRINT1("Found DESCRIPTIONS section\n");
KeyWord = DoDESCRIPTIONS(&DescriptionData);
break;
/* LANGUAGENAMES */
case 15:
DPRINT1("Found LANGUAGENAMES section\n");
KeyWord = DoLANGUAGENAMES(&LanguageData);
break;
/* ENDKBD */
case 16:
DPRINT1("Found ENDKBD section\n");
KeyWord = SkipLines();
break;
default:
break;
}
}
/* We are done */
fclose(gfpInput);
/* Now enter the output phase */
return DoOutput(StateCount,
ShiftStates,
DescriptionData,
LanguageData,
AttributeData,
DeadKeyData,
LigatureData,
KeyNameData,
KeyNameExtData,
KeyNameDeadData);
}
/* EOF */