DataMuseum.dk Presents historical artifacts from the history of: Rational R1000/400

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 Excavated with: AutoArchaeologist - Free & Open Source Software.

top - download

⟦3d4a41edf⟧ Ada Source

    Length: 35840 (0x8c00)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Complement_Array, seg_047b16

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

with Text_Io, Complement_Identifier_Array,
     Field_Identifier_Array, Generic_String_Sort_Array;
package body Complement_Array is

    package C_Array is new Generic_String_Sort_Array
                              (Element => Complement.Object,
                               Max_Element_Number =>
                                  Complement_Identifier_Array.Max_Element,
                               Null_Element => Complement.Null_Object,
                               Get_Key => Complement.Name,
                               Show_Element => Complement.Show);

    The_Array : C_Array.Object := C_Array.Null_Object;
    The_Iterator : C_Array.Iterator := C_Array.Null_Iterator;  
    Global_Ok : Boolean;


    procedure Put (Old_Subject : in Complement.Object;
                   Name : in Identifier.Object;
                   Ok : out Boolean) is

        New_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        if Complement.Is_A_Subject (Old_Subject) then
            Local_Ok := True;
            Complement.Copy (Old_Subject, New_Subject);
            Complement.Put_Name (New_Subject, Name, Local_Ok);
            C_Array.Put (The_Array, New_Subject, Local_Ok);
            if Local_Ok then
                Complement_Identifier_Array.Put (Name);
            end if;
        else
            Local_Ok := False;
        end if;
        Ok := Local_Ok;

    end Put;

    procedure Put_Word (Word : in Identifier.Object; Ok : out Boolean) is

        New_Word : Complement.Object;  
        Local_Ok : Boolean;

    begin
        Complement.Put_Word (New_Word, Word);
        C_Array.Put (The_Array, New_Word, Local_Ok);
        if Local_Ok then
            Complement_Identifier_Array.Put (Word);
        end if;  
        Ok := Local_Ok;
    end Put_Word;

    procedure Put_Verb (A_Synonym, Verb : in Identifier.Object;
                        Ok : out Boolean) is

        New_Verb : Complement.Object;
        Local_Ok : Boolean;

    begin
        Complement.Put_Verb (New_Verb, A_Synonym, Verb);
        C_Array.Put (The_Array, New_Verb, Local_Ok);
        if Local_Ok then
            Complement_Identifier_Array.Put (A_Synonym);
        end if;
        Ok := Local_Ok;
    end Put_Verb;

--procedure create_number_field(subject_index : in natural;field_name: in string; ok : out boolean) is
    procedure Create_Number_Field (Subject_Index : in Natural;
                                   Field_Index : in Positive;
                                   Ok : out Boolean) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      complement.create_number_field(a_subject,field_name,ok);
            Complement.Create_Number_Field (A_Subject, Field_Index, Ok);
            C_Array.Put (The_Array, A_Subject);
        else
            Ok := False;
        end if;
    end Create_Number_Field;

--procedure create_sentence_field(subject_index : in natural;field_name: in string; ok : out boolean) is
    procedure Create_Sentence_Field (Subject_Index : in Natural;
                                     Field_Index : in Positive;
                                     Ok : out Boolean) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      complement.create_sentence_field(a_subject,field_name,ok);
            Complement.Create_Sentence_Field (A_Subject, Field_Index, Ok);
            C_Array.Put (The_Array, A_Subject);
        else
            Ok := False;
        end if;
    end Create_Sentence_Field;

--procedure create_enumerate_field(subject_index : in natural;field_name: in string; ok : out boolean) is
    procedure Create_Enumerate_Field (Subject_Index : in Natural;
                                      Field_Index : in Positive;
                                      Ok : out Boolean) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      complement.create_enumerate_field(a_subject,field_name,ok);
            Complement.Create_Enumerate_Field (A_Subject, Field_Index, Ok);
            C_Array.Put (The_Array, A_Subject);
        else
            Ok := False;
        end if;
    end Create_Enumerate_Field;

--procedure field_Put_number (subject_index : in natural;field_name: in string;number : in integer; ok : out boolean) is
    procedure Field_Put_Number (Subject_Index : in Natural;
                                Field_Index : in Positive;
                                Number : in Integer;
                                Ok : out Boolean) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      complement.put_number(a_subject,field_name,number,ok);
            Complement.Field_Put_Number (A_Subject, Field_Index, Number, Ok);
            C_Array.Put (The_Array, A_Subject);
        else
            Ok := False;
        end if;
    end Field_Put_Number;

