DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ B T

⟦202dda68e⟧ TextFile

    Length: 130338 (0x1fd22)
    Types: TextFile
    Names: »B«

Derivation

└─⟦5f3412b64⟧ Bits:30000745 8mm tape, Rational 1000, ENVIRONMENT 12_6_5 TOOLS 
    └─ ⟦91c658230⟧ »DATA« 
        └─⟦5d656759a⟧ 
            └─⟦this⟧ 
└─⟦d10a02448⟧ Bits:30000409 8mm tape, Rational 1000, ENVIRONMENT, D_12_7_3
    └─ ⟦fc9b38f02⟧ »DATA« 
        └─⟦8e9e227a9⟧ 
            └─⟦this⟧ 

TextFile

with Access_List;
with Ada;
with Cmvc;
with Command;
with Common;
with Compilation;
--/ if DOCUMENT_FORMATTER then
--// with COMPOSE;
--/ end if;
with Debug;
--/ if DESIGN_FACILITY then
--// with DESIGN_IMPLEMENTATION;
--/ end if;
with Editor;
with Io;
with Job;
with Library;
--/ if MAIL then
--// with MAIL;
--/ end if;
with Operator;
with Queue;
with Script;
--/ if SPELLER then
--// with SPELLER;
--/ end if;
with System_Utilities;
with Text;
with What;
with Rxi_Key_Names;

----This file generated on: September 6, 1990 at 5:10:48 PM
----From Rational Development source file !ENVIRONMENT.EDITOR_KEYS.REV10_WORKING.UNITS.CREATE_COMMANDS_FILES.MASTER_KEYS_FILE'V(105)
----By user: GEB
----For terminal type: RXI

procedure Rxi_Commands is

    use Rxi_Key_Names;

    type Intent is (Interrupt, Prompt, Execute);

    Action : Intent;

    Key1, Key2, Key3, Key4, Key5, Key6 : Key_Names;

begin

    case Action is

        when Interrupt =>

            case Key1 is
                when Menu_Job_Kill =>
                    Job.Kill (0);
                when Menu_Job_Disable =>
                    Job.Disable (0);
                when Menu_Debug_Stop =>
                    Debug.Stop (Name => "");
                when Cm_D | Cms_D =>
                    Job.Disable (0);
                when C_G | Cs_G =>
                    Job.Interrupt;
                when M_G | Cm_G | Ms_G | Cms_G =>
                    Job.Kill (0);
                when Cm_S | Cms_S =>
                    Debug.Stop (Name => "");
                when others =>
                    null;
            end case;

        when Prompt =>

            case Key1 is
                when Menu_Pick =>
                    case Key2 is
                        when 'G' =>
                            case Key3 is
                                when 'D' =>
                                    Text.Create (Image_Name => ">>IMAGE_NAME<<",
                                                 Kind       => Text.File);
                                when 'E' =>
                                    Library.Create_Directory
                                       (Name     => ">>DIRECTORY NAME<<",
                                        Kind     => Library.Directory,
                                        Vol      => Library.Nil,
                                        Model    => "",
                                        Response => "<PROFILE>");
                                when 'F' =>
                                    Library.Create_World
                                       (Name     => ">>WORLD NAME<<",
                                        Kind     => Library.World,
                                        Vol      => Library.Nil,
                                        Model    => "!Model.R1000",
                                        Response => "<PROFILE>");
                                when others =>
                                    null;
                            end case;
                        when 'V' =>
                            Editor.Quit (Ignore_Changes => False);
                        when others =>
                            null;
                    end case;
                when C_Z =>
                    case Key2 is
                        when '%' | '5' =>
                            case Key3 is
                                when 'd' | C_D | 'D' | Cs_D =>
                                    Library.Create_Directory;
                                when 't' | C_T | 'T' | Cs_T =>
                                    Text.Create;
                                when 'w' | C_W | 'W' | Cs_W =>
                                    Library.Create_World;
                                when others =>
                                    null;
                            end case;
                        when '&' | '7' =>
                            case Key3 is
                                when 'm' | C_M | 'M' | Cs_M =>
                                    Debug.Modify (New_Value   => "",
                                                  Variable    => "<SELECTION>",
                                                  Stack_Frame => 0);
                                when others =>
                                    null;
                            end case;
                        when ')' | '0' =>
                            case Key3 is
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Access_List.Set
                                       (To_List    => "Network_Public => RWCOD",
                                        For_Object => "<SELECTION>",
                                        Response   => "<PROFILE>");
                                when others =>
                                    null;
                            end case;
                        when '/' | '?' =>
                            case Key3 is
                                when 'd' | C_D | 'D' | Cs_D =>
                                    What.Does (Name => "");
                                when others =>
                                    null;
                            end case;
                        when 'i' | C_I | 'I' | Cs_I =>
                            case Key3 is
                                when '/' | '?' =>
                                    Editor.Image.Find (Name => "");
                                when others =>
                                    null;
                            end case;
                        when others =>
                            null;
                    end case;
                when others =>
                    null;
            end case;

        when Execute =>

            case Key1 is
                when Menu_Return =>
                    Editor.Line.Insert (1);
                when Mouse_Down =>
                    Editor.Screen.Down;
                when Mouse_Right =>
                    Editor.Screen.Right;
                when Mouse_Image_Down =>
                    Editor.Image.Down;
                when Mouse_Image_Right =>
                    Editor.Image.Right;
                when Mouse_Button1 =>
                    Common.Definition
                       (Name => "<CURSOR>", In_Place => False, Visible => True);
                when Mouse_Button3 =>
                    Common.Enclosing (In_Place => False, Library => False);
                when Mouse_Button4 =>
                    Editor.Region.Start;
                when Mouse_Button4_Up =>
                    Editor.Region.Finish;
                when Mouse_Button1_Dbl =>
                    Common.Object.Parent (Repeat => 1);
                when Mouse_Button2_Dbl =>
                    Editor.Set.Designation_Off;
                when Mouse_Button3_Dbl =>
                    Common.Object.Child (Repeat => 1);
                when Mouse_Button5_Dbl =>
                    Common.Abandon;
                when Menu_Pick =>
                    case Key2 is
                        when Menu_Pick =>
                            Editor.Key.Prompt (Key_Code => "");
                        when '0' =>
                            Io.Echo ("User Menu-Pick 0" & Ascii.Lf);
                        when '1' =>
                            Io.Echo ("User Menu-Pick 1" & Ascii.Lf);
                        when '2' =>
                            Io.Echo ("User Menu-Pick 2" & Ascii.Lf);
                        when '3' =>
                            Io.Echo ("User Menu-Pick 3" & Ascii.Lf);
                        when '4' =>
                            Io.Echo ("User Menu-Pick 4" & Ascii.Lf);
                        when '5' =>
                            Io.Echo ("User Menu-Pick 5" & Ascii.Lf);
                        when '6' =>
                            Io.Echo ("User Menu-Pick 6" & Ascii.Lf);
                        when '7' =>
                            Io.Echo ("User Menu-Pick 7" & Ascii.Lf);
                        when '8' =>
                            Io.Echo ("User Menu-Pick 8" & Ascii.Lf);
                        when '9' =>
                            Io.Echo ("User Menu-Pick 9" & Ascii.Lf);
                        when 'A' =>
                            case Key3 is
                                when 'A' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Object.Next (Repeat => 1);
                                        when 'B' =>
                                            Common.Object.Previous
                                               (Repeat => 1);
                                        when 'C' =>
                                            Common.Object.Copy;
                                        when 'D' =>
                                            Common.Object.Move;
                                        when 'E' =>
                                            Common.Object.Insert;
                                        when 'F' =>
                                            Common.Object.Delete;
                                        when 'G' =>
                                            Common.Abandon
                                               (Window => "<IMAGE>");
                                        when others =>
                                            null;
                                    end case;
                                when 'B' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Region.Copy;
                                        when 'B' =>
                                            Editor.Region.Move;
                                        when 'C' =>
                                            Editor.Region.Delete;
                                        when 'D' =>
                                            Editor.Region.Fill
                                               (Column => 0, Leading => "");
                                        when 'E' =>
                                            Editor.Set.Designation_Off;
                                        when others =>
                                            null;
                                    end case;
                                when 'C' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Window.Join (Repeat => 1);
                                        when 'B' =>
                                            Editor.Window.Promote;
                                        when 'C' =>
                                            Editor.Window.Demote;
                                        when 'D' =>
                                            Editor.Window.Directory;
                                        when 'E' =>
                                            Editor.Window.Transpose
                                               (Offset => 1);
                                        when 'F' =>
                                            Editor.Window.Expand (Lines => 4);
                                        when 'G' =>
                                            Editor.Window.Expand (Lines => -4);
                                        when 'H' =>
                                            Editor.Window.Focus;
                                        when 'I' =>
                                            Editor.Window.Delete;
                                        when others =>
                                            null;
                                    end case;
                                when 'D' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Image.Beginning_Of
                                               (Offset => 0);
                                        when 'B' =>
                                            Editor.Image.End_Of (Offset => 0);
                                        when 'C' =>
                                            Editor.Image.Up (Repeat => 0);
                                        when 'D' =>
                                            Editor.Image.Down (Repeat => 0);
                                        when 'E' =>
                                            Editor.Image.Left (Repeat => 0);
                                        when 'F' =>
                                            Editor.Image.Right (Repeat => 0);
                                        when others =>
                                            null;
                                    end case;
                                when 'E' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Line.Join (Repeat => 1);
                                        when 'B' =>
                                            Editor.Line.Delete (Repeat => 1);
                                        when 'C' =>
                                            Editor.Line.Delete_Forward
                                               (Repeat => 1);
                                        when 'D' =>
                                            Editor.Line.Copy (Repeat => 1);
                                        when others =>
                                            null;
                                    end case;
                                when 'F' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Word.Previous (Repeat => 1);
                                        when 'B' =>
                                            Editor.Word.Next (Repeat => 1);
                                        when 'C' =>
                                            Editor.Word.Delete (Repeat => 1);
                                        when 'D' =>
                                            Editor.Word.Delete_Forward
                                               (Repeat => 1);
                                        when others =>
                                            null;
                                    end case;
                                when 'G' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Mark.Next (Repeat => 1);
                                        when 'B' =>
                                            Editor.Mark.Previous (Repeat => 1);
                                        when 'C' =>
                                            Editor.Mark.Push (Repeat => 1);
                                        when 'D' =>
                                            Editor.Mark.Swap;
                                        when 'E' =>
                                            Editor.Mark.Top;
                                        when 'F' =>
                                            Editor.Mark.Delete_Top;
                                        when 'G' =>
                                            Editor.Macro.Execute
                                               (Repeat => 1, Prior => 0);
                                        when others =>
                                            null;
                                    end case;
                                when 'H' =>
                                    case Key4 is
