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

⟦74fb6e2c4⟧ Ada Source

    Length: 26624 (0x6800)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Ada_Krn_Defs, seg_04cdec

Derivation

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

E3 Source Code



package body Ada_Krn_Defs is
    Priority_Inheritance_Enabled : Boolean;
    pragma Interface_Name (Priority_Inheritance_Enabled,
                           "__PRIORITY_INHERITANCE_ENABLED");

    Priority_Ceiling_Enabled : Boolean;
    pragma Interface_Name (Priority_Ceiling_Enabled,
                           "__PRIORITY_CEILING_ENABLED");

    Sporadic_Task_Enabled : Boolean;
    pragma Interface_Name (Sporadic_Task_Enabled, "__SPORADIC_TASK_ENABLED");

    function No_Krn_Task_Id return Krn_Task_Id is
    begin
        return null;
    end No_Krn_Task_Id;

    function No_Krn_Program_Id return Krn_Program_Id is
    begin
        return null;
    end No_Krn_Program_Id;


    --------------------------------------------------------------------------
    -- intr_entry_t: init subprograms
    --------------------------------------------------------------------------
    procedure Intr_Entry_Init (Intr_Entry : A_Intr_Entry_T;
                               Intr_Vector : Intr_Vector_Id_T;
                               Prio : Priority := Priority'Last) is
    begin
        Intr_Entry.all := (Intr_Vector => Intr_Vector, Prio => Prio);
    end Intr_Entry_Init;

    function Intr_Entry_Init
                (Intr_Entry : A_Intr_Entry_T;
                 Intr_Vector : Intr_Vector_Id_T;
                 Prio : Priority := Priority'Last) return Address is
    begin
        Intr_Entry.all := (Intr_Vector => Intr_Vector, Prio => Prio);
        return To_Address (Intr_Entry);
    end Intr_Entry_Init;

    function Intr_Entry_Init
                (
                 -- does an implicit "intr_entry: a_intr_entry_t := new intr_entry_t;"
                 Intr_Vector : Intr_Vector_Id_T;
                 Prio : Priority := Priority'Last)
                return Address is
        Intr_Entry : A_Intr_Entry_T :=
           new Intr_Entry_T'(Intr_Vector => Intr_Vector, Prio => Prio);
    begin
        return To_Address (Intr_Entry);
    end Intr_Entry_Init;


    --------------------------------------------------------------------------
    -- cond_attr_t: DEFAULT and init subprograms
    --------------------------------------------------------------------------
    function Default_Cond_Attr return A_Cond_Attr_T is
    begin
        return null;
    end Default_Cond_Attr;

    procedure Fifo_Cond_Attr_Init (Attr : A_Cond_Attr_T) is
    begin
        Attr.all := (Rec_Type => Krn_Defs.R_Fifo_Cond_Attr);
    end Fifo_Cond_Attr_Init;

    function Fifo_Cond_Attr_Init (Attr : A_Cond_Attr_T) return A_Cond_Attr_T is
    begin
        Attr.all := (Rec_Type => Krn_Defs.R_Fifo_Cond_Attr);
        return Attr;
    end Fifo_Cond_Attr_Init;

    function Fifo_Cond_Attr_Init return A_Cond_Attr_T
                -- does an implicit "attr: a_cond_attr_t := new cond_attr_t;"
                 is
        Attr : A_Cond_Attr_T := new Cond_Attr_T;
    begin
        Attr.all := (Rec_Type => Krn_Defs.R_Fifo_Cond_Attr);
        return Attr;
    end Fifo_Cond_Attr_Init;

    procedure Prio_Cond_Attr_Init (Attr : A_Cond_Attr_T) is
    begin
        Attr.all := (Rec_Type => Krn_Defs.R_Prio_Cond_Attr);
    end Prio_Cond_Attr_Init;

    function Prio_Cond_Attr_Init (Attr : A_Cond_Attr_T) return A_Cond_Attr_T is
    begin
        Attr.all := (Rec_Type => Krn_Defs.R_Prio_Cond_Attr);
        return Attr;
    end Prio_Cond_Attr_Init;

    function Prio_Cond_Attr_Init return A_Cond_Attr_T
                -- does an implicit "attr: a_cond_attr_t := new cond_attr_t;"
                 is
        Attr : A_Cond_Attr_T := new Cond_Attr_T;
    begin
        Attr.all := (Rec_Type => Krn_Defs.R_Prio_Cond_Attr);
        return Attr;
    end Prio_Cond_Attr_Init;


    --------------------------------------------------------------------------
    -- mutex_attr_t: DEFAULT and init subprograms
    --------------------------------------------------------------------------
    function Default_Mutex_Attr return A_Mutex_Attr_T is
    begin
        return null;
    end Default_Mutex_Attr;
    function Default_Mutex_Attr return Address is
    begin
        return No_Addr;
    end Default_Mutex_Attr;

    function Default_Intr_Attr return A_Mutex_Attr_T is
    begin
        return To_A_Mutex_Attr_T (Memory_Address (1));
    end Default_Intr_Attr;
    function Default_Intr_Attr return Address is
    begin
        return Memory_Address (1);
    end Default_Intr_Attr;

    procedure Fifo_Mutex_Attr_Init (Attr : A_Mutex_Attr_T) is
    begin
        Attr.Rec_Type := Krn_Defs.R_Fifo_Mutex_Attr;
    end Fifo_Mutex_Attr_Init;

    function Fifo_Mutex_Attr_Init
                (Attr : A_Mutex_Attr_T) return A_Mutex_Attr_T is
    begin
        Attr.Rec_Type := Krn_Defs.R_Fifo_Mutex_Attr;
        return Attr;
    end Fifo_Mutex_Attr_Init;

    function Fifo_Mutex_Attr_Init (Attr : A_Mutex_Attr_T) return Address is
    begin
        Attr.Rec_Type := Krn_Defs.R_Fifo_Mutex_Attr;
        return To_Address (Attr);
    end Fifo_Mutex_Attr_Init;

    function Fifo_Mutex_Attr_Init return A_Mutex_Attr_T
                -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 is
        Attr : A_Mutex_Attr_T := new Mutex_Attr_T;
    begin
        Attr.Rec_Type := Krn_Defs.R_Fifo_Mutex_Attr;
        return Attr;
    end Fifo_Mutex_Attr_Init;

    function Fifo_Mutex_Attr_Init return Address
                -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 is
        Attr : A_Mutex_Attr_T := new Mutex_Attr_T;
    begin
        Attr.Rec_Type := Krn_Defs.R_Fifo_Mutex_Attr;
        return To_Address (Attr);
    end Fifo_Mutex_Attr_Init;

    procedure Prio_Mutex_Attr_Init (Attr : A_Mutex_Attr_T) is
    begin
        Attr.Rec_Type := Krn_Defs.R_Prio_Mutex_Attr;
    end Prio_Mutex_Attr_Init;

    function Prio_Mutex_Attr_Init
                (Attr : A_Mutex_Attr_T) return A_Mutex_Attr_T is
    begin
        Attr.Rec_Type := Krn_Defs.R_Prio_Mutex_Attr;
        return Attr;
    end Prio_Mutex_Attr_Init;

    function Prio_Mutex_Attr_Init (Attr : A_Mutex_Attr_T) return Address is
    begin
        Attr.Rec_Type := Krn_Defs.R_Prio_Mutex_Attr;
        return To_Address (Attr);
    end Prio_Mutex_Attr_Init;

    function Prio_Mutex_Attr_Init return A_Mutex_Attr_T
                -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 is
        Attr : A_Mutex_Attr_T := new Mutex_Attr_T;
    begin
        Attr.Rec_Type := Krn_Defs.R_Prio_Mutex_Attr;
        return Attr;
    end Prio_Mutex_Attr_Init;

    function Prio_Mutex_Attr_Init return Address
                -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 is
        Attr : A_Mutex_Attr_T := new Mutex_Attr_T;
    begin
        Attr.Rec_Type := Krn_Defs.R_Prio_Mutex_Attr;
        return To_Address (Attr);
    end Prio_Mutex_Attr_Init;

    procedure Prio_Inherit_Mutex_Attr_Init (Attr : A_Mutex_Attr_T) is
    begin
        if not Priority_Inheritance_Enabled then
            raise Program_Error;
        end if;
        Attr.Rec_Type := Krn_Defs.R_Prio_Inherit_Mutex_Attr;
    end Prio_Inherit_Mutex_Attr_Init;

    function Prio_Inherit_Mutex_Attr_Init
                (Attr : A_Mutex_Attr_T) return A_Mutex_Attr_T is
    begin
        if not Priority_Inheritance_Enabled then
            raise Program_Error;
        end if;
        Attr.Rec_Type := Krn_Defs.R_Prio_Inherit_Mutex_Attr;
        return Attr;
    end Prio_Inherit_Mutex_Attr_Init;

    function Prio_Inherit_Mutex_Attr_Init
                (Attr : A_Mutex_Attr_T) return Address is
    begin
        if not Priority_Inheritance_Enabled then
            raise Program_Error;
        end if;
        Attr.Rec_Type := Krn_Defs.R_Prio_Inherit_Mutex_Attr;
        return To_Address (Attr);
    end Prio_Inherit_Mutex_Attr_Init;

    function Prio_Inherit_Mutex_Attr_Init return A_Mutex_Attr_T
                -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 is
        Attr : A_Mutex_Attr_T;
    begin
        if not Priority_Inheritance_Enabled then
            raise Program_Error;
        end if;
        Attr := new Mutex_Attr_T;
        Attr.Rec_Type := Krn_Defs.R_Prio_Inherit_Mutex_Attr;
        return Attr;
    end Prio_Inherit_Mutex_Attr_Init;

    function Prio_Inherit_Mutex_Attr_Init return Address
                -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 is
        Attr : A_Mutex_Attr_T;
    begin
        if not Priority_Inheritance_Enabled then
            raise Program_Error;
        end if;
        Attr := new Mutex_Attr_T;
        Attr.Rec_Type := Krn_Defs.R_Prio_Inherit_Mutex_Attr;
        return To_Address (Attr);
    end Prio_Inherit_Mutex_Attr_Init;

    procedure Prio_Ceiling_Mutex_Attr_Init
                 (Attr : A_Mutex_Attr_T;
                  Ceiling_Prio : Priority := Priority'Last) is
    begin
        if not Priority_Ceiling_Enabled then
            raise Program_Error;
        end if;
        To_A_Prio_Ceiling_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Prio_Ceiling_Mutex_Attr,
            Ceiling_Prio => Ceiling_Prio);
    end Prio_Ceiling_Mutex_Attr_Init;

    function Prio_Ceiling_Mutex_Attr_Init
                (Attr : A_Mutex_Attr_T;
                 Ceiling_Prio : Priority := Priority'Last)
                return A_Mutex_Attr_T is
    begin
        if not Priority_Ceiling_Enabled then
            raise Program_Error;
        end if;
        To_A_Prio_Ceiling_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Prio_Ceiling_Mutex_Attr,
            Ceiling_Prio => Ceiling_Prio);
        return Attr;
    end Prio_Ceiling_Mutex_Attr_Init;

    function Prio_Ceiling_Mutex_Attr_Init
                (Attr : A_Mutex_Attr_T;
                 Ceiling_Prio : Priority := Priority'Last) return Address is
    begin
        if not Priority_Ceiling_Enabled then
            raise Program_Error;
        end if;
        To_A_Prio_Ceiling_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Prio_Ceiling_Mutex_Attr,
            Ceiling_Prio => Ceiling_Prio);
        return To_Address (Attr);
    end Prio_Ceiling_Mutex_Attr_Init;

    function Prio_Ceiling_Mutex_Attr_Init
                (
                 -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 Ceiling_Prio : Priority := Priority'Last)
                return A_Mutex_Attr_T is
        Attr : A_Mutex_Attr_T;
    begin
        if not Priority_Ceiling_Enabled then
            raise Program_Error;
        end if;
        Attr := new Mutex_Attr_T;
        To_A_Prio_Ceiling_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Prio_Ceiling_Mutex_Attr,
            Ceiling_Prio => Ceiling_Prio);
        return Attr;
    end Prio_Ceiling_Mutex_Attr_Init;

    function Prio_Ceiling_Mutex_Attr_Init
                (
                 -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 Ceiling_Prio : Priority := Priority'Last)
                return Address is
        Attr : A_Mutex_Attr_T;
    begin
        if not Priority_Ceiling_Enabled then
            raise Program_Error;
        end if;
        Attr := new Mutex_Attr_T;
        To_A_Prio_Ceiling_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Prio_Ceiling_Mutex_Attr,
            Ceiling_Prio => Ceiling_Prio);
        return To_Address (Attr);
    end Prio_Ceiling_Mutex_Attr_Init;


    procedure Intr_Attr_Init
                 (Attr : A_Mutex_Attr_T;
                  Disable_Status : Intr_Status_T := Disable_Intr_Status) is
    begin
        To_A_Intr_Attr_T (Attr).all := (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
                                        Disable_Status => Disable_Status);
    end Intr_Attr_Init;

    function Intr_Attr_Init
                (Attr : A_Mutex_Attr_T;
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return A_Mutex_Attr_T is
    begin
        To_A_Intr_Attr_T (Attr).all := (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
                                        Disable_Status => Disable_Status);
        return Attr;
    end Intr_Attr_Init;

    function Intr_Attr_Init
                (Attr : A_Mutex_Attr_T;
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return Address is
    begin
        To_A_Intr_Attr_T (Attr).all := (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
                                        Disable_Status => Disable_Status);
        return To_Address (Attr);
    end Intr_Attr_Init;

    function Intr_Attr_Init
                (
                 -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return A_Mutex_Attr_T is
        Attr : A_Mutex_Attr_T;
    begin
        Attr := new Mutex_Attr_T;
        To_A_Intr_Attr_T (Attr).all := (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
                                        Disable_Status => Disable_Status);
        return Attr;
    end Intr_Attr_Init;

    function Intr_Attr_Init
                (
                 -- does an implicit "attr: a_mutex_attr_t := new mutex_attr_t;"
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return Address is
        Attr : A_Mutex_Attr_T;
    begin
        Attr := new Mutex_Attr_T;
        To_A_Intr_Attr_T (Attr).all := (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
                                        Disable_Status => Disable_Status);
        return To_Address (Attr);
    end Intr_Attr_Init;


    --------------------------------------------------------------------------
    -- task_attr_t: DEFAULT and init subprograms
    --------------------------------------------------------------------------
    function Default_Task_Attr return A_Task_Attr_T is
    begin
        return null;
    end Default_Task_Attr;

    function Default_Task_Attr return Address is
    begin
        return No_Addr;
    end Default_Task_Attr;

    procedure Task_Attr_Init (Task_Attr : A_Task_Attr_T;
                              Prio : Priority := Priority'First;
                              Mutex_Attr : A_Mutex_Attr_T := null;
                              Cond_Attr : A_Cond_Attr_T := null) is
    begin
        Task_Attr.all := (Prio => Prio,
                          Sporadic_Attr_Address => No_Addr,
                          Mutex_Attr_Address => To_Address (Mutex_Attr),
                          Cond_Attr_Address => To_Address (Cond_Attr));
    end Task_Attr_Init;

    function Task_Attr_Init
                (Task_Attr : A_Task_Attr_T;
                 Prio : Priority := Priority'First;
                 Mutex_Attr : A_Mutex_Attr_T := null;
                 Cond_Attr : A_Cond_Attr_T := null) return Address is
    begin
        Task_Attr.all := (Prio => Prio,
                          Sporadic_Attr_Address => No_Addr,
                          Mutex_Attr_Address => To_Address (Mutex_Attr),
                          Cond_Attr_Address => To_Address (Cond_Attr));
        return To_Address (Task_Attr);
    end Task_Attr_Init;

    function Task_Attr_Init
                (
                 -- does an implicit "task_attr: a_task_attr_t := new task_attr_t;"
                 Prio : Priority := Priority'First;
                 Mutex_Attr : A_Mutex_Attr_T := null;
                 Cond_Attr : A_Cond_Attr_T := null)
                return Address is
        Task_Attr : A_Task_Attr_T :=
           new Task_Attr_T'(Prio => Prio,
                            Sporadic_Attr_Address => No_Addr,
                            Mutex_Attr_Address => To_Address (Mutex_Attr),
                            Cond_Attr_Address => To_Address (Cond_Attr));
    begin
        return To_Address (Task_Attr);
    end Task_Attr_Init;

    procedure Sporadic_Task_Attr_Init (Task_Attr : A_Task_Attr_T;
                                       Sporadic_Attr : A_Sporadic_Attr_T;
                                       Prio : Priority;
                                       Low_Prio : Priority;
                                       Replenish_Period : Duration;
                                       Initial_Budget : Duration;
                                       Min_Replenishment : Duration := 0.0;
                                       Replenishment_Count : Natural := 2;
                                       Mutex_Attr : A_Mutex_Attr_T := null;
                                       Cond_Attr : A_Cond_Attr_T := null) is
    begin
        if not Sporadic_Task_Enabled then
            raise Program_Error;
        end if;
        Task_Attr.all := (Prio => Prio,
                          Sporadic_Attr_Address => To_Address (Sporadic_Attr),
                          Mutex_Attr_Address => To_Address (Mutex_Attr),
                          Cond_Attr_Address => To_Address (Cond_Attr));
        Sporadic_Attr.all := (Low_Prio => Low_Prio,
                              Replenish_Period => Replenish_Period,
                              Initial_Budget => Initial_Budget,
                              Min_Replenishment => Min_Replenishment,
                              Replenishment_Count => Replenishment_Count);
    end Sporadic_Task_Attr_Init;

    function Sporadic_Task_Attr_Init
                (Task_Attr : A_Task_Attr_T;
                 Sporadic_Attr : A_Sporadic_Attr_T;
                 Prio : Priority;
                 Low_Prio : Priority;
                 Replenish_Period : Duration;
                 Initial_Budget : Duration;
                 Min_Replenishment : Duration := 0.0;
                 Replenishment_Count : Natural := 2;
                 Mutex_Attr : A_Mutex_Attr_T := null;
                 Cond_Attr : A_Cond_Attr_T := null) return Address is
    begin
        if not Sporadic_Task_Enabled then
            raise Program_Error;
        end if;
        Task_Attr.all := (Prio => Prio,
                          Sporadic_Attr_Address => To_Address (Sporadic_Attr),
                          Mutex_Attr_Address => To_Address (Mutex_Attr),
                          Cond_Attr_Address => To_Address (Cond_Attr));
        Sporadic_Attr.all := (Low_Prio => Low_Prio,
                              Replenish_Period => Replenish_Period,
                              Initial_Budget => Initial_Budget,
                              Min_Replenishment => Min_Replenishment,
                              Replenishment_Count => Replenishment_Count);
        return To_Address (Task_Attr);
    end Sporadic_Task_Attr_Init;

    function Sporadic_Task_Attr_Init
                (
                 -- does an implicit "task_attr: a_task_attr_t := new task_attr_t;"
                 -- does an implicit "sporadic_attr: a_sporadic_attr_t :=
                 --\x09\x09\x09\x09\x09\x09\x09\x09\x09\x09\x09new sporadic_attr_t;"
                 Prio : Priority;
                 Low_Prio : Priority;
                 Replenish_Period : Duration;
                 Initial_Budget : Duration;
                 Min_Replenishment : Duration := 0.0;
                 Replenishment_Count : Natural := 2;
                 Mutex_Attr : A_Mutex_Attr_T := null;
                 Cond_Attr : A_Cond_Attr_T := null)
                return Address is
        Task_Attr : A_Task_Attr_T;
        Sporadic_Attr : A_Sporadic_Attr_T;
    begin
        if not Sporadic_Task_Enabled then
            raise Program_Error;
        end if;
        Task_Attr := new Task_Attr_T;
        Sporadic_Attr := new Sporadic_Attr_T;
        Task_Attr.all := (Prio => Prio,
                          Sporadic_Attr_Address => To_Address (Sporadic_Attr),
                          Mutex_Attr_Address => To_Address (Mutex_Attr),
                          Cond_Attr_Address => To_Address (Cond_Attr));
        Sporadic_Attr.all := (Low_Prio => Low_Prio,
                              Replenish_Period => Replenish_Period,
                              Initial_Budget => Initial_Budget,
                              Min_Replenishment => Min_Replenishment,
                              Replenishment_Count => Replenishment_Count);
        return To_Address (Task_Attr);
    end Sporadic_Task_Attr_Init;


    --------------------------------------------------------------------------
    -- semaphore_attr_t: DEFAULT subprogram
    --------------------------------------------------------------------------
    function Default_Semaphore_Attr return A_Semaphore_Attr_T is
    begin
        return null;
    end Default_Semaphore_Attr;


    --------------------------------------------------------------------------
    -- count_semaphore_attr_t: DEFAULT and init subprograms
    --------------------------------------------------------------------------
    function Default_Count_Semaphore_Attr return A_Count_Semaphore_Attr_T is
    begin
        return null;
    end Default_Count_Semaphore_Attr;

    function Default_Count_Intr_Attr return A_Count_Semaphore_Attr_T is
    begin
        return To_A_Count_Semaphore_Attr_T (Memory_Address (1));
    end Default_Count_Intr_Attr;

    procedure Count_Intr_Attr_Init
                 (Attr : A_Count_Semaphore_Attr_T;
                  Disable_Status : Intr_Status_T := Disable_Intr_Status) is
    begin
        To_A_Count_Intr_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
            Disable_Status => Disable_Status);
    end Count_Intr_Attr_Init;

    function Count_Intr_Attr_Init
                (Attr : A_Count_Semaphore_Attr_T;
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return A_Count_Semaphore_Attr_T is
    begin
        To_A_Count_Intr_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
            Disable_Status => Disable_Status);
        return Attr;
    end Count_Intr_Attr_Init;

    function Count_Intr_Attr_Init
                (
                 -- does an implicit
                 --  "attr: a_count_semaphore_attr_t := new count_semaphore_attr_t;"
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return A_Count_Semaphore_Attr_T is
        Attr : A_Count_Semaphore_Attr_T;
    begin
        Attr := new Count_Semaphore_Attr_T;
        To_A_Count_Intr_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
            Disable_Status => Disable_Status);
        return Attr;
    end Count_Intr_Attr_Init;


    --------------------------------------------------------------------------
    -- mailbox_attr_t: DEFAULT and init subprograms
    --------------------------------------------------------------------------
    function Default_Mailbox_Attr return A_Mailbox_Attr_T is
    begin
        return null;
    end Default_Mailbox_Attr;

    function Default_Mailbox_Intr_Attr return A_Mailbox_Attr_T is
    begin
        return To_A_Mailbox_Attr_T (Memory_Address (1));
    end Default_Mailbox_Intr_Attr;

    procedure Mailbox_Intr_Attr_Init
                 (Attr : A_Mailbox_Attr_T;
                  Disable_Status : Intr_Status_T := Disable_Intr_Status) is
    begin
        To_A_Mailbox_Intr_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
            Disable_Status => Disable_Status);
    end Mailbox_Intr_Attr_Init;

    function Mailbox_Intr_Attr_Init
                (Attr : A_Mailbox_Attr_T;
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return A_Mailbox_Attr_T is
    begin
        To_A_Mailbox_Intr_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
            Disable_Status => Disable_Status);
        return Attr;
    end Mailbox_Intr_Attr_Init;

    function Mailbox_Intr_Attr_Init
                (
                 -- does an implicit
                 --  "attr: a_mailbox_attr_t := new mailbox_attr_t;"
                 Disable_Status : Intr_Status_T := Disable_Intr_Status)
                return A_Mailbox_Attr_T is
        Attr : A_Mailbox_Attr_T;
    begin
        Attr := new Mailbox_Attr_T;
        To_A_Mailbox_Intr_Attr_T (Attr).all :=
           (Rec_Type => Krn_Defs.R_Intr_Mutex_Attr,
            Disable_Status => Disable_Status);
        return Attr;
    end Mailbox_Intr_Attr_Init;
end Ada_Krn_Defs;

E3 Meta Data

    nblk1=19
    nid=0
    hdr6=32
        [0x00] rec0=1d rec1=00 rec2=01 rec3=02a
        [0x01] rec0=18 rec1=00 rec2=02 rec3=032
        [0x02] rec0=1c rec1=00 rec2=03 rec3=030
        [0x03] rec0=1b rec1=00 rec2=04 rec3=076
        [0x04] rec0=1f rec1=00 rec2=05 rec3=084
        [0x05] rec0=1d rec1=00 rec2=06 rec3=01e
        [0x06] rec0=1b rec1=00 rec2=07 rec3=038
        [0x07] rec0=1c rec1=00 rec2=08 rec3=062
        [0x08] rec0=1b rec1=00 rec2=09 rec3=03a
        [0x09] rec0=1b rec1=00 rec2=0a rec3=02c
        [0x0a] rec0=1b rec1=00 rec2=0b rec3=006
        [0x0b] rec0=1b rec1=00 rec2=0c rec3=028
        [0x0c] rec0=18 rec1=00 rec2=0d rec3=026
        [0x0d] rec0=17 rec1=00 rec2=0e rec3=016
        [0x0e] rec0=19 rec1=00 rec2=0f rec3=05c
        [0x0f] rec0=17 rec1=00 rec2=10 rec3=03e
        [0x10] rec0=12 rec1=00 rec2=11 rec3=03e
        [0x11] rec0=14 rec1=00 rec2=12 rec3=048
        [0x12] rec0=13 rec1=00 rec2=13 rec3=04a
        [0x13] rec0=18 rec1=00 rec2=14 rec3=00a
        [0x14] rec0=12 rec1=00 rec2=15 rec3=042
        [0x15] rec0=1a rec1=00 rec2=16 rec3=00c
        [0x16] rec0=18 rec1=00 rec2=17 rec3=054
        [0x17] rec0=1c rec1=00 rec2=18 rec3=028
        [0x18] rec0=19 rec1=00 rec2=19 rec3=000
    tail 0x217542006874f7bbc0e84 0x42a00088462060003