--procedure filed_Put_sentence (subject_index : in natural;field_name: in string;sentence : in string; ok : out boolean) is
    procedure Field_Put_Sentence (Subject_Index : in Natural;
                                  Field_Index : in Positive;
                                  Sentence : in Identifier.Object;
                                  Ok : out Boolean) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      complement.put_sentence(a_subject,field_name,sentence,ok);
            Complement.Field_Put_Sentence
               (A_Subject, Field_Index, Sentence, Ok);
            C_Array.Put (The_Array, A_Subject);
        else
            Ok := False;
        end if;
    end Field_Put_Sentence;

--procedure field_Put_enumerate (subject_index : in natural;field_name: in string;enumeration,literal : in positive; ok : out boolean) is
    procedure Field_Put_Enumerate (Subject_Index : in Natural;
                                   Field_Index : in Positive;
                                   Enumeration, Literal : in Positive;
                                   Ok : out Boolean) is

        A_Subject : Complement.Object;
        Direction : Natural := Complement_Identifier_Array.Index
                                  (Field_Identifier_Array.Image (Field_Index));
        Other_Direction : Natural;
        Other_Place : Natural;
        Other_Field_Index : Natural;
        Local_Ok : Boolean;

    begin  
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
            Complement.Field_Put_Enumerate (A_Subject, Field_Index,
                                            Enumeration, Literal, Local_Ok);
            C_Array.Put (The_Array, A_Subject);
            if Direction in Positive and then
               Complement.Exit_Exist (A_Subject, Direction) then
                Other_Direction := Complement.Next_Direction
                                      (A_Subject, Direction);
                Other_Place := Complement.Next_Place (A_Subject, Direction);
                Other_Field_Index :=
                   Field_Identifier_Array.Index
                      (Complement_Identifier_Array.Image (Other_Direction));
                C_Array.Get (The_Array, A_Subject, Other_Place, Local_Ok);
                if Local_Ok then
                    Complement.Field_Put_Enumerate
                       (A_Subject, Other_Field_Index,
                        Enumeration, Literal, Local_Ok);
                    C_Array.Put (The_Array, A_Subject);
                end if;
            end if;
        end if;
        Ok := Local_Ok;
    end Field_Put_Enumerate;

    procedure Put_Movement (Animate_Name : in Identifier.Object;
                            Place : in Positive) is

        An_Animate : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, An_Animate,
                     Identifier.Image (Animate_Name), Local_Ok);
        if Local_Ok then
            Complement.Put_Movement (An_Animate, Place);
            C_Array.Put (The_Array, An_Animate);
        end if;
    end Put_Movement;

--procedure movement_init(animate_index : in natural) is

-- an_animate : complement.object;
-- local_ok : boolean;
--
-- begin
--     c_array.get(the_array,an_animate,animate_index,local_ok) is
--     if local_ok then
--         complement.movement_init(an_animate);
--     c_array.put(the_array,an_animate);
--   end if;
-- end;

    procedure Move (Animate_Index : in Natural) is

        An_Animate : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, An_Animate, Animate_Index, Local_Ok);
        if Local_Ok then
            Complement.Move (An_Animate);  
            C_Array.Put (The_Array, An_Animate);
        end if;
    end Move;

    procedure Put_Exit (Place_Index : in Natural;
                        Name, Start_Place, Start_Direction,
                        Next_Place, Next_Direction : in Positive;
                        Ok : out Boolean) is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            Complement.Put_Exit (A_Place, Name, Start_Place, Start_Direction,
                                 Next_Place, Next_Direction, Ok);
            C_Array.Put (The_Array, A_Place);
        else
            Ok := False;
        end if;
    end Put_Exit;

--procedure put_exit(place_index : in natural;name,start_place,start_direction,
--next_place,next_direction: in positive;ok : out boolean) is

--a_place : complement.object;
--local_ok : boolean;

--begin
--  c_array.get(the_array,a_place,place_index,local_ok);
--  if local_ok then
--complement.put_exit(a_place,name,start_place,start_direction,
--next_place,next_direction,ok);
--  else
--      ok:=false;
--  end if;
--end;