--/ if SPELLER then
--//                                    when 'A' =>
--//                                        SPELLER.CHECK_TEXT (DATA => "<TEXT>");
--//                                    when 'B' =>
--//                                        SPELLER.CHECK_IMAGE;
--//                                    when 'C' =>
--//                                        SPELLER.EXPLAIN_NEXT;
--//                                    when 'D' =>
--//                                        SPELLER.EXCHANGE_WORD (CHOICE => 1);
--//                                    when 'E' =>
--//                                        SPELLER.LEARN_WORD (THE_WORD => "",DICTIONARY => 0);
--/ end if;
                                        when others =>
                                            null;
                                    end case;
                                when others =>
                                    null;
                            end case;
                        when 'C' =>
                            case Key3 is
                                when 'A' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Definition
                                               (Name     => "<CURSOR>",
                                                In_Place => False,
                                                Visible  => True);
                                        when 'B' =>
                                            Common.Definition
                                               (Name     => "<CURSOR>",
                                                In_Place => True,
                                                Visible  => True);
                                        when 'C' =>
                                            What.Home_Library;
                                        when others =>
                                            null;
                                    end case;
                                when 'B' =>
                                    Common.Definition (Name     => "<CURSOR>",
                                                       In_Place => False,
                                                       Visible  => True);
                                when 'C' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Enclosing (In_Place => False,
                                                              Library => False);
                                        when 'B' =>
                                            Common.Enclosing (In_Place => True,
                                                              Library => False);
                                        when others =>
                                            null;
                                    end case;
                                when 'D' =>
                                    Common.Enclosing (In_Place => False,
                                                      Library  => False);
                                when 'E' =>
                                    case Key4 is
                                        when 'A' =>
                                            Ada.Other_Part (Name => "<IMAGE>",
                                                            In_Place => False);
                                        when 'B' =>
                                            Ada.Other_Part (Name => "<IMAGE>",
                                                            In_Place => True);
                                        when others =>
                                            null;
                                    end case;
                                when 'F' =>
                                    Ada.Other_Part (Name     => "<IMAGE>",
                                                    In_Place => False);
                                when 'G' =>
                                    case Key4 is
--/ if DESIGN_FACILITY then
--//                                    when 'A' =>
--//                                        DESIGN_IMPLEMENTATION.DEFINITION (IN_PLACE => FALSE,VISIBLE => TRUE);
--//                                    when 'B' =>
--//                                        DESIGN_IMPLEMENTATION.DEFINITION (IN_PLACE => TRUE,VISIBLE => TRUE);
--/ end if;
                                        when others =>
                                            null;
                                    end case;
--/ if DESIGN_FACILITY then
--//                            when 'H' =>
--//                                DESIGN_IMPLEMENTATION.DEFINITION (IN_PLACE => FALSE,VISIBLE => TRUE);
--/ end if;
                                when 'I' =>
                                    case Key4 is
--/ if DESIGN_FACILITY then
--//                                    when 'A' =>
--//                                        DESIGN_IMPLEMENTATION.ENCLOSING (IN_PLACE => FALSE);
--//                                    when 'B' =>
--//                                        DESIGN_IMPLEMENTATION.ENCLOSING (IN_PLACE => TRUE);
--/ end if;
                                        when others =>
                                            null;
                                    end case;
--/ if DESIGN_FACILITY then
--//                            when 'J' =>
--//                                DESIGN_IMPLEMENTATION.ENCLOSING (IN_PLACE => FALSE);
--/ end if;
                                when 'K' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Cursor.Next
                                               (Repeat    => 1,
                                                Prompt    => True,
                                                Underline => True);
                                        when 'B' =>
                                            Editor.Cursor.Next
                                               (Repeat    => 1,
                                                Prompt    => True,
                                                Underline => False);
                                        when 'C' =>
                                            Editor.Cursor.Next
                                               (Repeat    => 1,
                                                Prompt    => False,
                                                Underline => True);
                                        when 'D' =>
                                            Editor.Set.Designation_Off;
                                        when 'E' =>
                                            Common.Clear_Underlining;
                                        when others =>
                                            null;
                                    end case;
                                when 'L' =>
                                    Editor.Cursor.Next (Repeat    => 1,
                                                        Prompt    => True,
                                                        Underline => True);
                                when 'M' =>
                                    case Key4 is
                                        when 'A' =>
                                            Editor.Cursor.Previous
                                               (Repeat    => 1,
                                                Prompt    => True,
                                                Underline => True);
                                        when 'B' =>
                                            Editor.Cursor.Previous
                                               (Repeat    => 1,
                                                Prompt    => True,
                                                Underline => False);
                                        when 'C' =>
                                            Editor.Cursor.Previous
                                               (Repeat    => 1,
                                                Prompt    => False,
                                                Underline => True);
                                        when 'D' =>
                                            Editor.Set.Designation_Off;
                                        when 'E' =>
                                            Common.Clear_Underlining;
                                        when others =>
                                            null;
                                    end case;
                                when 'N' =>
                                    Editor.Cursor.Previous (Repeat    => 1,
                                                            Prompt    => True,
                                                            Underline => True);
                                when others =>
                                    null;
                            end case;
                        when 'D' =>
                            Common.Definition (Name     => "<CURSOR>",
                                               In_Place => False,
                                               Visible  => True);
                        when 'E' =>
                            case Key3 is
                                when 'A' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Promote;
                                        when 'B' =>
                                            Ada.Install_Unit;
                                        when 'C' =>
                                            Ada.Code_Unit;
                                        when 'D' =>
                                            Compilation.Promote
                                               (Unit => "<IMAGE>",
                                                Scope => Compilation.All_Parts,
                                                Goal => Compilation.Installed,
                                                Limit => "<WORLDS>",
                                                Effort_Only => False,
                                                Response => "<PROFILE>");
                                        when 'E' =>
                                            Compilation.Promote
                                               (Unit => "<IMAGE>",
                                                Scope => Compilation.All_Parts,
                                                Goal => Compilation.Coded,
                                                Limit => "<WORLDS>",
                                                Effort_Only => False,
                                                Response => "<PROFILE>");
                                        when 'F' =>
                                            Compilation.Promote
                                               (Unit => "<IMAGE>",
                                                Scope => Compilation.All_Parts,
                                                Goal => Compilation.Installed,
                                                Limit => "<ALL_WORLDS>",
                                                Effort_Only => False,
                                                Response => "<PROFILE>");
                                        when 'G' =>
                                            Compilation.Promote
                                               (Unit => "<IMAGE>",
                                                Scope => Compilation.All_Parts,
                                                Goal => Compilation.Coded,
                                                Limit => "<ALL_WORLDS>",
                                                Effort_Only => False,
                                                Response => "<PROFILE>");
                                        when others =>
                                            null;
                                    end case;
                                when 'B' =>
                                    Common.Promote;
                                when 'C' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Complete (Menu => True);
--/ if DESIGN_FACILITY then
--//                                    when 'B' =>
--//                                        DESIGN_IMPLEMENTATION.COMPLETE (INCLUDE_OPTIONAL_ANNOTATIONS => FALSE);
--/ end if;
                                        when others =>
                                            null;
                                    end case;
                                when 'D' =>
                                    Common.Complete (Menu => True);
                                when 'E' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Format;
--/ if DESIGN_FACILITY then
--//                                    when 'B' =>
--//                                        DESIGN_IMPLEMENTATION.FORMAT;
--/ end if;
                                        when others =>
                                            null;
                                    end case;
                                when 'F' =>
                                    Common.Format;
                                when 'G' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Edit (Name     => "<IMAGE>",
                                                         In_Place => False,
                                                         Visible  => False);
                                        when 'B' =>
                                            Common.Edit (Name     => "<IMAGE>",
                                                         In_Place => True,
                                                         Visible  => False);
                                        when 'C' =>
                                            Ada.Source_Unit;
                                        when 'D' =>
                                            Common.Demote;
                                        when others =>
                                            null;
                                    end case;
                                when 'H' =>
                                    Common.Edit (Name     => "<IMAGE>",
                                                 In_Place => False,
                                                 Visible  => False);
                                when others =>
                                    null;
                            end case;
                        when 'F' =>
                            Common.Promote;
                        when 'G' =>
                            case Key3 is
                                when 'A' =>
                                    Common.Create_Command;
                                when 'B' =>
                                    Ada.Create_Body (Name => "<IMAGE>");
                                when 'C' =>
                                    Common.Object.Insert;
                                when 'G' =>
                                    Ada.Create_Private (Name => "<IMAGE>");
                                when others =>
                                    null;
                            end case;
                        when 'I' =>
                            Common.Create_Command;
                        when 'J' =>
                            case Key3 is
                                when 'A' =>
                                    Common.Semanticize;
                                when 'C' =>
                                    case Key4 is
                                        when 'A' =>
                                            Common.Explain;
--/ if DESIGN_FACILITY then
--//                                    when 'B' =>
--//                                        DESIGN_IMPLEMENTATION.EXPLAIN;
--/ end if;
                                        when others =>
                                            null;
                                    end case;
                                when 'D' =>
                                    Common.Explain;
                                when 'E' =>
                                    Editor.Key.Prompt (Key_Code => "");
                                when 'F' =>
                                    case Key4 is
                                        when 'A' =>
                                            Ada.Show_Usage
                                               (Name    => "<CURSOR>",
                                                Global  => True,
                                                Limit   => "<ALL_WORLDS>",
                                                Closure => False);
                                        when 'B' =>
                                            Ada.Show_Usage (Name => "<CURSOR>",
                                                            Global => False,
                                                            Limit => "<WORLDS>",
                                                            Closure => False);
                                        when 'C' =>
                                            Ada.Show_Usage
                                               (Name    => "<CURSOR>",
                                                Global  => True,
                                                Limit   => "<ALL_WORLDS>",
                                                Closure => True);
