ReactOS  0.4.14-dev-114-gc8cbd56
output.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Build Tools [Keyboard Layout Compiler]
3  * LICENSE: BSD - See COPYING.BSD in the top level directory
4  * FILE: tools/kbdtool/output.c
5  * PURPOSE: Output Logic (Source Builder)
6  * PROGRAMMERS: ReactOS Foundation
7  */
8 
9 /* INCLUDES *******************************************************************/
10 
11 #include "kbdtool.h"
12 
13 /* GLOBALS ********************************************************************/
14 
19 struct tm *Now;
21 
22 /* FUNCTIONS ******************************************************************/
23 
24 PCHAR
26  IN BOOLEAN AddZero)
27 {
28  PCHAR p;
29 
30  /* Check for invalid character */
31  if (Char == -1)
32  {
33  /* No name */
34  strcpy(gCharName, "WCH_NONE");
35  }
36  else if ((Char > 31) && (Char < 128))
37  {
38  /* Use our global buffer */
39  p = gCharName;
40 
41  /* Add the first quote unless this was a zero-string */
42  if (!AddZero) *p++ = '\'';
43 
44  /* Now replace any other quote or comment character with a slash */
45  if ((Char == '\"') || (Char == '\'') || (Char == '\\')) *p++ = '\\';
46 
47  /* Now plug in the character */
48  *p++ = Char;
49 
50  /* And add the terminating quote, unless this was a zero-string */
51  if (!AddZero) *p++ = '\'';
52 
53  /* Terminate the buffer */
54  *p = '\0';
55  }
56  else
57  {
58  /* Handle special cases */
59  if (Char == '\b')
60  {
61  /* Bell */
62  strcpy(gCharName, "'\\b'");
63  }
64  else if (Char == '\n')
65  {
66  /* New line */
67  strcpy(gCharName, "'\\n'");
68  }
69  else if (Char == '\r')
70  {
71  /* Return */
72  strcpy(gCharName, "'\\r'");
73  }
74  else if (!AddZero)
75  {
76  /* Char value, in hex */
77  sprintf(gCharName, "0x%04x", Char);
78  }
79  else
80  {
81  /* Char value, C-style */
82  sprintf(gCharName, "\\x%04x", Char);
83  }
84  }
85 
86  /* Return the name */
87  return gCharName;
88 }
89 
90 VOID
93  BOOL DeadKey)
94 {
95  CHAR CharBuffer[255];
96  PKEYNAME NextName;
97  PCHAR Name, Buffer;
98  ULONG i;
99 
100  /* Loop all key names */
101  while (KeyName)
102  {
103  /* Go to the next key name */
104  NextName = KeyName->Next;
105 
106  /* Remember the name and our buffer address */
107  Name = KeyName->Name;
108  Buffer = CharBuffer;
109 
110  /* Check if it's an IDS name */
111  if (strncmp(Name, "IDS_", 4))
112  {
113  /* No, so start parsing it. First, handle initial quote */
114  if (*Name != '\"') *Buffer++ = '\"';
115 
116  /* Next, parse the name */
117  while (*Name)
118  {
119  /* Check if this is a C-style hex string */
120  if ((*Name != '\\') || ((*(Name + 1) != 'x') && (*(Name + 1) != 'X')))
121  {
122  /* It's not, so just copy straight into our buffer */
123  *Buffer++ = *Name++;
124  }
125  else
126  {
127  /* Continue scanning as long as this is a C-style hex string */
128  while ((*Name == '\\') && ((*(Name + 1) == 'x') || (*(Name + 1) == 'X')))
129  {
130  /* Copy 6 characters */
131  for (i = 0; (*Name) && (i < 6); i++) *Buffer++ = *Name++;
132  }
133 
134  /* Check if we still have something at the end */
135  if (*Name)
136  {
137  /* Terminate our buffer */
138  *Buffer++ = '\"';
139  *Buffer++ = ' ';
140  *Buffer++ = 'L';
141  *Buffer++ = '\"';
142  }
143  }
144  }
145 
146  /* Check for terminating quote */
147  if (*(Buffer - 1) != '\"') *Buffer++ = '\"';
148 
149  /* Terminate the buffer */
150  *Buffer++ = '\0';
151  }
152  else
153  {
154  /* Not yet supported */
155  printf("IDS Entries not yet handled!\n");
156  exit(1);
157  }
158 
159  /* Is this a dead key? */
160  if (DeadKey)
161  {
162  /* Not yet handled */
163  printf("Dead keys not yet handled\n");
164  exit(1);
165  }
166  else
167  {
168  /* Print the entry */
169  fprintf(FileHandle, " 0x%02x, L%s,\n", KeyName->Code, CharBuffer);
170  }
171 
172  /* Cleanup allocation */
173  free(KeyName->Name);
174  free(KeyName);
175 
176  /* Move on */
177  KeyName = NextName;
178  }
179 
180  /* Is this a dead key? */
181  if (DeadKey)
182  {
183  /* Not yet handled */
184  printf("Dead keys not yet handled\n");
185  exit(1);
186  }
187  else
188  {
189  /* Terminate the table */
190  fprintf(FileHandle, " 0 , NULL\n");
191  }
192 }
193 
194 BOOLEAN
195 kbd_h(IN PLAYOUT Layout)
196 {
197  CHAR OutputFile[13];
198  FILE *FileHandle;
199  ULONG i;
200  CHAR UndefChar;
201  USHORT SubCode;
202 
203  /* Build the keyboard name */
204  strcpy(OutputFile, gKBDName);
205  strcat(OutputFile, ".H");
206 
207  /* Open it */
208  FileHandle = fopen(OutputFile, "wt");
209  if (!FileHandle)
210  {
211  /* Fail */
212  printf(" %12s : can't open for write.\n", OutputFile);
213  return FALSE;
214  }
215 
216  /* Print the module header */
218  "/****************************** Module Header ******************************\\\n"
219  "* Module Name: %s\n*\n* keyboard layout header\n"
220  "*\n"
221  "* Copyright (c) 2009, ReactOS Foundation\n"
222  "*\n"
223  "* Various defines for use by keyboard input code.\n*\n* History:\n"
224  "*\n"
225  "* created by KBDTOOL v%d.%02d %s*\n"
226  "\\***************************************************************************/\n\n",
227  OutputFile,
228  gVersion,
229  gSubVersion,
230  asctime(Now));
231 
232  /* Print out the includes and defines */
234  "/*\n"
235  " * kbd type should be controlled by cl command-line argument\n"
236  " *\\n"
237  "#define KBD_TYPE 4\n\n"
238  "/*\n"
239  "* Include the basis of all keyboard table values\n"
240  "*/\n"
241  "#include \"kbd.h\"\n");
242 
243  /* Now print out the virtual key conversion table */
245  "/***************************************************************************\\\n"
246  "* The table below defines the virtual keys for various keyboard types where\n"
247  "* the keyboard differ from the US keyboard.\n"
248  "*\n"
249  "* _EQ() : all keyboard types have the same virtual key for this scancode\n"
250  "* _NE() : different virtual keys for this scancode, depending on kbd type\n"
251  "*\n"
252  "* +------+ +----------+----------+----------+----------+----------+----------+\n"
253  "* | Scan | | kbd | kbd | kbd | kbd | kbd | kbd |\n"
254  "* | code | | type 1 | type 2 | type 3 | type 4 | type 5 | type 6 |\n"
255  "\\****+-------+_+----------+----------+----------+----------+----------+----------+*/\n\n");
256 
257  /* Loop all keys */
258  for (i = 0; i < 110; i++)
259  {
260  /* Check if we processed this key */
261  if (Layout->Entry[i].Processed)
262  {
263  /* Check if it redefined a virtual key */
264  if (Layout->Entry[i].VirtualKey != Layout->Entry[i].OriginalVirtualKey)
265  {
266  /* Do we have a subcode? */
267  SubCode = Layout->Entry[i].ScanCode & 0xFF00;
268  if (SubCode)
269  {
270  /* Which kind is it? */
271  if (SubCode == 0xE000)
272  {
273  /* Extended 0 */
274  UndefChar = 'X';
275  }
276  else
277  {
278  /* Illegal */
279  if (SubCode != 0xE100)
280  {
281  /* Unrecognized */
282  printf("Weird scancode value %04x: expected xx, E0xx, or E1xx\n", SubCode);
283  exit(1);
284  }
285 
286  /* Extended 1 */
287  UndefChar = 'Y';
288  }
289  }
290  else
291  {
292  /* Normal key */
293  UndefChar = 'T';
294  }
295 
296  /* Print out the virtual key redefinition */
298  "#undef %c%02X\n#define %c%02X _EQ(%43s%23s\n",
299  UndefChar,
300  Layout->Entry[i].ScanCode,
301  UndefChar,
302  Layout->Entry[i].ScanCode,
303  getVKName(Layout->Entry[i].VirtualKey, 0),
304  ")");
305  }
306  }
307  }
308 
309  /* Cleanup and close */
310  fprintf(FileHandle,"\n");
312 
313  /* We made it */
314  return TRUE;
315 }
316 
317 BOOLEAN
318 kbd_rc(IN PKEYNAME DescriptionData,
319  IN PKEYNAME LanguageData)
320 {
321  CHAR OutputFile[13];
322  CHAR InternalName[13];
323  CHAR TimeBuffer[5];
324  FILE *FileHandle;
325  ULONG Length;
326  PCHAR p;
327  PKEYNAME NextDescription, NextLanguage;
328 
329  /* Build the keyboard name and internal name */
330  strcpy(OutputFile, gKBDName);
331  strcat(OutputFile, ".RC");
332  strcpy(InternalName, gKBDName);
333  for (p = InternalName; *p; p++) *p = tolower(*p);
334 
335  /* Open it */
336  FileHandle = fopen(OutputFile, "wb");
337  if (!FileHandle)
338  {
339  /* Fail */
340  printf(" %12s : can't open for write.\n", OutputFile);
341  return FALSE;
342  }
343 
344  /* Check if we have copyright */
346  if (!Length)
347  {
348  /* Set time string */
349  strftime(TimeBuffer, 5, "%Y", Now);
350 
351  /* Add copyright character */
352  strcpy(gCopyright, "(C)");
353 
354  /* Add the year */
355  strcat(gCopyright, TimeBuffer);
356 
357  /* Add blank company */
358  strcat(gCopyright, " ");
359  }
360 
361  /* Write the resource file header */
363  "#include \"winver.h\"\r\n"
364  "1 VERSIONINFO\r\n"
365  " FILEVERSION 1,0,%d,%d\r\n"
366  " PRODUCTVERSION 1,0,%d,%d\r\n"
367  " FILEFLAGSMASK 0x3fL\r\n"
368  " FILEFLAGS 0x0L\r\n"
369  "FILEOS 0x40004L\r\n"
370  " FILETYPE VFT_DLL\r\n"
371  " FILESUBTYPE VFT2_DRV_KEYBOARD\r\n"
372  "BEGIN\r\n"
373  " BLOCK \"StringFileInfo\"\r\n"
374  " BEGIN\r\n"
375  " BLOCK \"000004B0\"\r\n"
376  " BEGIN\r\n"
377  " VALUE \"CompanyName\", \"%s\\0\"\r\n"
378  " VALUE \"FileDescription\", \"%s Keyboard Layout\\0\"\r\n"
379  " VALUE \"FileVersion\", \"1, 0, %d, %d\\0\"\r\n",
380  gVersion,
381  gSubVersion,
382  gVersion,
383  gSubVersion,
384  gCompany,
385  gDescription,
386  gVersion,
387  gSubVersion);
388 
389  /* Continue writing it */
391  " VALUE \"InternalName\", \"%s (%d.%d)\\0\"\r\n"
392  " VALUE \"ProductName\",\"%s\\0\"\r\n"
393  " VALUE \"Release Information\",\"%s\\0\"\r\n"
394  " VALUE \"LegalCopyright\", \"%s\\0\"\r\n"
395  " VALUE \"OriginalFilename\",\"%s\\0\"\r\n"
396  " VALUE \"ProductVersion\", \"1, 0, %d, %d\\0\"\r\n"
397  " END\r\n"
398  " END\r\n"
399  " BLOCK \"VarFileInfo\"\r\n"
400  " BEGIN\r\n"
401  " VALUE \"Translation\", 0x0000, 0x04B0\r\n"
402  " END\r\n"
403  "END\r\n",
404  InternalName,
405  gVersion,
406  gSubVersion,
407  "Created by ReactOS KbdTool",
408  "Created by ReactOS KbdTool",
409  gCopyright,
410  InternalName,
411  gVersion,
412  gSubVersion);
413 
414  /* Now check if we have a locale name */
416  if (Length)
417  {
418  /* Write the stringtable header */
420  "\r\nSTRINGTABLE DISCARDABLE\r\nLANGUAGE %d, %d\r\n",
421  9,
422  1);
423  fprintf(FileHandle, "BEGIN\r\n");
424 
425  /* Language or locale? */
426  if (strchr(gLocaleName, '\"'))
427  {
428  /* Write the language name */
430  }
431  else
432  {
433  /* Write the locale name */
435  }
436 
437  /* Terminate the entry */
438  fprintf(FileHandle, "END\r\n\r\n");
439  }
440 
441  /* Check for description information */
442  while (DescriptionData)
443  {
444  /* Remember the next pointer */
445  NextDescription = DescriptionData->Next;
446 
447  /* Write the header */
449  "\r\nSTRINGTABLE DISCARDABLE\r\nLANGUAGE %d, %d\r\n",
450  DescriptionData->Code & 0x3FF,
451  DescriptionData->Code >> 10);
452  fprintf(FileHandle, "BEGIN\r\n");
453 
454  /* Quoted string or not? */
455  if (strchr(DescriptionData->Name, '\"'))
456  {
457  /* Write the description name */
458  fprintf(FileHandle, " %d %s\r\n", gStringIdForDescriptions, DescriptionData->Name);
459  }
460  else
461  {
462  /* Write the description name */
463  fprintf(FileHandle, " %d \"%s\"\r\n", gStringIdForDescriptions, DescriptionData->Name);
464  }
465 
466  /* Terminate the entry */
467  fprintf(FileHandle, "END\r\n\r\n");
468 
469  /* Free the allocation */
470  free(DescriptionData->Name);
471  free(DescriptionData);
472 
473  /* Move to the next entry */
474  DescriptionData = NextDescription;
475  }
476 
477  /* Check for language information */
478  while (LanguageData)
479  {
480  /* Remember the next pointer */
481  NextLanguage = LanguageData->Next;
482 
483  /* Write the header */
485  "\r\nSTRINGTABLE DISCARDABLE\r\nLANGUAGE %d, %d\r\n",
486  LanguageData->Code & 0x3FF,
487  LanguageData->Code >> 10);
488  fprintf(FileHandle, "BEGIN\r\n");
489 
490  /* Quoted string or not? */
491  if (strchr(LanguageData->Name, '\"'))
492  {
493  /* Write the language name */
494  fprintf(FileHandle, " %d %s\r\n", gStringIdForLanguageNames, LanguageData->Name);
495  }
496  else
497  {
498  /* Write the language name */
499  fprintf(FileHandle, " %d \"%s\"\r\n", gStringIdForLanguageNames, LanguageData->Name);
500  }
501 
502  /* Terminate the entry */
503  fprintf(FileHandle, "END\r\n\r\n");
504 
505  /* Free the allocation */
506  free(LanguageData->Name);
507  free(LanguageData);
508 
509  /* Move to the next entry */
510  LanguageData = NextLanguage;
511  }
512 
513  /* We're done! */
515  return TRUE;
516 }
517 
518 BOOLEAN
520 {
521  CHAR OutputFile[13];
522  FILE *FileHandle;
523 
524  /* Build the keyboard name and internal name */
525  strcpy(OutputFile, gKBDName);
526  strcat(OutputFile, ".DEF");
527 
528  /* Open it */
529  FileHandle = fopen(OutputFile, "wt");
530  if (!FileHandle)
531  {
532  /* Fail */
533  printf(" %12s : can't open for write.\n", OutputFile);
534  return FALSE;
535  }
536 
537  /* Write the file exports */
539  "LIBRARY %s\n\n"
540  "EXPORTS\n"
541  " KbdLayerDescriptor @1\n",
542  gKBDName);
543 
544  /* Clean up */
546  return TRUE;
547 }
548 
549 BOOLEAN
550 kbd_c(IN ULONG StateCount,
551  IN PULONG ShiftStates,
553  IN PLAYOUT Layout,
554  IN PVOID DeadKeyData,
555  IN PVOID LigatureData,
556  IN PKEYNAME KeyNameData,
557  IN PKEYNAME KeyNameExtData,
558  IN PKEYNAME KeyNameDeadData)
559 {
560  CHAR OutputFile[13];
561  CHAR KeyNameBuffer[50];
562  CHAR LineBuffer[256];
563  BOOLEAN NeedPlus;
564  FILE *FileHandle;
565  ULONG States[8];
566  ULONG i, j, k;
567  ULONG HighestState;
568  PVKNAME Entry;
569  PCHAR p;
570 
571  /* Build the keyboard name and internal name */
572  strcpy(OutputFile, gKBDName);
573  strcat(OutputFile, ".C");
574 
575  /* Open it */
576  FileHandle = fopen(OutputFile, "wt");
577  if (!FileHandle)
578  {
579  /* Fail */
580  printf(" %12s : can't open for write.\n", OutputFile);
581  return FALSE;
582  }
583 
584  /* Print the header */
586  "/***************************************************************************\\\n"
587  "* Module Name: %s\n*\n* keyboard layout\n"
588  "*\n"
589  "* Copyright (c) 2009, ReactOS Foundation\n"
590  "*\n"
591  "* History:\n"
592  "* KBDTOOL v%d.%02d - Created %s"
593  "\\***************************************************************************/\n\n",
594  OutputFile,
595  gVersion,
596  gSubVersion,
597  asctime(Now));
598 
599  /* What kind of driver is this? */
600  if (FallbackDriver)
601  {
602  /* Fallback only */
603  fprintf(FileHandle, "#include \"precomp.h\"\n");
604  }
605  else
606  {
607  /* Add the includes */
609  "#include <windows.h>\n"
610  "#include \"kbd.h\"\n"
611  "#include \"%s.h\"\n\n",
612  gKBDName);
613  }
614 
615  /* What kind of driver is this? */
616  if (FallbackDriver)
617  {
618  /* Only one section */
620  "#pragma data_seg(\"%s\")\n#define ALLOC_SECTION_LDATA\n\n",
621  ".kbdfallback");
622  }
623  else
624  {
625  /* Section and attributes depend on architecture */
627  "#if defined(_M_IA64)\n"
628  "#pragma section(\"%s\")\n"
629  "#define ALLOC_SECTION_LDATA __declspec(allocate(\"%s\"))\n"
630  "#else\n"
631  "#pragma data_seg(\"%s\")\n"
632  "#define ALLOC_SECTION_LDATA\n"
633  "#endif\n\n",
634  ".data",
635  ".data",
636  ".data");
637  }
638 
639  /* Scan code to virtual key conversion table header */
641  "/***************************************************************************\\\n"
642  "* ausVK[] - Virtual Scan Code to Virtual Key conversion table\n"
643  "\\***************************************************************************/\n\n");
644 
645  /* Table begin */
647  "static ALLOC_SECTION_LDATA USHORT ausVK[] = {\n"
648  " T00, T01, T02, T03, T04, T05, T06, T07,\n"
649  " T08, T09, T0A, T0B, T0C, T0D, T0E, T0F,\n"
650  " T10, T11, T12, T13, T14, T15, T16, T17,\n"
651  " T18, T19, T1A, T1B, T1C, T1D, T1E, T1F,\n"
652  " T20, T21, T22, T23, T24, T25, T26, T27,\n"
653  " T28, T29, T2A, T2B, T2C, T2D, T2E, T2F,\n"
654  " T30, T31, T32, T33, T34, T35,\n\n");
655 
656  /* Table continue */
658  " /*\n"
659  " * Right-hand Shift key must have KBDEXT bit set.\n"
660  " */\n"
661  " T36 | KBDEXT,\n\n"
662  " T37 | KBDMULTIVK, // numpad_* + Shift/Alt -> SnapShot\n\n"
663  " T38, T39, T3A, T3B, T3C, T3D, T3E,\n"
664  " T3F, T40, T41, T42, T43, T44,\n\n");
665 
666  /* Table continue */
668  " /*\n"
669  " * NumLock Key:\n"
670  " * KBDEXT - VK_NUMLOCK is an Extended key\n"
671  " * KBDMULTIVK - VK_NUMLOCK or VK_PAUSE (without or with CTRL)\n"
672  " */\n"
673  " T45 | KBDEXT | KBDMULTIVK,\n\n"
674  " T46 | KBDMULTIVK,\n\n");
675 
676  /* Numpad table */
678  " /*\n"
679  " * Number Pad keys:\n"
680  " * KBDNUMPAD - digits 0-9 and decimal point.\n"
681  " * KBDSPECIAL - require special processing by Windows\n"
682  " */\n"
683  " T47 | KBDNUMPAD | KBDSPECIAL, // Numpad 7 (Home)\n"
684  " T48 | KBDNUMPAD | KBDSPECIAL, // Numpad 8 (Up),\n"
685  " T49 | KBDNUMPAD | KBDSPECIAL, // Numpad 9 (PgUp),\n"
686  " T4A,\n"
687  " T4B | KBDNUMPAD | KBDSPECIAL, // Numpad 4 (Left),\n"
688  " T4C | KBDNUMPAD | KBDSPECIAL, // Numpad 5 (Clear),\n"
689  " T4D | KBDNUMPAD | KBDSPECIAL, // Numpad 6 (Right),\n"
690  " T4E,\n"
691  " T4F | KBDNUMPAD | KBDSPECIAL, // Numpad 1 (End),\n"
692  " T50 | KBDNUMPAD | KBDSPECIAL, // Numpad 2 (Down),\n"
693  " T51 | KBDNUMPAD | KBDSPECIAL, // Numpad 3 (PgDn),\n"
694  " T52 | KBDNUMPAD | KBDSPECIAL, // Numpad 0 (Ins),\n"
695  " T53 | KBDNUMPAD | KBDSPECIAL, // Numpad . (Del),\n\n");
696 
697  /* Table finish */
699  " T54, T55, T56, T57, T58, T59, T5A, T5B,\n"
700  " T5C, T5D, T5E, T5F, T60, T61, T62, T63,\n"
701  " T64, T65, T66, T67, T68, T69, T6A, T6B,\n"
702  " T6C, T6D, T6E, T6F, T70, T71, T72, T73,\n"
703  " T74, T75, T76, T77, T78, T79, T7A, T7B,\n"
704  " T7C, T7D, T7E\n\n"
705  "};\n\n");
706 
707  /* Key name table header */
708  fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_VK aE0VscToVk[] = {\n");
709 
710  /* Loop 110-key table */
711  for (i = 0; i < 110; i++)
712  {
713  /* Check for non-extended keys */
714  if ((Layout->Entry[i].ScanCode & 0xFF00) == 0xE000)
715  {
716  /* Which are valid */
717  if (Layout->Entry[i].ScanCode != 0xFF)
718  {
719  /* And mapped */
720  if (Layout->Entry[i].VirtualKey != 0xFF)
721  {
722  /* Output them */
724  " { 0x%02X, X%02X | KBDEXT }, // %s\n",
725  Layout->Entry[i].ScanCode,
726  Layout->Entry[i].ScanCode,
727  Layout->Entry[i].Name);
728  }
729  }
730  }
731  }
732 
733  /* Key name table finish */
734  fprintf(FileHandle, " { 0, 0 }\n};\n\n");
735 
736  /* Extended key name table header */
737  fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_VK aE1VscToVk[] = {\n");
738 
739  /* Loop 110-key table */
740  for (i = 0; i < 110; i++)
741  {
742  /* Check for extended keys */
743  if ((Layout->Entry[i].ScanCode & 0xFF00) == 0xE100)
744  {
745  /* Which are valid */
746  if (Layout->Entry[i].ScanCode != 0xFF)
747  {
748  /* And mapped */
749  if (Layout->Entry[i].VirtualKey != 0xFF)
750  {
751  /* Output them */
753  " { 0x%02X, Y%02X | KBDEXT }, // %s\n",
754  Layout->Entry[i].ScanCode,
755  Layout->Entry[i].ScanCode,
756  Layout->Entry[i].Name);
757  }
758  }
759  }
760  }
761 
762  /* Extended key name table finish */
764  " { 0x1D, Y1D }, // Pause\n"
765  " { 0 , 0 }\n};\n\n");
766 
767  /* Modifier table description */
769  "/***************************************************************************\\\n"
770  "* aVkToBits[] - map Virtual Keys to Modifier Bits\n"
771  "*\n"
772  "* See kbd.h for a full description.\n"
773  "*\n"
774  "* The keyboard has only three shifter keys:\n"
775  "* SHIFT (L & R) affects alphabnumeric keys,\n"
776  "* CTRL (L & R) is used to generate control characters\n"
777  "* ALT (L & R) used for generating characters by number with numpad\n"
778  "\\***************************************************************************/\n");
779 
780  /* Modifier table header */
781  fprintf(FileHandle, "static ALLOC_SECTION_LDATA VK_TO_BIT aVkToBits[] = {\n");
782 
783  /* Loop modifier table */
784  i = 0;
785  Entry = &Modifiers[0];
786  while (Entry->VirtualKey)
787  {
788  /* Print out entry */
790  " { %-12s, %-12s },\n",
791  getVKName(Entry->VirtualKey, 1),
792  Entry->Name);
793 
794  /* Move to the next one */
795  Entry = &Modifiers[++i];
796  }
797 
798  /* Modifier table finish */
799  fprintf(FileHandle, " { 0, 0 }\n};\n\n");
800 
801  /* Modifier conversion table description */
803  "/***************************************************************************\\\n"
804  "* aModification[] - map character modifier bits to modification number\n"
805  "*\n"
806  "* See kbd.h for a full description.\n"
807  "*\n"
808  "\\***************************************************************************/\n\n");
809 
810  /* Zero out local state data */
811  for (i = 0; i < 8; i++) States[i] = -1;
812 
813  /* Find the highest set state */
814  for (HighestState = 1, i = 0; (i < 8) && (ShiftStates[i] != -1); i++)
815  {
816  /* Save all state values */
817  States[ShiftStates[i]] = i;
818  if (ShiftStates[i] > HighestState) HighestState = ShiftStates[i];
819  }
820 
821  /* Modifier conversion table header */
823  "static ALLOC_SECTION_LDATA MODIFIERS CharModifiers = {\n"
824  " &aVkToBits[0],\n"
825  " %d,\n"
826  " {\n"
827  " // Modification# // Keys Pressed\n"
828  " // ============= // =============\n",
829  HighestState);
830 
831  /* Loop states */
832  for (i = 0; i <= HighestState; i++)
833  {
834  /* Check for invalid state */
835  if (States[i] == -1)
836  {
837  /* Invalid state header */
838  fprintf(FileHandle, " SHFT_INVALID, // ");
839  }
840  else
841  {
842  /* Is this the last one? */
843  if (i == HighestState)
844  {
845  /* Last state header */
846  fprintf(FileHandle, " %d // ", States[i]);
847  }
848  else
849  {
850  /* Normal state header */
851  fprintf(FileHandle, " %d, // ", States[i]);
852  }
853 
854  /* State 1 or higher? */
855  if (i >= 1)
856  {
857  /* J is the loop variable, K is the double */
858  for (NeedPlus = 0, j = 0, k = 1; (1u << j) <= i; j++, k = (1 << j))
859  {
860  /* Do we need to add a plus? */
861  if (NeedPlus)
862  {
863  /* Add it */
864  fprintf(FileHandle, "+");
865  NeedPlus = FALSE;
866  }
867 
868  /* Check if it's time to add a modifier */
869  if (i & k)
870  {
871  /* Get the key state name and copy it into our buffer */
872  strcpy(KeyNameBuffer, getVKName(Modifiers[j].VirtualKey, 1));
873 
874  /* Go go the 4th char (past the "KBD") and lower name */
875  for (p = &KeyNameBuffer[4]; *p; p++) *p = tolower(*p);
876 
877  /* Print it */
878  fprintf(FileHandle, "%s", &KeyNameBuffer[3]);
879 
880  /* We'll need a plus sign next */
881  NeedPlus = TRUE;
882  }
883  }
884  }
885 
886  /* Terminate the entry */
887  fprintf(FileHandle, "\n");
888  }
889  }
890 
891 
892  /* Modifier conversion table end */
893  fprintf(FileHandle," }\n" "};\n\n");
894 
895  /* Shift state translation table description */
897  "/***************************************************************************\\\n"
898  "*\n"
899  "* aVkToWch2[] - Virtual Key to WCHAR translation for 2 shift states\n"
900  "* aVkToWch3[] - Virtual Key to WCHAR translation for 3 shift states\n"
901  "* aVkToWch4[] - Virtual Key to WCHAR translation for 4 shift states\n");
902 
903  /* Check if there's exta shift states */
904  for (i = 5; i < HighestState; i++)
905  {
906  /* Print out extra information */
908  "* aVkToWch%d[] - Virtual Key to WCHAR translation for %d shift states\n",
909  i,
910  i);
911  }
912 
913  /* Shift state translation table description continue */
915  "*\n"
916  "* Table attributes: Unordered Scan, null-terminated\n"
917  "*\n"
918  "* Search this table for an entry with a matching Virtual Key to find the\n"
919  "* corresponding unshifted and shifted WCHAR characters.\n"
920  "*\n"
921  "* Special values for VirtualKey (column 1)\n"
922  "* 0xff - dead chars for the previous entry\n"
923  "* 0 - terminate the list\n"
924  "*\n"
925  "* Special values for Attributes (column 2)\n"
926  "* CAPLOK bit - CAPS-LOCK affect this key like SHIFT\n"
927  "*\n"
928  "* Special values for wch[*] (column 3 & 4)\n"
929  "* WCH_NONE - No character\n"
930  "* WCH_DEAD - Dead Key (diaresis) or invalid (US keyboard has none)\n"
931  "* WCH_LGTR - Ligature (generates multiple characters)\n"
932  "*\n"
933  "\\***************************************************************************/\n\n");
934 
935  /* Loop all the states */
936  for (i = 2; i <= StateCount; i++)
937  {
938  /* Check if this something else than state 2 */
939  if (i != 2)
940  {
941  /* Loop all the scan codes */
942  for (j = 0; j < 110; j++)
943  {
944  /* Check if this is the state for the entry */
945  if (i == Layout->Entry[j].StateCount) break;
946  }
947  }
948 
949  /* Print the table header */
951  "static ALLOC_SECTION_LDATA VK_TO_WCHARS%d aVkToWch%d[] = {\n"
952  "// | | Shift |",
953  i,
954  i);
955 
956  /* Print the correct state label */
957  for (k = 2; k < i; k++) fprintf(FileHandle, "%-9.9s|",
958  StateLabel[ShiftStates[k]]);
959 
960  /* Print the next separator */
961  fprintf(FileHandle, "\n// |=========|=========|");
962 
963  /* Check for extra states and print their separators too */
964  for (k = 2; k < i; k++) fprintf(FileHandle, "=========|");
965 
966  /* Finalize the separator header */
967  fprintf(FileHandle, "\n");
968 
969  /* Loop all the scan codes */
970  for (j = 0; j < 110; j++)
971  {
972  /* Check if this is the state for the entry */
973  if (i != Layout->Entry[j].StateCount) continue;
974 
975  /* Print out the entry for this key */
977  " {%-13s,%-7s",
978  getVKName(Layout->Entry[j].VirtualKey, 1),
979  CapState[Layout->Entry[j].Cap]);
980 
981  /* Initialize the buffer for this line */
982  *LineBuffer = '\0';
983 
984  /* Loop states */
985  for (k = 0; k < i; k++)
986  {
987  /* Check for dead key data */
988  if (DeadKeyData)
989  {
990  /* Not yet supported */
991  printf("Dead key data not supported!\n");
992  exit(1);
993  }
994 
995  /* Check if it's a ligature key */
996  if (Layout->Entry[j].LigatureCharData[k])
997  {
998  /* Not yet supported */
999  printf("Ligature key data not supported!\n");
1000  exit(1);
1001  }
1002 
1003  /* Print out the WCH_ name */
1005  ",%-9s",
1006  WChName(Layout->Entry[j].CharData[k], 0));
1007 
1008  /* If we have something on the line buffer by now, add WCH_NONE */
1009  if (*LineBuffer != '\0') strcpy(LineBuffer, "WCH_NONE ");
1010  }
1011 
1012  /* Finish the line */
1013  fprintf(FileHandle, "},\n");
1014 
1015  /* Do we have any data at all? */
1016  if (*LineBuffer != '\0')
1017  {
1018  /* Print it, we're done */
1019  fprintf(FileHandle, "%s},\n", LineBuffer);
1020  continue;
1021  }
1022 
1023  /* Otherwise, we're done, unless this requires SGCAP data */
1024  if (Layout->Entry[j].Cap != 2) continue;
1025 
1026  /* Not yet supported */
1027  printf("SGCAP not yet supported!\n");
1028  exit(1);
1029  }
1030 
1031  /* Did we only have two states? */
1032  if (i == 2)
1033  {
1034  /* Print out the built-in table */
1036  " {VK_TAB ,0 ,'\\t' ,'\\t' },\n"
1037  " {VK_ADD ,0 ,'+' ,'+' },\n"
1038  " {VK_DIVIDE ,0 ,'/' ,'/' },\n"
1039  " {VK_MULTIPLY ,0 ,'*' ,'*' },\n"
1040  " {VK_SUBTRACT ,0 ,'-' ,'-' },\n");
1041  }
1042 
1043  /* Terminate the table */
1044  fprintf(FileHandle, " {0 ,0 ");
1045  for (k = 0; k < i; k++) fprintf(FileHandle, ",0 ");
1046 
1047  /* Terminate the structure */
1048  fprintf(FileHandle, "}\n" "};\n\n");
1049  }
1050 
1051  /* Numpad translation table */
1053  "// Put this last so that VkKeyScan interprets number characters\n"
1054  "// as coming from the main section of the kbd (aVkToWch2 and\n"
1055  "// aVkToWch5) before considering the numpad (aVkToWch1).\n\n"
1056  "static ALLOC_SECTION_LDATA VK_TO_WCHARS1 aVkToWch1[] = {\n"
1057  " { VK_NUMPAD0 , 0 , '0' },\n"
1058  " { VK_NUMPAD1 , 0 , '1' },\n"
1059  " { VK_NUMPAD2 , 0 , '2' },\n"
1060  " { VK_NUMPAD3 , 0 , '3' },\n"
1061  " { VK_NUMPAD4 , 0 , '4' },\n"
1062  " { VK_NUMPAD5 , 0 , '5' },\n"
1063  " { VK_NUMPAD6 , 0 , '6' },\n"
1064  " { VK_NUMPAD7 , 0 , '7' },\n"
1065  " { VK_NUMPAD8 , 0 , '8' },\n"
1066  " { VK_NUMPAD9 , 0 , '9' },\n"
1067  " { 0 , 0 , '\\0' }\n"
1068  "};\n\n");
1069 
1070  /* Translation tables header */
1071  fprintf(FileHandle,"static ALLOC_SECTION_LDATA VK_TO_WCHAR_TABLE aVkToWcharTable[] = {\n");
1072 
1073  /* Loop states higher than 3 */
1074  for (i = 3; i <= StateCount; i++)
1075  {
1076  /* Print out the extra tables */
1078  " { (PVK_TO_WCHARS1)aVkToWch%d, %d, sizeof(aVkToWch%d[0]) },\n",
1079  i,
1080  i,
1081  i);
1082  }
1083 
1084  /* Array of translation tables */
1086  " { (PVK_TO_WCHARS1)aVkToWch2, 2, sizeof(aVkToWch2[0]) },\n"
1087  " { (PVK_TO_WCHARS1)aVkToWch1, 1, sizeof(aVkToWch1[0]) },\n"
1088  " { NULL, 0, 0 },\n"
1089  "};\n\n");
1090 
1091  /* Scan code to key name conversion table description */
1093  "/***************************************************************************\\\n"
1094  "* aKeyNames[], aKeyNamesExt[] - Virtual Scancode to Key Name tables\n"
1095  "*\n"
1096  "* Table attributes: Ordered Scan (by scancode), null-terminated\n"
1097  "*\n"
1098  "* Only the names of Extended, NumPad, Dead and Non-Printable keys are here.\n"
1099  "* (Keys producing printable characters are named by that character)\n"
1100  "\\***************************************************************************/\n\n");
1101 
1102  /* Check for key name data */
1103  if (KeyNameData)
1104  {
1105  /* Table header */
1106  fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_LPWSTR aKeyNames[] = {\n");
1107 
1108  /* Print table */
1109  PrintNameTable(FileHandle, KeyNameData, FALSE);
1110 
1111  /* Table end */
1112  fprintf(FileHandle, "};\n\n");
1113  }
1114 
1115  /* Check for extended key name data */
1116  if (KeyNameExtData)
1117  {
1118  /* Table header */
1119  fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_LPWSTR aKeyNamesExt[] = {\n");
1120 
1121  /* Print table */
1122  PrintNameTable(FileHandle, KeyNameExtData, FALSE);
1123 
1124  /* Table end */
1125  fprintf(FileHandle, "};\n\n");
1126  }
1127 
1128  /* Check for dead key name data */
1129  if (KeyNameDeadData)
1130  {
1131  /* Not yet supported */
1132  printf("Dead key name data not supported!\n");
1133  exit(1);
1134  }
1135 
1136  /* Check for dead key data */
1137  if (DeadKeyData)
1138  {
1139  /* Not yet supported */
1140  printf("Dead key data not supported!\n");
1141  exit(1);
1142  }
1143 
1144  /* Check for ligature data */
1145  if (LigatureData)
1146  {
1147  /* Not yet supported */
1148  printf("Ligature key data not supported!\n");
1149  exit(1);
1150  }
1151 
1152  /* Main keyboard table descriptor type */
1153  fprintf(FileHandle, "static ");
1154 
1155  /* FIXME? */
1156 
1157  /* Main keyboard table descriptor header */
1159  "ALLOC_SECTION_LDATA KBDTABLES KbdTables%s = {\n"
1160  " /*\n"
1161  " * Modifier keys\n"
1162  " */\n"
1163  " &CharModifiers,\n\n"
1164  " /*\n"
1165  " * Characters tables\n"
1166  " */\n"
1167  " aVkToWcharTable,\n\n"
1168  " /*\n"
1169  " * Diacritics\n"
1170  " */\n",
1171  FallbackDriver ? "Fallback" : "" );
1172 
1173  /* Descriptor dead key data section */
1174  if (DeadKeyData)
1175  {
1176  fprintf(FileHandle, " aDeadKey,\n\n");
1177  }
1178  else
1179  {
1180  fprintf(FileHandle, " NULL,\n\n");
1181  }
1182 
1183  /* Descriptor key name comment */
1185  " /*\n"
1186  " * Names of Keys\n"
1187  " */\n");
1188 
1189  /* Descriptor key name section */
1190  if (KeyNameData)
1191  {
1192  fprintf(FileHandle, " aKeyNames,\n");
1193  }
1194  else
1195  {
1196  fprintf(FileHandle, " NULL,\n");
1197  }
1198 
1199  /* Descriptor extended key name section */
1200  if (KeyNameExtData)
1201  {
1202  fprintf(FileHandle, " aKeyNamesExt,\n");
1203  }
1204  else
1205  {
1206  fprintf(FileHandle, " NULL,\n");
1207  }
1208 
1209  /* Descriptor dead key name section */
1210  if ((DeadKeyData) && (KeyNameDeadData))
1211  {
1212  fprintf(FileHandle, " aKeyNamesDead,\n\n");
1213  }
1214  else
1215  {
1216  fprintf(FileHandle, " NULL,\n\n");
1217  }
1218 
1219  /* Descriptor conversion table section */
1221  " /*\n"
1222  " * Scan codes to Virtual Keys\n"
1223  " */\n"
1224  " ausVK,\n"
1225  " sizeof(ausVK) / sizeof(ausVK[0]),\n"
1226  " aE0VscToVk,\n"
1227  " aE1VscToVk,\n\n"
1228  " /*\n"
1229  " * Locale-specific special processing\n"
1230  " */\n");
1231 
1232  /* FIXME: AttributeData and KLLF_ALTGR stuff */
1233 
1234  /* Descriptor locale-specific section */
1235  fprintf(FileHandle, " MAKELONG(%s, KBD_VERSION),\n\n", "0"); /* FIXME */
1236 
1237  /* Descriptor ligature data comment */
1238  fprintf(FileHandle, " /*\n * Ligatures\n */\n %d,\n", 0); /* FIXME */
1239 
1240  /* Descriptor ligature data section */
1241  if (!LigatureData)
1242  {
1243  fprintf(FileHandle, " 0,\n");
1244  fprintf(FileHandle, " NULL\n");
1245  }
1246  else
1247  {
1248  fprintf(FileHandle, " sizeof(aLigature[0]),\n");
1249  fprintf(FileHandle, " (PLIGATURE1)aLigature\n");
1250  }
1251 
1252  /* Descriptor finish */
1253  fprintf(FileHandle, "};\n\n");
1254 
1255  /* Keyboard layout callback function */
1257  "PKBDTABLES KbdLayerDescriptor(VOID)\n"
1258  "{\n"
1259  " return &KbdTables;\n"
1260  "}\n");
1261 
1262  /* Clean up */
1263  fclose(FileHandle);
1264  return TRUE;
1265 }
1266 
1267 ULONG
1268 DoOutput(IN ULONG StateCount,
1269  IN PULONG ShiftStates,
1270  IN PKEYNAME DescriptionData,
1271  IN PKEYNAME LanguageData,
1273  IN PVOID DeadKeyData,
1274  IN PVOID LigatureData,
1275  IN PKEYNAME KeyNameData,
1276  IN PKEYNAME KeyNameExtData,
1277  IN PKEYNAME KeyNameDeadData)
1278 {
1279  ULONG FailureCode = 0;
1280 
1281  /* Take the time */
1282  time(&Clock);
1283  Now = localtime(&Clock);
1284 
1285  /* Check if this just a fallback driver*/
1286  if (!FallbackDriver)
1287  {
1288  /* It's not, create header file */
1289  if (!kbd_h(&g_Layout)) FailureCode = 1;
1290 
1291  /* Create the resource file */
1292  if (!kbd_rc(DescriptionData, LanguageData)) FailureCode = 2;
1293  }
1294 
1295  /* Create the C file */
1296  if (!kbd_c(StateCount,
1297  ShiftStates,
1298  AttributeData,
1299  &g_Layout,
1300  DeadKeyData,
1301  LigatureData,
1302  KeyNameData,
1303  KeyNameExtData,
1304  KeyNameDeadData))
1305  {
1306  /* Failed in C file generation */
1307  FailureCode = 3;
1308  }
1309 
1310  /* Check if this just a fallback driver*/
1311  if (!FallbackDriver)
1312  {
1313  /* Generate the definition file */
1314  if (!kbd_def()) FailureCode = 4;
1315  }
1316 
1317  /* Done */
1318  return FailureCode;
1319 }
1320 
1321 
1322 /* EOF */
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
signed char * PCHAR
Definition: retypes.h:7
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING KeyName
Definition: ndis.h:4711
#define IN
Definition: typedefs.h:38
LAYOUT g_Layout
Definition: parser.c:25
#define TRUE
Definition: types.h:120
static char gCopyright[]
Definition: ftp.c:28
PCHAR WChName(IN ULONG Char, IN BOOLEAN AddZero)
Definition: output.c:25
struct _Entry Entry
Definition: kefuncs.h:640
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
PCHAR CapState[]
Definition: data.c:135
char CHAR
Definition: xmlstorage.h:175
#define free
Definition: debug_ros.c:5
VKNAME Modifiers[]
Definition: data.c:56
CHAR gCompany[256]
Definition: parser.c:20
__u16 time
Definition: mkdosfs.c:366
BOOLEAN kbd_def(VOID)
Definition: output.c:519
CHAR gDescription[256]
Definition: parser.c:19
CHAR gCharName[32]
Definition: output.c:20
_Check_return_ _CRTIMP char *__cdecl asctime(_In_ const struct tm *_Tm)
BOOLEAN kbd_h(IN PLAYOUT Layout)
Definition: output.c:195
BOOLEAN kbd_rc(IN PKEYNAME DescriptionData, IN PKEYNAME LanguageData)
Definition: output.c:318
#define sprintf(buf, format,...)
Definition: sprintf.c:55
HANDLE FileHandle
Definition: stats.c:38
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
time_t Clock
Definition: output.c:18
unsigned int BOOL
Definition: ntddk_ex.h:94
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
struct NameRec_ * Name
Definition: cdprocs.h:464
unsigned char BOOLEAN
Definition: bufpool.h:45
BOOLEAN FallbackDriver
Definition: main.c:24
BOOLEAN kbd_c(IN ULONG StateCount, IN PULONG ShiftStates, IN PVOID AttributeData, IN PLAYOUT Layout, IN PVOID DeadKeyData, IN PVOID LigatureData, IN PKEYNAME KeyNameData, IN PKEYNAME KeyNameExtData, IN PKEYNAME KeyNameDeadData)
Definition: output.c:550
struct tagKEYNAME * Next
Definition: kbdtool.h:31
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
size_t CDECL strftime(char *str, size_t max, const char *format, const struct tm *mstm)
Definition: strftime.c:293
ULONG gStringIdForDescriptions
Definition: output.c:15
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
PCHAR StateLabel[]
Definition: data.c:64
struct tm * Now
Definition: output.c:19
ULONG gSubVersion
Definition: main.c:17
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
Definition: time.h:76
_CRTIMP struct tm *__cdecl localtime(const time_t *_Time)
Definition: time.h:424
PCHAR getVKName(IN ULONG VirtualKey, IN BOOLEAN Prefix)
Definition: parser.c:65
CHAR gKBDName[10]
Definition: parser.c:17
__kernel_time_t time_t
Definition: linux.h:252
unsigned short USHORT
Definition: pedump.c:61
CHAR gLocaleName[256]
Definition: parser.c:21
unsigned int * PULONG
Definition: retypes.h:1
char * strchr(const char *String, int ch)
Definition: utclib.c:501
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
ULONG gStringIdForLocaleName
Definition: output.c:17
unsigned int ULONG
Definition: retypes.h:1
ULONG gStringIdForLanguageNames
Definition: output.c:16
void exit(int exitcode)
Definition: _exit.c:33
GLfloat GLfloat p
Definition: glext.h:8902
VOID PrintNameTable(FILE *FileHandle, PKEYNAME KeyName, BOOL DeadKey)
Definition: output.c:91
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
int tolower(int c)
Definition: utclib.c:902
int k
Definition: mpi.c:3369
base of all file and directory entries
Definition: entries.h:82
CHAR gVersion[]
Definition: init.c:22
#define printf
Definition: config.h:203
ULONG DoOutput(IN ULONG StateCount, IN PULONG ShiftStates, IN PKEYNAME DescriptionData, IN PKEYNAME LanguageData, IN PVOID AttributeData, IN PVOID DeadKeyData, IN PVOID LigatureData, IN PKEYNAME KeyNameData, IN PKEYNAME KeyNameExtData, IN PKEYNAME KeyNameDeadData)
Definition: output.c:1268