|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 Tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - downloadIndex: ┃ B T ┃
Length: 86204 (0x150bc)
Types: TextFile
Names: »B«
└─⟦85b835f43⟧ Bits:30000549 8mm tape, Rational 1000, Xlib rev 6.00
└─ ⟦0c20f784e⟧ »DATA«
└─⟦1abbe589f⟧
└─⟦059497ac5⟧
└─⟦this⟧
with Text_Io;
with Xlbt_Arithmetic;
use Xlbt_Arithmetic;
with Xlbt_Basic;
use Xlbt_Basic;
with Xlbt_Event2;
use Xlbt_Event2;
with Xlbt_Key;
use Xlbt_Key;
with Xlbt_Key2;
use Xlbt_Key2;
with Xlbt_Key_Defs;
use Xlbt_Key_Defs;
with Xlbt_String;
use Xlbt_String;
with Xlbp_Keyboard_Encoding;
use Xlbp_Keyboard_Encoding;
with Xlbit_Library2;
use Xlbit_Library2;
with Xlbit_Library4;
use Xlbit_Library4;
with Xlbip_Internal;
use Xlbip_Internal;
with Xlbmt_Network_Types;
use Xlbmt_Network_Types;
with Xlbmt_Parameters;
use Xlbmt_Parameters;
with Xlbmp_Error_Log;
use Xlbmp_Error_Log;
package body Xlbp_Key is
------------------------------------------------------------------------------
-- X Library Keys
--
-- Xlbp_Key - Used to translate key codes to/from key symbols and strings.
------------------------------------------------------------------------------
-- Copyright 1989 - 1991 by Rational, Santa Clara, California.
-- Copyright 1987 - 1989 by Digital Equipment Corporation, Maynard, Mass.
-- Copyright 1987 - 1989 by Massachusetts Institute of Technology,
-- Cambridge, Massachusetts.
--
-- All Rights Reserved.
--
-- Permission to use, copy, modify, and distribute this software and its
-- documentation for any purpose and without fee is hereby granted,
-- provided that the above copyright notice(s) appear in all copies and that
-- both that copyright notice(s) and this permission notice appear in
-- supporting documentation, and that the names of Digital, MIT, or Rational
-- not be used in advertising or publicity pertaining to distribution of
-- the software without specific, written prior permission.
--
-- Digital, MIT, and Rational disclaim all warranties with regard to this
-- software, including all implied warranties of merchantability and fitness,
-- in no event shall Digital, MIT, or Rational be liable for any special,
-- indirect or consequential damages or any damages whatsoever resulting from
-- loss of use, data or profits, whether in an action of contract, negligence
-- or other tortious action, arising out of or in connection with the use or
-- performance of this software.
------------------------------------------------------------------------------
-- ****************************************************************************
-- * Date - /Name/ Comment
-- *
-- * 7-NOV-90 - /GEB/ Implement the new multitasking protection scheme for
-- * - library state.
-- ****************************************************************************
All_Mods : constant X_Key_Button_Mask :=
X_Key_Button_Mask'
(Shift_Mask | Lock_Mask | Control_Mask | Mod_1_Mask |
Mod_2_Mask | Mod_3_Mask | Mod_4_Mask | Mod_5_Mask => True,
others => False);
type X_Mod_Mask_Array is array (X_Key_Modifier) of X_Key_Button_Mask;
Mod_Mask : constant X_Mod_Mask_Array :=
(Shift_Map_Index =>
X_Key_Button_Mask'(Shift_Mask => True, others => False),
Lock_Map_Index =>
X_Key_Button_Mask'(Lock_Mask => True, others => False),
Control_Map_Index =>
X_Key_Button_Mask'(Control_Mask => True, others => False),
Mod_1_Map_Index =>
X_Key_Button_Mask'(Mod_1_Mask => True, others => False),
Mod_2_Map_Index =>
X_Key_Button_Mask'(Mod_2_Mask => True, others => False),
Mod_3_Map_Index =>
X_Key_Button_Mask'(Mod_3_Mask => True, others => False),
Mod_4_Map_Index =>
X_Key_Button_Mask'(Mod_4_Mask => True, others => False),
Mod_5_Map_Index =>
X_Key_Button_Mask'(Mod_5_Mask => True, others => False));
function Initialize (Display : X_Display) return Boolean;
procedure Initialize_Ks_Info_Map;
--\f
function Find_Key_Code (Display : X_Display;
Code : X_Key_Sym) return X_Key_Code is
------------------------------------------------------------------------------
-- given a Key_Sym, returns the first key_code found after the index value
-- in the table. (Hopefully, can be found quickly).
------------------------------------------------------------------------------
begin
for I in Display.Key_Syms'Range (1) loop
for J in Display.Key_Syms'Range (2) loop
if Display.Key_Syms (I, J) = Code then
--/ if not TeleGen2_2d_Bug then
return I;
--/ else
--// return X_Key_Code (I);
--/ end if;
end if;
end loop;
end loop;
return 0;
end Find_Key_Code;
--\f
procedure Compute_Mask_From_Key_Trans (Display : X_Display;
P : X_Key_Trans) is
------------------------------------------------------------------------------
-- given a list of modifiers, computes the mask necessary for later matching.
-- This routine must lookup the key in the Keymap and then search to see
-- what modifier it is bound to, if any.
------------------------------------------------------------------------------
Code : X_Key_Code;
M : X_Modifier_Keymap := Display.Modifier_Map;
begin
P.State := X_Key_Button_Mask'(Any_Modifier => True, others => False);
for I in P.Modifiers'Range loop
-- if not found, then not on current keyboard
Code := Find_Key_Code (Display, P.Modifiers (I));
if Code = 0 then
return;
end if;
-- code is now the keycode for the modifier you want
for J in M.Modifiermap'Range loop
for K in M.Modifiermap (J)'Range loop
if M.Modifiermap (J) (K) = Code then
P.State := P.State or Mod_Mask (K);
exit;
end if;
end loop;
end loop;
end loop;
P.State (Any_Modifier) := False;
end Compute_Mask_From_Key_Trans;
--\f
procedure X_Convert_Case (Display : X_Display;
Sym : X_Key_Sym;
Lower : out X_Key_Sym;
Upper : out X_Key_Sym) is
------------------------------------------------------------------------------
-- Display - Specifies the display to use
-- Sym - Specifies the symbol to upper/lower casify
-- Lower - Receives the lower case version
-- Upper - Receives the upper case version
--
-- Called with a symbol in order to obtain the upper and lower case versions
-- of the symbol if there are such things. ie. 'A' and 'a' both have uc/lc
-- versions but '%' doesn't.
------------------------------------------------------------------------------
use Latin1;
begin
Lower := Sym;
Upper := Sym;
if Sym > 16#FF# then
return;
end if;
if Sym >= Xk_S_A and then Sym <= Xk_S_Z then
Lower := Sym + (Xk_A - Xk_S_A);
elsif Sym >= Xk_A and then Sym <= Xk_Z then
Upper := Sym - (Xk_A - Xk_S_A);
elsif Sym >= Xk_S_Agrave and then Sym <= Xk_S_Odiaeresis then
Lower := Sym + (Xk_Agrave - Xk_S_Agrave);
elsif Sym >= Xk_Agrave and then Sym <= Xk_Odiaeresis then
Upper := Sym - (Xk_Agrave - Xk_S_Agrave);
elsif Sym >= Xk_Ooblique and then Sym <= Xk_S_Thorn then
Lower := Sym + (Xk_Oslash - Xk_Ooblique);
elsif Sym >= Xk_Oslash and then Sym <= Xk_Thorn then
Upper := Sym - (Xk_Oslash - Xk_Ooblique);
end if;
end X_Convert_Case;
--\f
function Key_Code_To_Key_Sym (Display : X_Display;
Key_Code : X_Key_Code;
Col : U_Char) return X_Key_Sym is
Col_Odd : U_Char;
Col_Even : U_Char;
Per : U_Char;
Lc : X_Key_Sym;
Uc : X_Key_Sym;
begin
----If the Key_Code is nonsense or if the Col is not in the 0..3 range and
-- is also out of the Key_Syms range then return No_Symbol.
--/ if not TeleGen2_2d_Bug then
if not (Key_Code in Display.Key_Syms'Range (1)) then
--/ else
--// if not (TeleGen2_2d_Bug(Key_Code) in Display.Key_Syms'Range (1)) then
--/ end if;
return No_Symbol;
end if;
if Col < Display.Key_Syms'First (2) or else
(Col > Display.Key_Syms'Last (2) and then Col >= 4) then
return No_Symbol;
end if;
----If Col is in the 0..3 range then we have an answer even if we have to
-- compute it.
if Col < 4 then
----Locate the last non-No_Symbol entry for this Key_Code.
Col_Odd := Col;
Per := Display.Key_Syms'Last (2);
if Col > 1 then
while Per >= 2 and then
--/ if not TeleGen2_2d_Bug then
Display.Key_Syms (Key_Code, Per) = No_Symbol loop
--/ else
--// Display.Key_Syms (TeleGen2_2d_Bug(Key_Code), Per) =
--// No_Symbol loop
--/ end if;
Per := Per - 1;
end loop;
if Per < 2 then
Col_Odd := Col_Odd - 1;
end if;
end if;
----If the even/odd pair of X_Key_Syms indexed by Col is a single symbol and
-- a No_Symbol then do the X_Convert_Case call to see if we have an upper/lower
-- case alphabetical.
Col_Even := Col_Odd - Col_Odd rem 2;
Col_Odd := Col_Even + 1;
if Per < Col_Odd or else
--/ if not TeleGen2_2d_Bug then
Display.Key_Syms (Key_Code, Col_Odd) = No_Symbol then
X_Convert_Case
(Display, Display.Key_Syms (Key_Code, Col_Even), Lc, Uc);
--/ else
--// Display.Key_Syms (TeleGen2_2d_Bug(Key_Code), Col_Odd) =
--// No_Symbol then
--// X_Convert_Case (Display,
--// Display.Key_Syms (TeleGen2_2d_Bug(Key_Code),
--// Col_Even),
--// Lc,
--// Uc);
--/ end if;
if Col rem 2 = 0 then
return Lc;
else
if Lc = Uc then
return No_Symbol;
else
return Uc;
end if;
end if;
end if;
end if;
----Otherwise return whatever is in the table.
--/ if not TeleGen2_2d_Bug then
return Display.Key_Syms (Key_Code, Col);
--/ else
--// return Display.Key_Syms (TeleGen2_2d_Bug(Key_Code), Col);
--/ end if;
end Key_Code_To_Key_Sym;
--\f
function Init_Mod_Map (Display : X_Display) return Boolean is
Map : X_Modifier_Keymap;
Sym : X_Key_Sym;
P : X_Key_Trans;
begin
Map := X_Get_Modifier_Mapping (Display);
Display.Modifier_Map := Map;
if Map = None_X_Modifier_Keymap then
return False;
end if;
if Display.Key_Syms = null and then not Initialize (Display) then
return False;
end if;
Lock_Display (Display);
----If any Lock key contains Caps_Lock, then interpret as Caps_Lock,
-- else if any contains Shift_Lock, then interpret as Shift_Lock,
-- else ignore Lock altogether.
Display.Lock_Meaning := No_Symbol;
----Lock modifiers are in the second row of the matrix.
for I in Map.Modifiermap'Range loop
for J in Display.Key_Syms'Range (2) loop
Sym :=
Key_Code_To_Key_Sym (Display,
Map.Modifiermap (I) (Lock_Map_Index),
J);
if Sym = Misc.Xk_Caps_Lock then
Display.Lock_Meaning := Misc.Xk_Caps_Lock;
exit;
elsif Sym = Misc.Xk_Shift_Lock then
Display.Lock_Meaning := Misc.Xk_Shift_Lock;
end if;
end loop;
end loop;
----Now find any Mod<n> modifier acting as the Group modifier.
Display.Mode_Switch := None_X_Key_Button_Mask;
for I in Map.Modifiermap'Range loop
for J in Display.Key_Syms'Range (2) loop
for K in Mod_1_Map_Index .. Mod_5_Map_Index loop
Sym := Key_Code_To_Key_Sym (Display,
Map.Modifiermap (I) (K),
J);
if Sym = Misc.Xk_Mode_Switch then
Display.Mode_Switch :=
Display.Mode_Switch or Mod_Mask (K);
end if;
end loop;
end loop;
end loop;
P := Display.Key_Bindings;
while P /= null loop
Compute_Mask_From_Key_Trans (Display, P);
P := P.Next;
end loop;
Unlock_Display (Display);
return True;
end Init_Mod_Map;
--\f
function Initialize (Display : X_Display) return Boolean is
Ks : X_Key_Sym_List_2d;
begin
----Let's go get the key_syms from the server.
if Display.Key_Syms = null then
----Get the keysym array from the server.
Ks := X_Get_Keyboard_Mapping (Display,
Display.Min_Keycode,
Display.Max_Keycode);
----Stick the table into the display.
Lock_Display (Display);
Display.Key_Syms := Ks;
Unlock_Display (Display);
end if;
----Check the modifier and translation tables also.
if Display.Modifier_Map = null and then not Init_Mod_Map (Display) then
return False;
end if;
return Ks /= null;
end Initialize;
--\f
function X_Key_Code_To_Key_Sym (Display : X_Display;
Key_Code : X_Key_Code;
Column : U_Char) return X_Key_Sym is
begin
if Display.Key_Syms = null and then not Initialize (Display) then
return No_Symbol;
end if;
return Key_Code_To_Key_Sym (Display, Key_Code, Column);
end X_Key_Code_To_Key_Sym;
--\f
function X_Key_Sym_To_Key_Code (Display : X_Display;
Key_Symbol : X_Key_Sym) return X_Key_Code is
begin
if Display.Key_Syms = null and then not Initialize (Display) then
return None_X_Key_Code;
end if;
for I in Display.Key_Syms'Range (1) loop
for J in Display.Key_Syms'Range (2) loop
--/ if not TeleGen2_2d_Bug then
if Key_Code_To_Key_Sym (Display, I, J) = Key_Symbol then
return I;
end if;
--/ else
--// if Key_Code_To_Key_Sym (Display, X_Key_Code (I), J) = key_symbol then
--// return X_Key_Code (I);
--// end if;
--/ end if;
end loop;
end loop;
return 0;
end X_Key_Sym_To_Key_Code;
--\f
function X_Key_Sym_To_String (Key_Symbol : X_Key_Sym) return X_String is
use X_Ks_Info_Map;
Iter : X_Ks_Info_Map.Iter;
Flags : S_Long;
Map : X_Ks_Info_Map.Map renames X_Lib_Ks_Info_Map;
begin
if Map = None_Map then
Initialize_Ks_Info_Map;
end if;
Initialize (Map, Iter, Key_Symbol);
if Done (Iter) then
return "";
else
declare
Str : constant X_String := Key (Iter);
begin
return Str;
end;
end if;
end X_Key_Sym_To_String;
--\f
function X_Lookup_Key_Sym (Event : X_Event;
Column : U_Char) return X_Key_Sym is
begin
if Event.Display.Key_Syms = null and then
not Initialize (Event.Display) then
return No_Symbol;
end if;
return Key_Code_To_Key_Sym (Event.Display, Event.Key.Key_Code, Column);
end X_Lookup_Key_Sym;
--\f
procedure X_Translate_Key (Display : X_Display;
Key_Code : X_Key_Code;
Modifiers : X_Key_Button_Mask;
Modifiers_Return : out X_Key_Button_Mask;
Key_Sym_Return : out X_Key_Sym;
Status : out X_Status) is
Per : U_Char;
K1 : X_Key_Sym;
K2 : X_Key_Sym;
Sym : X_Key_Sym;
Lsym : X_Key_Sym;
Usym : X_Key_Sym;
begin
if Display.Key_Syms = null and then not Initialize (Display) then
Status := Failed;
return;
end if;
Modifiers_Return := Display.Mode_Switch;
Modifiers_Return (Shift_Mask) := True;
Modifiers_Return (Lock_Mask) := True;
--/ if not TeleGen2_2d_Bug then
if Key_Code not in Display.Key_Syms'Range (1) then
--/ else
--// if TeleGen2_2d_Bug(Key_Code) not in Display.Key_Syms'Range (1) then
--/ end if;
Key_Sym_Return := No_Symbol;
Status := Successful;
return;
end if;
Per := Display.Key_Syms'Length (2);
while Per > 2 and then
--/ if not TeleGen2_2d_Bug then
Display.Key_Syms (Key_Code, Per - 1) = No_Symbol loop
--/ else
--// Display.Key_Syms (TeleGen2_2d_Bug(Key_Code), Per - 1) =
--// No_Symbol loop
--/ end if;
Per := Per - 1;
end loop;
--/ if not TeleGen2_2d_Bug then
if Per > 2 and then
(Modifiers and Display.Mode_Switch) /= None_X_Key_Button_Mask then
K1 := Display.Key_Syms (Key_Code, 2);
if Per > 3 then
K2 := Display.Key_Syms (Key_Code, 3);
else
K2 := No_Symbol;
end if;
Per := Per - 2;
else
K1 := Display.Key_Syms (Key_Code, 0);
if Per > 1 then
K2 := Display.Key_Syms (Key_Code, 1);
else
K2 := No_Symbol;
end if;
end if;
--/ else
--// if Per > 2 and then
--// (Modifiers and Display.Mode_Switch) /= None_X_Key_Button_Mask then
--// K1 := Display.Key_Syms (TeleGen2_2d_Bug (Key_Code), 2);
--// if Per > 3 then
--// K2 := Display.Key_Syms (TeleGen2_2d_Bug (Key_Code), 3);
--// else
--// K2 := No_Symbol;
--// end if;
--// Per := Per - 2;
--// else
--// K1 := Display.Key_Syms (TeleGen2_2d_Bug (Key_Code), 0);
--// if Per > 1 then
--// K2 := Display.Key_Syms (TeleGen2_2d_Bug (Key_Code), 1);
--// else
--// K2 := No_Symbol;
--// end if;
--// end if;
--//
--/ end if;
if not Modifiers (Shift_Mask) and then
(not Modifiers (Lock_Mask) or else
Display.Lock_Meaning = No_Symbol) then
if Per = 1 or else K2 = No_Symbol then
X_Convert_Case (Display, K1, Lsym, Usym);
Usym := Lsym;
else
Usym := K1;
end if;
elsif not Modifiers (Lock_Mask) or else
Display.Lock_Meaning /= Misc.Xk_Caps_Lock then
if Per = 1 or else K2 = No_Symbol then
X_Convert_Case (Display, K1, Lsym, Usym);
else
Usym := K2;
end if;
else
if Per = 1 or else K2 = No_Symbol then
Sym := K1;
else
Sym := K2;
end if;
X_Convert_Case (Display, Sym, Lsym, Usym);
if not Modifiers (Shift_Mask) and then
(Sym /= K1) and then
((Sym /= Usym) or else (Lsym = Usym)) then
X_Convert_Case (Display, K1, Lsym, Usym);
end if;
end if;
if Usym = Misc.Xk_Void_Symbol then
Key_Sym_Return := No_Symbol;
else
Key_Sym_Return := Usym;
end if;
Status := Successful;
end X_Translate_Key;
--\f
procedure X_Translate_Key_Sym (Display : X_Display;
Symbol : X_Key_Sym;
Modifiers : X_Key_Button_Mask;
Buffer : in out X_String;
Result : out S_Natural;
Status : out X_Status) is
P : X_Key_Trans;
Hi_Bytes : S_Long;
C : S_Long;
begin
if Symbol = No_Symbol then
Result := 0;
Status := Failed;
return;
end if;
----See if symbol is rebound, if so, return that string.
P := Display.Key_Bindings;
while P /= None_X_Key_Trans loop
if (Modifiers and All_Mods) = P.State and then
Symbol = P.Key then
if P.Str'Length > Buffer'Length then
Result := Buffer'Length;
Buffer := P.Str (P.Str'First ..
P.Str'First + Buffer'Length - 1);
else
Result := P.Str'Length;
Buffer (Buffer'First .. Buffer'First + P.Str'Length - 1) :=
P.Str.all;
end if;
Status := Successful;
return;
end if;
P := P.Next;
end loop;
----Try to convert to Latin-1, handling control.
Hi_Bytes := S_Long (Symbol) / 2 ** 8;
if Buffer'Length = 0 or else
Hi_Bytes in 1 .. 16#FE# or else
(Hi_Bytes = 16#FF# and then
not (Symbol in Misc.Xk_Backspace .. Misc.Xk_Clear or else
Symbol = Misc.Xk_Return or else
Symbol = Misc.Xk_Escape or else
Symbol = Latin1.Xk_Space or else
Symbol = Misc.Xk_Tab or else
Symbol = Misc.Xk_Kp_Enter or else
Symbol in Misc.Xk_Kp_Multiply .. Misc.Xk_Kp_9 or else
Symbol = Misc.Xk_Kp_Equal or else
Symbol = Misc.Xk_Delete)) then
Result := 0;
Status := Failed;
return;
end if;
----If X keysym, convert to ascii by grabbing low 7 bits.
if Symbol = Misc.Xk_Kp_Space then
C := S_Long (Latin1.Xk_Space) rem 16#0080#; -- patch encoding botch
elsif Symbol = Latin1.Xk_Hyphen then
C := S_Long (Latin1.Xk_Minus) rem
16#0100#; -- map to equiv character */
elsif Hi_Bytes = 16#FF# then
C := S_Long (Symbol) rem 16#0080#;
else
C := S_Long (Symbol) rem 16#0100#;
end if;
----Only apply Control key if it makes sense, else ignore it.
if Modifiers (Control_Mask) then
if (C >= Character'Pos ('@') and then
C < Character'Pos (Ascii.Del)) or else
C = Character'Pos (' ') then
C := C rem 16#20#;
elsif C = Character'Pos ('2') then
C := 0;
elsif C >= Character'Pos ('3') and then
C <= Character'Pos ('7') then
C := C - (Character'Pos ('3') - Character'Pos (Ascii.Esc));
elsif C = Character'Pos ('8') then
C := Character'Pos (Ascii.Del);
elsif C = Character'Pos ('/') then
C := Character'Pos ('_') rem 16#20#;
end if;
end if;
Buffer (Buffer'First) := X_Character'Val (C);
Result := 1;
Status := Successful;
end X_Translate_Key_Sym;
--\f
procedure X_Lookup_String (Event : X_Event;
Buffer : in out X_String;
Result : out S_Natural;
Key_Symbol : out X_Key_Sym;
Status : out X_Compose_Status) is
Modifiers : X_Key_Button_Mask;
Symbol : X_Key_Sym;
Succ : X_Status;
begin
Status := (Compose_Ptr => None_X_String_Pointer, Chars_Matched => 0);
X_Translate_Key (Event.Display, Event.Key.Key_Code,
Event.Key.State, Modifiers, Symbol, Succ);
if Succ /= Successful then
Key_Symbol := No_Symbol;
Result := 0;
return;
end if;
Key_Symbol := Symbol;
X_Translate_Key_Sym (Event.Display, Symbol, Event.Key.State,
Buffer, Result, Succ);
--We don't care what the Succ is from this.
end X_Lookup_String;
--\f
procedure X_Rebind_Key_Sym (Display : X_Display;
Key_Symbol : X_Key_Sym;
Modifier_List : X_Key_Sym_Array;
Binding : X_String) is
P : X_Key_Trans;
begin
if Display.Key_Syms = null and then not Initialize (Display) then
return;
end if;
P := new X_Key_Trans_Rec;
Lock_Display (Display);
begin
P.Next := Display.Key_Bindings; -- chain onto list
Display.Key_Bindings := P;
P.Str := new X_String'(Binding);
P.Modifiers := new X_Key_Sym_Array'(Modifier_List);
P.Key := Key_Symbol;
Compute_Mask_From_Key_Trans (Display, P);
exception
when others =>
Display.Key_Bindings := P.Next;
Free_X_String_Pointer (P.Str);
Free_X_Key_Sym_List (P.Modifiers);
Free_X_Key_Trans (P);
Unlock_Display (Display);
raise;
end;
Unlock_Display (Display);
end X_Rebind_Key_Sym;
--\f
function X_String_To_Key_Sym (Name : X_String) return X_Key_Sym is
use X_Ks_Info_Map;
Ks : X_Key_Sym := No_Symbol;
Succ : Boolean;
Flags : S_Long;
Map : X_Ks_Info_Map.Map renames X_Lib_Ks_Info_Map;
begin
if Map = None_Map then
Initialize_Ks_Info_Map;
end if;
Find (Map, Name, Ks, Succ);
if Succ then
return Ks;
else
return No_Symbol;
end if;
end X_String_To_Key_Sym;
--\f
procedure X_Refresh_Keyboard_Mapping (Event : X_Event) is
Modifier : Boolean := False;
begin
Lock_Display (Event.Display);
begin
-- X_XX should really only refresh what is necessary, for now, make
-- initialize test fail
if Event.Mapping.Request = Mapping_Keyboard then
if Event.Display.Key_Syms /= null then
Free_X_Key_Sym_List_2d (Event.Display.Key_Syms);
end if;
elsif Event.Mapping.Request = Mapping_Modifier then
Free_X_Modifier_Keymap (Event.Display.Modifier_Map);
Event.Display.Key_Syms :=
null;-- X_XX - looks like astorage leak
Modifier := True;
end if;
exception
when others =>
Unlock_Display (Event.Display);
raise;
end;
Unlock_Display (Event.Display);
if Modifier then
Modifier := Init_Mod_Map (Event.Display);
end if;
end X_Refresh_Keyboard_Mapping;
--\f
function X_Is_Keypad_Key (Key_Symbol : X_Key_Sym) return Boolean is
--#define Is_Keypad_Key(key_symbol) \
-- (((unsigned)(key_symbol) >= XK_KP_Space) &&
-- ((unsigned)(key_symbol) <= XK_KP_Equal))
begin
return Key_Symbol >= Misc.Xk_Kp_Space and then
Key_Symbol <= Misc.Xk_Kp_Equal;
end X_Is_Keypad_Key;
function X_Is_Cursor_Key (Key_Symbol : X_Key_Sym) return Boolean is
--#define Is_Cursor_Key(key_symbol) \
-- (((unsigned)(key_symbol) >= XK_Home) &&
-- ((unsigned)(key_symbol) < XK_Select))
begin
return Key_Symbol >= Misc.Xk_Home and then Key_Symbol < Misc.Xk_Select;
end X_Is_Cursor_Key;
function X_Is_Pf_Key (Key_Symbol : X_Key_Sym) return Boolean is
--#define Is_PF_Key(key_symbol) \
-- (((unsigned)(key_symbol) >= XK_KP_F1) &&
-- ((unsigned)(key_symbol) <= XK_KP_F4))
begin
return Key_Symbol >= Misc.Xk_Kp_F1 and then Key_Symbol <= Misc.Xk_Kp_F4;
end X_Is_Pf_Key;
function X_Is_Function_Key (Key_Symbol : X_Key_Sym) return Boolean is
--#define Is_Function_Key(key_symbol) \
-- (((unsigned)(key_symbol) >= XK_F1) &&
-- ((unsigned)(key_symbol) <= XK_F35))
begin
return Key_Symbol >= Misc.Xk_F1 and then Key_Symbol <= Misc.Xk_F35;
end X_Is_Function_Key;
function X_Is_Misc_Function_Key (Key_Symbol : X_Key_Sym) return Boolean is
--#define Is_Misc_Function_Key(key_symbol) \
-- (((unsigned)(key_symbol) >= XK_Select) &&
-- ((unsigned)(key_symbol) < XK_KP_Space))
begin
return Key_Symbol >= Misc.Xk_Select and then
Key_Symbol < Misc.Xk_Kp_Space;
end X_Is_Misc_Function_Key;
function X_Is_Modifier_Key (Key_Symbol : X_Key_Sym) return Boolean is
--#define Is_Modifier_Key(key_symbol) \
-- (((unsigned)(key_symbol) >= XK_Shift_L) &&
-- ((unsigned)(key_symbol) <= XK_Hyper_R))
begin
return Key_Symbol >= Misc.Xk_Shift_L and then
Key_Symbol <= Misc.Xk_Hyper_R;
end X_Is_Modifier_Key;
--\f
procedure Init_Ks_Info_File is
File : Text_Io.File_Type;
Line : String (1 .. 128);
Len : Natural;
Namef : Natural;
Namel : Natural;
Valuef : Natural;
Valuel : Natural;
Flag : Boolean;
begin
----Open the file, if it exists at all.
begin
Text_Io.Open (File, Text_Io.In_File, X_Key_Sym_Db_File);
exception
when others =>
return;
end;
----Read every line in the file.
while not Text_Io.End_Of_File (File) loop
Text_Io.Get_Line (File, Line, Len);
Namef := 0;
Namel := 0;
Valuef := 0;
Valuel := 0;
----Find the name. The line may be blank or it may be a '!' comment line.
for I in 1 .. Len loop
if Line (I) = '!' then
goto Continue;
elsif Line (I) /= ' ' and then
Line (I) /= Ascii.Ht then
Namef := I;
exit;
end if;
end loop;
if Namef = 0 then
goto Continue;
end if;
----Find the end of the name.
for I in Namef + 1 .. Len loop
if Line (I) = ' ' or else
Line (I) = Ascii.Ht or else
Line (I) = ':' then
Namel := I - 1;
exit;
end if;
end loop;
if Namel = 0 then
goto Bad_Line;
end if;
----Find the beginning of the value. Make sure we have a ':'.
for I in Namel + 1 .. Len loop
if Line (I) = ':' then
if Valuel /= 0 then
goto Bad_Line;
end if;
Valuel := I;
elsif Line (I) /= ' ' and then
Line (I) /= Ascii.Ht then
Valuef := I;
exit;
end if;
end loop;
if Valuef = 0 or else Valuel = 0 then
goto Bad_Line;
end if;
----Find the end of the value. Convert it to a key_sym and put it into the
-- map.
for I in reverse Namef .. Len loop
if Line (I) /= ' ' and then
Line (I) /= Ascii.Ht then
begin
X_Ks_Info_Map.Insert
(X_Lib_Ks_Info_Map,
To_X_String (Line (Namef .. Namel)),
X_Key_Sym'Value ("16#" & Line (Valuef .. I) & "#"),
True);
exception
when others =>
goto Bad_Line;
end;
goto Continue;
end if;
end loop;
----Come here on bad lines.
<<Bad_Line>> null;
X_Report_Error ("XKsInfoDb", "BadLine",
"Xlib; Badly formed line in file %1." & Lf &
"Line: {%2}", To_X_String (X_Key_Sym_Db_File),
To_X_String (Line (1 .. Len)));
----Come here to process the next line.
<<Continue>> null;
end loop;
Text_Io.Close (File);
exception
when others =>
Text_Io.Close (File);
raise;
end Init_Ks_Info_File;
--\f
procedure Init_Ks_Info_Names is
use Xlbt_Key_Defs;
procedure I (M : in X_Ks_Info_Map.Map;
Key : in X_String;
Rt : in X_Key_Sym;
Dups_Ok : in Boolean := False)
renames X_Ks_Info_Map.Insert;
Map : X_Ks_Info_Map.Map renames X_Lib_Ks_Info_Map;
begin
--
-- This list is based on X_Key_Defs.@. Update it when you update that.
--
X_Ks_Info_Map.New_Map (Map);
I (Map, "leftcaret", Apl.Xk_Leftcaret);
I (Map, "rightcaret", Apl.Xk_Rightcaret);
I (Map, "downcaret", Apl.Xk_Downcaret);
I (Map, "upcaret", Apl.Xk_Upcaret);
I (Map, "overbar", Apl.Xk_Overbar);
I (Map, "downtack", Apl.Xk_Downtack);
I (Map, "upshoe", Apl.Xk_Upshoe);
I (Map, "downstile", Apl.Xk_Downstile);
I (Map, "underbar", Apl.Xk_Underbar);
I (Map, "jot", Apl.Xk_Jot);
I (Map, "quad", Apl.Xk_Quad);
I (Map, "uptack", Apl.Xk_Uptack);
I (Map, "circle", Apl.Xk_Circle);
I (Map, "upstile", Apl.Xk_Upstile);
I (Map, "downshoe", Apl.Xk_Downshoe);
I (Map, "rightshoe", Apl.Xk_Rightshoe);
I (Map, "leftshoe", Apl.Xk_Leftshoe);
I (Map, "lefttack", Apl.Xk_Lefttack);
I (Map, "righttack", Apl.Xk_Righttack);
I (Map, "Arabic_comma", Arabic.Xk_Arabic_Comma);
I (Map, "Arabic_semicolon", Arabic.Xk_Arabic_Semicolon);
I (Map, "Arabic_question_mark", Arabic.Xk_Arabic_Question_Mark);
I (Map, "Arabic_hamza", Arabic.Xk_Arabic_Hamza);
I (Map, "Arabic_maddaonalef", Arabic.Xk_Arabic_Maddaonalef);
I (Map, "Arabic_hamzaonalef", Arabic.Xk_Arabic_Hamzaonalef);
I (Map, "Arabic_hamzaonwaw", Arabic.Xk_Arabic_Hamzaonwaw);
I (Map, "Arabic_hamzaunderalef", Arabic.Xk_Arabic_Hamzaunderalef);
I (Map, "Arabic_hamzaonyeh", Arabic.Xk_Arabic_Hamzaonyeh);
I (Map, "Arabic_alef", Arabic.Xk_Arabic_Alef);
I (Map, "Arabic_beh", Arabic.Xk_Arabic_Beh);
I (Map, "Arabic_tehmarbuta", Arabic.Xk_Arabic_Tehmarbuta);
I (Map, "Arabic_teh", Arabic.Xk_Arabic_Teh);
I (Map, "Arabic_theh", Arabic.Xk_Arabic_Theh);
I (Map, "Arabic_jeem", Arabic.Xk_Arabic_Jeem);
I (Map, "Arabic_hah", Arabic.Xk_Arabic_Hah);
I (Map, "Arabic_khah", Arabic.Xk_Arabic_Khah);
I (Map, "Arabic_dal", Arabic.Xk_Arabic_Dal);
I (Map, "Arabic_thal", Arabic.Xk_Arabic_Thal);
I (Map, "Arabic_ra", Arabic.Xk_Arabic_Ra);
I (Map, "Arabic_zain", Arabic.Xk_Arabic_Zain);
I (Map, "Arabic_seen", Arabic.Xk_Arabic_Seen);
I (Map, "Arabic_sheen", Arabic.Xk_Arabic_Sheen);
I (Map, "Arabic_sad", Arabic.Xk_Arabic_Sad);
I (Map, "Arabic_dad", Arabic.Xk_Arabic_Dad);
I (Map, "Arabic_tah", Arabic.Xk_Arabic_Tah);
I (Map, "Arabic_zah", Arabic.Xk_Arabic_Zah);
I (Map, "Arabic_ain", Arabic.Xk_Arabic_Ain);
I (Map, "Arabic_ghain", Arabic.Xk_Arabic_Ghain);
I (Map, "Arabic_tatweel", Arabic.Xk_Arabic_Tatweel);
I (Map, "Arabic_feh", Arabic.Xk_Arabic_Feh);
I (Map, "Arabic_qaf", Arabic.Xk_Arabic_Qaf);
I (Map, "Arabic_kaf", Arabic.Xk_Arabic_Kaf);
I (Map, "Arabic_lam", Arabic.Xk_Arabic_Lam);
I (Map, "Arabic_meem", Arabic.Xk_Arabic_Meem);
I (Map, "Arabic_noon", Arabic.Xk_Arabic_Noon);
I (Map, "Arabic_ha", Arabic.Xk_Arabic_Ha);
I (Map, "Arabic_waw", Arabic.Xk_Arabic_Waw);
I (Map, "Arabic_alefmaksura", Arabic.Xk_Arabic_Alefmaksura);
I (Map, "Arabic_yeh", Arabic.Xk_Arabic_Yeh);
I (Map, "Arabic_fathatan", Arabic.Xk_Arabic_Fathatan);
I (Map, "Arabic_dammatan", Arabic.Xk_Arabic_Dammatan);
I (Map, "Arabic_kasratan", Arabic.Xk_Arabic_Kasratan);
I (Map, "Arabic_fatha", Arabic.Xk_Arabic_Fatha);
I (Map, "Arabic_damma", Arabic.Xk_Arabic_Damma);
I (Map, "Arabic_kasra", Arabic.Xk_Arabic_Kasra);
I (Map, "Arabic_shadda", Arabic.Xk_Arabic_Shadda);
I (Map, "Arabic_sukun", Arabic.Xk_Arabic_Sukun);
I (Map, "Arabic_switch", Arabic.Xk_Arabic_Switch);
I (Map, "Serbian_dje", Cyrillic.Xk_Serbian_Dje);
I (Map, "Macedonia_gje", Cyrillic.Xk_Macedonia_Gje);
I (Map, "Cyrillic_io", Cyrillic.Xk_Cyrillic_Io);
I (Map, "Ukrainian_ie", Cyrillic.Xk_Ukrainian_Ie);
I (Map, "Macedonia_dse", Cyrillic.Xk_Macedonia_Dse);
I (Map, "Ukrainian_i", Cyrillic.Xk_Ukrainian_I);
I (Map, "Ukrainian_yi", Cyrillic.Xk_Ukrainian_Yi);
I (Map, "Cyrillic_je", Cyrillic.Xk_Cyrillic_Je);
I (Map, "Cyrillic_lje", Cyrillic.Xk_Cyrillic_Lje);
I (Map, "Cyrillic_nje", Cyrillic.Xk_Cyrillic_Nje);
I (Map, "Serbian_tshe", Cyrillic.Xk_Serbian_Tshe);
I (Map, "Macedonia_kje", Cyrillic.Xk_Macedonia_Kje);
I (Map, "Byelorussian_shortu", Cyrillic.Xk_Byelorussian_Shortu);
I (Map, "Cyrillic_dzhe", Cyrillic.Xk_Cyrillic_Dzhe);
I (Map, "numerosign", Cyrillic.Xk_Numerosign);
I (Map, "Serbian_DJE", Cyrillic.Xk_Serbian_S_Dje);
I (Map, "Macedonia_GJE", Cyrillic.Xk_Macedonia_S_Gje);
I (Map, "Cyrillic_IO", Cyrillic.Xk_Cyrillic_S_Io);
I (Map, "Ukrainian_IE", Cyrillic.Xk_Ukrainian_S_Ie);
I (Map, "Macedonia_DSE", Cyrillic.Xk_Macedonia_S_Dse);
I (Map, "Ukrainian_I", Cyrillic.Xk_Ukrainian_S_I);
I (Map, "Ukrainian_YI", Cyrillic.Xk_Ukrainian_S_Yi);
I (Map, "Cyrillic_JE", Cyrillic.Xk_Cyrillic_S_Je);
I (Map, "Cyrillic_LJE", Cyrillic.Xk_Cyrillic_S_Lje);
I (Map, "Cyrillic_NJE", Cyrillic.Xk_Cyrillic_S_Nje);
I (Map, "Serbian_TSHE", Cyrillic.Xk_Serbian_S_Tshe);
I (Map, "Macedonia_KJE", Cyrillic.Xk_Macedonia_S_Kje);
I (Map, "Byelorussian_SHORTU", Cyrillic.Xk_Byelorussian_S_Shortu);
I (Map, "Cyrillic_DZHE", Cyrillic.Xk_Cyrillic_S_Dzhe);
I (Map, "Cyrillic_yu", Cyrillic.Xk_Cyrillic_Yu);
I (Map, "Cyrillic_a", Cyrillic.Xk_Cyrillic_A);
I (Map, "Cyrillic_be", Cyrillic.Xk_Cyrillic_Be);
I (Map, "Cyrillic_tse", Cyrillic.Xk_Cyrillic_Tse);
I (Map, "Cyrillic_de", Cyrillic.Xk_Cyrillic_De);
I (Map, "Cyrillic_ie", Cyrillic.Xk_Cyrillic_Ie);
I (Map, "Cyrillic_ef", Cyrillic.Xk_Cyrillic_Ef);
I (Map, "Cyrillic_ghe", Cyrillic.Xk_Cyrillic_Ghe);
I (Map, "Cyrillic_ha", Cyrillic.Xk_Cyrillic_Ha);
I (Map, "Cyrillic_i", Cyrillic.Xk_Cyrillic_I);
I (Map, "Cyrillic_shorti", Cyrillic.Xk_Cyrillic_Shorti);
I (Map, "Cyrillic_ka", Cyrillic.Xk_Cyrillic_Ka);
I (Map, "Cyrillic_el", Cyrillic.Xk_Cyrillic_El);
I (Map, "Cyrillic_em", Cyrillic.Xk_Cyrillic_Em);
I (Map, "Cyrillic_en", Cyrillic.Xk_Cyrillic_En);
I (Map, "Cyrillic_o", Cyrillic.Xk_Cyrillic_O);
I (Map, "Cyrillic_pe", Cyrillic.Xk_Cyrillic_Pe);
I (Map, "Cyrillic_ya", Cyrillic.Xk_Cyrillic_Ya);
I (Map, "Cyrillic_er", Cyrillic.Xk_Cyrillic_Er);
I (Map, "Cyrillic_es", Cyrillic.Xk_Cyrillic_Es);
I (Map, "Cyrillic_te", Cyrillic.Xk_Cyrillic_Te);
I (Map, "Cyrillic_u", Cyrillic.Xk_Cyrillic_U);
I (Map, "Cyrillic_zhe", Cyrillic.Xk_Cyrillic_Zhe);
I (Map, "Cyrillic_ve", Cyrillic.Xk_Cyrillic_Ve);
I (Map, "Cyrillic_softsign", Cyrillic.Xk_Cyrillic_Softsign);
I (Map, "Cyrillic_yeru", Cyrillic.Xk_Cyrillic_Yeru);
I (Map, "Cyrillic_ze", Cyrillic.Xk_Cyrillic_Ze);
I (Map, "Cyrillic_sha", Cyrillic.Xk_Cyrillic_Sha);
I (Map, "Cyrillic_e", Cyrillic.Xk_Cyrillic_E);
I (Map, "Cyrillic_shcha", Cyrillic.Xk_Cyrillic_Shcha);
I (Map, "Cyrillic_che", Cyrillic.Xk_Cyrillic_Che);
I (Map, "Cyrillic_hardsign", Cyrillic.Xk_Cyrillic_Hardsign);
I (Map, "Cyrillic_YU", Cyrillic.Xk_Cyrillic_S_Yu);
I (Map, "Cyrillic_A", Cyrillic.Xk_Cyrillic_S_A);
I (Map, "Cyrillic_BE", Cyrillic.Xk_Cyrillic_S_Be);
I (Map, "Cyrillic_TSE", Cyrillic.Xk_Cyrillic_S_Tse);
I (Map, "Cyrillic_DE", Cyrillic.Xk_Cyrillic_S_De);
I (Map, "Cyrillic_IE", Cyrillic.Xk_Cyrillic_S_Ie);
I (Map, "Cyrillic_EF", Cyrillic.Xk_Cyrillic_S_Ef);
I (Map, "Cyrillic_GHE", Cyrillic.Xk_Cyrillic_S_Ghe);
I (Map, "Cyrillic_HA", Cyrillic.Xk_Cyrillic_S_Ha);
I (Map, "Cyrillic_I", Cyrillic.Xk_Cyrillic_S_I);
I (Map, "Cyrillic_SHORTI", Cyrillic.Xk_Cyrillic_S_Shorti);
I (Map, "Cyrillic_KA", Cyrillic.Xk_Cyrillic_S_Ka);
I (Map, "Cyrillic_EL", Cyrillic.Xk_Cyrillic_S_El);
I (Map, "Cyrillic_EM", Cyrillic.Xk_Cyrillic_S_Em);
I (Map, "Cyrillic_EN", Cyrillic.Xk_Cyrillic_S_En);
I (Map, "Cyrillic_O", Cyrillic.Xk_Cyrillic_S_O);
I (Map, "Cyrillic_PE", Cyrillic.Xk_Cyrillic_S_Pe);
I (Map, "Cyrillic_YA", Cyrillic.Xk_Cyrillic_S_Ya);
I (Map, "Cyrillic_ER", Cyrillic.Xk_Cyrillic_S_Er);
I (Map, "Cyrillic_ES", Cyrillic.Xk_Cyrillic_S_Es);
I (Map, "Cyrillic_TE", Cyrillic.Xk_Cyrillic_S_Te);
I (Map, "Cyrillic_U", Cyrillic.Xk_Cyrillic_S_U);
I (Map, "Cyrillic_ZHE", Cyrillic.Xk_Cyrillic_S_Zhe);
I (Map, "Cyrillic_VE", Cyrillic.Xk_Cyrillic_S_Ve);
I (Map, "Cyrillic_SOFTSIGN", Cyrillic.Xk_Cyrillic_S_Softsign);
I (Map, "Cyrillic_YERU", Cyrillic.Xk_Cyrillic_S_Yeru);
I (Map, "Cyrillic_ZE", Cyrillic.Xk_Cyrillic_S_Ze);
I (Map, "Cyrillic_SHA", Cyrillic.Xk_Cyrillic_S_Sha);
I (Map, "Cyrillic_E", Cyrillic.Xk_Cyrillic_S_E);
I (Map, "Cyrillic_SHCHA", Cyrillic.Xk_Cyrillic_S_Shcha);
I (Map, "Cyrillic_CHE", Cyrillic.Xk_Cyrillic_S_Che);
I (Map, "Cyrillic_HARDSIGN", Cyrillic.Xk_Cyrillic_S_Hardsign);
I (Map, "Greek_ALPHAaccent", Greek.Xk_Greek_S_Alphaaccent);
I (Map, "Greek_EPSILONaccent", Greek.Xk_Greek_S_Epsilonaccent);
I (Map, "Greek_ETAaccent", Greek.Xk_Greek_S_Etaaccent);
I (Map, "Greek_IOTAaccent", Greek.Xk_Greek_S_Iotaaccent);
I (Map, "Greek_IOTAdiaeresis", Greek.Xk_Greek_Iotadiaeresis);
I (Map, "Greek_OMICRONaccent", Greek.Xk_Greek_S_Omicronaccent);
I (Map, "Greek_UPSILONaccent", Greek.Xk_Greek_S_Upsilonaccent);
I (Map, "Greek_UPSILONdieresis", Greek.Xk_Greek_S_Upsilondieresis);
I (Map, "Greek_OMEGAaccent", Greek.Xk_Greek_S_Omegaaccent);
I (Map, "Greek_accentdieresis", Greek.Xk_Greek_Accentdieresis);
I (Map, "Greek_horizbar", Greek.Xk_Greek_Horizbar);
I (Map, "Greek_alphaaccent", Greek.Xk_Greek_Alphaaccent);
I (Map, "Greek_epsilonaccent", Greek.Xk_Greek_Epsilonaccent);
I (Map, "Greek_etaaccent", Greek.Xk_Greek_Etaaccent);
I (Map, "Greek_iotaaccent", Greek.Xk_Greek_Iotaaccent);
I (Map, "Greek_iotadieresis", Greek.Xk_Greek_Iotadieresis);
I (Map, "Greek_iotaaccentdieresis", Greek.Xk_Greek_Iotaaccentdieresis);
I (Map, "Greek_omicronaccent", Greek.Xk_Greek_Omicronaccent);
I (Map, "Greek_upsilonaccent", Greek.Xk_Greek_Upsilonaccent);
I (Map, "Greek_upsilondieresis", Greek.Xk_Greek_Upsilondieresis);
I (Map, "Greek_upsilonaccentdieresis",
Greek.Xk_Greek_Upsilonaccentdieresis);
I (Map, "Greek_omegaaccent", Greek.Xk_Greek_Omegaaccent);
I (Map, "Greek_ALPHA", Greek.Xk_Greek_S_Alpha);
I (Map, "Greek_BETA", Greek.Xk_Greek_S_Beta);
I (Map, "Greek_GAMMA", Greek.Xk_Greek_S_Gamma);
I (Map, "Greek_DELTA", Greek.Xk_Greek_S_Delta);
I (Map, "Greek_EPSILON", Greek.Xk_Greek_S_Epsilon);
I (Map, "Greek_ZETA", Greek.Xk_Greek_S_Zeta);
I (Map, "Greek_ETA", Greek.Xk_Greek_S_Eta);
I (Map, "Greek_THETA", Greek.Xk_Greek_S_Theta);
I (Map, "Greek_IOTA", Greek.Xk_Greek_S_Iota);
I (Map, "Greek_KAPPA", Greek.Xk_Greek_S_Kappa);
I (Map, "Greek_LAMBDA", Greek.Xk_Greek_S_Lambda);
I (Map, "Greek_LAMDA", Greek.Xk_Greek_S_Lamda);
I (Map, "Greek_MU", Greek.Xk_Greek_S_Mu);
I (Map, "Greek_NU", Greek.Xk_Greek_S_Nu);
I (Map, "Greek_XI", Greek.Xk_Greek_S_Xi);
I (Map, "Greek_OMICRON", Greek.Xk_Greek_S_Omicron);
I (Map, "Greek_PI", Greek.Xk_Greek_S_Pi);
I (Map, "Greek_RHO", Greek.Xk_Greek_S_Rho);
I (Map, "Greek_SIGMA", Greek.Xk_Greek_S_Sigma);
I (Map, "Greek_TAU", Greek.Xk_Greek_S_Tau);
I (Map, "Greek_UPSILON", Greek.Xk_Greek_S_Upsilon);
I (Map, "Greek_PHI", Greek.Xk_Greek_S_Phi);
I (Map, "Greek_CHI", Greek.Xk_Greek_S_Chi);
I (Map, "Greek_PSI", Greek.Xk_Greek_S_Psi);
I (Map, "Greek_OMEGA", Greek.Xk_Greek_S_Omega);
I (Map, "Greek_alpha", Greek.Xk_Greek_Alpha);
I (Map, "Greek_beta", Greek.Xk_Greek_Beta);
I (Map, "Greek_gamma", Greek.Xk_Greek_Gamma);
I (Map, "Greek_delta", Greek.Xk_Greek_Delta);
I (Map, "Greek_epsilon", Greek.Xk_Greek_Epsilon);
I (Map, "Greek_zeta", Greek.Xk_Greek_Zeta);
I (Map, "Greek_eta", Greek.Xk_Greek_Eta);
I (Map, "Greek_theta", Greek.Xk_Greek_Theta);
I (Map, "Greek_iota", Greek.Xk_Greek_Iota);
I (Map, "Greek_kappa", Greek.Xk_Greek_Kappa);
I (Map, "Greek_lambda", Greek.Xk_Greek_Lambda);
I (Map, "Greek_lamda", Greek.Xk_Greek_Lamda);
I (Map, "Greek_mu", Greek.Xk_Greek_Mu);
I (Map, "Greek_nu", Greek.Xk_Greek_Nu);
I (Map, "Greek_xi", Greek.Xk_Greek_Xi);
I (Map, "Greek_omicron", Greek.Xk_Greek_Omicron);
I (Map, "Greek_pi", Greek.Xk_Greek_Pi);
I (Map, "Greek_rho", Greek.Xk_Greek_Rho);
I (Map, "Greek_sigma", Greek.Xk_Greek_Sigma);
I (Map, "Greek_finalsmallsigma", Greek.Xk_Greek_Finalsmallsigma);
I (Map, "Greek_tau", Greek.Xk_Greek_Tau);
I (Map, "Greek_upsilon", Greek.Xk_Greek_Upsilon);
I (Map, "Greek_phi", Greek.Xk_Greek_Phi);
I (Map, "Greek_chi", Greek.Xk_Greek_Chi);
I (Map, "Greek_psi", Greek.Xk_Greek_Psi);
I (Map, "Greek_omega", Greek.Xk_Greek_Omega);
I (Map, "Greek_switch", Greek.Xk_Greek_Switch);
I (Map, "hebrew_doublelowline", Hebrew.Xk_Hebrew_Doublelowline);
I (Map, "hebrew_aleph", Hebrew.Xk_Hebrew_Aleph);
I (Map, "hebrew_bet", Hebrew.Xk_Hebrew_Bet);
I (Map, "hebrew_gimel", Hebrew.Xk_Hebrew_Gimel);
I (Map, "hebrew_dalet", Hebrew.Xk_Hebrew_Dalet);
I (Map, "hebrew_he", Hebrew.Xk_Hebrew_He);
I (Map, "hebrew_waw", Hebrew.Xk_Hebrew_Waw);
I (Map, "hebrew_zain", Hebrew.Xk_Hebrew_Zain);
I (Map, "hebrew_chet", Hebrew.Xk_Hebrew_Chet);
I (Map, "hebrew_tet", Hebrew.Xk_Hebrew_Tet);
I (Map, "hebrew_yod", Hebrew.Xk_Hebrew_Yod);
I (Map, "hebrew_finalkaph", Hebrew.Xk_Hebrew_Finalkaph);
I (Map, "hebrew_kaph", Hebrew.Xk_Hebrew_Kaph);
I (Map, "hebrew_lamed", Hebrew.Xk_Hebrew_Lamed);
I (Map, "hebrew_finalmem", Hebrew.Xk_Hebrew_Finalmem);
I (Map, "hebrew_mem", Hebrew.Xk_Hebrew_Mem);
I (Map, "hebrew_finalnun", Hebrew.Xk_Hebrew_Finalnun);
I (Map, "hebrew_nun", Hebrew.Xk_Hebrew_Nun);
I (Map, "hebrew_samech", Hebrew.Xk_Hebrew_Samech);
I (Map, "hebrew_ayin", Hebrew.Xk_Hebrew_Ayin);
I (Map, "hebrew_finalpe", Hebrew.Xk_Hebrew_Finalpe);
I (Map, "hebrew_pe", Hebrew.Xk_Hebrew_Pe);
I (Map, "hebrew_finalzade", Hebrew.Xk_Hebrew_Finalzade);
I (Map, "hebrew_zade", Hebrew.Xk_Hebrew_Zade);
I (Map, "hebrew_qoph", Hebrew.Xk_Hebrew_Goph);
I (Map, "hebrew_resh", Hebrew.Xk_Hebrew_Resh);
I (Map, "hebrew_shin", Hebrew.Xk_Hebrew_Shin);
I (Map, "hebrew_taw", Hebrew.Xk_Hebrew_Taw);
I (Map, "Hebrew_switch", Hebrew.Xk_Hebrew_Switch);
I (Map, "overline", Katakana.Xk_Overline);
I (Map, "kana_fullstop", Katakana.Xk_Kana_Fullstop);
I (Map, "kana_openingbracket", Katakana.Xk_Kana_Openingbracket);
I (Map, "kana_closingbracket", Katakana.Xk_Kana_Closingbracket);
I (Map, "kana_comma", Katakana.Xk_Kana_Comma);
I (Map, "kana_conjunctive", Katakana.Xk_Kana_Conjunctive);
I (Map, "kana_WO", Katakana.Xk_Kana_Wo);
I (Map, "kana_a", Katakana.Xk_Kana_A);
I (Map, "kana_i", Katakana.Xk_Kana_I);
I (Map, "kana_u", Katakana.Xk_Kana_U);
I (Map, "kana_e", Katakana.Xk_Kana_E);
I (Map, "kana_o", Katakana.Xk_Kana_O);
I (Map, "kana_ya", Katakana.Xk_Kana_Ya);
I (Map, "kana_yu", Katakana.Xk_Kana_Yu);
I (Map, "kana_yo", Katakana.Xk_Kana_Yo);
I (Map, "kana_tsu", Katakana.Xk_Kana_Tsu);
I (Map, "prolongedsound", Katakana.Xk_Prolongedsound);
I (Map, "kana_A", Katakana.Xk_Kana_S_A);
I (Map, "kana_I", Katakana.Xk_Kana_S_I);
I (Map, "kana_U", Katakana.Xk_Kana_S_U);
I (Map, "kana_E", Katakana.Xk_Kana_S_E);
I (Map, "kana_O", Katakana.Xk_Kana_S_O);
I (Map, "kana_KA", Katakana.Xk_Kana_Ka);
I (Map, "kana_KI", Katakana.Xk_Kana_Ki);
I (Map, "kana_KU", Katakana.Xk_Kana_Ku);
I (Map, "kana_KE", Katakana.Xk_Kana_Ke);
I (Map, "kana_KO", Katakana.Xk_Kana_Ko);
I (Map, "kana_SA", Katakana.Xk_Kana_Sa);
I (Map, "kana_SHI", Katakana.Xk_Kana_Shi);
I (Map, "kana_SU", Katakana.Xk_Kana_Su);
I (Map, "kana_SE", Katakana.Xk_Kana_Se);
I (Map, "kana_SO", Katakana.Xk_Kana_So);
I (Map, "kana_TA", Katakana.Xk_Kana_Ta);
I (Map, "kana_CHI", Katakana.Xk_Kana_Chi);
I (Map, "kana_TSU", Katakana.Xk_Kana_S_Tsu);
I (Map, "kana_TE", Katakana.Xk_Kana_Te);
I (Map, "kana_TO", Katakana.Xk_Kana_To);
I (Map, "kana_NA", Katakana.Xk_Kana_Na);
I (Map, "kana_NI", Katakana.Xk_Kana_Ni);
I (Map, "kana_NU", Katakana.Xk_Kana_Nu);
I (Map, "kana_NE", Katakana.Xk_Kana_Ne);
I (Map, "kana_NO", Katakana.Xk_Kana_No);
I (Map, "kana_HA", Katakana.Xk_Kana_Ha);
I (Map, "kana_HI", Katakana.Xk_Kana_Hi);
I (Map, "kana_FU", Katakana.Xk_Kana_Fu);
I (Map, "kana_HE", Katakana.Xk_Kana_He);
I (Map, "kana_HO", Katakana.Xk_Kana_Ho);
I (Map, "kana_MA", Katakana.Xk_Kana_Ma);
I (Map, "kana_MI", Katakana.Xk_Kana_Mi);
I (Map, "kana_MU", Katakana.Xk_Kana_Mu);
I (Map, "kana_ME", Katakana.Xk_Kana_Me);
I (Map, "kana_MO", Katakana.Xk_Kana_Mo);
I (Map, "kana_YA", Katakana.Xk_Kana_S_Ya);
I (Map, "kana_YU", Katakana.Xk_Kana_S_Yu);
I (Map, "kana_YO", Katakana.Xk_Kana_S_Yo);
I (Map, "kana_RA", Katakana.Xk_Kana_Ra);
I (Map, "kana_RI", Katakana.Xk_Kana_Ri);
I (Map, "kana_RU", Katakana.Xk_Kana_Ru);
I (Map, "kana_RE", Katakana.Xk_Kana_Re);
I (Map, "kana_RO", Katakana.Xk_Kana_Ro);
I (Map, "kana_WA", Katakana.Xk_Kana_Wa);
I (Map, "kana_N", Katakana.Xk_Kana_N);
I (Map, "voicedsound", Katakana.Xk_Voicedsound);
I (Map, "semivoicedsound", Katakana.Xk_Semivoicedsound);
I (Map, "Kana_switch", Katakana.Xk_Kana_Switch);
I (Map, "space", Latin1.Xk_Space);
I (Map, "exclam", Latin1.Xk_Exclam);
I (Map, "quotedbl", Latin1.Xk_Quotedbl);
I (Map, "numbersign", Latin1.Xk_Numbersign);
I (Map, "dollar", Latin1.Xk_Dollar);
I (Map, "percent", Latin1.Xk_Percent);
I (Map, "ampersand", Latin1.Xk_Ampersand);
I (Map, "apostrophe", Latin1.Xk_Apostrophe);
I (Map, "parenleft", Latin1.Xk_Parenleft);
I (Map, "parenright", Latin1.Xk_Parenright);
I (Map, "asterisk", Latin1.Xk_Asterisk);
I (Map, "plus", Latin1.Xk_Plus);
I (Map, "comma", Latin1.Xk_Comma);
I (Map, "minus", Latin1.Xk_Minus);
I (Map, "period", Latin1.Xk_Period);
I (Map, "slash", Latin1.Xk_Slash);
I (Map, "0", Latin1.Xk_0);
I (Map, "1", Latin1.Xk_1);
I (Map, "2", Latin1.Xk_2);
I (Map, "3", Latin1.Xk_3);
I (Map, "4", Latin1.Xk_4);
I (Map, "5", Latin1.Xk_5);
I (Map, "6", Latin1.Xk_6);
I (Map, "7", Latin1.Xk_7);
I (Map, "8", Latin1.Xk_8);
I (Map, "9", Latin1.Xk_9);
I (Map, "colon", Latin1.Xk_Colon);
I (Map, "semicolon", Latin1.Xk_Semicolon);
I (Map, "less", Latin1.Xk_Less);
I (Map, "equal", Latin1.Xk_Equal);
I (Map, "greater", Latin1.Xk_Greater);
I (Map, "question", Latin1.Xk_Question);
I (Map, "at", Latin1.Xk_At);
I (Map, "A", Latin1.Xk_S_A);
I (Map, "B", Latin1.Xk_S_B);
I (Map, "C", Latin1.Xk_S_C);
I (Map, "D", Latin1.Xk_S_D);
I (Map, "E", Latin1.Xk_S_E);
I (Map, "F", Latin1.Xk_S_F);
I (Map, "G", Latin1.Xk_S_G);
I (Map, "H", Latin1.Xk_S_H);
I (Map, "I", Latin1.Xk_S_I);
I (Map, "J", Latin1.Xk_S_J);
I (Map, "K", Latin1.Xk_S_K);
I (Map, "L", Latin1.Xk_S_L);
I (Map, "M", Latin1.Xk_S_M);
I (Map, "N", Latin1.Xk_S_N);
I (Map, "O", Latin1.Xk_S_O);
I (Map, "P", Latin1.Xk_S_P);
I (Map, "Q", Latin1.Xk_S_Q);
I (Map, "R", Latin1.Xk_S_R);
I (Map, "S", Latin1.Xk_S_S);
I (Map, "T", Latin1.Xk_S_T);
I (Map, "U", Latin1.Xk_S_U);
I (Map, "V", Latin1.Xk_S_V);
I (Map, "W", Latin1.Xk_S_W);
I (Map, "X", Latin1.Xk_S_X);
I (Map, "Y", Latin1.Xk_S_Y);
I (Map, "Z", Latin1.Xk_S_Z);
I (Map, "bracketleft", Latin1.Xk_Bracketleft);
I (Map, "backslash", Latin1.Xk_Backslash);
I (Map, "bracketright", Latin1.Xk_Bracketright);
I (Map, "asciicircum", Latin1.Xk_Asciicircum);
I (Map, "underscore", Latin1.Xk_Underscore);
I (Map, "grave", Latin1.Xk_Grave);
I (Map, "a", Latin1.Xk_A);
I (Map, "b", Latin1.Xk_B);
I (Map, "c", Latin1.Xk_C);
I (Map, "d", Latin1.Xk_D);
I (Map, "e", Latin1.Xk_E);
I (Map, "f", Latin1.Xk_F);
I (Map, "g", Latin1.Xk_G);
I (Map, "h", Latin1.Xk_H);
I (Map, "i", Latin1.Xk_I);
I (Map, "j", Latin1.Xk_J);
I (Map, "k", Latin1.Xk_K);
I (Map, "l", Latin1.Xk_L);
I (Map, "m", Latin1.Xk_M);
I (Map, "n", Latin1.Xk_N);
I (Map, "o", Latin1.Xk_O);
I (Map, "p", Latin1.Xk_P);
I (Map, "q", Latin1.Xk_Q);
I (Map, "r", Latin1.Xk_R);
I (Map, "s", Latin1.Xk_S);
I (Map, "t", Latin1.Xk_T);
I (Map, "u", Latin1.Xk_U);
I (Map, "v", Latin1.Xk_V);
I (Map, "w", Latin1.Xk_W);
I (Map, "x", Latin1.Xk_X);
I (Map, "y", Latin1.Xk_Y);
I (Map, "z", Latin1.Xk_Z);
I (Map, "braceleft", Latin1.Xk_Braceleft);
I (Map, "bar", Latin1.Xk_Bar);
I (Map, "braceright", Latin1.Xk_Braceright);
I (Map, "asciitilde", Latin1.Xk_Asciitilde);
I (Map, "nobreakspace", Latin1.Xk_Nobreakspace);
I (Map, "exclamdown", Latin1.Xk_Exclamdown);
I (Map, "cent", Latin1.Xk_Cent);
I (Map, "sterling", Latin1.Xk_Sterling);
I (Map, "currency", Latin1.Xk_Currency);
I (Map, "yen", Latin1.Xk_Yen);
I (Map, "brokenbar", Latin1.Xk_Brokenbar);
I (Map, "section", Latin1.Xk_Section);
I (Map, "diaeresis", Latin1.Xk_Diaeresis);
I (Map, "copyright", Latin1.Xk_Copyright);
I (Map, "ordfeminine", Latin1.Xk_Ordfeminine);
I (Map, "guillemotleft", Latin1.Xk_Guillemotleft);
I (Map, "notsign", Latin1.Xk_Notsign);
I (Map, "hyphen", Latin1.Xk_Hyphen);
I (Map, "registered", Latin1.Xk_Registered);
I (Map, "macron", Latin1.Xk_Macron);
I (Map, "degree", Latin1.Xk_Degree);
I (Map, "plusminus", Latin1.Xk_Plusminus);
I (Map, "twosuperior", Latin1.Xk_Twosuperior);
I (Map, "threesuperior", Latin1.Xk_Threesuperior);
I (Map, "acute", Latin1.Xk_Acute);
I (Map, "mu", Latin1.Xk_Mu);
I (Map, "paragraph", Latin1.Xk_Paragraph);
I (Map, "periodcentered", Latin1.Xk_Periodcentered);
I (Map, "cedilla", Latin1.Xk_Cedilla);
I (Map, "onesuperior", Latin1.Xk_Onesuperior);
I (Map, "masculine", Latin1.Xk_Masculine);
I (Map, "guillemotright", Latin1.Xk_Guillemotright);
I (Map, "onequarter", Latin1.Xk_Onequarter);
I (Map, "onehalf", Latin1.Xk_Onehalf);
I (Map, "threequarters", Latin1.Xk_Threequarters);
I (Map, "questiondown", Latin1.Xk_Questiondown);
I (Map, "Agrave", Latin1.Xk_S_Agrave);
I (Map, "Aacute", Latin1.Xk_S_Aacute);
I (Map, "Acircumflex", Latin1.Xk_S_Acircumflex);
I (Map, "Atilde", Latin1.Xk_S_Atilde);
I (Map, "Adiaeresis", Latin1.Xk_S_Adiaeresis);
I (Map, "Aring", Latin1.Xk_S_Aring);
I (Map, "AE", Latin1.Xk_S_Ae);
I (Map, "Ccedilla", Latin1.Xk_S_Ccedilla);
I (Map, "Egrave", Latin1.Xk_S_Egrave);
I (Map, "Eacute", Latin1.Xk_S_Eacute);
I (Map, "Ecircumflex", Latin1.Xk_S_Ecircumflex);
I (Map, "Ediaeresis", Latin1.Xk_S_Ediaeresis);
I (Map, "Igrave", Latin1.Xk_S_Igrave);
I (Map, "Iacute", Latin1.Xk_S_Iacute);
I (Map, "Icircumflex", Latin1.Xk_S_Icircumflex);
I (Map, "Idiaeresis", Latin1.Xk_S_Idiaeresis);
I (Map, "ETH", Latin1.Xk_S_Eth);
I (Map, "Ntilde", Latin1.Xk_S_Ntilde);
I (Map, "Ograve", Latin1.Xk_S_Ograve);
I (Map, "Oacute", Latin1.Xk_S_Oacute);
I (Map, "Ocircumflex", Latin1.Xk_S_Ocircumflex);
I (Map, "Otilde", Latin1.Xk_S_Otilde);
I (Map, "Odiaeresis", Latin1.Xk_S_Odiaeresis);
I (Map, "multiply", Latin1.Xk_Multiply);
I (Map, "Ooblique", Latin1.Xk_Ooblique);
I (Map, "Ugrave", Latin1.Xk_S_Ugrave);
I (Map, "Uacute", Latin1.Xk_S_Uacute);
I (Map, "Ucircumflex", Latin1.Xk_S_Ucircumflex);
I (Map, "Udiaeresis", Latin1.Xk_S_Udiaeresis);
I (Map, "Yacute", Latin1.Xk_S_Yacute);
I (Map, "THORN", Latin1.Xk_S_Thorn);
I (Map, "ssharp", Latin1.Xk_Ssharp);
I (Map, "agrave", Latin1.Xk_Agrave);
I (Map, "aacute", Latin1.Xk_Aacute);
I (Map, "acircumflex", Latin1.Xk_Acircumflex);
I (Map, "atilde", Latin1.Xk_Atilde);
I (Map, "adiaeresis", Latin1.Xk_Adiaeresis);
I (Map, "aring", Latin1.Xk_Aring);
I (Map, "ae", Latin1.Xk_Ae);
I (Map, "ccedilla", Latin1.Xk_Ccedilla);
I (Map, "egrave", Latin1.Xk_Egrave);
I (Map, "eacute", Latin1.Xk_Eacute);
I (Map, "ecircumflex", Latin1.Xk_Ecircumflex);
I (Map, "ediaeresis", Latin1.Xk_Ediaeresis);
I (Map, "igrave", Latin1.Xk_Igrave);
I (Map, "iacute", Latin1.Xk_Iacute);
I (Map, "icircumflex", Latin1.Xk_Icircumflex);
I (Map, "idiaeresis", Latin1.Xk_Idiaeresis);
I (Map, "eth", Latin1.Xk_Eth);
I (Map, "ntilde", Latin1.Xk_Ntilde);
I (Map, "ograve", Latin1.Xk_Ograve);
I (Map, "oacute", Latin1.Xk_Oacute);
I (Map, "ocircumflex", Latin1.Xk_Ocircumflex);
I (Map, "otilde", Latin1.Xk_Otilde);
I (Map, "odiaeresis", Latin1.Xk_Odiaeresis);
I (Map, "division", Latin1.Xk_Division);
I (Map, "oslash", Latin1.Xk_Oslash);
I (Map, "ugrave", Latin1.Xk_Ugrave);
I (Map, "uacute", Latin1.Xk_Uacute);
I (Map, "ucircumflex", Latin1.Xk_Ucircumflex);
I (Map, "udiaeresis", Latin1.Xk_Udiaeresis);
I (Map, "yacute", Latin1.Xk_Yacute);
I (Map, "thorn", Latin1.Xk_Thorn);
I (Map, "ydiaeresis", Latin1.Xk_Ydiaeresis);
I (Map, "Aogonek", Latin2.Xk_S_Aogonek);
I (Map, "breve", Latin2.Xk_Breve);
I (Map, "Lstroke", Latin2.Xk_S_Lstroke);
I (Map, "Lcaron", Latin2.Xk_S_Lcaron);
I (Map, "Sacute", Latin2.Xk_S_Sacute);
I (Map, "Scaron", Latin2.Xk_S_Scaron);
I (Map, "Scedilla", Latin2.Xk_S_Scedilla);
I (Map, "Tcaron", Latin2.Xk_S_Tcaron);
I (Map, "Zacute", Latin2.Xk_S_Zacute);
I (Map, "Zcaron", Latin2.Xk_S_Zcaron);
I (Map, "Zabovedot", Latin2.Xk_S_Zabovedot);
I (Map, "aogonek", Latin2.Xk_Aogonek);
I (Map, "ogonek", Latin2.Xk_Ogonek);
I (Map, "lstroke", Latin2.Xk_Lstroke);
I (Map, "lcaron", Latin2.Xk_Lcaron);
I (Map, "sacute", Latin2.Xk_Sacute);
I (Map, "caron", Latin2.Xk_Caron);
I (Map, "scaron", Latin2.Xk_Scaron);
I (Map, "scedilla", Latin2.Xk_Scedilla);
I (Map, "tcaron", Latin2.Xk_Tcaron);
I (Map, "zacute", Latin2.Xk_Zacute);
I (Map, "doubleacute", Latin2.Xk_Doubleacute);
I (Map, "zcaron", Latin2.Xk_Zcaron);
I (Map, "zabovedot", Latin2.Xk_Zabovedot);
I (Map, "Racute", Latin2.Xk_S_Racute);
I (Map, "Abreve", Latin2.Xk_S_Abreve);
I (Map, "Lacute", Latin2.Xk_S_Lacute);
I (Map, "Cacute", Latin2.Xk_S_Cacute);
I (Map, "Ccaron", Latin2.Xk_S_Ccaron);
I (Map, "Eogonek", Latin2.Xk_S_Eogonek);
I (Map, "Ecaron", Latin2.Xk_S_Ecaron);
I (Map, "Dcaron", Latin2.Xk_S_Dcaron);
I (Map, "Dstroke", Latin2.Xk_S_Dstroke);
I (Map, "Nacute", Latin2.Xk_S_Nacute);
I (Map, "Ncaron", Latin2.Xk_S_Ncaron);
I (Map, "Odoubleacute", Latin2.Xk_S_Odoubleacute);
I (Map, "Rcaron", Latin2.Xk_S_Rcaron);
I (Map, "Uring", Latin2.Xk_S_Uring);
I (Map, "Udoubleacute", Latin2.Xk_S_Udoubleacute);
I (Map, "Tcedilla", Latin2.Xk_S_Tcedilla);
I (Map, "racute", Latin2.Xk_Racute);
I (Map, "abreve", Latin2.Xk_Abreve);
I (Map, "lactue", Latin2.Xk_Lacute);
I (Map, "cacute", Latin2.Xk_Cacute);
I (Map, "ccaron", Latin2.Xk_Ccaron);
I (Map, "eogonek", Latin2.Xk_Eogonek);
I (Map, "ecaron", Latin2.Xk_Ecaron);
I (Map, "dcaron", Latin2.Xk_Dcaron);
I (Map, "dstroke", Latin2.Xk_Dstroke);
I (Map, "nacute", Latin2.Xk_Nacute);
I (Map, "ncaron", Latin2.Xk_Ncaron);
I (Map, "odoubleacute", Latin2.Xk_Odoubleacute);
I (Map, "udoubleacute", Latin2.Xk_Udoubleacute);
I (Map, "rcaron", Latin2.Xk_Rcaron);
I (Map, "uring", Latin2.Xk_Uring);
I (Map, "tcedilla", Latin2.Xk_Tcedilla);
I (Map, "abovedot", Latin2.Xk_Abovedot);
I (Map, "Hstroke", Latin3.Xk_S_Hstroke);
I (Map, "Hcircumflex", Latin3.Xk_S_Hcircumflex);
I (Map, "Iabovedot", Latin3.Xk_Iabovedot);
I (Map, "Gbreve", Latin3.Xk_S_Gbreve);
I (Map, "Jcircumflex", Latin3.Xk_S_Jcircumflex);
I (Map, "hstroke", Latin3.Xk_Hstroke);
I (Map, "hcircumflex", Latin3.Xk_Hcircumflex);
I (Map, "idotless", Latin3.Xk_Idotless);
I (Map, "gbreve", Latin3.Xk_Gbreve);
I (Map, "jcircumflex", Latin3.Xk_Jcircumflex);
I (Map, "Cabovedot", Latin3.Xk_S_Cabovedot);
I (Map, "Ccircumflex", Latin3.Xk_S_Ccircumflex);
I (Map, "Gabovedot", Latin3.Xk_S_Gabovedot);
I (Map, "Gcircumflex", Latin3.Xk_S_Gcircumflex);
I (Map, "Ubreve", Latin3.Xk_S_Ubreve);
I (Map, "Scircumflex", Latin3.Xk_S_Scircumflex);
I (Map, "cabovedot", Latin3.Xk_Cabovedot);
I (Map, "ccircumflex", Latin3.Xk_Ccircumflex);
I (Map, "gabovedot", Latin3.Xk_Gabovedot);
I (Map, "gcircumflex", Latin3.Xk_Gcircumflex);
I (Map, "ubreve", Latin3.Xk_Ubreve);
I (Map, "scircumflex", Latin3.Xk_Scircumflex);
I (Map, "kra", Latin4.Xk_Kra);
I (Map, "Rcedilla", Latin4.Xk_S_Rcedilla);
I (Map, "Itilde", Latin4.Xk_S_Itilde);
I (Map, "Lcedilla", Latin4.Xk_S_Lcedilla);
I (Map, "Emacron", Latin4.Xk_S_Emacron);
I (Map, "Gcedilla", Latin4.Xk_S_Gcedilla);
I (Map, "Tslash", Latin4.Xk_S_Tslash);
I (Map, "rcedilla", Latin4.Xk_Rcedilla);
I (Map, "itilde", Latin4.Xk_Itilde);
I (Map, "lcedilla", Latin4.Xk_Lcedilla);
I (Map, "emacron", Latin4.Xk_Emacron);
I (Map, "gcedilla", Latin4.Xk_Gcedilla);
I (Map, "tslash", Latin4.Xk_Tslash);
I (Map, "ENG", Latin4.Xk_S_Eng);
I (Map, "eng", Latin4.Xk_Eng);
I (Map, "Amacron", Latin4.Xk_S_Amacron);
I (Map, "Iogonek", Latin4.Xk_S_Iogonek);
I (Map, "Eabovedot", Latin4.Xk_S_Eabovedot);
I (Map, "Imacron", Latin4.Xk_S_Imacron);
I (Map, "Ncedilla", Latin4.Xk_S_Ncedilla);
I (Map, "Omacron", Latin4.Xk_S_Omacron);
I (Map, "Kcedilla", Latin4.Xk_S_Kcedilla);
I (Map, "Uogonek", Latin4.Xk_S_Uogonek);
I (Map, "Utilde", Latin4.Xk_S_Utilde);
I (Map, "Umacron", Latin4.Xk_S_Umacron);
I (Map, "amacron", Latin4.Xk_Amacron);
I (Map, "iogonek", Latin4.Xk_Iogonek);
I (Map, "eabovedot", Latin4.Xk_Eabovedot);
I (Map, "imacron", Latin4.Xk_Imacron);
I (Map, "ncedilla", Latin4.Xk_Ncedilla);
I (Map, "omacron", Latin4.Xk_Omacron);
I (Map, "kcedilla", Latin4.Xk_Kcedilla);
I (Map, "uogonek", Latin4.Xk_Uogonek);
I (Map, "utilde", Latin4.Xk_Utilde);
I (Map, "umacron", Latin4.Xk_Umacron);
I (Map, "VoidSymbol", Misc.Xk_Void_Symbol);
I (Map, "BackSpace", Misc.Xk_Backspace);
I (Map, "Tab", Misc.Xk_Tab);
I (Map, "Linefeed", Misc.Xk_Linefeed);
I (Map, "Clear", Misc.Xk_Clear);
I (Map, "Return", Misc.Xk_Return);
I (Map, "Pause", Misc.Xk_Pause);
I (Map, "Scroll_Lock", Misc.Xk_Scroll_Lock);
I (Map, "Escape", Misc.Xk_Escape);
I (Map, "Delete", Misc.Xk_Delete);
I (Map, "Multi_key", Misc.Xk_Multi_Key);
I (Map, "Kanji", Misc.Xk_Kanji);
I (Map, "Muhenkan", Misc.Xk_Muhenkan);
I (Map, "Henkan_Mode", Misc.Xk_Henkan_Mode);
I (Map, "Henkan", Misc.Xk_Henkan);
I (Map, "Romaji", Misc.Xk_Romaji);
I (Map, "Hiragana", Misc.Xk_Hiragana);
I (Map, "Katakana", Misc.Xk_Katakana);
I (Map, "Hiragana_Katakana", Misc.Xk_Hiragana_Katakana);
I (Map, "Zenkaku", Misc.Xk_Zenkaku);
I (Map, "Hankaku", Misc.Xk_Hankaku);
I (Map, "Zenkaku_Hankaku", Misc.Xk_Zenkaku_Hankaku);
I (Map, "Touroku", Misc.Xk_Touroku);
I (Map, "Massyo", Misc.Xk_Massyo);
I (Map, "Kana_Lock", Misc.Xk_Kana_Lock);
I (Map, "Kana_Shift", Misc.Xk_Kana_Shift);
I (Map, "Eisu_Shift", Misc.Xk_Eisu_Lock);
I (Map, "Eisu_toggle", Misc.Xk_Eisu_Toggle);
I (Map, "Home", Misc.Xk_Home);
I (Map, "Left", Misc.Xk_Left);
I (Map, "Up", Misc.Xk_Up);
I (Map, "Right", Misc.Xk_Right);
I (Map, "Down", Misc.Xk_Down);
I (Map, "Prior", Misc.Xk_Prior);
I (Map, "Next", Misc.Xk_Next);
I (Map, "End", Misc.Xk_End);
I (Map, "Begin", Misc.Xk_Begin);
I (Map, "Select", Misc.Xk_Select);
I (Map, "Print", Misc.Xk_Print);
I (Map, "Execute", Misc.Xk_Execute);
I (Map, "Insert", Misc.Xk_Insert);
I (Map, "Undo", Misc.Xk_Undo);
I (Map, "Redo", Misc.Xk_Redo);
I (Map, "Menu", Misc.Xk_Menu);
I (Map, "Find", Misc.Xk_Find);
I (Map, "Cancel", Misc.Xk_Cancel);
I (Map, "Help", Misc.Xk_Help);
I (Map, "Break", Misc.Xk_Break);
I (Map, "Mode_switch", Misc.Xk_Mode_Switch);
I (Map, "script_switch", Misc.Xk_Script_Switch);
I (Map, "Num_Lock", Misc.Xk_Num_Lock);
I (Map, "KP_Space", Misc.Xk_Kp_Space);
I (Map, "KP_Tab", Misc.Xk_Kp_Tab);
I (Map, "KP_Enter", Misc.Xk_Kp_Enter);
I (Map, "KP_F1", Misc.Xk_Kp_F1);
I (Map, "KP_F2", Misc.Xk_Kp_F2);
I (Map, "KP_F3", Misc.Xk_Kp_F3);
I (Map, "KP_F4", Misc.Xk_Kp_F4);
I (Map, "KP_Equal", Misc.Xk_Kp_Equal);
I (Map, "KP_Multiply", Misc.Xk_Kp_Multiply);
I (Map, "KP_Add", Misc.Xk_Kp_Add);
I (Map, "KP_Separator", Misc.Xk_Kp_Separator);
I (Map, "KP_Subtract", Misc.Xk_Kp_Subtract);
I (Map, "KP_Decimal", Misc.Xk_Kp_Decimal);
I (Map, "KP_Divide", Misc.Xk_Kp_Divide);
I (Map, "KP_0", Misc.Xk_Kp_0);
I (Map, "KP_1", Misc.Xk_Kp_1);
I (Map, "KP_2", Misc.Xk_Kp_2);
I (Map, "KP_3", Misc.Xk_Kp_3);
I (Map, "KP_4", Misc.Xk_Kp_4);
I (Map, "KP_5", Misc.Xk_Kp_5);
I (Map, "KP_6", Misc.Xk_Kp_6);
I (Map, "KP_7", Misc.Xk_Kp_7);
I (Map, "KP_8", Misc.Xk_Kp_8);
I (Map, "KP_9", Misc.Xk_Kp_9);
I (Map, "F1", Misc.Xk_F1);
I (Map, "F2", Misc.Xk_F2);
I (Map, "F3", Misc.Xk_F3);
I (Map, "F4", Misc.Xk_F4);
I (Map, "F5", Misc.Xk_F5);
I (Map, "F6", Misc.Xk_F6);
I (Map, "F7", Misc.Xk_F7);
I (Map, "F8", Misc.Xk_F8);
I (Map, "F9", Misc.Xk_F9);
I (Map, "F10", Misc.Xk_F10);
I (Map, "F11", Misc.Xk_F11);
I (Map, "L1", Misc.Xk_L1);
I (Map, "F12", Misc.Xk_F12);
I (Map, "L2", Misc.Xk_L2);
I (Map, "F13", Misc.Xk_F13);
I (Map, "L3", Misc.Xk_L3);
I (Map, "F14", Misc.Xk_F14);
I (Map, "L4", Misc.Xk_L4);
I (Map, "F15", Misc.Xk_F15);
I (Map, "L5", Misc.Xk_L5);
I (Map, "F16", Misc.Xk_F16);
I (Map, "L6", Misc.Xk_L6);
I (Map, "F17", Misc.Xk_F17);
I (Map, "L7", Misc.Xk_L7);
I (Map, "F18", Misc.Xk_F18);
I (Map, "L8", Misc.Xk_L8);
I (Map, "F19", Misc.Xk_F19);
I (Map, "L9", Misc.Xk_L9);
I (Map, "F20", Misc.Xk_F20);
I (Map, "L10", Misc.Xk_L10);
I (Map, "F21", Misc.Xk_F21);
I (Map, "R1", Misc.Xk_R1);
I (Map, "F22", Misc.Xk_F22);
I (Map, "R2", Misc.Xk_R2);
I (Map, "F23", Misc.Xk_F23);
I (Map, "R3", Misc.Xk_R3);
I (Map, "F24", Misc.Xk_F24);
I (Map, "R4", Misc.Xk_R4);
I (Map, "F25", Misc.Xk_F25);
I (Map, "R5", Misc.Xk_R5);
I (Map, "F26", Misc.Xk_F26);
I (Map, "R6", Misc.Xk_R6);
I (Map, "F27", Misc.Xk_F27);
I (Map, "R7", Misc.Xk_R7);
I (Map, "F28", Misc.Xk_F28);
I (Map, "R8", Misc.Xk_R8);
I (Map, "F29", Misc.Xk_F29);
I (Map, "R9", Misc.Xk_R9);
I (Map, "F30", Misc.Xk_F30);
I (Map, "R10", Misc.Xk_R10);
I (Map, "F31", Misc.Xk_F31);
I (Map, "R11", Misc.Xk_R11);
I (Map, "F32", Misc.Xk_F32);
I (Map, "R12", Misc.Xk_R12);
I (Map, "R13", Misc.Xk_R13);
I (Map, "F33", Misc.Xk_F33);
I (Map, "F34", Misc.Xk_F34);
I (Map, "R14", Misc.Xk_R14);
I (Map, "F35", Misc.Xk_F35);
I (Map, "R15", Misc.Xk_R15);
I (Map, "Shift_L", Misc.Xk_Shift_L);
I (Map, "Shift_R", Misc.Xk_Shift_R);
I (Map, "Control_L", Misc.Xk_Control_L);
I (Map, "Control_R", Misc.Xk_Control_R);
I (Map, "Caps_Lock", Misc.Xk_Caps_Lock);
I (Map, "Shift_Lock", Misc.Xk_Shift_Lock);
I (Map, "Meta_L", Misc.Xk_Meta_L);
I (Map, "Meta_R", Misc.Xk_Meta_R);
I (Map, "Alt_L", Misc.Xk_Alt_L);
I (Map, "Alt_R", Misc.Xk_Alt_R);
I (Map, "Super_L", Misc.Xk_Super_L);
I (Map, "Super_R", Misc.Xk_Super_R);
I (Map, "Hyper_L", Misc.Xk_Hyper_L);
I (Map, "Hyper_R", Misc.Xk_Hyper_R);
I (Map, "emspace", Publishing.Xk_Emspace);
I (Map, "enspace", Publishing.Xk_Enspace);
I (Map, "em3space", Publishing.Xk_Em3space);
I (Map, "em4space", Publishing.Xk_Em4space);
I (Map, "digitspace", Publishing.Xk_Digitspace);
I (Map, "punctspace", Publishing.Xk_Punctspace);
I (Map, "thinspace", Publishing.Xk_Thinspace);
I (Map, "hairspace", Publishing.Xk_Hairspace);
I (Map, "emdash", Publishing.Xk_Emdash);
I (Map, "endash", Publishing.Xk_Endash);
I (Map, "signifblank", Publishing.Xk_Signifblank);
I (Map, "ellipsis", Publishing.Xk_Ellipsis);
I (Map, "doubbaselinedot", Publishing.Xk_Doubbaselinedot);
I (Map, "onethird", Publishing.Xk_Onethird);
I (Map, "twothirds", Publishing.Xk_Twothirds);
I (Map, "onefifth", Publishing.Xk_Onefifth);
I (Map, "twofifths", Publishing.Xk_Twofifths);
I (Map, "threefifths", Publishing.Xk_Threefifths);
I (Map, "fourfifths", Publishing.Xk_Fourfifths);
I (Map, "onesixth", Publishing.Xk_Onesixth);
I (Map, "fivesixths", Publishing.Xk_Fivesixths);
I (Map, "careof", Publishing.Xk_Careof);
I (Map, "figdash", Publishing.Xk_Figdash);
I (Map, "leftanglebracket", Publishing.Xk_Leftanglebracket);
I (Map, "decimalpoint", Publishing.Xk_Decimalpoint);
I (Map, "rightanglebracket", Publishing.Xk_Rightanglebracket);
I (Map, "marker", Publishing.Xk_Marker);
I (Map, "oneeighth", Publishing.Xk_Oneeighth);
I (Map, "threeeighths", Publishing.Xk_Threeeighths);
I (Map, "fiveeighths", Publishing.Xk_Fiveeighths);
I (Map, "seveneighths", Publishing.Xk_Seveneighths);
I (Map, "trademark", Publishing.Xk_Trademark);
I (Map, "signaturemark", Publishing.Xk_Signaturemark);
I (Map, "trademarkincircle", Publishing.Xk_Trademarkincircle);
I (Map, "leftopentriangle", Publishing.Xk_Leftopentriangle);
I (Map, "rightopentriangle", Publishing.Xk_Rightopentriangle);
I (Map, "emopencircle", Publishing.Xk_Emopencircle);
I (Map, "emopenrectangle", Publishing.Xk_Emopenrectangle);
I (Map, "leftsinglequotemark", Publishing.Xk_Leftsinglequotemark);
I (Map, "rightsinglequotemark", Publishing.Xk_Rightsinglequotemark);
I (Map, "leftdoublequotemark", Publishing.Xk_Leftdoublequotemark);
I (Map, "rightdoublequotemark", Publishing.Xk_Rightdoublequotemark);
I (Map, "prescription", Publishing.Xk_Prescription);
I (Map, "minutes", Publishing.Xk_Minutes);
I (Map, "seconds", Publishing.Xk_Seconds);
I (Map, "latincross", Publishing.Xk_Latincross);
I (Map, "hexagram", Publishing.Xk_Hexagram);
I (Map, "filledrectbullet", Publishing.Xk_Filledrectbullet);
I (Map, "filledlefttribullet", Publishing.Xk_Filledlefttribullet);
I (Map, "filledrighttribullet", Publishing.Xk_Filledrighttribullet);
I (Map, "emfilledcircle", Publishing.Xk_Emfilledcircle);
I (Map, "emfilledrect", Publishing.Xk_Emfilledrect);
I (Map, "enopencircbullet", Publishing.Xk_Enopencircbullet);
I (Map, "enopensquarebullet", Publishing.Xk_Enopensquarebullet);
I (Map, "openrectbullet", Publishing.Xk_Openrectbullet);
I (Map, "opentribulletup", Publishing.Xk_Opentribulletup);
I (Map, "opentribulletdown", Publishing.Xk_Opentribulletdown);
I (Map, "openstar", Publishing.Xk_Openstar);
I (Map, "enfilledcircbullet", Publishing.Xk_Enfilledcircbullet);
I (Map, "enfilledsqbullet", Publishing.Xk_Enfilledsqbullet);
I (Map, "filledtribulletup", Publishing.Xk_Filledtribulletup);
I (Map, "filledtribulletdown", Publishing.Xk_Filledtribulletdown);
I (Map, "leftpointer", Publishing.Xk_Leftpointer);
I (Map, "rightpointer", Publishing.Xk_Rightpointer);
I (Map, "club", Publishing.Xk_Club);
I (Map, "diamond", Publishing.Xk_Diamond);
I (Map, "heart", Publishing.Xk_Heart);
I (Map, "maltesecross", Publishing.Xk_Maltesecross);
I (Map, "dagger", Publishing.Xk_Dagger);
I (Map, "doubledagger", Publishing.Xk_Doubledagger);
I (Map, "checkmark", Publishing.Xk_Checkmark);
I (Map, "ballotcross", Publishing.Xk_Ballotcross);
I (Map, "musicalsharp", Publishing.Xk_Musicalsharp);
I (Map, "musicalflat", Publishing.Xk_Musicalflat);
I (Map, "malesymbol", Publishing.Xk_Malesymbol);
I (Map, "femalesymbol", Publishing.Xk_Femalesymbol);
I (Map, "telephone", Publishing.Xk_Telephone);
I (Map, "telephonerecorder", Publishing.Xk_Telephonerecorder);
I (Map, "phonographcopyright", Publishing.Xk_Phonographcopyright);
I (Map, "caret", Publishing.Xk_Caret);
I (Map, "singlelowquotemark", Publishing.Xk_Singlelowquotemark);
I (Map, "doublelowquotemark", Publishing.Xk_Doublelowquotemark);
I (Map, "cursor", Publishing.Xk_Cursor);
I (Map, "blank", Special.Xk_Blank);
I (Map, "soliddiamond", Special.Xk_Soliddiamond);
I (Map, "checkerboard", Special.Xk_Checkerboard);
I (Map, "ht", Special.Xk_Ht);
I (Map, "ff", Special.Xk_Ff);
I (Map, "cr", Special.Xk_Cr);
I (Map, "lf", Special.Xk_Lf);
I (Map, "nl", Special.Xk_Nl);
I (Map, "vt", Special.Xk_Vt);
I (Map, "lowrightcorner", Special.Xk_Lowrightcorner);
I (Map, "uprightcorner", Special.Xk_Uprightcorner);
I (Map, "upleftcorner", Special.Xk_Upleftcorner);
I (Map, "lowleftcorner", Special.Xk_Lowleftcorner);
I (Map, "crossinglines", Special.Xk_Crossinglines);
I (Map, "horizlinescan1", Special.Xk_Horizlinescan1);
I (Map, "horizlinescan3", Special.Xk_Horizlinescan3);
I (Map, "horizlinescan5", Special.Xk_Horizlinescan5);
I (Map, "horizlinescan7", Special.Xk_Horizlinescan7);
I (Map, "horizlinescan9", Special.Xk_Horizlinescan9);
I (Map, "leftt", Special.Xk_Leftt);
I (Map, "rightt", Special.Xk_Rightt);
I (Map, "bott", Special.Xk_Bott);
I (Map, "topt", Special.Xk_Topt);
I (Map, "vertbar", Special.Xk_Vertbar);
I (Map, "leftradical", Technical.Xk_Leftradical);
I (Map, "topleftradical", Technical.Xk_Topleftradical);
I (Map, "horizconnector", Technical.Xk_Horizconnector);
I (Map, "topintegral", Technical.Xk_Topintegral);
I (Map, "botintegral", Technical.Xk_Botintegral);
I (Map, "vertconnector", Technical.Xk_Vertconnector);
I (Map, "topleftsqbracket", Technical.Xk_Topleftsqbracket);
I (Map, "botleftsqbracket", Technical.Xk_Botleftsqbracket);
I (Map, "toprightsqbracket", Technical.Xk_Toprightsqbracket);
I (Map, "botrightsqbracket", Technical.Xk_Botrightsqbracket);
I (Map, "topleftparens", Technical.Xk_Topleftparens);
I (Map, "botleftparens", Technical.Xk_Botleftparens);
I (Map, "toprightparens", Technical.Xk_Toprightparens);
I (Map, "botrightparens", Technical.Xk_Botrightparens);
I (Map, "leftmiddlecurlybrace", Technical.Xk_Leftmiddlecurlybrace);
I (Map, "rightmiddlecurlybrace", Technical.Xk_Rightmiddlecurlybrace);
I (Map, "topleftsummation", Technical.Xk_Topleftsummation);
I (Map, "botleftsummation", Technical.Xk_Botleftsummation);
I (Map, "topvertsummationconnector",
Technical.Xk_Topvertsummationconnector);
I (Map, "botvertsummationconnector",
Technical.Xk_Botvertsummationconnector);
I (Map, "toprightsummation", Technical.Xk_Toprightsummation);
I (Map, "botrightsummation", Technical.Xk_Botrightsummation);
I (Map, "rightmiddlesummation", Technical.Xk_Rightmiddlesummation);
I (Map, "lessthanequal", Technical.Xk_Lessthanequal);
I (Map, "notequal", Technical.Xk_Notequal);
I (Map, "greaterthanequal", Technical.Xk_Greaterthanequal);
I (Map, "integral", Technical.Xk_Integral);
I (Map, "therefore", Technical.Xk_Therefore);
I (Map, "variation", Technical.Xk_Variation);
I (Map, "infinity", Technical.Xk_Infinity);
I (Map, "nabla", Technical.Xk_Nabla);
I (Map, "approximate", Technical.Xk_Approximate);
I (Map, "similarequal", Technical.Xk_Similarequal);
I (Map, "ifonlyif", Technical.Xk_Ifonlyif);
I (Map, "implies", Technical.Xk_Implies);
I (Map, "identical", Technical.Xk_Identical);
I (Map, "radical", Technical.Xk_Radical);
I (Map, "includedin", Technical.Xk_Includedin);
I (Map, "includes", Technical.Xk_Includes);
I (Map, "intersection", Technical.Xk_Intersection);
I (Map, "union", Technical.Xk_Union);
I (Map, "logicaland", Technical.Xk_Logicaland);
I (Map, "logicalor", Technical.Xk_Logicalor);
I (Map, "partialderivative", Technical.Xk_Partialderivative);
I (Map, "function", Technical.Xk_Function);
I (Map, "leftarrow", Technical.Xk_Leftarrow);
I (Map, "uparrow", Technical.Xk_Uparrow);
I (Map, "rightarrow", Technical.Xk_Rightarrow);
I (Map, "downarrow", Technical.Xk_Downarrow);
end Init_Ks_Info_Names;
--\f
procedure Initialize_Ks_Info_Map is
------------------------------------------------------------------------------
-- Initialize an empty X_Lib_Ks_Info_map. Lock the mutex, init the names,
-- init the site names, unlock the mutex, return.
------------------------------------------------------------------------------
use X_Ks_Info_Map;
begin
----Lock the mutex, then make sure that we really have something to do. We
-- may be the 2nd simultaneous task to attempt this. No need to do it twice.
Lock_Mutex (Mutex);
if X_Lib_Ks_Info_Map /= None_Map then
Unlock_Mutex (Mutex); -- Some other task beat us to it.
return;
end if;
----Init the map, trap exceptions.
begin
Init_Ks_Info_Names;
Init_Ks_Info_File;
exception
when others =>
Unlock_Mutex (Mutex);
X_Report_Exception ("XlibError",
"UnexpException",
"Unexpected exception during: %1" & Lf &
"Exception: %6",
"Initialize_Ks_Info_Map");
return;
end;
----All done.
Unlock_Mutex (Mutex);
end Initialize_Ks_Info_Map;
--\f
end Xlbp_Key;