--/ if DESIGN_FACILITY then
--//                                    when 'D' =>
--//                                        DESIGN_IMPLEMENTATION.SHOW_USAGE (IN_WORLD => "<CURSOR>");
--/ end if;
                                        when 'E' =>
                                            Ada.Show_Unused
                                               (In_Unit           => "<IMAGE>",
                                                Check_Other_Units => True);
                                        when 'F' =>
                                            Ada.Show_Unused
                                               (In_Unit           => "<IMAGE>",
                                                Check_Other_Units => False);
                                        when others =>
                                            null;
                                    end case;
                                when 'G' =>
                                    Ada.Show_Usage (Name    => "<CURSOR>",
                                                    Global  => True,
                                                    Limit   => "<ALL_WORLDS>",
                                                    Closure => False);
                                when 'H' =>
                                    case Key4 is
                                        when 'A' =>
                                            What.Object (Name => "<IMAGE>");
                                        when 'B' =>
                                            What.Users (All_Users => True);
                                        when 'C' =>
                                            What.Load (Verbose => True);
                                        when 'D' =>
                                            What.Time;
                                        when 'E' =>
                                            Access_List.Display
                                               (For_Object => "<CURSOR>");
                                        when others =>
                                            null;
                                    end case;
                                when 'I' =>
                                    What.Object (Name => "<IMAGE>");
                                when others =>
                                    null;
                            end case;
                        when 'K' =>
                            Common.Semanticize;
                        when 'L' =>
                            case Key3 is
                                when 'A' =>
                                    Cmvc.Check_In (What_Object => "<CURSOR>",
                                                   Comments    => "",
                                                   Work_Order  => "<DEFAULT>",
                                                   Response    => "<PROFILE>");
                                when 'B' =>
                                    Cmvc.Check_Out
                                       (What_Object => "<CURSOR>",
                                        Comments => "",
                                        Allow_Demotion => False,
                                        Allow_Implicit_Accept_Changes => True,
                                        Expected_Check_In_Time => "<TOMORROW>",
                                        Work_Order => "<DEFAULT>",
                                        Response => "<PROFILE>");
                                when 'C' =>
                                    Cmvc.Accept_Changes
                                       (Destination    => "<CURSOR>",
                                        Source         => "<LATEST>",
                                        Allow_Demotion => False,
                                        Comments       => "",
                                        Work_Order     => "<DEFAULT>",
                                        Response       => "<PROFILE>");
                                when 'D' =>
                                    Cmvc.Show (Objects  => "<CURSOR>",
                                               Response => "<PROFILE>");
                                when 'E' =>
                                    Cmvc.Show_Checked_Out_In_View
                                       (In_View  => "<CURSOR>",
                                        Response => "<PROFILE>");
                                when 'F' =>
                                    Cmvc.Show_Out_Of_Date_Objects
                                       (In_View  => "<CURSOR>",
                                        Response => "<PROFILE>");
                                when 'G' =>
                                    Cmvc.Information (For_View => "<CURSOR>",
                                                      Response => "<PROFILE>");
                                when 'H' =>
                                    Cmvc.Edit (View_Or_Config => "<CURSOR>",
                                               In_Place => False,
                                               Allow_Check_Out => True,
                                               Allow_Check_In => True,
                                               Allow_Accept_Changes => True);
                                when others =>
                                    null;
                            end case;
                        when 'N' =>
                            case Key3 is
                                when Menu_Debug_Stop =>
                                    Debug.Stop (Name => "");
                                when 'A' =>
                                    case Key4 is
                                        when 'A' =>
                                            Debug.Run (Stop_At =>
                                                          Debug.Statement,
                                                       Count   => 1,
                                                       In_Task => "");
                                        when 'B' =>
                                            Debug.Run (Stop_At =>
                                                          Debug.Local_Statement,
                                                       Count   => 1,
                                                       In_Task => "");
                                        when 'C' =>
                                            Debug.Execute (Name => "");
                                        when 'D' =>
                                            Debug.Run (Stop_At =>
                                                          Debug.Returned,
                                                       Count   => 1,
                                                       In_Task => "");
                                        when others =>
                                            null;
                                    end case;
                                when 'B' =>
                                    Debug.Run (Stop_At => Debug.Statement,
                                               Count   => 1,
                                               In_Task => "");
                                when 'C' =>
                                    Debug.Put (Variable    => "<SELECTION>",
                                               Stack_Frame => 0);
                                when 'E' =>
                                    Debug.Modify (New_Value   => "",
                                                  Variable    => "<SELECTION>",
                                                  Stack_Frame => 0);
                                when 'G' =>
                                    case Key4 is
                                        when 'A' =>
                                            Debug.Source (Location    => "_1",
                                                          Stack_Frame => 0);
                                        when 'B' =>
                                            Debug.Source (Location    => "_2",
                                                          Stack_Frame => 0);
                                        when 'C' =>
                                            Debug.Source (Location    => "_3",
                                                          Stack_Frame => 0);
                                        when 'D' =>
                                            Debug.Source (Location    => "_4",
                                                          Stack_Frame => 0);
                                        when 'E' =>
                                            Debug.Source (Location    => "_5",
                                                          Stack_Frame => 0);
                                        when 'F' =>
                                            Debug.Source (Location    => "_6",
                                                          Stack_Frame => 0);
                                        when 'G' =>
                                            Debug.Source (Location    => "_7",
                                                          Stack_Frame => 0);
                                        when 'H' =>
                                            Debug.Source (Location    => "_8",
                                                          Stack_Frame => 0);
                                        when 'I' =>
                                            Debug.Source (Location    => "_9",
                                                          Stack_Frame => 0);
                                        when 'J' =>
                                            Debug.Source (Location    => "_10",
                                                          Stack_Frame => 0);
                                        when 'Z' =>
                                            Debug.Source (Location    => "",
                                                          Stack_Frame => 0);
                                        when others =>
                                            null;
                                    end case;
                                when 'H' =>
                                    Debug.Source (Location    => "",
                                                  Stack_Frame => 0);
                                when 'I' =>
                                    Debug.Catch (Name        => "<SELECTION>",
                                                 In_Task     => "",
                                                 At_Location => "");
                                when 'K' =>
                                    case Key4 is
                                        when 'A' =>
                                            Debug.Break
                                               (Location => "<SELECTION>",
                                                Stack_Frame => 0,
                                                Count => 1,
                                                In_Task => "",
                                                Default_Lifetime => True);
                                        when 'B' =>
                                            Debug.Show (Values_For =>
                                                           Debug.Breakpoints);
                                        when 'C' =>
                                            Debug.Activate (Breakpoint => 0);
                                        when 'D' =>
                                            Debug.Remove (Breakpoint => 0,
                                                          Delete     => False);
                                        when 'E' =>
                                            Debug.Remove (Breakpoint => 0,
                                                          Delete     => True);
                                        when others =>
                                            null;
                                    end case;
                                when 'L' =>
                                    Debug.Break (Location => "<SELECTION>",
                                                 Stack_Frame => 0,
                                                 Count => 1,
                                                 In_Task => "",
                                                 Default_Lifetime => True);
                                when 'M' =>
                                    Debug.Stack
                                       (For_Task => "", Start => 0, Count => 0);
                                when 'O' =>
                                    Command.Debug;
                                when 'Z' =>
                                    Debug.Current_Debugger (Target => "");
                                when others =>
                                    null;
                            end case;
                        when 'O' =>
                            Debug.Current_Debugger (Target => "");
                        when 'P' =>
                            case Key3 is
--/ if MAIL then
--//                            when 'A' =>
--//                                MAIL.EDIT (MAILBOX => "MAIN",FOR_USER => "");
--//                            when 'B' =>
--//                                MAIL.EDIT (MAILBOX => "<SELECTION>",FOR_USER => "");
--//                            when 'C' =>
--//                                MAIL.SEND;
--//                            when 'D' =>
--//                                MAIL.REPLY (TO_ALL =>FALSE);
--//                            when 'E' =>
--//                                MAIL.FORWARD;
--/ end if;
                                when others =>
                                    null;
                            end case;
--/ if MAIL then
--//                    when 'Q' =>
--//                        MAIL.EDIT (MAILBOX => "MAIN",FOR_USER => "");
--/ end if;
                        when 'R' =>
                            case Key3 is
                                when Menu_Job_Kill =>
                                    Job.Kill (The_Job => 0, The_Session => "");
                                when Menu_Job_Disable =>
                                    Job.Disable (The_Job     => 0,
                                                 The_Session => "");
                                when 'A' =>
                                    Queue.Print (Name    => "<IMAGE>",
                                                 Options => "<DEFAULT>",
                                                 Banner  => "<DEFAULT>",
                                                 Header  => "<DEFAULT>",
                                                 Footer  => "<DEFAULT>");
                                when 'B' =>
                                    Job.Enable (The_Job     => 0,
                                                The_Session => "");
                                when 'D' =>
                                    Job.Connect (The_Job => 0);
                                when others =>
                                    null;
                            end case;
                        when 'T' =>
                            case Key3 is
                                when 'A' =>
                                    What.Does (Name => "<CURSOR>");
                                when 'B' =>
                                    Editor.Key.Name (Key_Code => "");
                                when 'C' =>
                                    Editor.Image.Find (Name => "Help Window");
                                when 'D' =>
                                    What.Does (Name => "Help_on_Help");
                                when others =>
                                    null;
                            end case;
                        when 'U' =>
                            What.Does (Name => "<CURSOR>");
                        when 'W' =>
                            case Key3 is
                                when 'A' =>
                                    Editor.Quit (Ignore_Changes => False);
                                when 'B' =>
                                    Editor.Quit (Ignore_Changes => True);
                                when others =>
                                    null;
                            end case;
                        when others =>
                            null;
                    end case;
                when Mouse_Minus =>
                    Editor.Set.Argument_Minus;
                when Mouse_0 =>
                    Editor.Set.Argument_Digit (Argument => 0);
                when Mouse_1 =>
                    Editor.Set.Argument_Digit (Argument => 1);
                when Mouse_2 =>
                    Editor.Set.Argument_Digit (Argument => 2);
                when Mouse_3 =>
                    Editor.Set.Argument_Digit (Argument => 3);
                when Mouse_4 =>
                    Editor.Set.Argument_Digit (Argument => 4);
                when Mouse_5 =>
                    Editor.Set.Argument_Digit (Argument => 5);
                when Mouse_6 =>
                    Editor.Set.Argument_Digit (Argument => 6);
                when Mouse_7 =>
                    Editor.Set.Argument_Digit (Argument => 7);
                when Mouse_8 =>
                    Editor.Set.Argument_Digit (Argument => 8);
                when Mouse_9 =>
                    Editor.Set.Argument_Digit (Argument => 9);
                when X_No_Op =>
                    Editor.Noop;
