ReactOS 0.4.15-dev-5666-gc548b97
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
19struct tm *Now;
21
22/* FUNCTIONS ******************************************************************/
23
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
90VOID
93 BOOL DeadKey)
94{
95 CHAR CharBuffer[255];
96 PKEYNAME NextName;
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
196{
197 CHAR OutputFile[13];
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,
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
318kbd_rc(IN PKEYNAME DescriptionData,
319 IN PKEYNAME LanguageData)
320{
321 CHAR OutputFile[13];
322 CHAR InternalName[13];
323 CHAR TimeBuffer[5];
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,
382 gVersion,
384 gCompany,
386 gVersion,
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,
407 "Created by ReactOS KbdTool",
408 "Created by ReactOS KbdTool",
410 InternalName,
411 gVersion,
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
520{
521 CHAR OutputFile[13];
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
550kbd_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;
565 ULONG States[8];
566 ULONG i, j, k;
567 ULONG HighestState;
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,
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 */
1264 return TRUE;
1265}
1266
1267ULONG
1268DoOutput(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,
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 */
unsigned char BOOLEAN
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
int tolower(int c)
Definition: utclib.c:902
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
char * strchr(const char *String, int ch)
Definition: utclib.c:501
struct NameRec_ * Name
Definition: cdprocs.h:460
Definition: bufpool.h:45
#define free
Definition: debug_ros.c:5
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
@ AttributeData
Definition: ntfs.h:168
__kernel_time_t time_t
Definition: linux.h:252
CHAR gVersion[]
Definition: init.c:22
unsigned int BOOL
Definition: ntddk_ex.h:94
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
#define printf
Definition: freeldr.h:94
GLfloat GLfloat p
Definition: glext.h:8902
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
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
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
CHAR gDescription[256]
Definition: parser.c:19
PCHAR getVKName(IN ULONG VirtualKey, IN BOOLEAN Prefix)
Definition: parser.c:65
LAYOUT g_Layout
Definition: parser.c:25
CHAR gKBDName[10]
Definition: parser.c:17
CHAR gLocaleName[256]
Definition: parser.c:21
BOOLEAN FallbackDriver
Definition: kbdtool.h:95
ULONG gSubVersion
Definition: kbdtool.h:110
CHAR gCompany[256]
Definition: parser.c:20
unsigned int * PULONG
Definition: retypes.h:1
signed char * PCHAR
Definition: retypes.h:7
unsigned int ULONG
Definition: retypes.h:1
__u16 time
Definition: mkdosfs.c:8
static char gCopyright[]
Definition: ftp.c:28
#define sprintf(buf, format,...)
Definition: sprintf.c:55
int k
Definition: mpi.c:3369
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
unsigned short USHORT
Definition: pedump.c:61
_Check_return_ _CRTIMP char *__cdecl asctime(_In_ const struct tm *_Tm)
_CRTIMP struct tm *__cdecl localtime(const time_t *_Time)
Definition: time.h:416
#define exit(n)
Definition: config.h:202
VKNAME Modifiers[]
Definition: data.c:56
PCHAR StateLabel[]
Definition: data.c:64
PCHAR CapState[]
Definition: data.c:135
BOOLEAN kbd_h(IN PLAYOUT Layout)
Definition: output.c:195
struct tm * Now
Definition: output.c:19
PCHAR WChName(IN ULONG Char, IN BOOLEAN AddZero)
Definition: output.c:25
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
BOOLEAN kbd_rc(IN PKEYNAME DescriptionData, IN PKEYNAME LanguageData)
Definition: output.c:318
CHAR gCharName[32]
Definition: output.c:20
ULONG gStringIdForDescriptions
Definition: output.c:15
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
BOOLEAN kbd_def(VOID)
Definition: output.c:519
VOID PrintNameTable(FILE *FileHandle, PKEYNAME KeyName, BOOL DeadKey)
Definition: output.c:91
ULONG gStringIdForLocaleName
Definition: output.c:17
ULONG gStringIdForLanguageNames
Definition: output.c:16
time_t Clock
Definition: output.c:18
size_t CDECL strftime(char *str, size_t max, const char *format, const struct tm *mstm)
Definition: strftime.c:293
base of all file and directory entries
Definition: entries.h:83
UNICODE_STRING Name
Definition: fltmgrint.h:145
struct tagKEYNAME * Next
Definition: kbdtool.h:31
Definition: time.h:68
#define IN
Definition: typedefs.h:39
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
char CHAR
Definition: xmlstorage.h:175