|
|
/******************************* 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;}
|
