|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - download
Length: 31744 (0x7c00)
Types: Ada Source
Notes: 03_class, FILE, R1k_Segment, e3_tag, package V_I_Taskop, seg_04b9c4
└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
└─ ⟦cfc2e13cd⟧ »Space Info Vol 2«
└─⟦this⟧
-- Copyright 1986,1987,1988, 1992 Verdix Corporation
------------------------------------------------------------------------------
-- User interface to the ADA tasking operations
--
-- The compiler calls the following subprograms to implement the
-- ADA tasking semantics.
------------------------------------------------------------------------------
with System;
use System;
with Unsigned_Types;
with Ada_Krn_Defs;
with Link_Block;
with V_Usr_Conf_I;
with V_I_Cifo;
package V_I_Taskop is
pragma Suppress (All_Checks);
pragma Suppress (Exception_Tables);
pragma Not_Elaborated;
--------------------------------------------------------------------------
-- Tasking operation data structures. TASK_ID and PROGRAM_ID are
-- defined in system.
--------------------------------------------------------------------------
type Master_Id is private;
No_Master_Id : constant Master_Id;
type A_List_Id is private;
No_A_List_Id : constant A_List_Id;
--------------------------------------------------------------------------
-- Misc types provided for backward compatibility with
-- earlier releases of VADS. The subprograms in this package are
-- backward compatible with these subtypes.
--
-- Note, day_t is now defined in system.a and not v_i_types.a.
--------------------------------------------------------------------------
subtype A_Task_T is System.Task_Id;
subtype A_Program_T is System.Program_Id;
subtype A_Master_T is Master_Id;
subtype A_Alist_T is A_List_Id;
type Act_Status_T is (Act_Ok, Act_Elab_Err, Act_Except,
Act_Elab_Err_Act_Except);
-- Select statements are implemented with a list of open entry numbers
-- (zero for closed entries); the number of items in this list is passed
-- as a parameter.
type Entry_Record_T is
record
Entry_Id : Integer;
end record;
type A_Entry_Record_T is access Entry_Record_T;
pragma Local_Access (A_Entry_Record_T);
-- Delay records follow entry record in the list that compiler-generated
-- code passes to ts_select_delay.
type Delay_Record_T is
record
Delay_Alt_Return_Info : Integer;
Seconds_To_Delay : Duration;
end record;
type A_Delay_Record_T is access Delay_Record_T;
pragma Local_Access (A_Delay_Record_T);
type Abort_List_T is
record
Tsk : Task_Id;
end record;
-- CIFO option
pragma May_Make_Access_Value (Abort_List_T);
-- CIFO option
type A_Abort_List_T is access Abort_List_T;
pragma Local_Access (A_Abort_List_T);
--------------------------------------------------------------------------
-- Task abort
--------------------------------------------------------------------------
procedure Ts_Abort (Abort_List : in A_Abort_List_T;
Abort_List_Length : in Integer);
--------------------------------------------------------------------------
-- Disable/enable the current task from being completed when aborted.
-- These services must be paired. They can be nested. No return, if
-- not nested and the current task has been marked abnormal by a previous
-- abort.
--
-- Currently, not called by the compiler. However, called by Vads Exec
-- services.
--------------------------------------------------------------------------
procedure Ts_Disable_Complete;
procedure Ts_Enable_Complete;
--------------------------------------------------------------------------
-- Task activation
--------------------------------------------------------------------------
function Ts_Init_Activate_List return A_List_Id;
-- This activates a group of tasks at once.
procedure Ts_Activate_List
(Activation_List : A_List_Id; Is_Allocator : Integer);
-- This enters the named task into the runnable pool of tasks.
-- The return_pc parameter is used for debugging purposes.
procedure Ts_Activate (Tsk : in Task_Id; Return_Pc : in Address);
-- DA_RTS
-- Activate a task created with ts_create_simple_task
procedure Ts_Activate_Simple_Task (Tsk : A_Task_T);
-- Set the current task inactive. The task will not keep the program
-- from becoming idle. The da comm library keeps a cache of tasks that
-- are in the inactive state.
procedure Ts_Set_Inactive;
-- DA_RTS
-- This is called by a newly-activated task to indicate to the RTS
-- that is had completed its activation. This will cause the
-- activating task to unblock.
procedure Ts_Activation_Complete (Act_Status : in Act_Status_T);
function Ts_Activation_Exceptions return Act_Status_T;
--------------------------------------------------------------------------
-- Task attributes
--------------------------------------------------------------------------
-- This is called when the CALLABLE attribute is used.
function Ts_Callable (Tsk : in Task_Id) return Boolean;
-- This implements the 'TERMINATED attribute.
function Ts_Terminated (Tsk : in Task_Id) return Boolean;
-- This returns the number of tasks queued at the entry (of the
-- current task) whose id is passed. This implements the 'COUNT
-- attribute.
function Ts_Entry_Count (Entry_Id : in Integer) return Integer;
--------------------------------------------------------------------------
-- Task rendezvous
--------------------------------------------------------------------------
-- This is called by generated code to due an plain entry call.
-- The task to call is named by the task id passed in 'called_task'.
-- The entry id to do the call on is passed in 'called_entry'.
-- A pointer to the parameters to pass to the accept statement
-- that accepts this call is passed in 'param_block'.
procedure Ts_Call (Called_Task : in Task_Id;
Called_Entry : in Integer;
Param_Block : in Address);
-- This is called by the generated code to do a conditional entry
-- call.
-- This is like 'ts_call' except that is will return immediately
-- with a return value of false if the call cannot be accepted right
-- away.
function Ts_Conditional_Call (Called_Task : in Task_Id;
Called_Entry : in Integer;
Param_Block : in Address) return Boolean;
-- CIFO_TRIVIAL_ENTRY
-- This is called for a conditional entry call to a trivial accept
-- statement. Supports the CIFO TRIVIAL_ENTRY pragma.
function Ts_Trivial_Conditional_Call
(Called_Task : in Task_Id; Called_Entry : in Integer)
return Boolean;
-- CIFO_TRIVIAL_ENTRY
-- This is like 'ts_conditional_call' above except that it will
-- wait for a specified amount of time for the call to go through
-- if it is not immediately able to perform the call. The time
-- to wait for the call it passed in 'timeout' and is in milliseconds.
function Ts_Timed_Call (Timeout : in Duration;
Called_Task : in Task_Id;
Called_Entry : in Integer;
Param_Block : in Address) return Boolean;
-- An entry list is built by the generated code during the
-- evaluation of the guards of a select statment. A pointer to
-- the entry list and it length (in entries) is passed to one of
-- the 'ts_select ...' routines.
--
-- An entry list is a list of small integers that are either zero
-- or the index of an entry. Each integer corresponds to an accept
-- alternative in the select statement being executed. A zero
-- indicates that the alternative is closed. A non-zero value
-- indicates that the alternative is open an its value indicates the
-- entry being accepted.
--
-- If an entry is accepted in a select procedure, its index in the
-- entry list is returned in the 'result' parameter.
--
-- This is called when a select statement having no else, terminate,
-- or delay alternatives is executed.
procedure Ts_Select (User_Entry_List : in A_Entry_Record_T;
Elist_Len : in Integer;
Param_Block : out Address;
Result : out Integer);
-- This is called when an accept statement that is not an alternative
-- of a select statement is executed.
function Ts_Accept (Accepting_Entry : in Integer) return Address;
-- This is called when an accept statement doesn't have any parameters or a
-- "do ... end" sequence of statements. The accept simply serves as a
-- synchronization point. There isn't a subsequent ts_finish_accept.
procedure Ts_Fast_Accept (Accepting_Entry : Integer);
-- CIFO_TRIVIAL_ENTRY
-- This is called for a trivial accept statement. Supports
-- the CIFO TRIVIAL_ENTRY pragma.
procedure Ts_Trivial_Accept (Accepting_Entry : Integer);
-- CIFO_TRIVIAL_ENTRY
-- This is called when a select statment with an else alternative
-- is executed. If the else alternative is taken the 'result'
-- parameter is returned with -1.
procedure Ts_Select_Else (User_Entry_List : in A_Entry_Record_T;
Elist_Len : in Integer;
Param_Block : out Address;
Result : out Integer);
-- This is called when a select statment with a delay alternative(s)
-- is executed.
procedure Ts_Select_Delay (User_Entry_List : in A_Entry_Record_T;
Elist_Len : in Integer;
Dlist_Len : in Integer;
Param_Block : out Address;
Result : out Integer);
-- This is called when a select statment with a terminate alternative
-- is executed. 'termin_open' is true if the terminate alternative
-- is open (i.e., if it has no guard or if its guard is true.
procedure Ts_Select_Terminate (User_Entry_List : in A_Entry_Record_T;
Elist_Len : in Integer;
Termin_Open : in Integer;
Param_Block : out Address;
Result : out Integer);
-- Called when the end of an accept body is reached.
-- If an exception occurred in the body of the accept, the first
-- paramenter is true and the second points to the string that
-- describes the exception.
procedure Ts_Finish_Accept (Exception_Occurred : in Integer;
Exception_String : in Address);
-- CIFO option
-- When called from within a rendezvous, this function returns
-- the task id of the calling task. Otherwise it returns null.
function Ts_Caller return Task_Id;
-- CIFO option
--------------------------------------------------------------------------
-- RTS initialization and main procedure exit
--------------------------------------------------------------------------
-- This routine is called explicity by startup to set up the Ada RTS.
-- If ts_initialize returns, then, the program is ready to exit and
-- it returns the exit status.
function Ts_Initialize (Usr_Link_Block : Link_Block.A_Link_Block_T;
Configuration_Table : V_Usr_Conf_I.
A_Configuration_Table_T;
Main_Pragmas : V_I_Cifo.A_Main_Pragmas_T;
Startup_Continue : Address) return Integer;
-- This is called by the main procedure of a program when it wishes
-- to complete the whole program. This procedure is not called
-- by generated code, it is the last entry in the elaboration table
-- if it is to be called.
procedure Ts_Exit (Status : Integer);
--------------------------------------------------------------------------
-- Task, master and program creation
--------------------------------------------------------------------------
-- This creates a new Ada task. The 'master' parameter is the master
-- id (returned by 'ts_create_master') for the master of the task to
-- be created. 'prio' is a priority in the range 1..10. 'stack_size'
-- is the size of the stack area that the new task requires. 'start'
-- is the address of the first instruction of the task's code.
-- 'entry_count' is the number of entries that the new task has.
function Ts_Create_Task (Master : Master_Id;
Prio : Integer;
Stack_Size : Integer;
Start : Address;
Entry_Count : Integer;
Generic_Param : Address;
Task_Attr : Ada_Krn_Defs.A_Task_Attr_T;
Has_Pragma_Prio : Integer) return Task_Id;
-- This is like 'ts_create_task' above, except that it also enters
-- the task id of the new task in the activation table passed
-- in the 'activate_list' parameter. See the 'ts_activ' package.
function Ts_Create_Task_And_Link (Master : Master_Id;
Prio : Integer;
Stack_Size : Integer;
Start : Address;
Entry_Count : Integer;
Activation_List : A_List_Id;
Generic_Param : Address;
Task_Attr : Ada_Krn_Defs.A_Task_Attr_T;
Has_Pragma_Prio : Integer) return Task_Id;
-- DA_RTS
-- Called to create a simple ada task. This task does not have
-- a master. This task will not make a call to ts_activation_complete
-- and should not be attached to the current task. This task has
-- no entry points and no elaboration address.
--
-- This task might eventually perform other ada tasking semantics
-- like rendezvous, ...
--
-- This task is activated via ts_activate_simple_task.
--
function Ts_Create_Simple_Task (Prio : Integer;
Stack_Size : Natural;
Start : Address;
Task_Attr : Ada_Krn_Defs.A_Task_Attr_T;
Has_Pragma_Prio : Integer) return A_Task_T;
-- DA_RTS
-- CIFO_SYNCHRONIZATION
procedure Ts_Set_Entry_Criteria (Tsk : Task_Id;
Entry_Criteria : V_I_Cifo.Queuing_T);
procedure Ts_Set_Select_Criteria (Tsk : Task_Id; Lexical_Order : Integer);
-- CIFO_SYNCHRONIZATION
-- This returns an id to use in future calls to 'ts_create_task'
-- 'ts_create_task_and_link', and 'ts_complete_master'. The
-- effect of this call is to create an internal RTS structure
-- to keep track of the tasks for whom the current task is
-- master.
function Ts_Create_Master
(Fp : Address; Generic_Param : Address) return Master_Id;
-- This returns the task id of the current task.
function Ts_Tid return Task_Id;
-- This creates and activates a new ada program. It
-- is layered upon the ada_krn_i.program_start service. The
-- following description of its operation is only applicable
-- to the VADS_MICRO for cross targets.
--
-- The first passed parameter is the address of
-- the new program's link_block. The
-- second parameter is a user defined key stored in the new program's
-- control block. This key is passed to the PROGRAM_SWITCH_EVENT
-- callouts. The key may be obtained by routines in the new
-- program via v_i_tasks.get_program_key.
-- This key can be used to point to a list of program arguments.
-- The key for the main program is set to 0 (NO_ADDR). The third
-- parameter is the address of a routine called when the program
-- terminates. It can be set to NO_ADDR for no callout.
--
-- The terminate callout procedure is called as follows:
-- procedure terminate_callout_proc(
--\x09\x09krn_prg:\x09\x09krn_program_id;-- program being terminated
-- key:\x09\x09\x09address);\x09-- its corresponding user defined key
--
-- The terminate_callout_proc must be compiled with stack limit
-- checking suppressed. The PROGRAM_SWITCH_EVENT callout isn't
-- called before calling the terminate_callout_proc. Also, the
-- terminate_callout_proc is called with the underlying kernel's
-- krn_program_id and not the Ada program_id.
function Ts_Create_Program
(User_Link_Block_A : Address;
Key : Address := Memory_Address (2);
Terminate_Callout : Address := No_Addr) return Program_Id;
pragma Inline_Only (Ts_Create_Program);
--------------------------------------------------------------------------
-- Delay and current time
--------------------------------------------------------------------------
-- This returns after delaying for at least the amount of time
-- specified by 'delay_val'. 'delay_val' is internal representation
-- for duration, normally milliseconds.
procedure Ts_Delay (Delay_Val : in Duration);
-- This returns the current time, wherein, duration_time has been
-- normalized to be less than a day.
procedure Ts_Current_Time (Day : out Day_T; Sec : out Duration);
--------------------------------------------------------------------------
-- Task and master completion/termination
--------------------------------------------------------------------------
-- This completes the calling task. This never returns and
-- the calling task never executes again.
procedure Ts_Complete_Task;
-- This waits for the completion of all of the tasks whose master
-- is named by the master id passed. Then the calling task
-- is completed just as it is in 'ts_complete_task'.
procedure Ts_Complete_Master (Master : in Master_Id);
procedure Ts_Exception_Master (Master : in Master_Id);
procedure Ts_Terminate_List (Activation_List : in out A_List_Id);
-- CIFO option
-- Installs a cleanup procedure used to recover resources
-- allocated by the CIFO. Called by the RTS when a task terminates.
procedure Ts_Cifo_Term_Callout (Proc : System.Address);
-- CIFO option
--------------------------------------------------------------------------
-- Stack Limit
--------------------------------------------------------------------------
-- This returns the stack_limit of the current task. Handles
-- the case where the caller task is executing code in a fast rendezvous
-- using the acceptor's stack.
--
-- When the stack limit is stored in a register (g4 for SPARC, s7 for
-- MIPS), the compiler emits a call to this routine whenever
-- an Ada subprogram is called from 'C'. For MP Ada, the compiler
-- can no longer reference the stack limit directly from memory.
function Ts_Get_Stack_Limit return Address;
--------------------------------------------------------------------------
-- Exception information
--------------------------------------------------------------------------
-- Gets/puts the last exception information for the current task.
-- If in an ISR, accesses the last exception information for the current
-- program.
procedure Ts_Get_Last_Exception (Id : out Address; Pc : out Address);
procedure Ts_Put_Last_Exception (Id : Address; Pc : Address);
--------------------------------------------------------------------------
-- Interrupt Entry
--------------------------------------------------------------------------
-- Attaches interrupt entry in current task to interrupt vector that can
-- be posted by interrupt handler
procedure Ts_Attach_Interrupt (Attached_Entry : Integer;
Intr_Entry : Ada_Krn_Defs.A_Intr_Entry_T);
-- Detaches all interrupt entries in passed task from signals.
procedure Ts_Detach_Interrupt (Tsk : in Task_Id);
--------------------------------------------------------------------------
-- Interrupt Entry ISRs
--------------------------------------------------------------------------
-- Attaches isr to interrupt vector specified by the interrupt entry
function Ts_Attach_Isr
(Intr_Entry : Ada_Krn_Defs.A_Intr_Entry_T; Isr : Address)
return Address;
-- Detaches isr from interrupt vector specified by the interrupt entry
function Ts_Detach_Isr
(Intr_Entry : Ada_Krn_Defs.A_Intr_Entry_T) return Address;
--------------------------------------------------------------------------
-- Interrupt Task
--------------------------------------------------------------------------
-- Creates a task that repetitively waits for and then processes an
-- interrupt. The created task is inactive until ts_activate_intr_task
-- is called.
function Ts_Create_Intr_Task
(Prio : Integer;
Stack_Size : Integer;
Start : Address;
Intr_Vector : Ada_Krn_Defs.Intr_Vector_Id_T;
Handler : System.Address;
Task_Attr : Ada_Krn_Defs.A_Task_Attr_T := null) return Task_Id;
-- Makes a previously created interrupt task runnable.
procedure Ts_Activate_Intr_Task (Intr_Task : Task_Id);
-- This completes the calling interrupt task.
procedure Ts_Complete_Intr_Task;
-- Gets the interrupt vector for the current interrupt task.
-- The interrupt vector was passed when the interrupt task was created.
function Ts_Get_Intr_Task_Vector return Ada_Krn_Defs.Intr_Vector_Id_T;
-- Gets the handler for the current interrupt task.
-- The handler was passed when the interrupt task was created.
function Ts_Get_Intr_Task_Handler return Address;
type Intr_Task_State_T is (Intr_Task_Ready, Intr_Task_Waiting);
-- Sets the Ada tasking state for the current interrupt task
procedure Ts_Set_Intr_Task_State (Intr_Task_State : Intr_Task_State_T);
private
type Master_Id is new Unsigned_Types.Unsigned_Integer;
No_Master_Id : constant Master_Id := 0;
type A_List_Id is new Unsigned_Types.Unsigned_Integer;
No_A_List_Id : constant A_List_Id := 0;
pragma Interface (Ada, Ts_Abort);
pragma Interface_Name (Ts_Abort, "TS_ABORT");
pragma Interface (Ada, Ts_Disable_Complete);
pragma Interface_Name (Ts_Disable_Complete, "TS_DISABLE_COMPLETE");
pragma Interface (Ada, Ts_Enable_Complete);
pragma Interface_Name (Ts_Enable_Complete, "TS_ENABLE_COMPLETE");
pragma Interface (Ada, Ts_Init_Activate_List);
pragma Interface_Name (Ts_Init_Activate_List, "TS_INIT_ACTIVATE_LIST");
pragma Interface (Ada, Ts_Activate_List);
pragma Interface_Name (Ts_Activate_List, "TS_ACTIVATE_LIST");
pragma Interface (Ada, Ts_Activate);
pragma Interface_Name (Ts_Activate, "TS_ACTIVATE");
-- DA_RTS
pragma Interface (Ada, Ts_Activate_Simple_Task);
pragma Interface_Name (Ts_Activate_Simple_Task, "TS_ACTIVATE_SIMPLE_TASK");
pragma Interface (Ada, Ts_Set_Inactive);
pragma Interface_Name (Ts_Set_Inactive, "TS_SET_INACTIVE");
-- DA_RTS
pragma Interface (Ada, Ts_Activation_Complete);
pragma Interface_Name (Ts_Activation_Complete, "TS_ACTIVATION_COMPLETE");
pragma Interface (Ada, Ts_Activation_Exceptions);
pragma Interface_Name (Ts_Activation_Exceptions,
"TS_ACTIVATION_EXCEPTIONS");
pragma Interface (Ada, Ts_Callable);
pragma Interface_Name (Ts_Callable, "TS_CALLABLE");
-- CIFO option
pragma Interface (Ada, Ts_Caller);
pragma Interface_Name (Ts_Caller, "TS_CALLER");
-- CIFO option
pragma Interface (Ada, Ts_Terminated);
pragma Interface_Name (Ts_Terminated, "TS_TERMINATED");
pragma Interface (Ada, Ts_Entry_Count);
pragma Interface_Name (Ts_Entry_Count, "TS_ENTRY_COUNT");
pragma Interface (Ada, Ts_Call);
pragma Interface_Name (Ts_Call, "TS_CALL");
pragma Interface (Ada, Ts_Conditional_Call);
pragma Interface_Name (Ts_Conditional_Call, "TS_CONDITIONAL_CALL");
-- CIFO_TRIVIAL_ENTRY
pragma Interface (Ada, Ts_Trivial_Conditional_Call);
pragma Interface_Name (Ts_Trivial_Conditional_Call,
"TS_TRIVIAL_CONDITIONAL_CALL");
-- CIFO_TRIVIAL_ENTRY
pragma Interface (Ada, Ts_Timed_Call);
pragma Interface_Name (Ts_Timed_Call, "TS_TIMED_CALL");
pragma Interface (Ada, Ts_Select);
pragma Interface_Name (Ts_Select, "TS_SELECT");
pragma Interface (Ada, Ts_Accept);
pragma Interface_Name (Ts_Accept, "TS_ACCEPT");
pragma Interface (Ada, Ts_Fast_Accept);
pragma Interface_Name (Ts_Fast_Accept, "TS_FAST_ACCEPT");
-- CIFO_TRIVIAL_ENTRY
pragma Interface (Ada, Ts_Trivial_Accept);
pragma Interface_Name (Ts_Trivial_Accept, "TS_TRIVIAL_ACCEPT");
-- CIFO_TRIVIAL_ENTRY
pragma Interface (Ada, Ts_Select_Else);
pragma Interface_Name (Ts_Select_Else, "TS_SELECT_ELSE");
pragma Interface (Ada, Ts_Select_Delay);
pragma Interface_Name (Ts_Select_Delay, "TS_SELECT_DELAY");
pragma Interface (Ada, Ts_Select_Terminate);
pragma Interface_Name (Ts_Select_Terminate, "TS_SELECT_TERMINATE");
pragma Interface (Ada, Ts_Finish_Accept);
pragma Interface_Name (Ts_Finish_Accept, "TS_FINISH_ACCEPT");
pragma Interface (Ada, Ts_Initialize);
pragma Interface_Name (Ts_Initialize, "TS_INITIALIZE");
pragma Interface (Ada, Ts_Exit);
pragma Interface_Name (Ts_Exit, "TS_EXIT");
pragma Interface (Ada, Ts_Create_Task);
pragma Interface_Name (Ts_Create_Task, "TS_CREATE_TASK");
pragma Interface (Ada, Ts_Create_Task_And_Link);
pragma Interface_Name (Ts_Create_Task_And_Link, "TS_CREATE_TASK_AND_LINK");
-- DA_RTS
pragma Interface (Ada, Ts_Create_Simple_Task);
pragma Interface_Name (Ts_Create_Simple_Task, "TS_CREATE_SIMPLE_TASK");
-- DA_RTS
-- CIFO_SYNCHRONIZATION
pragma Interface (Ada, Ts_Set_Entry_Criteria);
pragma Interface_Name (Ts_Set_Entry_Criteria, "TS_SET_ENTRY_CRITERIA");
pragma Interface (Ada, Ts_Set_Select_Criteria);
pragma Interface_Name (Ts_Set_Select_Criteria, "TS_SET_SELECT_CRITERIA");
-- CIFO_SYNCHRONIZATION
pragma Interface (Ada, Ts_Create_Master);
pragma Interface_Name (Ts_Create_Master, "TS_CREATE_MASTER");
pragma Interface (Ada, Ts_Tid);
pragma Interface_Name (Ts_Tid, "TS_TID");
pragma Interface (Ada, Ts_Delay);
pragma Interface_Name (Ts_Delay, "TS_DELAY");
pragma Interface (Ada, Ts_Current_Time);
pragma Interface_Name (Ts_Current_Time, "TS_CURRENT_TIME");
pragma Interface (Ada, Ts_Complete_Task);
pragma Interface_Name (Ts_Complete_Task, "TS_COMPLETE_TASK");
pragma Interface (Ada, Ts_Complete_Master);
pragma Interface_Name (Ts_Complete_Master, "TS_COMPLETE_MASTER");
pragma Interface (Ada, Ts_Exception_Master);
pragma Interface_Name (Ts_Exception_Master, "TS_EXCEPTION_MASTER");
pragma Interface (Ada, Ts_Terminate_List);
pragma Interface_Name (Ts_Terminate_List, "TS_TERMINATE_LIST");
-- CIFO option
pragma Interface (Ada, Ts_Cifo_Term_Callout);
pragma Interface_Name (Ts_Cifo_Term_Callout, "TS_CIFO_TERM_CALLOUT");
-- CIFO option
pragma Interface (Ada, Ts_Get_Stack_Limit);
pragma Interface_Name (Ts_Get_Stack_Limit, "TS_GET_STACK_LIMIT");
pragma Interface (Ada, Ts_Get_Last_Exception);
pragma Interface_Name (Ts_Get_Last_Exception, "TS_GET_LAST_EXCEPTION");
pragma Interface (Ada, Ts_Put_Last_Exception);
pragma Interface_Name (Ts_Put_Last_Exception, "TS_PUT_LAST_EXCEPTION");
pragma Interface (Ada, Ts_Attach_Interrupt);
pragma Interface_Name (Ts_Attach_Interrupt, "TS_ATTACH_INTERRUPT");
pragma Interface (Ada, Ts_Detach_Interrupt);
pragma Interface_Name (Ts_Detach_Interrupt, "TS_DETACH_INTERRUPT");
pragma Interface (Ada, Ts_Attach_Isr);
pragma Interface_Name (Ts_Attach_Isr, "TS_ATTACH_ISR");
pragma Interface (Ada, Ts_Detach_Isr);
pragma Interface_Name (Ts_Detach_Isr, "TS_DETACH_ISR");
pragma Interface (Ada, Ts_Create_Intr_Task);
pragma Interface_Name (Ts_Create_Intr_Task, "TS_CREATE_INTR_TASK");
pragma Interface (Ada, Ts_Activate_Intr_Task);
pragma Interface_Name (Ts_Activate_Intr_Task, "TS_ACTIVATE_INTR_TASK");
pragma Interface (Ada, Ts_Complete_Intr_Task);
pragma Interface_Name (Ts_Complete_Intr_Task, "TS_COMPLETE_INTR_TASK");
pragma Interface (Ada, Ts_Get_Intr_Task_Vector);
pragma Interface_Name (Ts_Get_Intr_Task_Vector, "TS_GET_INTR_TASK_VECTOR");
pragma Interface (Ada, Ts_Get_Intr_Task_Handler);
pragma Interface_Name (Ts_Get_Intr_Task_Handler,
"TS_GET_INTR_TASK_HANDLER");
pragma Interface (Ada, Ts_Set_Intr_Task_State);
pragma Interface_Name (Ts_Set_Intr_Task_State, "TS_SET_INTR_TASK_STATE");
end V_I_Taskop;
nblk1=1e
nid=0
hdr6=3c
[0x00] rec0=20 rec1=00 rec2=01 rec3=006
[0x01] rec0=17 rec1=00 rec2=02 rec3=006
[0x02] rec0=1a rec1=00 rec2=03 rec3=06e
[0x03] rec0=18 rec1=00 rec2=04 rec3=040
[0x04] rec0=17 rec1=00 rec2=05 rec3=098
[0x05] rec0=16 rec1=00 rec2=06 rec3=028
[0x06] rec0=14 rec1=00 rec2=07 rec3=030
[0x07] rec0=13 rec1=00 rec2=08 rec3=064
[0x08] rec0=14 rec1=00 rec2=09 rec3=06a
[0x09] rec0=15 rec1=00 rec2=0a rec3=056
[0x0a] rec0=12 rec1=00 rec2=0b rec3=062
[0x0b] rec0=14 rec1=00 rec2=0c rec3=022
[0x0c] rec0=13 rec1=00 rec2=0d rec3=00a
[0x0d] rec0=11 rec1=00 rec2=0e rec3=06c
[0x0e] rec0=14 rec1=00 rec2=0f rec3=064
[0x0f] rec0=18 rec1=00 rec2=10 rec3=01c
[0x10] rec0=13 rec1=00 rec2=11 rec3=01c
[0x11] rec0=13 rec1=00 rec2=12 rec3=080
[0x12] rec0=17 rec1=00 rec2=13 rec3=060
[0x13] rec0=16 rec1=00 rec2=14 rec3=092
[0x14] rec0=15 rec1=00 rec2=15 rec3=034
[0x15] rec0=17 rec1=00 rec2=16 rec3=024
[0x16] rec0=15 rec1=00 rec2=17 rec3=08c
[0x17] rec0=17 rec1=00 rec2=18 rec3=02c
[0x18] rec0=16 rec1=00 rec2=19 rec3=04a
[0x19] rec0=15 rec1=00 rec2=1a rec3=042
[0x1a] rec0=14 rec1=00 rec2=1b rec3=010
[0x1b] rec0=12 rec1=00 rec2=1c rec3=04c
[0x1c] rec0=14 rec1=00 rec2=1d rec3=01e
[0x1d] rec0=12 rec1=00 rec2=1e rec3=000
tail 0x21750be1686843892e803 0x42a00088462060003