--/ if HAVE_DELTA2          then
--//            when X_SCREEN_HEIGHT =>
--//                EDITOR.SCREEN.SET_LINES(24);
--//            when X_SCREEN_WIDTH =>
--//                EDITOR.SCREEN.SET_COLUMNS(80);
--/ end if;
                when X_Screen_Redraw =>
                    Editor.Window.Focus;
                when Tab | S_Tab =>
                    Editor.Char.Tab_Forward;
                when C_Tab | Cs_Tab =>
                    Editor.Char.Tab_Backward;
                when M_Tab | Ms_Tab =>
                    Editor.Char.Tab_To_Comment;
                when Cm_Tab | Cms_Tab =>
                    What.Tabs;
                when Carriage_Return =>
                    Editor.Line.Indent;
                when C_Carriage_Return | Cs_Carriage_Return =>
                    Common.Commit;
                when M_Carriage_Return | Ms_Carriage_Return =>
                    Command.Debug;
                when S_Carriage_Return =>
                    Editor.Line.Insert (1);
                when Escape | C_C =>
                    case Key2 is
                        when Delete | S_Delete =>
                            Editor.Word.Delete_Backward;
                        when '!' | '1' =>
                            Debug.Run;
                        when '"' | ''' =>
                            Editor.Word.Capitalize;
                        when '#' | '3' =>
                            Debug.Run (Debug.Returned);
                        when '$' | '4' =>
                            Debug.Execute;
                        when '%' =>
                            Debug.Break (Location         => "<SELECTION>",
                                         Stack_Frame      => 0,
                                         Count            => 1,
                                         In_Task          => "",
                                         Default_Lifetime => False);
                        when '&' | '7' =>
                            Debug.Stack;
                        when '(' | '9' =>
                            Editor.Region.Start;
                        when ')' | '0' =>
                            Editor.Region.Finish;
                        when '*' | '8' =>
                            Debug.Put;
                        when '+' | '=' =>
                            Editor.Char.Insert_String ("=>");
                        when ',' | '<' =>
                            Editor.Word.Lower_Case;
                        when '.' | '>' =>
                            Editor.Word.Upper_Case;
                        when '/' | '?' =>
                            Common.Enclosing (In_Place => False,
                                              Library  => False);
                        when '2' | '@' | C_At_Sign =>
                            Debug.Run (Stop_At => Debug.Local_Statement);
                        when '5' =>
                            Debug.Break (Location         => "<SELECTION>",
                                         Stack_Frame      => 0,
                                         Count            => 1,
                                         In_Task          => "",
                                         Default_Lifetime => True);
                        when '6' | '^' | C_Circumflex =>
                            Debug.Source (Location => "", Stack_Frame => 0);
                        when ':' | C_Colon | ';' | C_Semicolon =>
                            Common.Definition (Name     => "<CURSOR>",
                                               In_Place => False,
                                               Visible  => True);
                        when 'a' | C_A | 'A' | Cs_A =>
                            Editor.Word.Beginning_Of;
                        when 'b' | C_B | 'B' | Cs_B =>
                            Editor.Image.Beginning_Of;
                        when 'd' | C_D | 'D' | Cs_D =>
                            Editor.Word.Delete_Forward;
                        when 'e' | C_E | 'E' | Cs_E =>
                            Editor.Word.End_Of;
                        when 'h' | C_H | 'H' | Cs_H =>
                            Editor.Word.Previous;
                        when 'i' | C_I | 'I' | Cs_I =>
                            Editor.Char.Tab_Backward;
                        when 'j' | C_J | 'J' | Cs_J =>
                            Editor.Word.Next;
                        when 'k' | C_K | 'K' | Cs_K =>
                            Editor.Word.Delete;
                        when 'l' | C_L | 'L' | Cs_L =>
                            Editor.Screen.Clear;
                        when 'm' | C_M | 'M' | Cs_M =>
                            Editor.Line.Insert (1);
                        when 'n' | C_N | 'N' | Cs_N =>
                            Editor.Cursor.Next (Prompt    => True,
                                                Underline => True);
                        when 'o' | C_O | 'O' | Cs_O =>
                            Editor.Line.Join;
                        when 'p' | C_P | 'P' | Cs_P =>
                            case Key3 is
--/ if DESIGN_FACILITY then
--//                            when '/' | '?' | 'h' | C_H | 'H' | CS_H =>
--//                                DESIGN_IMPLEMENTATION.ENCLOSING (IN_PLACE => FALSE);
--//                            when ':' | C_COLON | ';' | C_SEMICOLON | 'j' | C_J | 'J' | CS_J =>
--//                                DESIGN_IMPLEMENTATION.DEFINITION (IN_PLACE => FALSE,VISIBLE => TRUE);
--/ end if;
                                when 'b' | C_B | 'B' | Cs_B =>
                                    case Key4 is
--/ if DESIGN_FACILITY then
--//                                    when '2' | '@' | C_AT_SIGN =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @");
--//                                    when 'b' | C_B | 'B' | CS_B =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| ");
--//                                    when 'c' | C_C | 'C' | CS_C =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @COMPONENT_KIND ");
--/ end if;
                                        when 'd' | C_D | 'D' | Cs_D =>
                                            case Key5 is
--/ if DESIGN_FACILITY then
--//                                            when 'e' | C_E | 'E' | CS_E =>
--//                                                EDITOR.CHAR.INSERT_STRING("--| @DECOMPOSITION ");
--//                                            when 's' | C_S | 'S' | CS_S =>
--//                                                EDITOR.CHAR.INSERT_STRING("--| @DATA_STRUCTURE ");
--/ end if;
                                                when others =>
                                                    null;
                                            end case;
--/ if DESIGN_FACILITY then
--//                                    when 'f' | C_F | 'F' | CS_F =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @FILE_STRUCTURE ");
--//                                    when 'i' | C_I | 'I' | CS_I =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @INPUT ");
--//                                    when 'n' | C_N | 'N' | CS_N =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @NOTE ");
--/ end if;
                                        when 's' | C_S | 'S' | Cs_S =>
                                            case Key5 is
--/ if DESIGN_FACILITY then
--//                                            when 'a' | C_A | 'A' | CS_A =>
--//                                                EDITOR.CHAR.INSERT_STRING("--| @SATISFIES ");
--//                                            when 't' | C_T | 'T' | CS_T =>
--//                                                EDITOR.CHAR.INSERT_STRING("--| @STATES ");
--/ end if;
                                                when others =>
                                                    null;
                                            end case;
                                        when others =>
                                            null;
                                    end case;
--/ if DESIGN_FACILITY then
--//                            when 'k' | C_K | 'K' | CS_K =>
--//                                DESIGN_IMPLEMENTATION.COMPLETE (INCLUDE_OPTIONAL_ANNOTATIONS => FALSE);
--//                            when 'o' | C_O | 'O' | CS_O =>
--//                                EDITOR.CHAR.INSERT_STRING("--| @OUTPUT ");
--/ end if;
                                when 'r' | C_R | 'R' | Cs_R =>
                                    case Key4 is
--/ if DESIGN_FACILITY then
--//                                    when 'a' | C_A | 'A' | CS_A =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @RAISES ");
--/ end if;
                                        when 'c' | C_C | 'C' | Cs_C =>
                                            case Key5 is
--/ if DESIGN_FACILITY then
--//                                            when 'a' | C_A | 'A' | CS_A =>
--//                                                EDITOR.CHAR.INSERT_STRING("--| @REQUIREMENT CAPABILITY ");
--//                                            when 'o' | C_O | 'O' | CS_O =>
--//                                                EDITOR.CHAR.INSERT_STRING("--| @REQUIREMENT CONSTITUENT ");
--/ end if;
                                                when others =>
                                                    null;
                                            end case;
--/ if DESIGN_FACILITY then
--//                                    when 'f' | C_F | 'F' | CS_F =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @REQUIREMENT FUNCTION ");
--//                                    when 'i' | C_I | 'I' | CS_I =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @REQUIREMENT INTERFACE ");
--//                                    when 's' | C_S | 'S' | CS_S =>
--//                                        EDITOR.CHAR.INSERT_STRING("--| @REQUIREMENT SUBFUNCTION ");
--/ end if;
                                        when others =>
                                            null;
                                    end case;
--/ if DESIGN_FACILITY then
--//                            when 't' | C_T | 'T' | CS_T =>
--//                                DESIGN_IMPLEMENTATION.FORMAT;
--//                            when 'u' | C_U | 'U' | CS_U =>
--//                                DESIGN_IMPLEMENTATION.SHOW_USAGE (IN_WORLD => "<CURSOR>");
--//                            when 'x' | C_X | 'X' | CS_X =>
--//                                DESIGN_IMPLEMENTATION.EXPLAIN;
--/ end if;
                                when others =>
                                    null;
                            end case;
                        when 'r' | C_R | 'R' | Cs_R =>
                            Editor.Search.Replace_Previous (Target => "",
                                                            Replacement => "",
                                                            Repeat => 1,
                                                            Wildcard => False);
                        when 's' | C_S | 'S' | Cs_S =>
                            Editor.Search.Replace_Next (Target      => "",
                                                        Replacement => "",
                                                        Repeat      => 1,
                                                        Wildcard    => False);
                        when 't' | C_T | 'T' | Cs_T =>
                            Editor.Word.Transpose;
                        when 'u' | C_U | 'U' | Cs_U =>
                            Editor.Cursor.Previous
                               (Prompt => True, Underline => True);
                        when 'v' | C_V | 'V' | Cs_V =>
                            Editor.Image.End_Of;
                        when 'w' | C_W | 'W' | Cs_W =>
                            Editor.Region.Copy;
                        when 'x' | C_X | 'X' | Cs_X =>
                            Editor.Macro.Execute;
                        when 'y' | C_Y | 'Y' | Cs_Y =>
                            Editor.Hold_Stack.Next;
                        when others =>
                            null;
                    end case;
                when Delete | S_Delete =>
                    Editor.Char.Delete_Backward;
                when C_Delete | Cs_Delete =>
                    Editor.Char.Delete_Spaces;
                when M_Delete | Ms_Delete =>
                    Editor.Word.Delete_Backward;
                when Cm_Delete | Cms_Delete =>
                    Editor.Line.Delete_Backward;
                when Left =>
                    Editor.Cursor.Left;
                when C_Left =>
                    Common.Object.Parent;
                when M_Left =>
                    Editor.Word.Previous;
                when Cm_Left =>
                    Common.Enclosing (In_Place => False, Library => False);
                when S_Left =>
                    Common.Enclosing (In_Place => True, Library => False);
                when Cs_Left =>
                    Editor.Screen.Left;
                when Ms_Left =>
                    Editor.Image.Left;
                when Cms_Left =>
                    Editor.Screen.Previous;
                when Up =>
                    Editor.Cursor.Up;
                when C_Up =>
                    Common.Object.Previous;
                when M_Up | Ms_Up =>
                    Editor.Cursor.Previous (Prompt => True, Underline => True);
                when Cm_Up | M_Z | Ms_Z =>
                    Editor.Window.Previous;
                when S_Up =>
                    Editor.Image.Up;
                when Cs_Up =>
                    Editor.Screen.Up;
                when Cms_Up =>
                    Editor.Screen.Top;
                when Right =>
                    Editor.Cursor.Right;
                when C_Right =>
                    Common.Object.Child;
                when M_Right =>
                    Editor.Word.Next;
                when Cm_Right =>
                    Common.Definition (Name     => "<CURSOR>",
                                       In_Place => False,
                                       Visible  => False);
                when S_Right =>
                    Common.Definition
                       (Name => "<CURSOR>", In_Place => True, Visible => False);
                when Cs_Right =>
                    Editor.Screen.Right;
                when Ms_Right =>
                    Editor.Image.Right;
                when Cms_Right =>
                    Editor.Screen.Next;
                when Down =>
                    Editor.Cursor.Down;
                when C_Down =>
                    Common.Object.Next;
                when M_Down | Ms_Down =>
                    Editor.Cursor.Next (Prompt => True, Underline => True);
                when Cm_Down | M_V | Ms_V =>
                    Editor.Window.Next;
                when S_Down =>
                    Editor.Image.Down;
                when Cs_Down =>
                    Editor.Screen.Down;
                when Cms_Down =>
                    Editor.Screen.Push;
                when ' ' | S_Space =>
                    Editor.Char.Insert_Character (1, ' ');
                when C_Space | M_Space | Cm_Space |
                     Cs_Space | Ms_Space | Cms_Space =>
                    Editor.Char.Insert_Character (1, ' ');
                when C_Exclam | M_Exclam | Cm_Exclam | C_1 | M_1 | Cm_1 =>
                    Editor.Set.Argument_Digit (1);
                when C_Quotation | C_Tick =>
                    Editor.Char.Quote;
                when C_Sharp | M_Sharp | Cm_Sharp | C_3 | M_3 | Cm_3 =>
                    Editor.Set.Argument_Digit (3);
                when C_Dollar | M_Dollar | Cm_Dollar | C_4 | M_4 | Cm_4 =>
                    Editor.Set.Argument_Digit (4);
                when C_Percent | M_Percent | Cm_Percent | C_5 | M_5 | Cm_5 =>
                    Editor.Set.Argument_Digit (5);
                when C_Ampersand | M_Ampersand |
                     Cm_Ampersand | C_7 | M_7 | Cm_7 =>
                    Editor.Set.Argument_Digit (7);
                when C_Left_Paren | M_Left_Paren |
                     Cm_Left_Paren | C_9 | M_9 | Cm_9 =>
                    Editor.Set.Argument_Digit (9);
                when C_Right_Paren | M_Right_Paren |
                     Cm_Right_Paren | C_0 | M_0 | Cm_0 =>
                    Editor.Set.Argument_Digit (0);
                when C_Star | M_Star | Cm_Star | C_8 | M_8 | Cm_8 =>
                    Editor.Set.Argument_Digit (8);
                when C_Plus | C_Equal =>
                    Editor.Char.Insert_String ("=>");
                when C_Comma | C_Less_Than =>
                    Editor.Char.Lower_Case;
                when M_Comma | M_Less_Than =>
                    Editor.Word.Lower_Case;
                when Cm_Comma | Cm_Less_Than =>
                    Editor.Line.Lower_Case;
                when C_Minus | C_Underline =>
                    Editor.Set.Argument_Minus;
                when C_Period | C_Greater_Than =>
                    Editor.Char.Upper_Case;
                when M_Period | M_Greater_Than =>
                    Editor.Word.Upper_Case;
                when Cm_Period | Cm_Greater_Than =>
                    Editor.Line.Upper_Case;
                when C_Slash | C_Question =>
                    Common.Explain;
                when C_2 | M_2 | Cm_2 | M_At_Sign | Cm_At_Sign =>
                    Editor.Set.Argument_Digit (2);
                when C_6 | M_6 | Cm_6 | C_Circumflex |
                     M_Circumflex | Cm_Circumflex =>
                    Editor.Set.Argument_Digit (6);
                when C_Colon | C_Semicolon =>
                    Editor.Char.Insert_String (":=");
                when C_At_Sign =>
                    Editor.Mark.Push;
                when C_A | Cs_A =>
                    Editor.Line.Beginning_Of;
                when M_A | Ms_A =>
                    Editor.Word.Beginning_Of;
                when Cm_A | Cms_A =>
                    Editor.Line.Beginning_Of;
                when C_B | Cs_B =>
                    Editor.Image.Up;
                when M_B | Ms_B =>
                    Editor.Word.Beginning_Of;
                when Cm_B | Cms_B =>
                    Editor.Line.Beginning_Of;
                when M_C | Ms_C | M_Y | Ms_Y =>
                    Editor.Hold_Stack.Next;
                when Cm_C | Cms_C =>
                    Editor.Line.Copy;
                when Cs_C =>
                    Editor.Hold_Stack.Push;
                when C_D | Cs_D =>
                    Editor.Char.Delete_Forward;
                when M_D | Ms_D =>
                    Editor.Word.Delete;
                when C_E | Cs_E =>
                    Editor.Line.End_Of;
                when M_E | Ms_E =>
                    Editor.Word.End_Of;
                when Cm_E | Cms_E =>
                    Editor.Line.End_Of;
                when C_F | Cs_F =>
                    Editor.Set.Argument_Prefix;
                when Cm_F | Cms_F =>
                    Editor.Cursor.Right (8);
                when C_H | Cs_H =>
                    Editor.Cursor.Left;
                when M_H | Ms_H =>
                    Editor.Word.Previous;
                when Cm_H | Cms_H =>
                    Editor.Cursor.Left (8);
                when C_I | Cs_I =>
                    Editor.Char.Tab_Forward;
                when Cm_I | Cms_I =>
                    Ada.Insert_Blank_Line;
                when C_J | Cs_J =>
                    Editor.Cursor.Right;
                when M_J | Ms_J =>
                    Editor.Word.Next;
                when Cm_J | Cms_J =>
                    Editor.Cursor.Right (8);
                when C_K | Cs_K =>
                    Editor.Line.Delete_Forward;
                when M_K | Ms_K =>
                    Editor.Word.Delete_Forward;
                when Cm_K | Cms_K =>
                    Ada.Delete_Blank_Line;
                when C_L | Cs_L =>
                    Editor.Screen.Redraw;
                when M_L | Ms_L =>
                    Editor.Screen.Clear;
                when C_M | Cs_M =>
                    Editor.Line.Indent;
                when M_M | Ms_M =>
                    Editor.Mark.Next;
                when C_N | Cs_N =>
                    Editor.Cursor.Down;
                when M_N | Ms_N =>
                    Editor.Cursor.Next (Prompt => True, Underline => True);
                when Cm_N | Cms_N =>
                    Editor.Cursor.Down (8);
                when C_O | Cs_O =>
                    Editor.Line.Open;
                when M_O | Cm_O | Ms_O | Cms_O =>
                    Editor.Line.Join;
                when C_P =>
                    case Key2 is
                        when Delete | S_Delete =>
                            Editor.Word.Delete_Backward;
                        when Left | S_Left =>
                            Editor.Word.Previous;
                        when Right | S_Right =>
                            Editor.Word.Next;
--/ if SPELLER then
--//                    when DOWN | S_DOWN =>
--//                        SPELLER.EXPLAIN_NEXT;
--/ end if;
                        when ',' | '<' =>
                            Editor.Word.Lower_Case;
                        when '.' | '>' =>
                            Editor.Word.Upper_Case;
--/ if SPELLER then
--//                    when '/' | '?' =>
--//                        SPELLER.CHECK_TEXT (DATA => "<TEXT>");
--/ end if;
                        when '6' | '^' | C_Circumflex =>
                            Editor.Word.Capitalize;
                        when 'a' | C_A | 'A' | Cs_A =>
                            Editor.Word.Beginning_Of;
                        when 'd' | C_D | 'D' | Cs_D =>
                            Editor.Word.Delete;
                        when 'e' | C_E | 'E' | Cs_E =>
                            Editor.Word.End_Of;
--/ if SPELLER then
--//                    when 'i' | C_I | 'I' | CS_I =>
--//                        SPELLER.LEARN_WORD (THE_WORD => "",DICTIONARY => 0);
--/ end if;
                        when 'k' | C_K | 'K' | Cs_K =>
                            Editor.Word.Delete_Forward;
--/ if SPELLER then
--//                    when 'l' | C_L | 'L' | CS_L =>
--//                        SPELLER.LEARN_WORD (THE_WORD => "",DICTIONARY => 1);
--//                    when 'm' | C_M | 'M' | CS_M =>
--//                        SPELLER.CHECK_IMAGE;
--//                    when 'n' | C_N | 'N' | CS_N =>
--//                        SPELLER.EXPLAIN_NEXT;
--//                    when 'r' | C_R | 'R' | CS_R =>
--//                        SPELLER.LEARN_REPLACEMENT (THE_WORD => "",CHOICE => 1,DICTIONARY => 0);
--/ end if;
                        when 't' | C_T | 'T' | Cs_T =>
                            Editor.Word.Transpose;
--/ if SPELLER then
--//                    when 'w' | C_W | CS_W =>
--//                        SPELLER.SPELLER_WINDOW (IN_PLACE => FALSE);
--//                    when 'W' =>
--//                        SPELLER.SPELLER_WINDOW (IN_PLACE => TRUE);
--//                    when 'x' | C_X | 'X' | CS_X =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 1);
--//                    when KP_0 | S_KP_0 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 10);
--//                    when KP_1 | S_KP_1 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 1);
--//                    when KP_2 | S_KP_2 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 2);
--//                    when KP_3 | S_KP_3 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 3);
--//                    when KP_4 | S_KP_4 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 4);
--//                    when KP_5 | S_KP_5 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 5);
--//                    when KP_6 | S_KP_6 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 6);
--//                    when KP_7 | S_KP_7 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 7);
--//                    when KP_8 | S_KP_8 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 8);
--//                    when KP_9 | S_KP_9 =>
--//                        SPELLER.EXCHANGE_WORD (CHOICE => 9);
--/ end if;
                        when others =>
                            null;
                    end case;
                when C_Q | Cs_Q =>
                    Editor.Char.Quote;
                when M_Q | Ms_Q =>
                    Editor.Key.Prompt (Key_Code => "");
                when C_R | Cs_R =>
                    Editor.Search.Previous (Target => "", Wildcard => False);
                when M_R =>
                    Editor.Search.Replace_Previous (Target      => "",
                                                    Replacement => "",
                                                    Repeat      => 1,
                                                    Wildcard    => False);
                when Cm_R =>
                    Editor.Search.Replace_Previous (Target      => "",
                                                    Replacement => "",
                                                    Repeat      => -1,
                                                    Wildcard    => False);
                when Ms_R =>
                    Editor.Search.Replace_Previous (Target      => "",
                                                    Replacement => "",
                                                    Repeat      => 1,
                                                    Wildcard    => True);
                when Cms_R =>
                    Editor.Search.Replace_Previous (Target      => "",
                                                    Replacement => "",
                                                    Repeat      => -1,
                                                    Wildcard    => True);
                when C_S | Cs_S =>
                    Editor.Search.Next (Target => "", Wildcard => False);
                when M_S =>
                    Editor.Search.Replace_Next (Target      => "",
                                                Replacement => "",
                                                Repeat      => 1,
                                                Wildcard    => False);
                when Ms_S =>
                    Editor.Search.Replace_Next (Target      => "",
                                                Replacement => "",
                                                Repeat      => 1,
                                                Wildcard    => True);
                when C_T | Cs_T =>
                    Editor.Char.Transpose;
                when M_T | Ms_T =>
                    Editor.Word.Transpose;
                when Cm_T | Cms_T =>
                    Editor.Line.Transpose;
                when C_U | Cs_U =>
                    Editor.Cursor.Up;
                when M_U | Ms_U =>
                    Editor.Cursor.Previous (Prompt => True, Underline => True);
                when Cm_U | Cms_U =>
                    Editor.Cursor.Up (8);
                when C_V | Cs_V =>
                    Editor.Image.Down;
                when C_W =>
                    Editor.Region.Delete;
                when C_X =>
                    case Key2 is
                        when Delete | S_Delete =>
                            Editor.Line.Delete_Backward;
                        when '"' | ''' =>
                            Editor.Line.Capitalize;
                        when '(' | '9' =>
                            Editor.Macro.Start;
                        when ')' | '0' =>
                            Editor.Macro.Finish;
                        when '+' | '=' =>
                            Editor.Char.Insert_String (":=");
                        when ',' | '<' =>
                            Editor.Line.Lower_Case;
                        when '-' | '_' | C_Underline =>
                            Editor.Line.Center;
                        when '.' | '>' =>
                            Editor.Line.Upper_Case;
                        when '/' | '?' =>
                            Common.Enclosing (In_Place => True,
                                              Library  => False);
                        when ':' | C_Colon | ';' | C_Semicolon =>
                            Common.Definition (Name     => "<CURSOR>",
                                               In_Place => True,
                                               Visible  => True);
                        when 'a' | C_A | 'A' | Cs_A =>
                            Common.Object.First_Child;
                        when 'b' | C_B | 'B' | Cs_B =>
                            Editor.Window.Previous;
                        when 'd' | C_D | 'D' | Cs_D =>
                            Editor.Line.Delete_Forward;
                        when 'e' | C_E | 'E' | Cs_E =>
                            Common.Object.Last_Child;
                        when 'h' | C_H | 'H' | Cs_H =>
                            Common.Object.Parent;
                        when 'i' | C_I | 'I' | Cs_I =>
                            Editor.Char.Tab_To_Comment;
                        when 'j' | C_J | 'J' | Cs_J =>
                            Common.Object.Child;
                        when 'k' | C_K | 'K' | Cs_K =>
                            Editor.Line.Delete;
                        when 'l' | C_L | 'L' | Cs_L =>
                            Editor.Line.Copy;
                        when 'm' | C_M | 'M' | Cs_M =>
                            Common.Commit;
                        when 'n' | C_N | 'N' | Cs_N =>
                            Common.Object.Next;
                        when 'o' | C_O | 'O' | Cs_O =>
                            Editor.Line.Insert (-1);
                        when 'r' | C_R | 'R' | Cs_R =>
                            Editor.Search.Previous
                               (Target => "", Wildcard => True);
                        when 's' | C_S | 'S' | Cs_S =>
                            Editor.Search.Next (Target => "", Wildcard => True);
                        when 't' | C_T | 'T' | Cs_T =>
                            Editor.Line.Transpose;
                        when 'u' | C_U | 'U' | Cs_U =>
                            Common.Object.Previous;
                        when 'v' | C_V | 'V' | Cs_V =>
                            Editor.Window.Next;
                        when 'w' | C_W | 'W' | Cs_W =>
                            Editor.Hold_Stack.Push;
                        when 'x' | C_X | 'X' | Cs_X =>
                            Editor.Set.Designation_Off;
                        when 'y' | C_Y | 'Y' | Cs_Y =>
                            Editor.Region.Move;
                        when others =>
                            null;
                    end case;
                when M_X | Ms_X =>
                    Editor.Macro.Execute;
                when Cs_X =>
                    Editor.Set.Designation_Off;
                when C_Y | Cs_Y =>
                    Editor.Hold_Stack.Top;
                when C_Z =>
                    case Key2 is
                        when Delete | S_Delete =>
                            Editor.Char.Delete_Spaces;
                        when '!' | '1' =>
                            case Key3 is
                                when '!' | '1' =>
                                    Ada.Source_Unit;
                                when '#' | '3' =>
                                    Compilation.Demote
                                       (Unit        => "<IMAGE>",
                                        Goal        => Compilation.Source,
                                        Limit       => "<ALL_WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when '$' | '4' =>
                                    Common.Demote;
                                when '%' | '5' =>
                                    Compilation.Demote
                                       (Unit        => "<IMAGE>",
                                        Goal        => Compilation.Installed,
                                        Limit       => "<WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when '2' | '@' | C_At_Sign =>
                                    Compilation.Demote
                                       (Unit        => "<IMAGE>",
                                        Goal        => Compilation.Source,
                                        Limit       => "<WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when '6' | '^' | C_Circumflex =>
                                    Compilation.Demote
                                       (Unit        => "<IMAGE>",
                                        Goal        => Compilation.Installed,
                                        Limit       => "<ALL_WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when others =>
                                    null;
                            end case;
                        when '$' | '4' =>
                            case Key3 is
                                when '$' | '4' =>
                                    What.Users (All_Users => True);
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Access_List.Display
                                       (For_Object => "<CURSOR>");
                                when 'd' | C_D | 'D' | Cs_D =>
                                    Operator.Disk_Space;
                                when 'k' | C_K | 'K' | Cs_K =>
                                    What.Locks (Name => "<IMAGE>");
                                when 'l' | C_L | 'L' | Cs_L =>
                                    What.Load;
                                when 'o' | C_O | 'O' | Cs_O =>
                                    What.Object (Name => "<IMAGE>");
                                when 't' | C_T | 'T' | Cs_T =>
                                    What.Time;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    What.Users (All_Users => False);
                                when others =>
                                    null;
                            end case;
                        when '&' | '7' =>
                            case Key3 is
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Debug.Activate (Breakpoint => 0);
                                when 'b' | C_B | 'B' | Cs_B =>
                                    Debug.Show;
                                when 'c' | C_C =>
                                    Debug.Catch (Name        => "",
                                                 In_Task     => "",
                                                 At_Location => "");
                                when 'C' =>
                                    Debug.Catch (Name        => "<SELECTION>",
                                                 In_Task     => "",
                                                 At_Location => "");
                                when Cs_C =>
                                    Debug.Catch (Name        => "<SELECTION>",
                                                 In_Task     => "",
                                                 At_Location => "");
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Debug.Show (Debug.Exceptions);
                                when 'f' | C_F =>
                                    Debug.Forget (Name        => "",
                                                  In_Task     => "",
                                                  At_Location => "");
                                when 'F' =>
                                    Debug.Forget (Name        => "all",
                                                  In_Task     => "",
                                                  At_Location => "");
                                when Cs_F =>
                                    Debug.Forget (Name        => "",
                                                  In_Task     => "",
                                                  At_Location => "");
                                when 'k' | C_K | 'K' | Cs_K =>
                                    Debug.Break (Location => "<SELECTION>",
                                                 Stack_Frame => 0,
                                                 Count => 1,
                                                 In_Task => "",
                                                 Default_Lifetime => False);
                                when 'p' | C_P =>
                                    Debug.Propagate (Name        => "",
                                                     In_Task     => "",
                                                     At_Location => "");
                                when 'P' =>
                                    Debug.Propagate (Name => "<SELECTION>",
                                                     In_Task => "",
                                                     At_Location => "");
                                when Cs_P =>
                                    Debug.Propagate (Name => "<SELECTION>",
                                                     In_Task => "",
                                                     At_Location => "");
                                when 'r' | C_R =>
                                    Debug.Remove (Breakpoint => 0,
                                                  Delete     => False);
                                when 'R' =>
                                    Debug.Remove (Breakpoint => 0,
                                                  Delete     => True);
                                when 't' | C_T | 'T' | Cs_T =>
                                    Debug.Task_Display;
                                when 'v' | C_V | 'V' | Cs_V =>
                                    Debug.Information (Debug.Rendezvous);
                                when 'w' | C_W | 'W' | Cs_W =>
                                    Debug.Current_Debugger ("");
                                when 'z' | C_Z | 'Z' | Cs_Z =>
                                    Command.Debug;
                                when others =>
                                    null;
                            end case;
                        when '(' | '9' =>
                            case Key3 is
                                when 'c' | C_C | 'C' | Cs_C =>
                                    Job.Connect (0);
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Job.Enable (0);
                                when others =>
                                    null;
                            end case;
                        when ')' | '0' =>
                            case Key3 is
                                when ')' | '0' =>
                                    Text.End_Of_Input;
                                when 'p' | C_P | 'P' | Cs_P =>
                                    Queue.Print;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Common.Clear_Underlining;
                                when others =>
                                    null;
                            end case;
                        when '*' | '8' =>
                            case Key3 is
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Debug.Enable (Debug.Addresses);
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Debug.Set_Value
                                       (Variable => Debug.Element_Count,
                                        To_Value => 5);
                                when 'f' | C_F | 'F' | Cs_F =>
                                    Debug.Set_Value
                                       (Variable => Debug.First_Element,
                                        To_Value => 0);
                                when 'i' | C_I | 'I' | Cs_I =>
                                    Debug.Information (Debug.Exceptions);
                                when 'p' | C_P | 'P' | Cs_P =>
                                    Debug.Set_Value
                                       (Variable => Debug.Pointer_Level,
                                        To_Value => 5);
                                when others =>
                                    null;
                            end case;
                        when '/' | '?' =>
                            case Key3 is
                                when 'c' | C_C | 'C' | Cs_C =>
                                    What.Does (Name => "<CURSOR>");
                                when 'h' | C_H | 'H' | Cs_H =>
                                    What.Home_Library;
                                when 'i' | C_I | 'I' | Cs_I =>
                                    What.Tabs;
                                when 'k' | C_K | 'K' | Cs_K =>
                                    Editor.Key.Name;
                                when 'l' | C_L | 'L' | Cs_L =>
                                    What.Line;
                                when 'q' | C_Q | 'Q' | Cs_Q =>
                                    What.Does (Name => "Help_on_Help");
                                when 's' | C_S | 'S' | Cs_S =>
                                    Script.Pretty_Print
                                       (Script_File  => "",
                                        Command_File =>
                                           "!machine.error_logs.key_script");
                                when 'w' | C_W | 'W' | Cs_W =>
                                    Editor.Image.Find ("Help Window");
                                when 'x' | C_X | 'X' | Cs_X =>
                                    Common.Explain;
                                when others =>
                                    null;
                            end case;
                        when '2' | '@' | C_At_Sign =>
                            case Key3 is
                                when '!' | '1' =>
                                    Ada.Code_Unit;
                                when '#' | '3' =>
                                    Compilation.Make
                                       (Unit        => "<IMAGE>",
                                        Scope       => Compilation.Load_Views,
                                        Goal        => Compilation.Coded,
                                        Limit       => "<ALL_WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when '$' | '4' =>
                                    Ada.Install_Unit;
                                when '%' | '5' =>
                                    Compilation.Promote
                                       (Unit        => "<IMAGE>",
                                        Scope       => Compilation.Subunits_Too,
                                        Goal        => Compilation.Installed,
                                        Limit       => "<WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when '2' | '@' | C_At_Sign =>
                                    Compilation.Make
                                       (Unit        => "<IMAGE>",
                                        Scope       => Compilation.All_Parts,
                                        Goal        => Compilation.Coded,
                                        Limit       => "<WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when '6' | '^' | C_Circumflex =>
                                    Compilation.Promote
                                       (Unit        => "<IMAGE>",
                                        Scope       => Compilation.All_Parts,
                                        Goal        => Compilation.Installed,
                                        Limit       => "<WORLDS>",
                                        Effort_Only => False,
                                        Response    => "<PROFILE>");
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Cmvc.Accept_Changes
                                       (Destination          => "<CURSOR>",
                                        Source               => "<LATEST>",
                                        Allow_Demotion       => True,
                                        Remake_Demoted_Units => False,
                                        Comments             => "",
                                        Work_Order           => "<DEFAULT>",
                                        Response             => "<PROFILE>");
                                when 'd' | C_D | 'D' | Cs_D =>
                                    Cmvc.Show_Out_Of_Date_Objects
                                       (In_View  => "<CURSOR>",
                                        Response => "<PROFILE>");
                                when 'i' | C_I | 'I' | Cs_I =>
                                    Cmvc.Check_In (What_Object => "<CURSOR>",
                                                   Comments    => "",
                                                   Work_Order  => "<DEFAULT>",
                                                   Response    => "<PROFILE>");
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Cmvc.Get_Notes
                                       (To_File     => "<WINDOW>",
                                        What_Object => "<CURSOR>",
                                        Response    => "<PROFILE> USE_ERROR");
                                when 'o' | C_O | 'O' | Cs_O =>
                                    Cmvc.Check_Out
                                       (What_Object => "<CURSOR>",
                                        Comments => "",
                                        Allow_Implicit_Accept_Changes => True,
                                        Allow_Demotion => True,
                                        Remake_Demoted_Units => False);
                                when 'p' | C_P | 'P' | Cs_P =>
                                    Cmvc.Put_Notes
                                       (From_File   => "<WINDOW>",
                                        What_Object => "<CURSOR>",
                                        Response    => "<PROFILE> USE_ERROR");
                                when 's' | C_S | 'S' | Cs_S =>
                                    Cmvc.Show (Objects  => "<CURSOR>",
                                               Response => "<PROFILE>");
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Cmvc.Show_Checked_Out_By_User
                                       (In_View  => "<CURSOR>",
                                        Who      => System_Utilities.User_Name,
                                        Response => "<PROFILE>");
                                when 'v' | C_V | 'V' | Cs_V =>
                                    Cmvc.Show_Checked_Out_In_View
                                       (In_View  => "<CURSOR>",
                                        Response => "<PROFILE>");
                                when others =>
                                    null;
                            end case;
                        when '6' | '^' | C_Circumflex =>
                            case Key3 is
--/ if MAIL then
--//                            when 'e' | C_E | 'E' | CS_E | 'm' | C_M | 'M' | CS_M =>
--//                                MAIL.EDIT (MAILBOX => "MAIN",FOR_USER => "");
--/ end if;
                                when others =>
                                    null;
                            end case;
                        when ':' | C_Colon | ';' | C_Semicolon =>
                            case Key3 is
                                when Delete | S_Delete =>
                                    Ada.Delete_Blank_Line;
                                when 'b' | C_B | 'B' | Cs_B =>
                                    Ada.Create_Body;
                                when 'c' | C_C | 'C' | Cs_C =>
                                    Ada.Code_Unit;
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Ada.Get_Errors;
                                when 'i' | C_I | 'I' | Cs_I =>
                                    Ada.Install_Unit;
                                when 'm' | C_M | 'M' | Cs_M =>
                                    Ada.Insert_Blank_Line;
                                when 'n' | 'N' =>
                                    Ada.Show_Unused
                                       (In_Unit           => "<IMAGE>",
                                        Check_Other_Units => False);
                                when C_N | Cs_N =>
                                    Ada.Show_Unused (In_Unit => "<IMAGE>",
                                                     Check_Other_Units => True);
                                when 'q' | C_Q | 'Q' | Cs_Q =>
                                    Ada.Install_Stub;
                                when 'r' | C_R | 'R' | Cs_R =>
                                    Ada.Create_Private;
                                when 's' | C_S | 'S' | Cs_S =>
                                    Ada.Source_Unit;
                                when 'u' =>
                                    Ada.Show_Usage (Name    => "<CURSOR>",
                                                    Global  => False,
                                                    Limit   => "<WORLDS>",
                                                    Closure => False);
                                when C_U | Cs_U =>
                                    Ada.Show_Usage (Name    => "<CURSOR>",
                                                    Global  => True,
                                                    Limit   => "<ALL_WORLDS>",
                                                    Closure => False);
                                when 'U' =>
                                    Ada.Show_Usage (Name    => "<CURSOR>",
                                                    Global  => True,
                                                    Limit   => "<ALL_WORLDS>",
                                                    Closure => True);
                                when 'w' | C_W | 'W' | Cs_W =>
                                    Ada.Make_Separate;
                                when 'x' | C_X | 'X' | Cs_X =>
                                    Ada.Withdraw;
                                when 'y' | C_Y | 'Y' | Cs_Y =>
                                    Ada.Make_Inline;
                                when others =>
                                    null;
                            end case;
                        when 'c' | C_C | 'C' | Cs_C =>
                            Common.Create_Command;
                        when 'd' | C_D | 'D' | Cs_D =>
                            case Key3 is
                                when 'd' | C_D | 'D' | Cs_D =>
                                    Common.Definition (Name     => "<CURSOR>",
                                                       In_Place => False,
                                                       Visible  => False);
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Common.Enclosing (In_Place => False,
                                                      Library  => False);
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Common.Definition (Name     => "<CURSOR>",
                                                       In_Place => False,
                                                       Visible  => True);
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Ada.Other_Part (Name     => "<IMAGE>",
                                                    In_Place => False);
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Common.Enclosing (In_Place => False,
                                                      Library  => True);
                                when others =>
                                    null;
                            end case;
                        when 'e' | C_E | 'E' | Cs_E =>
                            Common.Edit;
                        when 'f' | C_F | 'F' | Cs_F =>
                            case Key3 is
                                when 'f' | C_F | 'F' | Cs_F =>
                                    Common.Definition (Name     => "<CURSOR>",
                                                       In_Place => True,
                                                       Visible  => False);
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Common.Enclosing (In_Place => True,
                                                      Library  => False);
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Common.Definition (Name     => "<CURSOR>",
                                                       In_Place => True,
                                                       Visible  => True);
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Ada.Other_Part (Name     => "<IMAGE>",
                                                    In_Place => True);
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Common.Enclosing (In_Place => True,
                                                      Library  => True);
                                when others =>
                                    null;
                            end case;
                        when 'h' | C_H | 'H' | Cs_H =>
                            Editor.Cursor.Left (8);
                        when 'i' | C_I | 'I' | Cs_I =>
                            case Key3 is
                                when Left | S_Left =>
                                    Editor.Image.Left;
                                when Up | S_Up =>
                                    Editor.Image.Up;
                                when Right | S_Right =>
                                    Editor.Image.Right;
                                when Down | S_Down =>
                                    Editor.Image.Down;
                                when '!' | '1' =>
                                    Debug.Source ("_1");
                                when '#' | '3' =>
                                    Debug.Source ("_3");
                                when '$' | '4' =>
                                    Debug.Source ("_4");
                                when '%' | '5' =>
                                    Debug.Source ("_5");
                                when '&' | '7' =>
                                    Debug.Source ("_7");
                                when '(' | '9' =>
                                    Debug.Source ("_9");
                                when ')' | '0' =>
                                    Debug.Source ("_10");
                                when '*' | '8' =>
                                    Debug.Source ("_8");
                                when '2' | '@' | C_At_Sign =>
                                    Debug.Source ("_2");
                                when '6' | '^' | C_Circumflex =>
                                    Debug.Source ("_6");
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Editor.Image.Beginning_Of;
--/ if DOCUMENT_FORMATTER then
--//                            when 'c' | C_C | 'C' | CS_C =>
--//                                COMPOSE (DOCUMENT => "<CURSOR>",DEVICE => "PostScript",OPTIONS => "",RESPONSE => "<PROFILE>");
--/ end if;
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Editor.Image.End_Of;
                                when 'f' | C_F | 'F' | Cs_F =>
                                    Editor.Set.Fill_Mode (True);
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Editor.Image.Left;
                                when 'i' | C_I | 'I' | Cs_I =>
                                    Common.Abandon;
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Editor.Image.Right;
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Editor.Image.Down;
                                when 'o' | C_O | 'O' | Cs_O =>
                                    Editor.Set.Insert_Mode (False);
                                when 'p' | C_P | 'P' | Cs_P =>
                                    Editor.Set.Insert_Mode (True);
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Editor.Image.Up;
                                when 'x' | C_X | 'X' | Cs_X =>
                                    Editor.Set.Fill_Mode (False);
                                when others =>
                                    null;
                            end case;
                        when 'j' | C_J | 'J' | Cs_J =>
                            Editor.Cursor.Right (8);
                        when 'k' | C_K | 'K' | Cs_K =>
                            Common.Complete;
                        when 'l' | C_L | 'L' | Cs_L =>
                            case Key3 is
                                when 'b' | C_B | 'B' | Cs_B =>
                                    Editor.Cursor.Previous
                                       (Prompt => True, Underline => False);
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Editor.Cursor.Previous
                                       (Prompt => False, Underline => True);
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Editor.Cursor.Next (Prompt    => False,
                                                        Underline => True);
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Editor.Cursor.Next (Prompt    => True,
                                                        Underline => True);
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Editor.Cursor.Previous
                                       (Prompt => True, Underline => True);
                                when 'v' | C_V | 'V' | Cs_V =>
                                    Editor.Cursor.Next (Prompt    => True,
                                                        Underline => False);
                                when others =>
                                    null;
                            end case;
                        when 'm' | C_M | 'M' | Cs_M =>
                            case Key3 is
                                when Delete | S_Delete =>
                                    Editor.Mark.Delete_Top;
                                when Left | S_Left =>
                                    Editor.Mark.Previous;
                                when Up | S_Up =>
                                    Editor.Mark.Top;
                                when Right | S_Right =>
                                    Editor.Mark.Next;
                                when Down | S_Down =>
                                    Editor.Mark.Push;
                                when '(' | '9' | 'a' | C_A |
                                     'A' | Cs_A | '[' | '{' =>
                                    Editor.Macro.Start;
                                when ')' | '0' | 'e' | C_E |
                                     'E' | Cs_E | ']' | '}' =>
                                    Editor.Macro.Finish;
                                when 'f' | C_F | 'F' | Cs_F =>
                                    Editor.Macro.Bind;
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Editor.Mark.Previous;
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Editor.Mark.Next;
                                when 'm' | C_M | 'M' | Cs_M |
                                     'x' | C_X | 'X' | Cs_X =>
                                    Editor.Macro.Execute;
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Editor.Mark.Push;
                                when 'p' | C_P | 'P' | Cs_P =>
                                    Editor.Mark.Copy_Top;
                                when 'r' | C_R | 'R' | Cs_R =>
                                    Editor.Mark.Rotate;
                                when 't' | C_T | 'T' | Cs_T =>
                                    Editor.Mark.Swap;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Editor.Mark.Top;
                                when others =>
                                    null;
                            end case;
                        when 'n' | C_N | 'N' | Cs_N =>
                            Editor.Window.Next;
                        when 'o' | C_O | 'O' | Cs_O =>
                            case Key3 is
                                when Tab =>
                                    Editor.Char.Tab_To_Comment;
                                when Left | S_Left =>
                                    Common.Object.Parent;
                                when Up | S_Up =>
                                    Common.Object.Previous;
                                when Right | S_Right =>
                                    Common.Object.Child;
                                when Down | S_Down =>
                                    Common.Object.Next;
                                when '!' | '1' =>
                                    Common.Expand;
                                when '.' | '>' =>
                                    Common.Elide;
                                when '/' | '?' =>
                                    Common.Explain;
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Common.Object.First_Child;
                                when 'b' | C_B | 'B' | Cs_B =>
                                    Common.Undo;
                                when 'c' | C_C | 'C' | Cs_C =>
                                    Common.Object.Copy;
                                when 'd' | C_D | 'D' | Cs_D |
                                     'k' | C_K | 'K' | Cs_K =>
                                    Common.Object.Delete;
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Common.Object.Last_Child;
                                when 'g' | 'G' =>
                                    Common.Abandon;
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Common.Object.Parent;
                                when 'i' | C_I | 'I' | Cs_I =>
                                    Common.Object.Insert;
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Common.Object.Child;
                                when 'l' | C_L | 'L' | Cs_L =>
                                    Common.Revert;
                                when 'm' | C_M | 'M' | Cs_M =>
                                    Common.Object.Move;
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Common.Object.Next;
                                when 'r' | C_R | 'R' | Cs_R =>
                                    Common.Redo;
                                when 's' | C_S | 'S' | Cs_S =>
                                    Common.Sort_Image;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Common.Object.Previous;
                                when 'v' | C_V | 'V' | Cs_V =>
                                    Common.Redo;
                                when 'x' | C_X | 'X' | Cs_X =>
                                    Common.Release;
                                when others =>
                                    null;
                            end case;
                        when 'p' | C_P | 'P' | Cs_P =>
                            Common.Semanticize;
                        when 'q' | C_Q | 'Q' | Cs_Q =>
                            Editor.Key.Prompt (Key_Code => "");
                        when 'r' | C_R | 'R' | Cs_R =>
                            case Key3 is
                                when Delete | S_Delete =>
                                    Editor.Hold_Stack.Delete_Top;
                                when Left | S_Left =>
                                    Editor.Hold_Stack.Previous;
                                when Up | S_Up =>
                                    Editor.Hold_Stack.Top;
                                when Right | S_Right =>
                                    Editor.Hold_Stack.Next;
                                when Down | S_Down =>
                                    Editor.Hold_Stack.Push;
                                when '"' | ''' | '6' | '^' | C_Circumflex =>
                                    Editor.Region.Capitalize;
                                when '(' | '9' | '[' | '{' =>
                                    Editor.Region.Start;
                                when ')' | '0' | ']' | '}' =>
                                    Editor.Region.Finish;
                                when '+' | '=' =>
                                    Editor.Region.Uncomment;
                                when ',' | '<' =>
                                    Editor.Region.Lower_Case;
                                when '-' | '_' | C_Underline =>
                                    Editor.Region.Comment;
                                when '.' | '>' =>
                                    Editor.Region.Upper_Case;
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Editor.Region.Beginning_Of;
                                when 'c' | C_C | 'C' | Cs_C =>
                                    Editor.Region.Copy;
                                when 'd' | C_D | 'D' | Cs_D |
                                     'k' | C_K | 'K' | Cs_K =>
                                    Editor.Region.Delete;
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Editor.Region.End_Of;
                                when 'f' | C_F | 'F' | Cs_F =>
                                    Editor.Region.Fill;
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Editor.Hold_Stack.Previous;
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Editor.Hold_Stack.Next;
                                when 'm' | C_M | 'M' | Cs_M =>
                                    Editor.Region.Move;
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Editor.Hold_Stack.Push;
                                when 'p' | C_P | 'P' | Cs_P =>
                                    Editor.Hold_Stack.Copy_Top;
                                when 'q' | C_Q | 'Q' | Cs_Q =>
                                    Editor.Region.Justify;
                                when 'r' | C_R | 'R' | Cs_R =>
                                    Editor.Hold_Stack.Rotate;
                                when 't' | C_T | 'T' | Cs_T =>
                                    Editor.Hold_Stack.Swap;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Editor.Hold_Stack.Top;
                                when 'x' | C_X | 'X' | Cs_X =>
                                    Editor.Region.Off;
                                when others =>
                                    null;
                            end case;
                        when 's' | C_S | 'S' | Cs_S =>
                            case Key3 is
                                when Left | C_Left | S_Left | Cs_Left =>
                                    Editor.Screen.Left;
                                when Up | C_Up | S_Up | Cs_Up =>
                                    Editor.Screen.Up;
                                when Right | C_Right | S_Right | Cs_Right =>
                                    Editor.Screen.Right;
                                when Down | C_Down | S_Down | Cs_Down =>
                                    Editor.Screen.Down;
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Editor.Screen.Previous;
                                when 'j' | C_J | 'J' | Cs_J =>
                                    Editor.Screen.Next;
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Editor.Screen.Push;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Editor.Screen.Top;
                                when others =>
                                    null;
                            end case;
                        when 't' | C_T | 'T' | Cs_T =>
                            Common.Format;
                        when 'u' | C_U | 'U' | Cs_U =>
                            Editor.Window.Previous;
                        when 'w' | C_W | 'W' | Cs_W =>
                            case Key3 is
                                when Delete | S_Delete =>
                                    Editor.Window.Join (-1);
                                when Left | S_Left =>
                                    Editor.Window.Parent;
                                when Up | S_Up =>
                                    Editor.Window.Previous;
                                when Right | S_Right =>
                                    Editor.Window.Child;
                                when Down | S_Down =>
                                    Editor.Window.Next;
                                when '!' | '1' =>
                                    Editor.Window.Expand;
                                when '#' | '3' =>
                                    Editor.Window.Frames (3);
                                when '$' | '4' =>
                                    Editor.Window.Frames (4);
                                when '%' | '5' =>
                                    Editor.Window.Frames (5);
                                when '&' | '7' =>
                                    Editor.Window.Frames (7);
                                when '.' | '>' =>
                                    Editor.Window.Expand (-4);
                                when '/' | '?' =>
                                    Editor.Window.Directory;
                                when '2' | '@' | C_At_Sign =>
                                    Editor.Window.Frames (2);
                                when '6' | '^' | C_Circumflex =>
                                    Editor.Window.Frames (6);
                                when 'a' | C_A | 'A' | Cs_A =>
                                    Editor.Window.Beginning_Of;
                                when 'b' | C_B | 'B' | Cs_B =>
                                    Editor.Window.Parent;
                                when 'c' | C_C | 'C' | Cs_C =>
                                    Editor.Window.Copy;
                                when 'd' | C_D | 'D' | Cs_D | 'k' | C_K |
                                     'K' | Cs_K | 'w' | C_W | 'W' |
                                     Cs_W | 'x' | C_X | 'X' | Cs_X =>
                                    Editor.Window.Delete;
                                when 'e' | C_E | 'E' | Cs_E =>
                                    Editor.Window.End_Of;
                                when 'f' | C_F | 'F' | Cs_F =>
                                    Editor.Window.Focus;
                                when 'h' | C_H | 'H' | Cs_H =>
                                    Common.Enclosing (In_Place => False,
                                                      Library  => False);
                                when 'm' | C_M | 'M' | Cs_M |
                                     'z' | C_Z | 'Z' | Cs_Z =>
                                    Editor.Window.Promote;
                                when 'n' | C_N | 'N' | Cs_N =>
                                    Editor.Window.Next;
                                when 'o' | C_O | 'O' | Cs_O =>
                                    Editor.Window.Join (1);
                                when 't' | C_T | 'T' | Cs_T =>
                                    Editor.Window.Transpose;
                                when 'u' | C_U | 'U' | Cs_U =>
                                    Editor.Window.Previous;
                                when 'v' | C_V | 'V' | Cs_V =>
                                    Editor.Window.Child;
                                when 'y' | C_Y | 'Y' | Cs_Y =>
                                    Editor.Window.Demote;
                                when others =>
                                    null;
                            end case;
                        when 'x' | C_X | 'X' | Cs_X =>
                            Common.Explain;
                        when 'z' | C_Z | Cs_Z =>
                            Common.Promote;
                        when 'Z' =>
                            Command.Spawn;
                        when others =>
                            null;
                    end case;
                when Cs_Z =>
                    Editor.Image.Up;
                when C_Left_Bracket | C_Left_Brace =>
                    Editor.Region.Start;
                when M_Left_Bracket | M_Left_Brace =>
                    Editor.Macro.Start;
                when C_Right_Bracket | C_Right_Brace =>
                    Editor.Region.Finish;
                when M_Right_Bracket | M_Right_Brace =>
                    Editor.Macro.Finish;
                when C_Bar =>
                    Editor.Char.Quote;
--/ if DESIGN_FACILITY then
--//            when M_BAR =>
--//                EDITOR.CHAR.INSERT_STRING("--| ");
--/ end if;
                when Kp_Enter | S_Kp_Enter =>
                    Common.Commit;
                when Kp_0 | S_Kp_0 =>
                    Editor.Set.Argument_Digit (0);
                when C_Kp_0 | M_Kp_0 | Cm_Kp_0 | Cs_Kp_0 | Ms_Kp_0 | Cms_Kp_0 =>
                    Editor.Set.Argument_Digit (0);
                when Kp_1 | S_Kp_1 =>
                    Editor.Set.Argument_Digit (1);
                when C_Kp_1 | M_Kp_1 | Cm_Kp_1 | Cs_Kp_1 | Ms_Kp_1 | Cms_Kp_1 =>
                    Editor.Set.Argument_Digit (1);
                when Kp_2 | S_Kp_2 =>
                    Editor.Set.Argument_Digit (2);
                when C_Kp_2 | M_Kp_2 | Cm_Kp_2 | Cs_Kp_2 | Ms_Kp_2 | Cms_Kp_2 =>
                    Editor.Set.Argument_Digit (2);
                when Kp_3 | S_Kp_3 =>
                    Editor.Set.Argument_Digit (3);
                when C_Kp_3 | M_Kp_3 | Cm_Kp_3 | Cs_Kp_3 | Ms_Kp_3 | Cms_Kp_3 =>
                    Editor.Set.Argument_Digit (3);
                when Kp_4 | S_Kp_4 =>
                    Editor.Set.Argument_Digit (4);
                when C_Kp_4 | M_Kp_4 | Cm_Kp_4 | Cs_Kp_4 | Ms_Kp_4 | Cms_Kp_4 =>
                    Editor.Set.Argument_Digit (4);
                when Kp_5 | S_Kp_5 =>
                    Editor.Set.Argument_Digit (5);
                when C_Kp_5 | M_Kp_5 | Cm_Kp_5 | Cs_Kp_5 | Ms_Kp_5 | Cms_Kp_5 =>
                    Editor.Set.Argument_Digit (5);
                when Kp_6 | S_Kp_6 =>
                    Editor.Set.Argument_Digit (6);
                when C_Kp_6 | M_Kp_6 | Cm_Kp_6 | Cs_Kp_6 | Ms_Kp_6 | Cms_Kp_6 =>
                    Editor.Set.Argument_Digit (6);
                when Kp_7 | S_Kp_7 =>
                    Editor.Set.Argument_Digit (7);
                when C_Kp_7 | M_Kp_7 | Cm_Kp_7 | Cs_Kp_7 | Ms_Kp_7 | Cms_Kp_7 =>
                    Editor.Set.Argument_Digit (7);
                when Kp_8 | S_Kp_8 =>
                    Editor.Set.Argument_Digit (8);
                when C_Kp_8 | M_Kp_8 | Cm_Kp_8 | Cs_Kp_8 | Ms_Kp_8 | Cms_Kp_8 =>
                    Editor.Set.Argument_Digit (8);
                when Kp_9 | S_Kp_9 =>
                    Editor.Set.Argument_Digit (9);
                when C_Kp_9 | M_Kp_9 | Cm_Kp_9 | Cs_Kp_9 | Ms_Kp_9 | Cms_Kp_9 =>
                    Editor.Set.Argument_Digit (9);
                when Kp_Separator | S_Kp_Separator =>
                    Editor.Set.Argument_Prefix;
                when C_Kp_Separator | M_Kp_Separator | Cm_Kp_Separator |
                     Cs_Kp_Separator | Ms_Kp_Separator | Cms_Kp_Separator =>
                    Editor.Set.Argument_Prefix;
                when Kp_Subtract | S_Kp_Subtract =>
                    Editor.Set.Argument_Minus;
                when C_Kp_Subtract | M_Kp_Subtract | Cm_Kp_Subtract |
                     Cs_Kp_Subtract | Ms_Kp_Subtract | Cms_Kp_Subtract =>
                    Editor.Set.Argument_Minus;
                when Kp_Decimal | S_Kp_Decimal =>
                    Text.End_Of_Input;
                when others =>
                    null;
            end case;

    end case;

end Rxi_Commands;