--procedure exit_put_enumerate(place_index : in natural;direction : in string;enumeration,literal : in positive; ok : out boolean) is

--a_place : complement.object;
--local_ok : boolean;

--begin
--  c_array.get(the_array,a_place,place_index,local_ok);
--  if local_ok then
--complement.exit_put_enumerate(a_place,index(direction),enumeration,literal,ok);
-- else
--      ok:=false;
--  end if;
--end;

    function Exit_Exist (Place_Index : in Natural; Direction : in Positive)
                        return Boolean is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            return Complement.Exit_Exist (A_Place, Direction);  
        else
            return False;
        end if;
    end Exit_Exist;

--function exit_exist(place_index: in natural;direction : in string) return boolean is

--begin
--return exit_exist(place_index,index(direction));
--end;

    function Exits_Exist (Place_Index : in Natural) return Boolean is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            return Complement.Exits_Exist (A_Place);
        else
            return False;
        end if;
    end Exits_Exist;

--function exit_enumeration(place_index: in natural;direction : in positive) return natural is

--a_place : complement.object;
--local_ok : boolean;

--begin
--  c_array.get(the_array,a_place,place_index,local_ok);
--  if local_ok then
--      return complement.enumeration_exit(a_place,direction);
-- else
--      return 0;
-- end if;
--end;

--function exit_literal(place_index: in natural;direction : in positive) return natural is

--a_place : complement.object;
--local_ok : boolean;

