Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2856 lines
84 KiB

/******************************* Module Header *******************************\
* Module Name: KBDTXT2C.C
*
* Copyright (c) 1985-2001, Microsoft Corporation
*
* History:
* 1995-03-26 a-KChang
* 1997-06-13 GregoryW v2.00 BiDi Support
* 1997-06-19 IanJa v2.01 Add ATTRIBUTES section
* 1998-03-04 IanJa v3.0 Add dead key composition can be dead char too
* (Useful for CAN/CSA, Serge Caron @ Attachmate
* and a customer of Eliyas Yakub's)
* 1998-05-01 HiroYama v3.01 -k switch to make fallback layout for win32k.sys
* 1998-05-08 IanJa v3.02 new E1 scancodes allowed
* 1998-05-19 v-thief v3.03 Add IA64 support. Implies that the data arrays
* are located in the long data section.
* Uses IA64 compiler specific pragmas.
* data_seg() is not explicit enough.
* 1998-05-20 v-thief v3.04 For the fallback layout in win32k.sys, we are
* not relocating the data in long data section.
* 1998-10-29 WKwok v3.05 Specify VER_LANGNEUTRAL in RC.
* 1998-12-03 IanJa v3.06 Add SpeedRacer VKs, include strid.h
* 1999-01-12 IanJa v3.07 check for dup VKs, beautify, improve VkKeyScan
* 1999-01-28 v-thief v3.08 fixed IA64 warnings for .data section. The new
* IA64 compiler defaults to a "long" attribute
* for this known section.
* 1999-02-11 IanJa v3.09 check for dup chars (for VkKeyScanEx's sake)
* 1999-03-25 IanJa v3.10 no more vkoem.h (get VKs from winuser.h)
* 1999-03-31 IanJa v3.11 comment out spurious DumpLayoutEntry() call
* 2001-06-28 Hiroyama v3.12 fix the upper case warnings etc..
putting the sanity check in "-W".
\*****************************************************************************/
#include <windows.h>
#include <winuserp.h>
#include "kbdx.h"
DWORD gVersion = 3;
DWORD gSubVersion = 12;
char *KeyWord[] = { /* used by isKeyWord() */
"KBD", /* 0 */
"VERSION", /* 1 */
"MODIFIERS", /* 2 */
"SHIFTSTATE", /* 3 */
"ATTRIBUTES", /* 4 */
"LAYOUT", /* 5 */
"DEADKEY", /* 6 */
"LIGATURE", /* 7 */
"KEYNAME", /* 8 */
"KEYNAME_EXT", /* 9 */
"KEYNAME_DEAD", /* 10 */
"ENDKBD", /* 11 */
};
#define KEYWORD_KBD 0
#define KEYWORD_VERSION 1
#define KEYWORD_MODIFIERS 2
#define KEYWORD_SHIFTSTATE 3
#define KEYWORD_ATTRIBUTES 4
#define KEYWORD_LAYOUT 5
#define KEYWORD_DEADKEY 6
#define KEYWORD_LIGATURE 7
#define KEYWORD_KEYNAME 8
#define KEYWORD_KEYNAME_EXT 9
#define KEYWORD_KEYNAME_DEAD 10
#define KEYWORD_ENDKBD 11
#define NUMKEYWORD ( sizeof(KeyWord) / sizeof(char*) )
#define NOT_KEYWORD 999 /* a number bigger than NUMKEYWORD */
#define DEADKEYCODE 6 /* only DEADKEY can have multiple entries */
VKEYNAME VKName[] = { /* used only by virtual keys other than 0-9 and A-Z */
{VK_BACK, "BACK" },
{VK_CANCEL, "CANCEL" },
{VK_ESCAPE, "ESCAPE" },
{VK_RETURN, "RETURN" },
{VK_SPACE, "SPACE" },
{VK_DECIMAL, "DECIMAL" },
{VK_OEM_1, "OEM_1" },
{VK_OEM_PLUS, "OEM_PLUS" },
{VK_OEM_COMMA, "OEM_COMMA" },
{VK_OEM_MINUS, "OEM_MINUS" },
{VK_OEM_PERIOD, "OEM_PERIOD" },
{VK_OEM_2, "OEM_2" },
{VK_OEM_3, "OEM_3" },
{VK_OEM_4, "OEM_4" },
{VK_OEM_5, "OEM_5" },
{VK_OEM_6, "OEM_6" },
{VK_OEM_7, "OEM_7" },
{VK_OEM_8, "OEM_8" },
{VK_OEM_102, "OEM_102" },
{0xC1, "ABNT_C1" },
{0xC2, "ABNT_C2" },
{VK_SHIFT, "SHIFT" },
{VK_LSHIFT, "LSHIFT" },
{VK_RSHIFT, "RSHIFT" },
{VK_MENU, "MENU" },
{VK_LMENU, "LMENU" },
{VK_RMENU, "RMENU" },
{VK_CONTROL, "CONTROL" },
{VK_LCONTROL, "LCONTROL" },
{VK_RCONTROL, "RCONTROL" },
{VK_SEPARATOR, "SEPARATOR" },
{VK_ICO_00, "ICO_00" },
{VK_DELETE, "DELETE" },
{VK_INSERT, "INSERT" },
{VK_GROUPSHIFT, "GROUPSHIFT" },
{VK_RGROUPSHIFT,"RGROUPSHIFT"},
};
#define NUMVKNAME ( sizeof(VKName) / sizeof(VKEYNAME) )
/*
* Default ScanCode-VirtualKey relation
*
* Includes a comment string used only for E0 prefixed scancodes and
* then only as a comment for aE0VscToVk[] entries in the output .C file
*
* This does not have to be ordered by scancode or virtual key code.
* The order *does* affect VkKeyScan[Ex] - each aVkToWch*[] table is
* ordered according to the order of the entries in this table.
*
*
* Scan VKey comment
* ==== ========= =======
*/
SC_VK ScVk[] = {
{0x02, 0x31, NULL}, /* 1 */
{0x03, 0x32, NULL}, /* 2 */
{0x04, 0x33, NULL}, /* 3 */
{0x05, 0x34, NULL}, /* 4 */
{0x06, 0x35, NULL}, /* 5 */
{0x07, 0x36, NULL}, /* 6 */
{0x08, 0x37, NULL}, /* 7 */
{0x09, 0x38, NULL}, /* 8 */
{0x0a, 0x39, NULL}, /* 9 */
{0x0b, 0x30, NULL}, /* 0 */
{0x0c, 0xbd, NULL}, /* OEM_MINUS */
{0x0d, 0xbb, NULL}, /* OEM_PLUS */
{0x10, 0x51, NULL}, /* Q */
{0x11, 0x57, NULL}, /* W */
{0x12, 0x45, NULL}, /* E */
{0x13, 0x52, NULL}, /* R */
{0x14, 0x54, NULL}, /* T */
{0x15, 0x59, NULL}, /* Y */
{0x16, 0x55, NULL}, /* U */
{0x17, 0x49, NULL}, /* I */
{0x18, 0x4f, NULL}, /* O */
{0x19, 0x50, NULL}, /* P */
{0x1a, 0xdb, NULL}, /* OEM_4 */
{0x1b, 0xdd, NULL}, /* OEM_6 */
{0x1e, 0x41, NULL}, /* A */
{0x1f, 0x53, NULL}, /* S */
{0x20, 0x44, NULL}, /* D */
{0x21, 0x46, NULL}, /* F */
{0x22, 0x47, NULL}, /* G */
{0x23, 0x48, NULL}, /* H */
{0x24, 0x4a, NULL}, /* J */
{0x25, 0x4b, NULL}, /* K */
{0x26, 0x4c, NULL}, /* L */
{0x27, 0xba, NULL}, /* OEM_1 */
{0x28, 0xde, NULL}, /* OEM_7 */
{0x29, 0xc0, NULL}, /* OEM_3 */
{0x2b, 0xdc, NULL}, /* OEM_5 */
{0x2c, 0x5a, NULL}, /* Z */
{0x2d, 0x58, NULL}, /* X */
{0x2e, 0x43, NULL}, /* C */
{0x2f, 0x56, NULL}, /* V */
{0x30, 0x42, NULL}, /* B */
{0x31, 0x4e, NULL}, /* N */
{0x32, 0x4d, NULL}, /* M */
{0x33, 0xbc, NULL}, /* OEM_COMMA */
{0x34, 0xbe, NULL}, /* OEM_PERIOD */
{0x35, 0xbf, NULL}, /* OEM_2 */
{0x56, 0xe2, NULL}, /* OEM_102 */
{0x73, 0xc1, NULL}, /* ABNT_C1 */
{0x7e, 0xc2, NULL}, /* ABNT_C2 */
// extended scancodes
// The comment is only as a comment for aE0VscToVk[] entries
// in the output .C file
{0xE010, VK_MEDIA_PREV_TRACK, "Speedracer: Previous Track" },
{0xE019, VK_MEDIA_NEXT_TRACK, "Speedracer: Next Track" },
{0xE01D, VK_RCONTROL , "RControl" },
{0xE020, VK_VOLUME_MUTE , "Speedracer: Volume Mute" },
{0xE021, VK_LAUNCH_APP2 , "Speedracer: Launch App 2" },
{0xE022, VK_MEDIA_PLAY_PAUSE, "Speedracer: Media Play/Pause" },
{0xE024, VK_MEDIA_STOP , "Speedracer: Media Stop" },
{0xE02E, VK_VOLUME_DOWN , "Speedracer: Volume Down" },
{0xE030, VK_VOLUME_UP , "Speedracer: Volume Up" },
{0xE032, VK_BROWSER_HOME , "Speedracer: Browser Home" },
{0xE035, VK_DIVIDE , "Numpad Divide" },
{0xE037, VK_SNAPSHOT , "Snapshot" },
{0xE038, VK_RMENU , "RMenu" },
{0xE047, VK_HOME , "Home" },
{0xE048, VK_UP , "Up" },
{0xE049, VK_PRIOR , "Prior" },
{0xE04B, VK_LEFT , "Left" },
{0xE04D, VK_RIGHT , "Right" },
{0xE04F, VK_END , "End" },
{0xE050, VK_DOWN , "Down" },
{0xE051, VK_NEXT , "Next" },
{0xE052, VK_INSERT , "Insert" },
{0xE053, VK_DELETE , "Delete" },
{0xE05B, VK_LWIN , "Left Win" },
{0xE05C, VK_RWIN , "Right Win" },
{0xE05D, VK_APPS , "Application" },
// reserved (VKey == 0xff)
{0xE05E, 0xff , "Power" },
{0xE05F, VK_SLEEP , "Speedracer: Sleep" },
{0xE060, 0xff , "BAD SCANCODE" }, // break would be 0xE0
{0xE061, 0xff , "BAD SCANCODE" }, // break would be 0xE1
// available for adding extended scancodes (VKey == 0x00)
{0xE065, VK_BROWSER_SEARCH , "Speedracer: Browser Search" },
{0xE066, VK_BROWSER_FAVORITES , "Speedracer: Browser Favorites" },
{0xE067, VK_BROWSER_REFRESH , "Speedracer: Browser Refresh" },
{0xE068, VK_BROWSER_STOP , "Speedracer: Browser Stop" },
{0xE069, VK_BROWSER_FORWARD , "Speedracer: Browser Forward" },
{0xE06A, VK_BROWSER_BACK , "Speedracer: Browser Back" },
{0xE06B, VK_LAUNCH_APP1 , "Speedracer: Launch App 1" },
{0xE06C, VK_LAUNCH_MAIL , "Speedracer: Launch Mail" },
{0xE06D, VK_LAUNCH_MEDIA_SELECT, "Speedracer: Launch Media Selector"},
// These come near the end for VkKeyScan...
{0x53, VK_DECIMAL, NULL }, /* Numpad Decimal */
{0x0e, VK_BACK, NULL }, /* Backspace */
{0x01, VK_ESCAPE, NULL }, /* Escape */
{0xE01C, VK_RETURN, "Numpad Enter" },
{0x1c, VK_RETURN, NULL }, /* Enter */
{0x39, VK_SPACE, NULL }, /* Space */
{0xE046, VK_CANCEL, "Break (Ctrl + Pause)" },
// ...but the 0xffff entries (for new scancodes) must come last
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
{0xffff, 0x00, NULL },
};
#define NUMSCVK ( sizeof(ScVk) / sizeof(SC_VK) )
typedef struct {
UINT Vk;
char *pszModBits;
} MODIFIERS, *PMODIFIERS;
MODIFIERS Modifiers[] = {
{ VK_SHIFT, "KBDSHIFT" },
{ VK_CONTROL, "KBDCTRL" },
{ VK_MENU, "KBDALT" },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL },
{ 0, NULL }
};
char* StateLabel[] = {
"", /* 0 */
"Shift", /* 1 */
" Ctrl", /* 2 */
"S+Ctrl", /* 3 */
" Alt", /* 4:not used */
"Shift+Alt", /* 5:not used */
" Ctl+Alt", /* 6 */
"S+Ctl+Alt", /* 7 */
" X1 ", /* 8 */
"S+ X1 ", /* 9 */
" C+ X1 ", /* 10 */
"S+C+ X1 ", /* 11 */
" A+X1 ", /* 12 */
"S+ A+X1 ", /* 13 */
" C+A+X1 ", /* 14 */
"S+C+A+X1 ", /* 15 */
" X2", /* 16 */
"S+ X2", /* 17 */
" C+ X2", /* 18 */
"S+C+ X2", /* 19 */
" A+ X2", /* 20 */
"S+ A+ X2", /* 21 */
" C+A+ X2", /* 22 */
"S+C+A+ X2", /* 23 */
" X1+X2", /* 24 */
"S+ X1+X2", /* 25 */
" C+ X1+X2", /* 26 */
"S+C+ X1+X2", /* 27 */
" A+X1+X2", /* 28 */
"S+ A+X1+X2", /* 29 */
" C+A+X1+X2", /* 30 */
"S+C+A+X1+X2", /* 31 */
" X3", /* 32 */
"S+ X3", /* 33 */
" C+ X3", /* 34 */
"S+C+ X3", /* 35 */
" A+ X3", /* 36 */
"S+ A+ X3", /* 37 */
" C+A+ X3", /* 38 */
"S+C+A+ X3", /* 39 */
" X1+ X3", /* 40 */
"S+ X1+ X3", /* 41 */
" C+ X1+ X3", /* 42 */
"S+C+ X1+ X3", /* 43 */
" A+X1+ X3", /* 44 */
"S+ A+X1+ X3", /* 45 */
" C+A+X1+ X3", /* 46 */
"S+C+A+X1+ X3", /* 47 */
" X2+X3", /* 48 */
"S+ X2+X3", /* 49 */
" C+ X2+X3", /* 50 */
"S+C+ X2+X3", /* 51 */
" A+ X2+X3", /* 52 */
"S+ A+ X2+X3", /* 53 */
" C+A+ X2+X3", /* 54 */
"S+C+A+ X2+X3", /* 55 */
" X1+X2+X3", /* 56 */
"S+ X1+X2+X3", /* 57 */
" C+ X1+X2+X3", /* 58 */
"S+C+ X1+X2+X3", /* 59 */
" A+X1+X2+X3", /* 60 */
"S+ A+X1+X2+X3", /* 61 */
" C+A+X1+X2+X3", /* 62 */
"S+C+A+X1+X2+X3", /* 63 */
"unexpected", /* 64 */
"unexpected", /* 65 */
};
/*************************************************************\
* forward declarations *
\*************************************************************/
BOOL NextLine(char *Buf, DWORD cchBuf, FILE *fIn);
int SkipLines(void);
int isKeyWord(char *s);
int getVKNum(char *pVK);
char *getVKName(int VK, BOOL prefixVK_);
int doKBD();
int doMODIFIERS();
int doSHIFTSTATE(int *nState, int aiState[]);
int doATTRIBUTES(char *szAttrs);
int doLAYOUT(KEYLAYOUT Layout[], int aiState[], int nState);
int doDEADKEY(PDEADKEY *ppDeadKey);
int doLIGATURE(PLIGATURE *ppLigature);
int doKEYNAME(PKEYNAME *ppKeyName);
int kbd_h(KEYLAYOUT Layout[]);
int kbd_rc(void);
int kbd_def(void);
char *WChName(int WC, int Zero);
VOID __cdecl Error(const char *Text, ... );
ULONG __cdecl Warning(int nLine, const char *Text, ... );
VOID DumpLayoutEntry(PKEYLAYOUT pLayout);
BOOL MergeState(KEYLAYOUT[], int Vk, WCHAR, WCHAR, WCHAR, int aiState[], int nState);
int kbd_c(int nState,
int aiState[],
char * szAttrs,
KEYLAYOUT Layout[],
PDEADKEY pDeadKey,
PLIGATURE pLigature,
PKEYNAME pKeyName,
PKEYNAME pKeyNameExt,
PKEYNAME pKeyNameDead);
void PrintNameTable(FILE *pOut, PKEYNAME pKN, BOOL bDead);
/*************************************************************\
* Global variables
\*************************************************************/
BOOL verbose = FALSE;
BOOL fallback_driver = FALSE;
BOOL sanity_check = FALSE;
FILE *gfpInput;
char gBuf[LINEBUFSIZE];
int gLineCount;
LPSTR gpszFileName;
char gVKeyName[WORDBUFSIZE];
char gKBDName[MAXKBDNAME];
char gDescription[LINEBUFSIZE];
int gID = 0;
char gCharName[WORDBUFSIZE];
struct tm *Now;
time_t Clock;
void usage()
{
fprintf(stderr, "Usage: KbdTool [-v] [-k] file\n");
fprintf(stderr, "\t[-?] display this message\n");
fprintf(stderr, "\t[-v] verbose diagnostics/warnings\n");
fprintf(stderr, "\t[-k] builds kbd layout for embedding in the kernel\n");
fprintf(stderr, "\t[-W] performs sanity check\n");
exit(EXIT_FAILURE);
}
/*************************************************************\
* Main
\*************************************************************/
int _cdecl main(int argc, char** argv)
{
int c;
int i;
int nKW[NUMKEYWORD]; /* keep track of KeyWord read to prevent duplicates */
int iKW;
int nState; /* number of states */
int aiState[MAXSTATES];
char szAttrs[128] = "\0";
int nTotal = 0;
int nFailH = 0;
int nFailC = 0;
int nFailRC = 0;
int nFailDEF = 0;
KEYLAYOUT Layout[NUMSCVK];
PDEADKEY pDeadKey = NULL;
PLIGATURE pLigature = NULL;
PKEYNAME pKeyName = NULL;
PKEYNAME pKeyNameExt = NULL;
PKEYNAME pKeyNameDead = NULL;
printf("\nKbdTool v%d.%02d - convert keyboard text file to C file\n\n",
gVersion, gSubVersion);
while ((c = getopt(argc, argv, "vkW?")) != EOF) {
switch (c) {
case 'v':
verbose = TRUE;
break;
case 'k': // means 'kernel'
fallback_driver = TRUE;
break;
case 'W': // Turn on warning
sanity_check = TRUE;
break;
case '?':
default:
usage();
// never reaches here
}
}
if (optind == argc) {
usage();
// never reaches here
}
argv = argv + optind;
while (*argv) {
nTotal++;
gpszFileName = *argv;
if ((gfpInput = fopen(*argv, "rt")) == NULL) {
Error("can't open for read\n");
nFailH++;
nFailC++;
nFailRC++;
nFailDEF++;
argv++;
continue;
}
printf("%-23s:\n", *argv);
/* initialize for each input file */
for (i = 0; i < NUMKEYWORD; i++) {
nKW[i]=0;
}
gLineCount = 0;
/**********************************/
if ((iKW = SkipLines()) >= NUMKEYWORD) {
fclose(gfpInput);
Error("no keyword found\n");
nFailH++;
nFailC++;
nFailRC++;
nFailDEF++;
continue;
}
while (iKW < NUMKEYWORD - 1) {
nKW[iKW]++;
if (iKW != DEADKEYCODE && nKW[iKW] > 1 && verbose) {
Warning(0, "duplicate %s", KeyWord[iKW]);
}
switch (iKW) {
case KEYWORD_KBD:
iKW = doKBD();
break;
case KEYWORD_VERSION: // ignored for now
iKW = SkipLines();
break;
case KEYWORD_MODIFIERS:
iKW = doMODIFIERS();
break;
case KEYWORD_SHIFTSTATE:
iKW = doSHIFTSTATE(&nState, aiState);
if (nState < 2) {
fclose(gfpInput);
Error("must have at least 2 states\n");
nFailH++;
nFailC++;
continue;
}
break;
case KEYWORD_ATTRIBUTES:
iKW = doATTRIBUTES(szAttrs);
break;
case KEYWORD_LAYOUT:
if ((iKW = doLAYOUT(Layout, aiState, nState)) == -1) {
fclose(gfpInput);
return EXIT_FAILURE;
}
/* add layout checking later */
break;
case KEYWORD_DEADKEY:
if ((iKW = doDEADKEY(&pDeadKey)) == -1) {
fclose(gfpInput);
return EXIT_FAILURE;
}
break;
case KEYWORD_LIGATURE:
if ((iKW = doLIGATURE(&pLigature)) == -1) {
fclose(gfpInput);
return EXIT_FAILURE;
}
break;
case KEYWORD_KEYNAME:
if ((iKW = doKEYNAME(&pKeyName)) == -1) {
fclose(gfpInput);
return EXIT_FAILURE;
}
break;
case KEYWORD_KEYNAME_EXT:
if ((iKW = doKEYNAME(&pKeyNameExt)) == -1) {
fclose(gfpInput);
return EXIT_FAILURE;
}
break;
case KEYWORD_KEYNAME_DEAD:
if ((iKW = doKEYNAME(&pKeyNameDead)) == -1) {
fclose(gfpInput);
return EXIT_FAILURE;
}
break;
default:
break;
}
}
fclose(gfpInput);
/* add later : checking for LAYOUT & DEADKEY */
time(&Clock);
Now = localtime(&Clock);
if (!fallback_driver && kbd_h(Layout) == FAILURE) {
nFailH++;
}
if (!fallback_driver && kbd_rc() != SUCCESS) {
nFailRC++;
}
if (kbd_c(nState, aiState, szAttrs, Layout,
pDeadKey, pLigature, pKeyName, pKeyNameExt, pKeyNameDead) == FAILURE) {
nFailC++;
}
if (!fallback_driver && kbd_def() != SUCCESS) {
nFailDEF++;
}
printf("\n");
argv++;
}
printf("\n %13d ->% 12d %12d %12d %12d\n",
nTotal, nTotal - nFailH, nTotal - nFailRC,
nTotal - nFailC, nTotal - nFailDEF);
return EXIT_SUCCESS;
}
/*************************************************************\
* Check keyword
* Return: 0 - 8 for valid keyword
* 9 for invalid keyword
\*************************************************************/
int isKeyWord(char *s)
{
int i;
for(i = 0; i < NUMKEYWORD; i++)
{
if(_strcmpi(KeyWord[i], s) == 0)
{
return i;
}
}
return NOT_KEYWORD;
}
/*************************************************************\
* Skip lines till a valid keyword is available
* Return: 0 - 8 for valid keyword
* 9 for invalid keyword
\*************************************************************/
int SkipLines()
{
int iKW;
char KW[WORDBUFSIZE];
while (NextLine(gBuf, LINEBUFSIZE, gfpInput))
{
if(sscanf(gBuf, "%s", KW) == 1)
{
if((iKW = isKeyWord(KW)) < NUMKEYWORD)
{
return iKW;
}
}
}
return NUMKEYWORD;
}
/*************************************************************\
* Convert Virtual Key name to integer
* Return : -1 if fail
\*************************************************************/
int getVKNum(char *pVK)
{
int i, len;
len = strlen(pVK);
if (len < 1) {
return -1;
}
if (len == 1) {
if (*pVK >= '0' && *pVK <= '9') {
return *pVK;
}
*pVK = (char)toupper(*pVK);
if (*pVK >= 'A' && *pVK <='Z') {
return *pVK;
}
} else {
for (i = 0; i < NUMVKNAME; i++) {
if(_strcmpi(VKName[i].pName, pVK) == 0) {
return VKName[i].VKey;
}
}
/*
* Hey! It's unknown! Perhaps it is a new one, in which
* case it must be of the form 0xNN
*/
if (pVK[0] == '0' &&
(pVK[1] == 'x' || pVK[1] == 'X')) {
pVK[1] = 'x';
if (sscanf(pVK, "0x%x", &i) == 1) {
return i;
}
}
}
return -1;
}
/*************************************************************\
* Convert VK integer to name and store it in gVKeyName
\*************************************************************/
char *getVKName(int VK, BOOL prefixVK_)
{
int i;
char *s;
s = gVKeyName;
if((VK >= 'A' && VK <= 'Z') || (VK >= '0' && VK <= '9'))
{
*s++ = '\'';
*s++ = (char)VK;
*s++ = '\'';
*s = '\0';
return gVKeyName;
}
if(prefixVK_)
{
strcpy(gVKeyName, "VK_");
}
else
{
strcpy(gVKeyName, "");
}
for(i = 0; i < NUMVKNAME; i++)
{
if(VKName[i].VKey == VK)
{
strcat(s, VKName[i].pName);
return gVKeyName;
}
}
strcpy(gVKeyName, "#ERROR#");
return gVKeyName;
}
/*************************************************************\
* KBD section
* read in gKBDName and gDescription if any
* Return : next keyword
\*************************************************************/
int doKBD()
{
char *p;
*gKBDName = '\0';
*gDescription = '\0';
if (sscanf(gBuf, "KBD %5s \"%40[^\"]\" %d", gKBDName, gDescription, &gID) < 2)
{
// if (sscanf(gBuf, "KBD %5s ;%40[^\n]", gKBDName, gDescription) < 2)
// {
Error("unrecognized keyword");
// }
}
return (SkipLines());
}
/****************************************************************************\
* MODIFIERS section [OPTIONAL]
* Additions to the standard MODIFIERS CharModifiers section.
* Useful now for adding RCONTROL shiftstates (eg: CAN/CSA prototype)
* Useful in future for KBDGRPSELTAP keys that flip the kbd into an alternate
* layout until the next character is produced (then reverts to main layout).
*
* Example of syntax is
* MODIFIERS
* RCONTROL 8
* RSHIFT KBDGRPSELTAP
* I hope to be able to extend this to allow key combos as KBDGRPSELTAP, since
* the CAN/CSA keyboard may want to have RShift+AltGr flip into the alternate
* layout (group 2 character set) in addition to just RCtrl, since some terminal
* emulators use the RCtrl key as an "Enter" key.
\****************************************************************************/
int doMODIFIERS()
{
int i = 3;
int iKW = NOT_KEYWORD;
char achModifier[WORDBUFSIZE];
char achModBits[LINEBUFSIZE];
while(NextLine(gBuf, LINEBUFSIZE, gfpInput)) {
if (sscanf(gBuf, "%s", achModifier) != 1) {
continue;
}
if ((iKW = isKeyWord(achModifier)) < NUMKEYWORD) {
break;
}
if (sscanf(gBuf, " %s %[^;\n]", achModifier, achModBits) < 2) {
Warning(0, "poorly formed MODIFIER entry");
break;
}
Modifiers[i].Vk = getVKNum(achModifier);
Modifiers[i].pszModBits = _strdup(achModBits); // never freed!
if (++i > (sizeof(Modifiers)/sizeof(Modifiers[0]))) {
Warning(0, "Too many MODIFIER entries");
break;
}
}
return iKW;
}
/*************************************************************\
* SHIFTSTATE section
* read number of states and each state
* return : next keyword
\*************************************************************/
int doSHIFTSTATE(int *nState, int* aiState)
{
int i;
int iKW;
int iSt;
char Tmp[WORDBUFSIZE];
for(i = 0; i < MAXSTATES; i++)
{
aiState[i] = -1;
}
*nState = 0;
while(NextLine(gBuf, LINEBUFSIZE, gfpInput))
{
if(sscanf(gBuf, "%s", Tmp) != 1)
{
continue;
}
if((iKW = isKeyWord(Tmp)) < NUMKEYWORD)
{
break;
}
if(sscanf(gBuf, " %2s[012367]", Tmp) != 1)
{
if (verbose) {
Warning(0, "invalid state");
}
continue; /* add printf error later */
}
iSt = atoi(Tmp);
for (i = 0; i < *nState; i++) {
if (aiState[i] == iSt && verbose) {
Warning(0, "duplicate state %d", iSt);
break;
}
}
if (*nState < MAXSTATES) {
aiState[(*nState)++] = iSt;
} else {
if (verbose) {
Warning(0, "too many states %d", *nState);
}
}
}
return iKW;
}
/****************************************************************************\
* ATTRIBUTES section [OPTIONAL]
*
* Example of syntax is
* ATTRIBUTES
* LRM_RLM
* SHIFTLOCK
* ALTGR
*
* These convert to
* KLLF_LRM_RLM (layout generates LRM/RLM 200E/200F with L/RShift+BackSpace)
* KLLF_SHIFTLOCK (Capslock only turns CapsLock on, Shift turns it off)
* KLLF_ALTGR (this is normally inferred by number of states > 5)
*
\****************************************************************************/
char *Attribute[] = {
"LRM_RLM" ,
"SHIFTLOCK",
"ALTGR"
};
#define NUMATTR (sizeof(Attribute) / sizeof(Attribute[0]))
/*
* Returns next key word encountered, and places in szAttr:
* empty string ("") or
* something like "KLLF_SHIFTLOCK" or "KLLF_SHIFTLOCK | KLLF_LRM_RLM"
*/
int doATTRIBUTES(char *szAttrs)
{
int iKW = NOT_KEYWORD;
int i;
char achAttribute[WORDBUFSIZE];
szAttrs[0] = '\0';
while (NextLine(gBuf, LINEBUFSIZE, gfpInput)) {
if (sscanf(gBuf, "%s", achAttribute) != 1) {
continue;
}
if ((iKW = isKeyWord(achAttribute)) < NUMKEYWORD) {
break;
}
for (i = 0; i < NUMATTR; i++) {
if (_strcmpi(Attribute[i], achAttribute) == 0) {
if (szAttrs[0] != '\0') {
strcat(szAttrs, " | ");
}
strcat(szAttrs, "KLLF_");
strcat(szAttrs, Attribute[i]);
}
}
if (szAttrs[0] == '\0') {
Warning(0, "poorly formed ATTRIBUTES entry");
break;
}
}
return iKW;
}
/**********************************************************************\
* GetCharacter
* Scans the string in p to return a character value and type
* syntax in p is:
* xxxx four hex digits, may be followed by a @ or %
* eg: 00e8, 00AF@, aaaa%
* c a character, may be followed with @ or %
* eg: x, ^@, %%
* -1 not a character
*
* return : character value (0xFFFF if badly formed)
* type of character in pdwType
* 0 plain char (ends with neither @ nor %)
* CHARTYPE_DEAD dead char (ends with @)
* CHARTYPE_LIG ligature (ends with %)
* CHARTYPE_BAD badly formed character value, exit.
*
\**********************************************************************/
#define CHARTYPE_DEAD 1
#define CHARTYPE_LIG 2
#define CHARTYPE_BAD 3
WCHAR GetCharacter(unsigned char *p, DWORD *pdwType)
{
int Len;
DWORD dwCh;
*pdwType = 0;
// if the last char is @ or % it is dead or ligature
if (Len = strlen(p) - 1) {
if (*(p + Len) == '@') {
*pdwType = CHARTYPE_DEAD;
} else if (*(p + Len) == '%') {
*pdwType = CHARTYPE_LIG;
}
}
if (Len < 2) {
return *p;
} else if (sscanf(p, "%4x", &dwCh) != 1) {
if (verbose) {
Warning(0, "LAYOUT error %s", p);
}
*pdwType = CHARTYPE_BAD;
return 0;
} else {
return (WCHAR)dwCh;
}
}
int WToUpper(int wch)
{
WCHAR src[1] = { (WCHAR)wch };
WCHAR result[1];
if (LCMapStringW(0, LCMAP_UPPERCASE, src, 1, result, 1) == 0) {
return L'\0';
}
return result[0];
}
/*************************************************************\
* LAYOUT section
* return : next keyword
* -1 if memory problem
\*************************************************************/
int doLAYOUT(KEYLAYOUT Layout[], int aiState[], int nState)
{
int i, idx, iCtrlState;
BOOL fHasCharacters;
int iKW;
int Len;
USHORT Scan;
DWORD WChr;
char Cap[MAXWCLENGTH];
unsigned char WC[MAXSTATES][MAXWCLENGTH];
char Tmp[WORDBUFSIZE];
int i1, i2;
int iScVk;
memset(Layout, 0, NUMSCVK * sizeof(KEYLAYOUT));
// Initialize layout entries
for (idx = 0; idx < NUMSCVK; idx++) {
Layout[idx].defined = FALSE;
Layout[idx].nState = 0;
}
/*
* Accumulate layout entries in the order they are read
*/
idx = -1;
while (NextLine(gBuf, LINEBUFSIZE, gfpInput)) {
if (sscanf(gBuf, " %s", Tmp) != 1 || *Tmp == ';') {
continue;
}
if ((iKW = isKeyWord(Tmp)) < NUMKEYWORD) {
break;
}
i = sscanf(gBuf, " %x %s %s", &Scan, Tmp, Cap);
if (i == 3) {
fHasCharacters = TRUE;
} else if (i == 2) {
fHasCharacters = FALSE;
} else {
Error("not enough entries on line");
return -1;
}
/*
* We have found an Entry
*/
idx++;
if (idx >= NUMSCVK) {
Error("ScanCode %02x - too many scancodes", Scan);
return -1;
}
Layout[idx].Scan = Scan;
Layout[idx].nLine = gLineCount;
/*
* Find and use the Default values for this Scan
*/
for (iScVk = 0; iScVk < NUMSCVK; iScVk++) {
if (ScVk[iScVk].Scan == 0xffff) {
// We didn't find a match (the 0xffff entries come last)
Warning(0, "defining new scancode 0x%2X, %s", Scan, Tmp);
Layout[idx].VKey = (unsigned char)getVKNum(Tmp);
Layout[idx].defined = TRUE;
ScVk[iScVk].bUsed = TRUE;
break;
}
if (Scan == ScVk[iScVk].Scan) {
if (ScVk[iScVk].bUsed == TRUE) {
Error("Scancode %X was previously defined", Scan);
return -1;
}
if (ScVk[iScVk].VKey == 0xff) {
Error("Scancode %X is reserved", Scan);
return -1;
}
// Save the default VK for generating kbd*.h
Layout[idx].VKeyDefault = ScVk[iScVk].VKey;
Layout[idx].VKeyName = ScVk[iScVk].VKeyName;
Layout[idx].defined = TRUE;
ScVk[iScVk].bUsed = TRUE;
break;
}
}
iScVk = 0xFFFF; // finished with iScVk for now
if ((Layout[idx].VKey = (unsigned char)getVKNum(Tmp)) == -1) {
if (verbose) {
Warning(0, "invalid VK %s", Tmp);
}
continue;
}
if (fHasCharacters) {
if(_strcmpi(Cap, "SGCAP") == 0) {
*Cap = '2';
}
if(sscanf(Cap, "%1d[012]", &(Layout[idx].Cap)) != 1) {
Error("invalid Cap %s", Cap);
return -1;
}
}
if ((Layout[idx].nState = sscanf(gBuf,
" %*s %*s %*s %s %s %s %s %s %s %s %s",
WC[0], WC[1], WC[2], WC[3], WC[4], WC[5], WC[6], WC[7])) < 2)
{
if (fHasCharacters) {
Error("must have at least 2 characters");
return -1;
}
}
for (i = 0; i < Layout[idx].nState; i++) {
DWORD dwCharType;
if (_strcmpi(WC[i], "-1") == 0) {
Layout[idx].WCh[i] = -1;
continue;
}
Layout[idx].WCh[i] = GetCharacter(WC[i], &dwCharType);
if (dwCharType == CHARTYPE_DEAD) {
Layout[idx].DKy[i] = 1;
} else if (dwCharType == CHARTYPE_LIG) {
Layout[idx].LKy[i] = 1;
} else if (dwCharType == CHARTYPE_BAD) {
break;
}
}
if (sanity_check && Layout[idx].nState > 0) {
int nAltGr, nShiftAltGr;
/*
* Check that characters a-z and A-Z are on VK_A - VK_Z
* N.b. maybe overactive warnings for the intl layouts.
*/
if (((Layout[idx].WCh[0] >= 'a') && (Layout[idx].WCh[0] <= 'z')) ||
((Layout[idx].WCh[1] >= 'A') && (Layout[idx].WCh[1] <= 'Z'))) {
if ((Layout[idx].VKey != _toupper(Layout[idx].WCh[0])) && (Layout[idx].VKey != Layout[idx].WCh[1])) {
Warning(0, "VK_%s (0x%2x) does not match %c %c",
Tmp, Layout[idx].VKey, Layout[idx].WCh[0], Layout[idx].WCh[1]);
}
}
/*
* Check that CAPLOKALTGR is set appropriately
*/
nAltGr = 0;
nShiftAltGr = 0;
for (i = 0; i < nState; i++) {
if (aiState[i] == (KBDCTRL | KBDALT)) {
nAltGr = i;
} else if (aiState[i] == (KBDCTRL | KBDALT | KBDSHIFT)) {
nShiftAltGr = i;
}
}
/*
* Check only if nShiftAltGr has a valid character; i.e. not zero, nor a dead key.
*/
if (nAltGr && nShiftAltGr && Layout[idx].WCh[nShiftAltGr] && Layout[idx].WCh[nShiftAltGr] != -1) {
if (Layout[idx].WCh[nShiftAltGr] != WToUpper(Layout[idx].WCh[nAltGr])) {
if (Layout[idx].Cap & CAPLOKALTGR) {
Warning(0, "VK_%s (0x%2x) [Shift]AltGr = [%2x],%2x should not be CAPLOKALTGR?",
Tmp, Layout[idx].VKey,
Layout[idx].WCh[nAltGr], Layout[idx].WCh[nShiftAltGr]);
}
} else if (Layout[idx].WCh[nShiftAltGr] != Layout[idx].WCh[nAltGr]) {
/*
* If the character is completely same, no need for CAPLOKALTGR.
*/
if ((Layout[idx].Cap & CAPLOKALTGR) == 0) {
Warning(0, "VK_%s (0x%2x) [Shift]AltGr = [%2x],%2x should be CAPLOKALTGR?",
Tmp, Layout[idx].VKey,
Layout[idx].WCh[nAltGr], Layout[idx].WCh[nShiftAltGr]);
}
}
}
}
/* SGCAP: read the next line */
if (Layout[idx].Cap & 0x02) {
if((Layout[idx].pSGCAP = malloc( sizeof(KEYLAYOUT) )) == NULL)
{
Error("can't allocate SGCAP struct");
return -1;
}
memset(Layout[idx].pSGCAP, 0, sizeof(KEYLAYOUT));
if (NextLine(gBuf, LINEBUFSIZE, gfpInput) &&
(Layout[idx].pSGCAP->nState = sscanf(gBuf, " -1 -1 0 %s %s %s %s %s %s %s %s",
WC[0], WC[1], WC[2], WC[3], WC[4], WC[5], WC[6], WC[7])) != 0) {
// DumpLayoutEntry(&Layout[idx]);
for (i = 0; i < Layout[idx].pSGCAP->nState; i++) {
if (_strcmpi(WC[i], "-1") == 0) {
Layout[idx].pSGCAP->WCh[i] = -1;
continue;
}
if ((Len = strlen(WC[i]) - 1) > 0 && *WC[i + Len] == '@') {
Layout[idx].pSGCAP->DKy[i] = 1; /* it is a dead key */
}
if (Len == 0) {
Layout[idx].pSGCAP->WCh[i] = *WC[i];
} else {
if (sscanf(WC[i], "%4x", &WChr) != 1) {
if (verbose) {
Warning(0, "SGCAP LAYOUT error %s", WC[i]);
}
continue;
} else {
Layout[idx].pSGCAP->WCh[i] = WChr;
}
}
}
} else {
Error("invalid SGCAP");
}
}
// DumpLayoutEntry(&Layout[idx]);
}
/*
* Pick up any unused ScVk[] entries (defaults)
*/
for (iScVk = 0; iScVk < NUMSCVK; iScVk++) {
// if we reach 0xffff, we have come to the end.
if (ScVk[iScVk].Scan == 0xffff) {
break;
}
if (!ScVk[iScVk].bUsed) {
idx++;
if (idx >= NUMSCVK) {
Error("ScanCode %02x - too many scancodes", ScVk[iScVk].Scan);
return -1;
}
Layout[idx].Scan = ScVk[iScVk].Scan;
Layout[idx].VKey = ScVk[iScVk].VKey;
Layout[idx].VKeyDefault = ScVk[iScVk].VKey;
Layout[idx].VKeyName = ScVk[iScVk].VKeyName;
Layout[idx].defined = TRUE;
Layout[idx].nLine = 0;
// DumpLayoutEntry(&Layout[idx]);
} else {
ScVk[iScVk].bUsed = FALSE;
}
}
/*
* Now make sure some standard Ctrl characters are present
*/
MergeState(Layout, VK_BACK, L'\b', L'\b', 0x007f, aiState, nState);
MergeState(Layout, VK_CANCEL, 0x0003, 0x0003, 0x0003, aiState, nState);
MergeState(Layout, VK_ESCAPE, 0x001b, 0x001b, 0x001b, aiState, nState);
MergeState(Layout, VK_RETURN, L'\r', L'\r', L'\n', aiState, nState);
MergeState(Layout, VK_SPACE, L' ', L' ', L' ', aiState, nState);
/*
* Check VK not duplicated
*/
for (idx = 0; idx < NUMSCVK; idx++) {
for (i = idx + 1; i < NUMSCVK; i++) {
if (Layout[idx].VKey == Layout[i].VKey) {
if (Layout[idx].VKey == 0xFF) {
// undefined extended and non-extended versions of the same key
continue;
}
if ((BYTE)Layout[idx].Scan == (BYTE)Layout[i].Scan) {
// extended and non-extended versions of the same key
continue;
}
Error("VK_%s (%02x) found at scancode %02x and %02x",
getVKName(Layout[idx].VKey, 0), Layout[idx].VKey, Layout[idx].Scan, Layout[i].Scan);
}
}
}
/*
* Find duplicated characters and warn of VkKeyScanEx results
*/
if (verbose) {
for (i1 = 0; i1 < NUMSCVK; i1++) {
for (i2 = i1 + 1; i2 < NUMSCVK; i2++) {
int ich1, ich2;
for (ich1 = 0; ich1 < Layout[i1].nState; ich1++) {
if (Layout[i1].WCh[ich1] == -1) {
// there may be many WCH_NONEs (padding, or empty holes)
continue;
}
if (Layout[i1].WCh[ich1] < 0x20) {
// Don't care about Ctrl chars.
// these are usually duplicated eg: Ctrl-M == Return, etc.
continue;
}
if ((Layout[i1].VKey == VK_DECIMAL) || (Layout[i2].VKey == VK_DECIMAL)) {
// kbdtool has put VK_DECIMAL at the end just for VkKeyScanEx
// It is usually period or comma, and we prefer to get those
// from the main section of the keyboard.
continue;
}
for (ich2 = 0; ich2 < Layout[i2].nState; ich2++) {
if (Layout[i1].WCh[ich1] == Layout[i2].WCh[ich2]) {
char achVK1[40];
char achVK2[40];
strncpy(achVK1, getVKName(Layout[i1].VKey, TRUE), sizeof(achVK1));
strncpy(achVK2, getVKName(Layout[i2].VKey, TRUE), sizeof(achVK2));
Warning(Layout[i1].nLine,
"%04x is on %s and %s",
Layout[i1].WCh[ich1],
achVK1, achVK2);
}
}
}
}
}
}
return iKW;
}
/*************************************************************\
* DEADKEY section
* return : next keyword
* -1 if memory problem
\*************************************************************/
int doDEADKEY(PDEADKEY *ppDeadKey)
{
char Tmp[WORDBUFSIZE];
int iKW;
DEADKEY *pDeadKey;
PDEADTRANS pDeadTrans;
PDEADTRANS *ppDeadTrans;
DWORD dw;
static PDEADKEY pLastDeadKey;
int iLen;
DWORD dwCharType;
if (sscanf(gBuf, " DEADKEY %s", Tmp) != 1) {
Warning(0, "missing dead key");
return SkipLines();
}
/* add later : check if dw is in Layout*/
if((pDeadKey = (DEADKEY*) malloc( sizeof(DEADKEY) )) == NULL)
{
Error("can't allocate DEADKEY struct");
return -1;
}
pDeadKey->Dead = GetCharacter(Tmp, &dwCharType);
if (dwCharType != 0) {
Error("DEADKEY character value badly formed");
return -1;
}
pDeadKey->pNext = NULL;
pDeadKey->pDeadTrans = NULL;
/*
* Link into end of list (maintaining original order)
*/
if (*ppDeadKey) {
ppDeadKey = &(pLastDeadKey->pNext);
}
*ppDeadKey = pDeadKey;
pLastDeadKey = pDeadKey;
// ppDeadKey = &(pDeadKey->pNext);
ppDeadTrans = &(pDeadKey->pDeadTrans);
while(NextLine(gBuf, LINEBUFSIZE, gfpInput))
{
if (sscanf(gBuf, " %s", Tmp) != 1 || *Tmp == ';') {
continue;
}
if((iKW = isKeyWord(Tmp)) < NUMKEYWORD)
{
break;
}
// get base character
dw = GetCharacter(Tmp, &dwCharType);
if (dwCharType != 0) {
Error("DEADKEY %x: base character value badly formed", pDeadKey->Dead);
return -1;
}
/* add later : check dw */
if((pDeadTrans = (DEADTRANS *) malloc( sizeof(DEADTRANS) )) == NULL)
{
Error("can't allocate DEADTRANS struct");
return -1;
}
memset(pDeadTrans, 0, sizeof(DEADTRANS));
pDeadTrans->pNext = NULL;
pDeadTrans->Base = dw;
pDeadTrans->uFlags = 0;
/*
* Link to end of list (maintaining original order)
*/
*ppDeadTrans = pDeadTrans;
ppDeadTrans = &(pDeadTrans->pNext);
if (sscanf(gBuf, " %*s %s", Tmp) != 1) {
if (verbose) {
Warning(0, "missing deadtrans key");
}
continue;
}
pDeadTrans->WChar = GetCharacter(Tmp, &dwCharType);
if (dwCharType == CHARTYPE_DEAD) {
pDeadTrans->uFlags |= 0x0001; // DKF_DEAD in oak\inc\kbd.h
} else if (dwCharType != 0) {
Error("DEADKEY character value badly formed");
return -1;
}
}
return iKW;
}
static int gMaxLigature = 0;
/*************************************************************\
* LIGATURE section
* return : next keyword
* -1 if memory problem
\*************************************************************/
int doLIGATURE(PLIGATURE *ppLigature)
{
int i;
int iKW;
DWORD WChr;
char Mod[MAXWCLENGTH];
unsigned char WC[MAXLIGATURES+1][MAXWCLENGTH];
char Tmp[WORDBUFSIZE];
LIGATURE *pLigature;
static PLIGATURE pLastLigature;
while(NextLine(gBuf, LINEBUFSIZE, gfpInput))
{
if(sscanf(gBuf, " %s", Tmp) != 1 || *Tmp == ';')
{
continue;
}
if((iKW = isKeyWord(Tmp)) < NUMKEYWORD)
{
break;
}
if(sscanf(gBuf, " %s %s", Tmp, Mod) != 2)
{
if(verbose)
{
Warning(0, "invalid LIGATURE");
}
continue;
}
if((pLigature = (LIGATURE*) malloc( sizeof(LIGATURE) )) == NULL)
{
Error("can't allocate LIGATURE struct");
return -1;
}
pLigature->pNext = NULL;
if((pLigature->VKey = (unsigned char)getVKNum(Tmp)) == -1)
{
if(verbose)
{
Warning(0, "invalid VK %s", Tmp);
}
continue;
}
if(sscanf(Mod, "%1d[012367]", &(pLigature->Mod)) != 1)
{
if(verbose)
{
Warning(0, "invalid Mod %s", Mod);
}
continue;
}
/*
* We're currently limited to MAXLIGATURES characters per
* ligature. In order to support more characters per ligature,
* increase this define (in kbdx.h).
*/
if((pLigature->nCharacters = \
sscanf(gBuf, " %*s %*s %s %s %s %s %s %s", \
&WC[0], &WC[1], &WC[2], &WC[3], &WC[4], &WC[5])) < 2)
{
if(verbose)
{
Warning(0, "must have at least 2 characters");
}
continue;
}
if (pLigature->nCharacters > MAXLIGATURES)
{
if(verbose)
{
Warning(0, "exceeded maximum # of characters for ligature");
}
continue;
}
for(i = 0; i < pLigature->nCharacters; i++)
{
DWORD dwCharType;
pLigature->WCh[i] = GetCharacter(WC[i], &dwCharType);
if (dwCharType != 0) {
if(verbose) {
Warning(0, "LIGATURE error %s", WC[i]);
}
break;
}
}
/*
* Link into end of list (maintaining original order)
*/
if (*ppLigature) {
ppLigature = &(pLastLigature->pNext);
}
*ppLigature = pLigature;
pLastLigature = pLigature;
gMaxLigature = max(pLigature->nCharacters, gMaxLigature);
}
return iKW;
}
/*************************************************************\
* KEYNAME, KEYNAME_EXT, KEYNAME_DEAD sections
* return : next keyword
* -1 if memory problem
\*************************************************************/
int doKEYNAME(PKEYNAME *ppKeyName)
{
KEYNAME *pKN;
int iKW;
char Tmp[WORDBUFSIZE];
int Char;
char *p;
char *q;
*ppKeyName = NULL;
while(NextLine(gBuf, LINEBUFSIZE, gfpInput))
{
if(sscanf(gBuf, " %s", Tmp) != 1 || *Tmp == ';')
{
continue;
}
if((iKW = isKeyWord(Tmp)) < NUMKEYWORD)
{
break;
}
if(sscanf(Tmp, " %4x", &Char) != 1)
{
if(verbose)
{
Warning(0, "invalid char code");
}
continue;
}
/* add later : check Scan code */
if(sscanf(gBuf, " %*4x %s[^\n]", Tmp) != 1)
{
if(verbose)
{
Warning(0, "missing name");
}
continue;
}
p = strstr(gBuf, Tmp);
if((q = strchr(p, '\n')) != NULL)
{
*q = '\0';
}
if((pKN = (void*) malloc( sizeof(KEYNAME) )) == NULL)
{
Error("can't allocate KEYNAME struct");
return -1;
}
pKN->Code = Char;
pKN->pName = _strdup(p);
pKN->pNext = NULL;
/*
* Link to end of list (maintaining original order)
*/
*ppKeyName = pKN;
ppKeyName = &(pKN->pNext);
}
return iKW;
}
/*************************************************************\
* write kbd*.rc *
\*************************************************************/
int kbd_rc(void)
{
char OutName[FILENAMESIZE];
char kbdname[MAXKBDNAME];
FILE *pOut;
strcpy(OutName, "KBD");
strcat(OutName, gKBDName);
strcat(OutName, ".RC");
strcpy(kbdname, gKBDName);
_strlwr(kbdname);
printf(" %12s", OutName);
if((pOut = fopen(OutName, "wt")) == NULL)
{
printf(": can't open for write; ");
return FAILURE;
}
fprintf(pOut,
"#include <windows.h>\n"
"#include <ntverp.h>\n"
"\n"
"#define VER_FILETYPE VFT_DLL\n"
"#define VER_FILESUBTYPE VFT2_DRV_KEYBOARD\n" );
fprintf(pOut,
"#define VER_FILEDESCRIPTION_STR \"%s Keyboard Layout\"\n", gDescription);
fprintf(pOut,
"#define VER_INTERNALNAME_STR \"kbd%s (%d.%d)\"\n",
kbdname, gVersion, gSubVersion);
fprintf(pOut,
"#define VER_ORIGINALFILENAME_STR \"kbd%s.dll\"\n", kbdname);
fprintf(pOut,
"\n"
"#define VER_LANGNEUTRAL\n"
"#include \"common.ver\"\n");
fclose(pOut);
return SUCCESS;
}
/*************************************************************\
* write kbd*.def *
\*************************************************************/
int kbd_def(void)
{
char OutName[FILENAMESIZE];
FILE *pOut;
strcpy(OutName, "KBD");
strcat(OutName, gKBDName);
strcat(OutName, ".DEF");
printf(" %12s", OutName);
if((pOut = fopen(OutName, "wt")) == NULL)
{
printf(": can't open for write; ");
return FAILURE;
}
fprintf(pOut,
"LIBRARY KBD%s\n"
"\n"
"EXPORTS\n"
" KbdLayerDescriptor @1\n", gKBDName);
fclose(pOut);
return SUCCESS;
}
/*************************************************************\
* write kbd*.h *
\*************************************************************/
int kbd_h(KEYLAYOUT Layout[])
{
char OutName[FILENAMESIZE];
FILE *pOut;
int nDiff = 0;
int idx;
strcpy(OutName, "KBD");
strcat(OutName, gKBDName);
strcat(OutName, ".H");
printf(" %12s ", OutName);
if((pOut = fopen(OutName, "wt")) == NULL)
{
printf(": can't open for write; ");
return FAILURE;
}
fprintf(pOut,"/****************************** Module Header ******************************\\\n"
"* Module Name: %s\n*\n* keyboard layout header for %s\n"
"*\n"
"* Copyright (c) 1985-2001, Microsoft Corporation\n"
"*\n"
"* Various defines for use by keyboard input code.\n*\n* History:\n"
"*\n"
"* created by KBDTOOL v%d.%02d %s*\n"
"\\***************************************************************************/\n\n"
, OutName, gDescription, gVersion, gSubVersion, asctime(Now));
fprintf(pOut,"/*\n"
" * kbd type should be controlled by cl command-line argument\n"
" */\n"
"#define KBD_TYPE 4\n\n"
"/*\n"
"* Include the basis of all keyboard table values\n"
"*/\n"
"#include \"kbd.h\"\n"
// "#include \"strid.h\"\n" --- do this in v3.07
);
fprintf(pOut,"/***************************************************************************\\\n"
"* The table below defines the virtual keys for various keyboard types where\n"
"* the keyboard differ from the US keyboard.\n"
"*\n"
"* _EQ() : all keyboard types have the same virtual key for this scancode\n"
"* _NE() : different virtual keys for this scancode, depending on kbd type\n"
"*\n"
"* +------+ +----------+----------+----------+----------+----------+----------+\n"
"* | Scan | | kbd | kbd | kbd | kbd | kbd | kbd |\n"
"* | code | | type 1 | type 2 | type 3 | type 4 | type 5 | type 6 |\n"
"\\****+-------+_+----------+----------+----------+----------+----------+----------+*/\n\n");
for (idx = 0; idx < NUMSCVK; idx++) {
if (Layout[idx].defined && (Layout[idx].VKey != Layout[idx].VKeyDefault))
{
char ch;
switch (Layout[idx].Scan & 0xFF00) {
case 0xE100:
ch = 'Y';
break;
case 0xE000:
ch = 'X';
break;
case 0x0000:
ch = 'T';
break;
default:
Error("Weird scancode value %04x: expected xx, E0xx or E1xx",
(Layout[idx].Scan & 0xFF00));
return FAILURE;
}
fprintf(pOut,
"#undef %c%02X\n"
"#define %c%02X _EQ(%43s%23s\n",
ch, LOBYTE(Layout[idx].Scan),
ch, LOBYTE(Layout[idx].Scan), getVKName(Layout[idx].VKey, 0), ")");
}
}
fprintf(pOut,"\n");
fclose(pOut);
return SUCCESS;
}
/*************************************************************\
* Convert a Unicode value to a text string
* Zero = 0 : return 'A'; 0x????
* 1 : return A ; \x????
* return : ptr to gCharName where result is stored
\*************************************************************/
char *WChName(int WC, int Zero)
{
char *s;
if(WC == -1)
{
strcpy(gCharName, "WCH_NONE");
}
else if(WC > 0x1F && WC < 0x7F)
{
s = gCharName;
if(Zero == 0)
{
*s++ = '\'';
}
if(WC == '\"' || WC == '\'' || WC == '\\')
{
*s++ = '\\';
}
*s++ = (char)WC;
if(Zero == 0)
{
*s++ = '\'';
}
*s = '\0';
}
else
{
switch (WC) {
case L'\r':
strcpy(gCharName, "'\\r'");
break;
case L'\n':
strcpy(gCharName, "'\\n'");
break;
case L'\b':
strcpy(gCharName, "'\\b'");
break;
default:
if(Zero == 0) {
sprintf(gCharName, "0x%04x", WC);
} else {
sprintf(gCharName, "\\x%04x", WC);
}
}
}
return gCharName;
}
void PrintNameTable(
FILE *pOut,
PKEYNAME pKN,
BOOL bDead)
{
char *p;
char *q;
int k;
char ExtraLine[LINEBUFSIZE];
while (pKN)
{
KEYNAME *pKNOld;
p = ExtraLine;
q = pKN->pName;
if (strncmp(q, "IDS_", 4) == 0) {
strcpy(p, "(LPWSTR)");
strcat(p, q);
} else {
*p++ = 'L';
if( *q != '\"' ) {
*p++ = '\"';
}
while(*q)
{
if( *q == '\\' && ( *(q+1) == 'x' || *(q+1) == 'X' ) )
{
while( *q == '\\' && ( *(q+1) == 'x' || *(q+1) == 'X' ) )
{
for(k = 0; *q && k < 6; k++)
{
*p++ = *q++;
}
}
if( *q )
{
*p++ = '\"';
*p++ = ' ';
*p++ = 'L';
*p++ = '\"';
}
}
else
{
*p++ = *q++;
}
}
if( *(p - 1) != '\"' )
{
*p++ = '\"';
}
*p++ = '\0';
}
if (bDead) {
fprintf(pOut," L\"%s\"\t%s,\n", WChName(pKN->Code, 1), ExtraLine);
} else {
fprintf(pOut," 0x%02x, %s,\n", pKN->Code, ExtraLine);
}
pKNOld = pKN;
pKN = pKN->pNext;
/*
* Free the memory (why bother???)
*/
free(pKNOld->pName);
free(pKNOld);
}
if (bDead) {
fprintf(pOut," NULL\n");
} else {
fprintf(pOut," 0 , NULL\n");
}
}
/*************************************************************\
* write kbd*.c *
\*************************************************************/
int kbd_c(
int nState,
int aiState[],
char * szAttrs,
KEYLAYOUT Layout[],
PDEADKEY pDeadKey,
PLIGATURE pLigature,
PKEYNAME pKeyName,
PKEYNAME pKeyNameExt,
PKEYNAME pKeyNameDead)
{
char OutName[13];
char ExtraLine[LINEBUFSIZE];
char Tmp[WORDBUFSIZE];
char *p;
char *q;
FILE *pOut;
int MaxSt;
int aiSt[MAXSTATES];
int idx, idxSt, j, k, m;
DWORD dwEmptyTables = 0; // bitmask of empty VK_TO_WCHARS tables
KEYNAME *pKN;
DEADTRANS *pDeadTrans;
char *Cap[] = {
"0",
"CAPLOK",
"SGCAPS",
"CAPLOK | SGCAPS",
"CAPLOKALTGR",
"CAPLOK | CAPLOKALTGR"
};
strcpy(OutName, "KBD");
strcat(OutName, gKBDName);
strcat(OutName, ".C");
printf(" %12s", OutName);
if((pOut = fopen(OutName, "wt")) == NULL)
{
printf(": can't open for write\n");
return FAILURE;
}
fprintf(pOut,"/***************************************************************************\\\n"
"* Module Name: %s\n*\n* keyboard layout for %s\n"
"*\n"
"* Copyright (c) 1985-2001, Microsoft Corporation\n"
"*\n"
"* History:\n"
"* KBDTOOL v%d.%02d - Created %s"
"\\***************************************************************************/\n\n",
OutName, gDescription, gVersion, gSubVersion, asctime(Now)
);
if (fallback_driver) {
fprintf(pOut, "#include \"precomp.h\"\n");
}
else {
fprintf(pOut, "#include <windows.h>\n"
"#include \"kbd.h\"\n"
"#include \"kbd%s.h\"\n\n",
gKBDName);
}
if ( fallback_driver ) {
fprintf(pOut,"#pragma data_seg(\"%s\")\n"
"#define ALLOC_SECTION_LDATA"
#ifdef LATER
" const"
#endif
"\n\n",
".kbdfallback" );
}
else {
fprintf(pOut,"#if defined(_M_IA64)\n"
"#pragma section(\"%s\")\n"
"#define ALLOC_SECTION_LDATA __declspec(allocate(\"%s\"))\n"
"#else\n"
"#pragma data_seg(\"%s\")\n"
"#define ALLOC_SECTION_LDATA\n"
"#endif\n\n",
".data",
".data",
".data");
}
fprintf(pOut,"/***************************************************************************\\\n"
"* ausVK[] - Virtual Scan Code to Virtual Key conversion table for %s\n"
"\\***************************************************************************/\n\n"
,gDescription);
fprintf(pOut,"static ALLOC_SECTION_LDATA USHORT ausVK[] = {\n"
" T00, T01, T02, T03, T04, T05, T06, T07,\n"
" T08, T09, T0A, T0B, T0C, T0D, T0E, T0F,\n"
" T10, T11, T12, T13, T14, T15, T16, T17,\n"
" T18, T19, T1A, T1B, T1C, T1D, T1E, T1F,\n"
" T20, T21, T22, T23, T24, T25, T26, T27,\n"
" T28, T29, T2A, T2B, T2C, T2D, T2E, T2F,\n"
" T30, T31, T32, T33, T34, T35,\n\n");
fprintf(pOut," /*\n"
" * Right-hand Shift key must have KBDEXT bit set.\n"
" */\n"
" T36 | KBDEXT,\n\n"
" T37 | KBDMULTIVK, // numpad_* + Shift/Alt -> SnapShot\n\n"
" T38, T39, T3A, T3B, T3C, T3D, T3E,\n"
" T3F, T40, T41, T42, T43, T44,\n\n");
fprintf(pOut," /*\n"
" * NumLock Key:\n"
" * KBDEXT - VK_NUMLOCK is an Extended key\n"
" * KBDMULTIVK - VK_NUMLOCK or VK_PAUSE (without or with CTRL)\n"
" */\n"
" T45 | KBDEXT | KBDMULTIVK,\n\n"
" T46 | KBDMULTIVK,\n\n");
fprintf(pOut," /*\n"
" * Number Pad keys:\n"
" * KBDNUMPAD - digits 0-9 and decimal point.\n"
" * KBDSPECIAL - require special processing by Windows\n"
" */\n"
" T47 | KBDNUMPAD | KBDSPECIAL, // Numpad 7 (Home)\n"
" T48 | KBDNUMPAD | KBDSPECIAL, // Numpad 8 (Up),\n"
" T49 | KBDNUMPAD | KBDSPECIAL, // Numpad 9 (PgUp),\n"
" T4A,\n"
" T4B | KBDNUMPAD | KBDSPECIAL, // Numpad 4 (Left),\n"
" T4C | KBDNUMPAD | KBDSPECIAL, // Numpad 5 (Clear),\n"
" T4D | KBDNUMPAD | KBDSPECIAL, // Numpad 6 (Right),\n"
" T4E,\n"
" T4F | KBDNUMPAD | KBDSPECIAL, // Numpad 1 (End),\n"
" T50 | KBDNUMPAD | KBDSPECIAL, // Numpad 2 (Down),\n"
" T51 | KBDNUMPAD | KBDSPECIAL, // Numpad 3 (PgDn),\n"
" T52 | KBDNUMPAD | KBDSPECIAL, // Numpad 0 (Ins),\n"
" T53 | KBDNUMPAD | KBDSPECIAL, // Numpad . (Del),\n\n");
fprintf(pOut," T54, T55, T56, T57, T58, T59, T5A, T5B,\n"
" T5C, T5D, T5E, T5F, T60, T61, T62, T63,\n"
" T64, T65, T66, T67, T68, T69, T6A, T6B,\n"
" T6C, T6D, T6E, T6F, T70, T71, T72, T73,\n"
" T74, T75, T76, T77, T78, T79, T7A, T7B,\n"
" T7C, T7D, T7E\n\n"
"};\n\n");
//
// Output E0-prefixed (extended) scancodes
//
fprintf(pOut,"static ALLOC_SECTION_LDATA VSC_VK aE0VscToVk[] = {\n");
for (idx = 0; idx < NUMSCVK; idx++) {
// skip keys that are not E0 extended
if ((Layout[idx].Scan & 0xFF00) != 0xE000) {
continue;
}
// if not undefined (Scan 0xffff) and not reserved (VKey 0xff)
if ((Layout[idx].Scan != 0xffff) && (Layout[idx].VKey != 0xff)) {
fprintf(pOut," { 0x%02X, X%02X | KBDEXT }, // %s\n",
Layout[idx].Scan & 0xFF, Layout[idx].Scan & 0xFF, Layout[idx].VKeyName);
}
}
fprintf(pOut," { 0, 0 }\n"
"};\n\n");
// Output 0xE1-prefixed scancodes
fprintf(pOut,"static ALLOC_SECTION_LDATA VSC_VK aE1VscToVk[] = {\n");
for (idx = 0; idx < NUMSCVK; idx++) {
// skip keys that are not E1 extended
if ((Layout[idx].Scan & 0xFF00) != 0xE100) {
continue;
}
// if not undefined (Scan 0xffff) and not reserved (VKey 0xff)
if ((Layout[idx].Scan != 0xffff) && (Layout[idx].VKey != 0xff)) {
fprintf(pOut," { 0x%02X, Y%02X | KBDEXT }, // %s\n",
Layout[idx].Scan & 0xFF, Layout[idx].Scan & 0xFF,
Layout[idx].VKeyName);
}
}
fprintf(pOut," { 0x1D, Y1D }, // Pause\n"
" { 0 , 0 }\n"
"};\n\n");
fprintf(pOut,"/***************************************************************************\\\n"
"* aVkToBits[] - map Virtual Keys to Modifier Bits\n"
"*\n"
"* See kbd.h for a full description.\n"
"*\n"
"* %s Keyboard has only three shifter keys:\n"
"* SHIFT (L & R) affects alphabnumeric keys,\n"
"* CTRL (L & R) is used to generate control characters\n"
"* ALT (L & R) used for generating characters by number with numpad\n"
"\\***************************************************************************/\n"
,gDescription);
// if (we get an RCONTROL, change VK_CONTROL to be VK_LCONTROL) { same for RMENU, RSHIFT?
// } CAN/CSA tap selection....
fprintf(pOut,"static ALLOC_SECTION_LDATA VK_TO_BIT aVkToBits[] = {\n");
for (idx = 0; Modifiers[idx].Vk != 0; idx++) {
fprintf(pOut, " { %-12s, %-12s },\n",
getVKName(Modifiers[idx].Vk, TRUE),
Modifiers[idx].pszModBits);
}
fprintf(pOut, " { 0 , 0 }\n};\n\n");
fprintf(pOut,"/***************************************************************************\\\n"
"* aModification[] - map character modifier bits to modification number\n"
"*\n"
"* See kbd.h for a full description.\n"
"*\n"
"\\***************************************************************************/\n\n");
for (idxSt = 0; idxSt < MAXSTATES; idxSt++) {
aiSt[idxSt] = -1;
}
MaxSt = 1;
for (idxSt = 0; idxSt < MAXSTATES && aiState[idxSt] > -1; idxSt++) {
aiSt[aiState[idxSt]] = idxSt;
if (aiState[idxSt] > MaxSt) {
MaxSt = aiState[idxSt];
}
}
fprintf(pOut,"static ALLOC_SECTION_LDATA MODIFIERS CharModifiers = {\n"
" &aVkToBits[0],\n"
" %d,\n"
" {\n"
" // Modification# // Keys Pressed\n"
" // ============= // =============\n"
,MaxSt);
for (idxSt = 0; idxSt <= MaxSt; idxSt++) {
int iMod;
BOOL bNeedPlus;
if(aiSt[idxSt] == -1) {
fprintf(pOut," SHFT_INVALID, // ");
} else if(idxSt == MaxSt) {
fprintf(pOut," %d // ", aiSt[idxSt]);
} else {
fprintf(pOut," %d, // ", aiSt[idxSt]);
}
bNeedPlus = FALSE;
for (iMod = 0; (1 << iMod) <= idxSt; iMod++) {
if (bNeedPlus) {
fprintf(pOut, "+ ");
bNeedPlus = FALSE;
}
if ((1 << iMod) & idxSt) {
char achModifier[50];
strcpy(achModifier, getVKName(Modifiers[iMod].Vk, TRUE));
for (j = 4; (j < 50) && (achModifier[j] != '\0'); j++) {
achModifier[j] = (char)tolower(achModifier[j]);
}
fprintf(pOut, "%s ", &achModifier[3]);
bNeedPlus = TRUE;
}
}
fprintf(pOut, "\n");
}
fprintf(pOut," }\n"
"};\n\n");
fprintf(pOut,"/***************************************************************************\\\n"
"*\n"
"* aVkToWch2[] - Virtual Key to WCHAR translation for 2 shift states\n"
"* aVkToWch3[] - Virtual Key to WCHAR translation for 3 shift states\n"
"* aVkToWch4[] - Virtual Key to WCHAR translation for 4 shift states\n");
for (idxSt = 5; idxSt < MaxSt; idxSt++) {
fprintf(pOut,
"* aVkToWch%d[] - Virtual Key to WCHAR translation for %d shift states\n",
idxSt, idxSt);
}
fprintf(pOut,"*\n"
"* Table attributes: Unordered Scan, null-terminated\n"
"*\n"
"* Search this table for an entry with a matching Virtual Key to find the\n"
"* corresponding unshifted and shifted WCHAR characters.\n"
"*\n"
"* Special values for VirtualKey (column 1)\n"
"* 0xff - dead chars for the previous entry\n"
"* 0 - terminate the list\n"
"*\n"
"* Special values for Attributes (column 2)\n"
"* CAPLOK bit - CAPS-LOCK affect this key like SHIFT\n"
"*\n"
"* Special values for wch[*] (column 3 & 4)\n"
"* WCH_NONE - No character\n"
"* WCH_DEAD - Dead Key (diaresis) or invalid (US keyboard has none)\n"
"* WCH_LGTR - Ligature (generates multiple characters)\n"
"*\n"
"\\***************************************************************************/\n\n");
for (idxSt = 2; idxSt <= nState; idxSt++) {
/*
* Quickly check if this table would actually be empty.
* An empty table (containing just zero terminator) is pointless.
* Also it will go into the .bss section, which we would have to merge
* into the .data section with a linker flag, else NT wouldn't load it
* (bug #120244 - IanJa)
*/
BOOL bEmpty;
bEmpty = TRUE;
if (idxSt == 2) {
// Special case for TAB ADD DIVIDE MULTIPLY SUBTRACT (below)
bEmpty = FALSE;
} else {
for (j = 0; j < NUMSCVK; j++) {
if (Layout[j].nState == idxSt) {
bEmpty = FALSE;
break;
}
}
}
if (bEmpty) {
fprintf(stderr, "\ntable %d is empty\n", idxSt);
dwEmptyTables |= (1 << idxSt);
continue;
}
fprintf(pOut,"static ALLOC_SECTION_LDATA VK_TO_WCHARS%d aVkToWch%d[] = {\n"
"// | | Shift |"
,idxSt, idxSt);
for (j = 2; j < idxSt; j++) {
fprintf(pOut,"%-9.9s|", StateLabel[aiState[j]]);
}
fprintf(pOut,"\n// |=========|=========|");
for(j = 2; j < idxSt; j++) {
fprintf(pOut,"=========|");
}
fprintf(pOut,"\n");
for (j = 0; j < NUMSCVK; j++) {
if (idxSt != Layout[j].nState) {
continue;
}
fprintf(pOut," {%-13s,%-7s", \
getVKName(Layout[j].VKey, 1), Cap[Layout[j].Cap]);
*ExtraLine = '\0';
for (k = 0; k < idxSt; k++) {
if (pDeadKey != NULL && Layout[j].DKy[k] == 1) {
/*
* it is a dead key
*/
if (*ExtraLine == '\0') {
strcpy(ExtraLine, " {0xff ,0 ");
if (Layout[j].Cap != 2) {
/*
* Not SGCap
*/
for (m = 0; m < k; m++) {
strcat(ExtraLine, ",WCH_NONE ");
}
} else {
/*
* added for a new kbdCZ that has both SGCap and WCH_DEAD
*/
for (m = 0; m < k; m++ ) {
if (Layout[j].pSGCAP->WCh[m] == 0) {
strcat( ExtraLine, ",WCH_NONE " );
} else {
sprintf( Tmp, ",%-9s", WChName( Layout[j].pSGCAP->WCh[m], 0 ) );
strcat( ExtraLine, Tmp );
}
}
}
}
sprintf(Tmp,",%-9s", WChName(Layout[j].WCh[k], 0));
strcat(ExtraLine, Tmp);
fprintf(pOut,",WCH_DEAD ");
} else if(Layout[j].LKy[k] == 1) {
/*
* it is a ligature key
*/
if (pLigature == NULL) {
Error("Ligature entry with no LIGATURE table");
fclose(pOut);
return FAILURE;
}
fprintf(pOut,",WCH_LGTR ");
if (*ExtraLine != '\0') {
strcat(ExtraLine, ",WCH_NONE ");
}
} else {
fprintf(pOut,",%-9s", WChName(Layout[j].WCh[k], 0));
if (*ExtraLine != '\0') {
strcat(ExtraLine, ",WCH_NONE ");
}
}
}
fprintf(pOut,"},\n");
if (*ExtraLine != '\0') {
fprintf(pOut,"%s},\n", ExtraLine);
continue; /* skip if WCH_DEAD */
}
/*
* skip if not SGCAP
*/
if (Layout[j].Cap != 2) {
continue;
}
if (Layout[j].pSGCAP == NULL) {
fclose(pOut);
Error("failed SGCAP error");
return FAILURE;
}
fprintf(pOut," {%-13s,0 ", getVKName(Layout[j].VKey, 1));
for (k = 0; k < Layout[j].pSGCAP->nState; k++) {
fprintf(pOut,",%-9s", WChName(Layout[j].pSGCAP->WCh[k], 0));
}
fprintf(pOut,"},\n");
free (Layout[j].pSGCAP);
}
/*
* These entries appear last to make VkKeyScan[Ex] results match
* Windows 95/98. See DRIVERS\KEYBOARD\WIN3.1\TAB4.INC (under
* \\redrum\w98slmRO\proj\dos\src)
*/
if (idxSt == 2) {
fprintf(pOut," {VK_TAB ,0 ,'\\t' ,'\\t' },\n"
" {VK_ADD ,0 ,'+' ,'+' },\n"
" {VK_DIVIDE ,0 ,'/' ,'/' },\n"
" {VK_MULTIPLY ,0 ,'*' ,'*' },\n"
" {VK_SUBTRACT ,0 ,'-' ,'-' },\n");
}
fprintf(pOut," {0 ,0 ");
for (k = 0; k < idxSt; k++) {
fprintf(pOut,",0 ");
}
fprintf(pOut,"}\n"
"};\n\n");
}
fprintf(pOut,"// Put this last so that VkKeyScan interprets number characters\n"
"// as coming from the main section of the kbd (aVkToWch2 and\n"
"// aVkToWch5) before considering the numpad (aVkToWch1).\n\n"
"static ALLOC_SECTION_LDATA VK_TO_WCHARS1 aVkToWch1[] = {\n"
" { VK_NUMPAD0 , 0 , '0' },\n"
" { VK_NUMPAD1 , 0 , '1' },\n"
" { VK_NUMPAD2 , 0 , '2' },\n"
" { VK_NUMPAD3 , 0 , '3' },\n"
" { VK_NUMPAD4 , 0 , '4' },\n"
" { VK_NUMPAD5 , 0 , '5' },\n"
" { VK_NUMPAD6 , 0 , '6' },\n"
" { VK_NUMPAD7 , 0 , '7' },\n"
" { VK_NUMPAD8 , 0 , '8' },\n"
" { VK_NUMPAD9 , 0 , '9' },\n"
" { 0 , 0 , '\\0' }\n"
"};\n\n");
fprintf(pOut,"static ALLOC_SECTION_LDATA VK_TO_WCHAR_TABLE aVkToWcharTable[] = {\n");
for (idxSt = 3; idxSt <= nState; idxSt++) {
if ((dwEmptyTables & (1 << idxSt)) == 0) {
fprintf(pOut,
" { (PVK_TO_WCHARS1)aVkToWch%d, %d, sizeof(aVkToWch%d[0]) },\n",
idxSt, idxSt, idxSt);
}
}
fprintf(pOut," { (PVK_TO_WCHARS1)aVkToWch2, 2, sizeof(aVkToWch2[0]) },\n"
" { (PVK_TO_WCHARS1)aVkToWch1, 1, sizeof(aVkToWch1[0]) },\n"
" { NULL, 0, 0 },\n"
"};\n\n");
fprintf(pOut,"/***************************************************************************\\\n"
"* aKeyNames[], aKeyNamesExt[] - Virtual Scancode to Key Name tables\n"
"*\n"
"* Table attributes: Ordered Scan (by scancode), null-terminated\n"
"*\n"
"* Only the names of Extended, NumPad, Dead and Non-Printable keys are here.\n"
"* (Keys producing printable characters are named by that character)\n"
"\\***************************************************************************/\n\n");
if (pKeyName != NULL) {
fprintf(pOut,"static ALLOC_SECTION_LDATA VSC_LPWSTR aKeyNames[] = {\n");
PrintNameTable(pOut, pKeyName, FALSE);
fprintf(pOut,"};\n\n");
}
if (pKeyNameExt != NULL) {
fprintf(pOut,"static ALLOC_SECTION_LDATA VSC_LPWSTR aKeyNamesExt[] = {\n");
PrintNameTable(pOut, pKeyNameExt, FALSE);
fprintf(pOut,"};\n\n");
}
if (pKeyNameDead != NULL) {
if (pDeadKey == NULL) {
fprintf(pOut,"/*** No dead key defined, dead key names ignored ! ***\\\n\n");
}
fprintf(pOut,"static ALLOC_SECTION_LDATA DEADKEY_LPWSTR aKeyNamesDead[] = {\n");
PrintNameTable(pOut, pKeyNameDead, TRUE);
fprintf(pOut,"};\n\n");
if(pDeadKey == NULL) {
fprintf(pOut,"\\*****************************************************/\n\n");
}
}
if (pDeadKey != NULL) {
PDEADKEY pDeadKeyTmp = pDeadKey;
fprintf(pOut,"static ALLOC_SECTION_LDATA DEADKEY aDeadKey[] = {\n");
while (pDeadKeyTmp != NULL) {
PDEADKEY pDeadKeyOld;
pDeadTrans = pDeadKeyTmp->pDeadTrans;
while (pDeadTrans != NULL) {
PDEADTRANS pDeadTransOld;
fprintf(pOut," DEADTRANS( ");
if (strlen(WChName(pDeadTrans->Base, 0)) == 3) {
fprintf(pOut,"L%-6s, ", WChName(pDeadTrans->Base, 0));
} else {
fprintf(pOut,"%-7s, ", WChName(pDeadTrans->Base, 0));
}
if (strlen(WChName(pDeadKeyTmp->Dead, 0)) == 3) {
fprintf(pOut,"L%-6s, ", WChName(pDeadKeyTmp->Dead, 0));
} else {
fprintf(pOut,"%-7s, ", WChName(pDeadKeyTmp->Dead, 0));
}
if (strlen(WChName(pDeadTrans->WChar, 0)) == 3) {
fprintf(pOut,"L%-6s, ", WChName(pDeadTrans->WChar, 0));
} else {
fprintf(pOut,"%-7s, ", WChName(pDeadTrans->WChar, 0));
}
fprintf(pOut,"0x%04x),\n", pDeadTrans->uFlags);
pDeadTransOld = pDeadTrans;
pDeadTrans = pDeadTrans->pNext;
free(pDeadTransOld);
}
fprintf(pOut,"\n");
pDeadKeyOld = pDeadKeyTmp;
pDeadKeyTmp = pDeadKeyTmp->pNext;
free(pDeadKeyOld);
}
fprintf(pOut," 0, 0\n");
fprintf(pOut,"};\n\n");
}
if (pLigature != NULL) {
PLIGATURE pLigatureTmp = pLigature;
fprintf(pOut,"static ALLOC_SECTION_LDATA LIGATURE%d aLigature[] = {\n", gMaxLigature);
while (pLigatureTmp != NULL) {
PLIGATURE pLigatureOld;
fprintf(pOut," {%-13s,%-7d", \
getVKName(pLigatureTmp->VKey, 1), pLigatureTmp->Mod);
for (k = 0; k < gMaxLigature; k++) {
if (k < pLigatureTmp->nCharacters) {
fprintf(pOut,",%-9s", WChName(pLigatureTmp->WCh[k], 0));
} else {
fprintf(pOut,",WCH_NONE ");
}
}
fprintf(pOut,"},\n");
pLigatureOld = pLigatureTmp;
pLigatureTmp = pLigatureTmp->pNext;
free(pLigatureOld);
}
fprintf(pOut," {%-13d,%-7d", 0, 0);
for (k = 0; k < gMaxLigature; k++) {
fprintf(pOut,",%-9d", 0);
}
fprintf(pOut,"}\n};\n\n");
}
if (!fallback_driver) {
fprintf(pOut, "static ");
}
fprintf(pOut,"ALLOC_SECTION_LDATA KBDTABLES KbdTables%s = {\n"
" /*\n"
" * Modifier keys\n"
" */\n"
" &CharModifiers,\n\n"
" /*\n"
" * Characters tables\n"
" */\n"
" aVkToWcharTable,\n\n"
" /*\n"
" * Diacritics\n"
" */\n",
fallback_driver ? "Fallback" : "");
if (pDeadKey != NULL) {
fprintf(pOut," aDeadKey,\n\n");
} else {
fprintf(pOut," NULL,\n\n");
}
fprintf(pOut," /*\n"
" * Names of Keys\n"
" */\n");
if (pKeyName != NULL) {
fprintf(pOut," aKeyNames,\n");
} else {
fprintf(pOut," NULL,\n");
}
if (pKeyNameExt != NULL) {
fprintf(pOut," aKeyNamesExt,\n");
} else {
fprintf(pOut," NULL,\n");
}
if (pDeadKey != NULL && pKeyNameDead != NULL) {
fprintf(pOut," aKeyNamesDead,\n\n");
} else {
fprintf(pOut," NULL,\n\n");
}
fprintf(pOut," /*\n"
" * Scan codes to Virtual Keys\n"
" */\n"
" ausVK,\n"
" sizeof(ausVK) / sizeof(ausVK[0]),\n"
" aE0VscToVk,\n"
" aE1VscToVk,\n\n"
" /*\n"
" * Locale-specific special processing\n"
" */\n");
if (MaxSt > 5) {
if (szAttrs[0] != '\0') {
strcat(szAttrs, " | ");
}
strcat(szAttrs, "KLLF_ALTGR");
} else if (szAttrs[0] == '\0') {
strcpy(szAttrs, "0");
}
fprintf(pOut," MAKELONG(%s, KBD_VERSION),\n\n", szAttrs);
fprintf(pOut," /*\n"
" * Ligatures\n"
" */\n"
" %d,\n", gMaxLigature);
if (pLigature != NULL) {
fprintf(pOut," sizeof(aLigature[0]),\n");
fprintf(pOut," (PLIGATURE1)aLigature\n");
} else {
fprintf(pOut," 0,\n");
fprintf(pOut," NULL\n");
}
fprintf(pOut, "};\n\n");
if (!fallback_driver) {
fprintf(pOut,"PKBDTABLES KbdLayerDescriptor(VOID)\n"
"{\n"
" return &KbdTables;\n"
"}\n");
}
fclose(pOut);
return SUCCESS;
}
/*****************************************************************************\
* read next (content-containing) line from input file
* Consumes lines the are empty, or contain just comments.
*
* Buf - contains the new line.
* (A nul character is inserted before any comment portion)
* cchBuf - provides number of characters in Buf
* gLineCount - Incremented for each line read (including skipped lines)
*
* Returns TRUE - if new line is returned in Buf
* FALSE - if end of file was reached
\*****************************************************************************/
BOOL NextLine(char *Buf, DWORD cchBuf, FILE *fIn)
{
char *p;
char *pComment;
while (fgets(Buf, cchBuf, fIn) != NULL) {
gLineCount++;
p = Buf;
// skip leading white spaces
while( *p && (*p == ' ' || *p == '\t')) {
p++;
}
if (*p == ';') {
// This line is purely comment, so skip it
continue;
}
if ((pComment = strstr(p, "//")) != NULL) {
if (pComment == p) {
// This line is purely comment, so skip it
continue;
}
// separate comment portion from content-containing portion
*pComment = '\0';
} else {
// remove newline at the end
if ((p = strchr(p, '\n')) != NULL) {
*p = '\0';
}
}
// We are returning a content-containing line
return TRUE;
}
// we reached the end of the file
return FALSE;
}
VOID __cdecl Error(const char *Text, ... )
{
char Temp[1024];
va_list valist;
va_start(valist, Text);
vsprintf(Temp,Text,valist);
printf("\n%s(%d): error : %s\n", gpszFileName, gLineCount, Temp);
va_end(valist);
exit(EXIT_FAILURE);
}
ULONG __cdecl Warning(int nLine, const char *Text, ... )
{
char Temp[1024];
va_list valist;
if (nLine == 0) {
nLine = gLineCount;
}
va_start(valist, Text);
vsprintf(Temp,Text,valist);
printf("%s(%d): warning : %s\n", gpszFileName, nLine, Temp);
va_end(valist);
return 0;
}
VOID DumpLayoutEntry(PKEYLAYOUT pLayout)
{
printf("Scan %2x, VK %2x, VKDef %2x, Cap %d, nState %d, defined %x\n",
pLayout->Scan,
pLayout->VKey,
pLayout->VKeyDefault,
pLayout->Cap,
pLayout->nState,
pLayout->defined
);
printf("WCh[] = %x, %x, %x, %x, %x, %x, %x, %x, %x\n",
pLayout->WCh[0], pLayout->WCh[1],
pLayout->WCh[2], pLayout->WCh[3],
pLayout->WCh[4], pLayout->WCh[5],
pLayout->WCh[6], pLayout->WCh[7],
pLayout->WCh[8]);
printf("DKy[] = %x, %x, %x, %x, %x, %x, %x, %x, %x\n",
pLayout->DKy[0], pLayout->DKy[1],
pLayout->DKy[2], pLayout->DKy[3],
pLayout->DKy[4], pLayout->DKy[5],
pLayout->DKy[6], pLayout->DKy[7],
pLayout->DKy[8]);
printf("LKy[] = %x, %x, %x, %x, %x, %x, %x, %x, %x\n",
pLayout->LKy[0], pLayout->LKy[1],
pLayout->LKy[2], pLayout->LKy[3],
pLayout->LKy[4], pLayout->LKy[5],
pLayout->LKy[6], pLayout->LKy[7],
pLayout->LKy[8]);
printf("pSGCAP = %p\n", pLayout->pSGCAP);
printf("VKeyName = %s\n", pLayout->VKeyName);
}
/*
* Helper routine to make sure Backspace, Enter, Esc, Space and Cancel
* have the right characters.
* If they aren't defined by the input file, this is where we set their
* default values.
*/
BOOL MergeState(
KEYLAYOUT Layout[],
int Vk,
WCHAR wchUnshifted,
WCHAR wchShifted,
WCHAR wchCtrl,
int aiState[],
int nState)
{
static int idxCtrl = -1;
int idxSt, idx;
PKEYLAYOUT pLayout = NULL;
// which state is Ctrl?
if (idxCtrl == -1) {
for (idxSt = 0; idxSt < nState; idxSt++) {
if (aiState[idxSt] == KBDCTRL) {
idxCtrl = idxSt;
break;
}
}
}
if (idxCtrl == -1) {
Error("No Ctrl state");
}
// find the VK we want to merge
for (idx = 0; idx < NUMSCVK; idx++) {
if (Layout[idx].VKey == Vk) {
pLayout = &Layout[idx];
break;
}
}
if (pLayout == NULL) {
Error("No VK %2x state", Vk);
}
/*
* Now merge the default values in
*/
// printf("BEFORE ====================\n");
// DumpLayoutEntry(pLayout);
if (pLayout->WCh[0] == 0) {
pLayout->WCh[0] = wchUnshifted;
}
if (pLayout->WCh[1] == 0) {
pLayout->WCh[1] = wchShifted;
}
if (pLayout->WCh[idxCtrl] == 0) {
pLayout->WCh[idxCtrl] = wchCtrl;
}
// pad empty slots with WCH_NONE
for (idxSt = pLayout->nState; idxSt < idxCtrl; idxSt++) {
if (pLayout->WCh[idxSt] == 0) {
pLayout->WCh[idxSt] = -1; // WCH_NONE
}
}
if (pLayout->nState <= idxCtrl) {
pLayout->nState = idxCtrl + 1;
}
pLayout->defined = TRUE;
// printf("AFTER ===================\n");
// DumpLayoutEntry(pLayout);
// printf("=========================\n\n");
return TRUE;
}