--begin
--  c_array.get(the_array,a_place,place_index,local_ok);
--  if local_ok then
--      return complement.literal_exit(a_place,direction);
--  else
--      return 0;
--  end if;
--end;

    function Exit_Name (Place_Index : in Natural; Direction : in Positive)
                       return String is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            return Name (Complement.Exit_Name (A_Place, Direction));  
        else
            return "";
        end if;
    end Exit_Name;

    function Next_Place (Place_Index : in Natural; Direction : in Positive)
                        return Natural is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            return Complement.Next_Place (A_Place, Direction);  
        else
            return 0;
        end if;
    end Next_Place;

    procedure Put_Place (Subject_Index : in Natural;
                         Place : in Natural;
                         Ok : out Boolean) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
            Complement.Put_Place (A_Subject, Place, Ok);  
            C_Array.Put (The_Array, A_Subject);
        else
            Ok := False;
        end if;
    end Put_Place;

    procedure Show is

    begin
        Text_Io.Put_Line ("Complement Array :");
        C_Array.Show (The_Array);
    end Show;

    procedure Show (Subject_Name : in String) is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin  
        C_Array.Get (The_Array, A_Subject, Subject_Name, Local_Ok);
        if Local_Ok then
            Complement.Show (A_Subject);
        end if;
    end Show;


    procedure List_Exits_Init (Place_Index : in Natural) is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            Complement.List_Exits_Init (A_Place);  
            C_Array.Put (The_Array, A_Place);
        end if;
    end List_Exits_Init;

    procedure List_Exits_Next (Place_Index : in Natural) is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            Complement.List_Exits_Next (A_Place);  
            C_Array.Put (The_Array, A_Place);
        end if;
    end List_Exits_Next;

    function List_Exits_Direction (Place_Index : in Natural) return String is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            return Name (Complement.List_Exits_Direction (A_Place));  
        else
            return "";
        end if;
    end List_Exits_Direction;

    function List_Exits_Done (Place_Index : in Natural) return Boolean is

        A_Place : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Place, Place_Index, Local_Ok);
        if Local_Ok then
            return Complement.List_Exits_Done (A_Place);  
        else
            return True;
        end if;
    end List_Exits_Done;

    procedure Put_Group (Complement_Name : in String;
                         An_Index : in Positive;
                         Ok : out Boolean) is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            Complement.Put_Group (A_Complement, An_Index, Ok);
            C_Array.Put (The_Array, A_Complement);
        else
            Ok := False;
        end if;
    end Put_Group;

    procedure List_Group_Init (Complement_Name : in String) is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            Complement.List_Group_Init (A_Complement);  
            C_Array.Put (The_Array, A_Complement);
        end if;
    end List_Group_Init;

    procedure List_Group_Next (Complement_Name : in String) is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            Complement.List_Group_Next (A_Complement);  
            C_Array.Put (The_Array, A_Complement);
        end if;
    end List_Group_Next;

    function List_Group_Name (Complement_Name : in String) return String is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.List_Group_Name (A_Complement);  
        else
            return "";
        end if;
    end List_Group_Name;

    function List_Group_Done (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.List_Group_Done (A_Complement);  
        else
            return True;
        end if;
    end List_Group_Done;

    procedure List_Complement_Init is

    begin
        C_Array.Init (The_Array, The_Iterator);
    end List_Complement_Init;

    procedure List_Complement_Next is

    begin
        C_Array.Next (The_Iterator);
    end List_Complement_Next;

    function List_Complement_Place return Natural is

    begin
        return Complement.Place (C_Array.Value (The_Iterator));
    end List_Complement_Place;

    function List_Complement_Name return String is

    begin
        return Complement.Name (C_Array.Value (The_Iterator));
    end List_Complement_Name;

    function List_Complement_Done return Boolean is


    begin
        return C_Array.Done (The_Iterator);
    end List_Complement_Done;

--function field_is_a_number (subject_index : in natural;field_name : in string) return boolean is
    function Field_Is_A_Number
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Boolean is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_is_a_number(a_subject,field_name);
            return Complement.Field_Is_A_Number (A_Subject, Field_Index);
        else
            return False;
        end if;
    end Field_Is_A_Number;

--function field_is_a_sentence (subject_index : in natural;field_name : in string) return boolean is
    function Field_Is_A_Sentence
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Boolean is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_is_a_sentence(a_subject,field_name);
            return Complement.Field_Is_A_Sentence (A_Subject, Field_Index);  
        else
            return False;
        end if;
    end Field_Is_A_Sentence;

--function field_is_an_enumerate (subject_index : in natural;field_name : in string) return boolean is
    function Field_Is_An_Enumerate
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Boolean is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_is_an_enumerate(a_subject,field_name);
            return Complement.Field_Is_An_Enumerate (A_Subject, Field_Index);
        else
            return False;
        end if;
    end Field_Is_An_Enumerate;

--function field_exist (subject_index:in natural;field_name : in string) return boolean is
    function Field_Belong
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Boolean is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_exist(a_subject,field_name);
            return Complement.Field_Belong (A_Subject, Field_Index);  
        else
            return False;
        end if;
    end Field_Belong;


    function Is_A_Subject (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;
   begin       C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.Is_A_Subject (A_Complement);
        else
            return False;
        end if;
    end Is_A_Subject;

    function Is_An_Animate (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.Is_An_Animate (A_Complement);
        else
            return False;
        end if;
    end Is_An_Animate;

    function Is_A_Place (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.Is_A_Place (A_Complement);
        else
            return False;
        end if;
    end Is_A_Place;

    function Is_An_Entity (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.Is_An_Entity (A_Complement);  
        else
            return False;
        end if;
    end Is_An_Entity;

    function Is_A_Word (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.Is_A_Word (A_Complement);  
        else
            return False;
        end if;
    end Is_A_Word;

    function Is_A_Verb (Complement_Name : in String) return Boolean is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Complement_Name, Local_Ok);
        if Local_Ok then
            return Complement.Is_A_Verb (A_Complement);  
        else
            return False;
        end if;
    end Is_A_Verb;

    function Belong (Complement_Name : in Identifier.Object) return Boolean is

    begin
        return C_Array.Belong (The_Array, Identifier.Image (Complement_Name));
    end Belong;

    function Name (Subject_Index : in Natural) return String is

        A_Complement : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Complement, Subject_Index, Local_Ok);
        if Local_Ok then
            return Complement.Name (A_Complement);
        else
            return "";
        end if;
    end Name;

    function Index (Complement_Name : in String) return Natural is

    begin
        return C_Array.Index (The_Array, Complement_Name);
    end Index;

    function Place (Subject_Index : in Natural) return Natural is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
            return Complement.Place (A_Subject);
        else
            return 0;
        end if;
    end Place;

--function field_number (subject_index : in natural;field_name:in string) return Integer is
    function Field_Number
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Integer is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
            return Complement.Field_Number (A_Subject, Field_Index);
--        return complement.field_number(a_subject,field_name);
        else
            return 0;
        end if;
    end Field_Number;

--function field_sentence (subject_index : in natural;field_name:in string) return String is
    function Field_Sentence
                (Subject_Index : in Natural; Field_Index : in Positive)
                return String is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_sentence(a_subject,field_name);
            return Complement.Field_Sentence (A_Subject, Field_Index);  
        else
            return "";
        end if;
    end Field_Sentence;

--function field_Enumeration (subject_index : in natural;field_name:in string) return Natural is
    function Field_Enumeration
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Natural is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_enumeration(a_subject,field_name);
            return Complement.Field_Enumeration (A_Subject, Field_Index);
        else
            return 0;
        end if;
    end Field_Enumeration;

--function field_Literal (subject_index : in natural;field_name:in string) return Natural is
    function Field_Literal
                (Subject_Index : in Natural; Field_Index : in Positive)
                return Natural is

        A_Subject : Complement.Object;
        Local_Ok : Boolean;

    begin
        C_Array.Get (The_Array, A_Subject, Subject_Index, Local_Ok);
        if Local_Ok then
--      return complement.field_literal(a_subject,field_name);
            return Complement.Field_Literal (A_Subject, Field_Index);
        else
            return 0;
        end if;
    end Field_Literal;

    --   function Synonym (Verb_Index : in Natural) return Natural is

    --     A_Verb : Complement.Object;
    --   Local_Ok : Boolean;

    -- begin
    --  C_Array.Get (The_Array, A_Verb, Verb_Index, Local_Ok);
    --   if Local_Ok then
    --      return Complement.Synonym (A_Verb);
    -- else
    --    return 0;
    -- end if;
    --  end Synonym;


begin
    Put_Word (Identifier.From_String ("global"), Global_Ok);
end Complement_Array;

    nblk1=22
    nid=0
    hdr6=44
        [0x00] rec0=1b rec1=00 rec2=01 rec3=02e
        [0x01] rec0=20 rec1=00 rec2=1f rec3=010
        [0x02] rec0=1a rec1=00 rec2=1d rec3=004
        [0x03] rec0=08 rec1=00 rec2=19 rec3=052
        [0x04] rec0=1b rec1=00 rec2=14 rec3=038
        [0x05] rec0=17 rec1=00 rec2=13 rec3=018
        [0x06] rec0=1a rec1=00 rec2=1c rec3=07c
        [0x07] rec0=14 rec1=00 rec2=12 rec3=042
        [0x08] rec0=15 rec1=00 rec2=1b rec3=03c
        [0x09] rec0=23 rec1=00 rec2=1e rec3=010
        [0x0a] rec0=1c rec1=00 rec2=0f rec3=028
        [0x0b] rec0=05 rec1=00 rec2=0d rec3=00a
        [0x0c] rec0=21 rec1=00 rec2=10 rec3=01e
        [0x0d] rec0=0e rec1=00 rec2=0e rec3=012
        [0x0e] rec0=25 rec1=00 rec2=04 rec3=056
        [0x0f] rec0=21 rec1=00 rec2=0c rec3=000
        [0x10] rec0=28 rec1=00 rec2=17 rec3=02c
        [0x11] rec0=20 rec1=00 rec2=0b rec3=014
        [0x12] rec0=21 rec1=00 rec2=18 rec3=040
        [0x13] rec0=20 rec1=00 rec2=21 rec3=04e
        [0x14] rec0=25 rec1=00 rec2=11 rec3=03c
        [0x15] rec0=06 rec1=00 rec2=22 rec3=044
        [0x16] rec0=1d rec1=00 rec2=0a rec3=034
        [0x17] rec0=00 rec1=00 rec2=09 rec3=00c
        [0x18] rec0=1c rec1=00 rec2=08 rec3=046
        [0x19] rec0=1f rec1=00 rec2=07 rec3=002
        [0x1a] rec0=01 rec1=00 rec2=20 rec3=002
        [0x1b] rec0=1f rec1=00 rec2=16 rec3=018
        [0x1c] rec0=23 rec1=00 rec2=06 rec3=046
        [0x1d] rec0=23 rec1=00 rec2=05 rec3=058
        [0x1e] rec0=20 rec1=00 rec2=03 rec3=004
        [0x1f] rec0=1d rec1=00 rec2=02 rec3=00c
        [0x20] rec0=1c rec1=00 rec2=15 rec3=048
        [0x21] rec0=12 rec1=00 rec2=1a rec3=001
    tail 0x2174b5dde8654980b75c3 0x42a00088462060003