--| --|Item: Ada PCTE Binding --|$Revision: 0.2 $ --|$State: Prototype $ --| --|The Version Description Document (VDD) included with this release provides --|detailed information regarding the condition of the software. The "User --|Feedback" section of the VDD describes how to obtain additional information. --| --|Distribution Statement "A", per DoD Directive 5230.24 --|Authorized for public release; distribution is unlimited. --| --|Copyright (c) 1992, Paramax Systems Corporation, Reston, Virginia --|Copyright is assigned to the U.S. Government, upon delivery thereto, --|in accordance with the DFAR Special Works Clause. --| --|Developed by: Paramax Systems Corporation, --| --|This software, developed under the Software Technology for Adaptable, --|Reliable Systems (STARS) program, is approved for release under --|Distribution "A" of the Scientific and Technical Information Program --|Classification Scheme (DoD Directive 5230.24) unless otherwise indicated. --|Sponsored by the U.S. Defense Advanced Research Projects Agency (DARPA) --|under contract F19628-88-D-0031, the STARS program is supported by the --|military services, SEI, and MITRE, with the U.S. Air Force as the executive --|contracting agent. --| --|Permission to use, copy, modify, and comment on this software and its --|documentation for purposes stated under Distribution "A" and without fee --|is hereby granted, provided that this notice appears in each whole or --|partial copy. This software retains Contractor indemnification to --|the Government regarding copyrights pursuant to the above referenced --|STARS contract. The Government disclaims all responsibility against --|liability, including costs and expenses for violation of proprietary --|rights, or copyrights arising out of the creation or use of this --|software. --| --|In addition, the Government, Paramax, and its subcontractors disclaim all --|warranties with regard to this software, including all implied warranties --|of merchantability and fitness, and in no event shall the Government, --|Paramax, or its subcontractor(s) be liable for any special, indirect or --|consequential damages or any damages whatsoever resulting from the loss of --|use, data, or profits, whether in action of contract, negligence or other --|tortious action, arising in connection with the use or performance of this --|software. --| --|$Log $ --| -- Version Information -- ^^^^^^^^^^^^^^^^^^^ -- -- PCTE - Ada Language Interface. -- Version: 0.2. -- Release Date: November 30, 1992. -- Compiled under SUN OS 4.1.2 using SunAda 1.0 -- -- -- General Information -- ^^^^^^^^^^^^^^^^^^^ -- -- This is an alpha release of the Paramax STARS Ada binding to Emeraude's -- PCTE 1.5 using the ECMA PCTE Ada binding specifications. The binding -- is incomplete in this release. See the Version Description Document -- provided with this alpha release for information on which interfaces -- have been implemented. It is expected that future releases will -- expand the number of interfaces implemented. The interfaces defined -- herein are subject to change. -- -- For further information, contact the authors: -- -- -- Robert Smith -- Paramax Systems Corp. -- Valley Forge Labs -- 70 E. Swedesford Road -- Paoli, PA. 19301 -- smith@prc.unisys.com (current) -- smith@vfl.paramax.com (future) -- +1 215 648-2402 -- -- Michael Horton -- Paramax Systems Corp. -- Valley Forge Labs -- 70 E. Swedesford Road -- Paoli, PA. 19301 -- horton@prc.unisys.com (current) -- horton@vfl.paramax.com (future) -- +1 215 648-2527 -- -- with pcte_1_5_int, errors_c, error; with unchecked_deallocation; with system; package body Pcte_process is type pathname_ptr is access Pcte.reference.pathname; procedure free is new unchecked_deallocation ( object => Pcte.reference.pathname, name => pathname_ptr); -- All of the following data structures are to support invoking -- processes through 1.5. Most of this should be part of a process -- object (attributes, links). 1.5 does not support process objects -- so I create a list of currently active processes. To simplify -- things I use an array of processes (max of 16 for now) which -- will be reused as processes terminate. This is ugly but just -- a quick hack job to get the RLF port working. When I learn more -- about writing schema defs, I may actually implement a limited -- form of process objects PROCESS_LIST_MAX : constant Pcte.natural := 16; DEFAULT_ADDRESS : constant system.address := system.no_addr; type string_pointer is access string; type string_list is array (Pcte.natural range <>) of string_pointer; type string_list_pointer is access string_list; type c_list is array (Pcte.natural range <>) of system.address; type c_list_pointer is access c_list; type process_record is record process_id : pcte_1_5_int.pid_t; active : Pcte.boolean; delete : Pcte.boolean; arg_list : string_list_pointer; arg_c_list : c_list_pointer; env_list : string_list_pointer; env_c_list : c_list_pointer; end record; type process is access process_record; type process_list is array (pcte.natural range 1 .. PROCESS_LIST_MAX) of process; pcte_processes : process_list; procedure free is new unchecked_deallocation ( object => process_record, name => process); procedure free is new unchecked_deallocation ( object => c_list, name => c_list_pointer); procedure free is new unchecked_deallocation ( object => string_list, name => string_list_pointer); procedure free is new unchecked_deallocation ( object => string, name => string_pointer); procedure clear_process (proc : in out process) is begin if proc = null then return; -- nothing to clear end if; if proc.arg_list /= null then for i in proc.arg_list'RANGE loop free (proc.arg_list (i)); end loop; free (proc.arg_list); free (proc.arg_c_list); end if; if proc.env_list /= null then for i in proc.env_list'RANGE loop free (proc.env_list (i)); end loop; free (proc.env_list); free (proc.env_c_list); end if; proc.active := false; proc.process_id := 0; end clear_process; procedure free_process (proc : in out process) is begin clear_process (proc); free (proc); end free_process; procedure build_c_list ( sequence : in Pcte_process.strings.sequence; ada_list : in out string_list_pointer; list : in out c_list_pointer) is item_count : Pcte.natural := Pcte_process.strings.length_of (sequence); begin if item_count = 0 then ada_list := null; list := null; return; -- nothing to convert end if; ada_list := new string_list (1 .. item_count); list := new c_list (1 .. item_count + 1); -- one more for the null for i in ada_list'RANGE loop ada_list (i) := new Pcte.string'( Pcte_process.strings.get(sequence, Pcte.positive (i)) & ascii.nul); list (i) := ada_list (i).all (ada_list(i)'FIRST)'ADDRESS; end loop; list (list'LAST) := system.no_addr; -- trailing null to terminate end build_c_list; -- 13.2.1 PROCESS_CREATE procedure create ( static_context : in Pcte.object_reference; process_type : in Pcte.type_reference; implicit_deletion : in Pcte.boolean; access_mask : in Pcte_discretionary.object.access_rights; new_process : in out Pcte.object_reference; parent : in Pcte.object_reference := CURRENT_PROCESS; site : in Pcte.object_reference := LOCAL_EXECUTION_SITE; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end create; -- 13.2.2 PROCESS_CREATE_AND_START procedure create_and_start ( static_context : in Pcte.object_reference; arguments : in Pcte_process.strings.sequence; environment : in Pcte_process.strings.sequence; implicit_deletion : in Pcte.boolean; access_mask : in Pcte_discretionary.object.access_rights; new_process : in out Pcte.object_reference; site : in Pcte.object_reference := LOCAL_EXECUTION_SITE; status : in Pcte_error.handle := EXCEPTION_ONLY) is -- 1.5 has no process objects so we assume implicit_deletion is true -- (actually we ignore it). -- -- For now we will also assume that the site is always -- LOCAL_EXECUTION_SITE context_path : pathname_ptr; current_process : Pcte.natural := 0; arg_address : system.address := DEFAULT_ADDRESS; env_address : system.address := DEFAULT_ADDRESS; process_id : pcte_1_5_int.pid_t; errno : standard.integer; begin -- get a C acceptable path name context_path := new Pcte.reference.pathname'( Pcte.reference.get_path (static_context, status) & ascii.nul); -- find an available process record (hope there is one) for i in pcte_processes'RANGE loop if pcte_processes (i) = null or else not pcte_processes (i).active then if pcte_processes (i) = null then pcte_processes (i) := new process_record; end if; current_process := i; exit; end if; end loop; -- bail out if we have no process record available (bad hack) if current_process = 0 then error.process_status_info ( status, pcte_error.INTERNAL_IMPLEMENTATION_ERROR ); return; end if; --now convert string lists into c acceptable lists of addresses if Pcte_process.strings.length_of (arguments) /= 0 then build_c_list ( arguments, pcte_processes (current_process).arg_list, pcte_processes (current_process).arg_c_list); arg_address := pcte_processes (current_process).arg_c_list(1)'ADDRESS; end if; if pcte_process.strings.length_of (environment) /= 0 then build_c_list ( environment, pcte_processes (current_process).env_list, pcte_processes (current_process).env_c_list); env_address := pcte_processes (current_process).env_c_list(1)'ADDRESS; end if; process_id := pcte_1_5_int.start ( context_path (context_path'FIRST)'ADDRESS, arg_address, env_address, DEFAULT_ADDRESS); if pcte_1_5_int."=" (process_id, pcte_1_5_int.pid_t (-1)) then -- we've got an error errno := errors_c.get_errno; case errno is when errors_c.EAGAIN => error.process_status_info ( status, pcte_error.LIMIT_WOULD_BE_EXCEEDED, errno); when errors_c.EREFOBJ | errors_c.ENOLINK | errors_c.ELTYPE | errors_c.ETYPEREF | errors_c.ENOMOUNT => error.process_status_info ( status, pcte_error.PATHNAME_DOES_NOT_DESIGNATE_AN_EXISTING_OBJECT, errno); when errors_c.ENOTSELECTED => error.process_status_info ( status, pcte_error.EXECUTION_SITE_IS_NOT_IN_EXECUTION_CLASS, errno); when errors_c.EACCES | errors_c.ENOEXEC => error.process_status_info ( status, pcte_error.STATIC_CONTEXT_CONTENTS_CANNOT_BE_EXECUTED, errno); when errors_c.ETXTBSY => error.process_status_info ( status, pcte_error.STATIC_CONTEXT_IS_IN_USE, errno); when errors_c.ENOMEM => error.process_status_info ( status, pcte_error.STATIC_CONTEXT_REQUIRES_TOO_MUCH_MEMORY, errno); when errors_c.E2BIG => error.process_status_info ( status, pcte_error.INTERNAL_IMPLEMENTATION_ERROR, errno); when errors_c.ENOTCNCT => error.process_status_info ( status, pcte_error.EXECUTION_SITE_IS_NOT_AVAILABLE, errno); when errors_c.EINTR | errors_c.EDEADLOCK => error.process_status_info ( status, pcte_error.INTERNAL_IMPLEMENTATION_ERROR, errno); when errors_c.EFAULT => error.process_status_info ( status, pcte_error.INTERNAL_IMPLEMENTATION_ERROR, errno); when others => error.process_status_info ( status, pcte_error.INTERNAL_IMPLEMENTATION_ERROR, errno); end case; -- clean up the process record and make available to next call clear_process (pcte_processes (current_process)); return; end if; pcte_processes (current_process).active := true; pcte_processes (current_process).process_id := process_id; pcte_processes (current_process).delete := true; -- for now -- initialize the new object Pcte.reference.set_absolute ( new_process, Pcte.reference.ON_FIRST_USE, context_path.all, status); Pcte.reference.set_reference_id ( new_process, Pcte.integer (process_id)); error.process_status_info (status, pcte_error.NO_ERROR); end create_and_start; -- 13.2.3 PROCESS_INTERRUPT_OPERATION procedure interrupt_operation ( process : in Pcte.object_reference; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end interrupt_operation; -- 13.2.4 PROCESS_RESUME procedure resume ( process : in Pcte.object_reference; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end resume; -- 13.2.5 PROCESS_SET_ALARM procedure set_alarm ( duration : in Pcte.natural; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_alarm; -- 13.2.6 PROCESS_SET_FILE_SIZE_LIMIT procedure set_file_size_limit ( fslimit : in Pcte.natural; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_file_size_limit; -- 13.2.7 PROCESS_SET_OPERATION_TIME_OUT procedure set_operation_time_out ( duration : in Pcte.natural; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_operation_time_out; -- 13.2.8 PROCESS_SET_PRIORITY procedure set_priority ( priority : in Pcte.natural; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_priority; -- 13.2.9 PROCESS_SET_REFERENCED_OBJECT procedure set_referenced_object ( reference_name : in Pcte.key; object : in Pcte.object_reference; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_referenced_object; -- 13.2.10 PROCESS_SET_TERMINATION_STATUS procedure set_termination_status ( termination_status : in Pcte.integer; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_termination_status; -- 13.2.11 PROCESS_SET_WORKING_SCHEMA procedure set_working_schema ( sds_sequence : in Pcte_process.object_references.sequence; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is -- We'll only do this for the current process for the moment. -- This will extract the sds' from the sequence and pass these -- to setschema. use errors_c; count : Pcte.natural := Pcte_process.object_references.length_of ( sds_sequence); sds_list : c_list (1 .. count + 1); -- add on the trailing nul sds_ptr_list : array (1 .. count) of pathname_ptr; tmp_obj : Pcte.object_reference; result : standard.integer; errno : standard.integer; begin for i in 1 .. Pcte.positive (count) loop tmp_obj := Pcte_Process.object_references.get (sds_sequence, i); sds_ptr_list (Pcte.natural (i)) := new Pcte.reference.pathname'(Pcte.reference.get_path ( tmp_obj, status) & ascii.nul); sds_list (Pcte.natural (i)) := sds_ptr_list (Pcte.natural (i))( sds_ptr_list (Pcte.natural (i))'FIRST)'ADDRESS; end loop; sds_list (count + 1) := system.no_addr; -- the terminatorf result := pcte_1_5_int.setschema (sds_list (sds_list'FIRST)'ADDRESS); -- Now, we have to free up all the memory we used for i in 1 .. count loop free (sds_ptr_list (i)); end loop; -- Let's do the error handling after freeing all the memory if result < 0 then errno := errors_c.get_errno; case errno is when EFAULT | EACCES => error.process_status_info ( status, pcte_error.SDS_NAME_IS_INVALID, errno); when EINVAL | ENOSDS => error.process_status_info ( status, pcte_error.SDS_IS_UNKNOWN, errno); when EBUSY => error.process_status_info ( status, pcte_error.SDS_IS_UNDER_MODIFICATION, errno); when ENOMEM => error.process_status_info ( status, pcte_error.LIMIT_WOULD_BE_EXCEEDED, errno); when others => error.process_status_info ( status, pcte_error.SDS_NAME_IS_INVALID, errno); end case; return; -- not raising an exception end if; error.process_status_info (status, pcte_error.NO_ERROR); end set_working_schema; --% procedure get_working_schema is a non-standard interface procedure get_working_schema ( sds_sequence : in out Pcte_process.object_references.sequence; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is max_sdses : constant positive := 100; -- arbitrary limit sds_names : array (positive range 1 .. max_sdses) of string (1 .. pcte_1_5_int.SDSNAMESIZE); sds_count : integer; name_size : natural; begin sds_count := pcte_1_5_int.getschema (max_sdses, sds_names (sds_names'FIRST)'ADDRESS); Pcte_process.object_references.delete (sds_sequence); for i in 1 .. sds_count loop for j in 1 .. pcte_1_5_int.SDSNAMESIZE loop if sds_names (i) (j) = ascii.nul then name_size := j - 1; exit; end if; end loop; declare sds : Pcte.object_reference; begin Pcte.reference.set_absolute (sds, Pcte.reference.ON_FIRST_USE, sds_names (i) (1 .. name_size), status); Pcte_process.object_references.put (sds_sequence, sds, i); end; end loop; end get_working_schema; -- 13.2.12 PROCESS_START procedure start ( process : in Pcte.object_reference; initial_status : in Pcte_process.initial_status; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end start; procedure start ( process : in Pcte.object_reference; site : in Pcte.object_reference; initial_status : in Pcte_process.initial_status; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end start; -- 13.2.13 PROCESS_SUSPEND procedure suspend ( process : in Pcte.object_reference := CURRENT_PROCESS; alarm : in Pcte.natural := 0; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end suspend; -- 13.2.14 PROCESS_TERMINATE procedure terminate_process ( process : in Pcte.object_reference := CURRENT_PROCESS; termination_status : in Pcte.integer := FORCED_TERMINATION; status : in Pcte_error.handle := EXCEPTION_ONLY) is -- The name of the procedure is modified because 'terminate' -- is an Ada reserved word. begin null; -- STUB end terminate_process; -- 13.2.15 PROCESS_UNSET_REFERENCED_OBJECT procedure unset_referenced_object ( reference_name : in Pcte.key; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end unset_referenced_object; -- 13.2.16 PROCESS_WAIT_FOR_ANY_CHILD procedure wait_for_any_child ( termination_status : out Pcte.integer; status : in Pcte_error.handle := EXCEPTION_ONLY) is proc_id : standard.integer; p_status : standard.integer; begin proc_id := pcte_1_5_int.wait (p_status'ADDRESS); for i in pcte_processes'range loop if pcte_processes (i) /= null and then standard.integer (pcte_processes (i).process_id) = proc_id then free_process (pcte_processes (i)); exit; end if; end loop; -- temporary (until I handle the errors) termination_status := Pcte.integer (p_status); error.process_status_info (status, pcte_error.NO_ERROR); end wait_for_any_child; -- 13.2.17 PROCESS_WAIT_FOR_CHILD procedure wait_for_child ( child : in Pcte.object_reference; termination_status : out Pcte.integer; status : in Pcte_error.handle := EXCEPTION_ONLY) is pid : pcte_1_5_int.pid_t; return_pid : standard.integer; p_status : standard.integer; errno : standard.integer; begin pid := pcte_1_5_int.pid_t (Pcte.reference.get_reference_id (child)); return_pid := pcte_1_5_int.waitp (pid, p_status'ADDRESS); if return_pid = -1 then errno := errors_c.get_errno; case errno is when errors_c.ECHILD | errors_c.EINVAL => error.process_status_info ( status, pcte_error.PROCESS_IS_UNKNOWN, errno); when errors_c.EINTR => error.process_status_info ( status, pcte_error.OPERATION_IS_INTERRUPTED, errno); when others => error.process_status_info ( status, pcte_error.INTERNAL_IMPLEMENTATION_ERROR, errno); end case; end if; -- error occurred error.process_status_info (status, pcte_error.NO_ERROR); for i in pcte_processes'range loop if pcte_processes (i) /= null and then pcte_1_5_int."="(pcte_processes (i).process_id, pid) then free_process (pcte_processes (i)); exit; end if; end loop; end wait_for_child; -- 13.3.1 PROCESS_SET_CONSUMER_IDENTITY procedure set_consumer_identity ( group : in Pcte.object_reference; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_consumer_identity; -- 13.3.2 PROCESS_UNSET_CONSUMER_IDENTITY procedure unset_consumer_identity ( status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end unset_consumer_identity; -- 13.4.1 PROCESS_ADOPT_USER_GROUP procedure adopt_user_group ( user_group : in Pcte.object_reference; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end adopt_user_group; -- 13.4.2 PROCESS_CHANGE_ADOPTABILITY_OF_USER_GROUP_FOR_CHILD procedure change_adoptability_of_user_group_for_child ( user_group : in Pcte.object_reference; adoptability : in Pcte.boolean; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end change_adoptability_of_user_group_for_child; -- 13.4.3 PROCESS_GET_DEFAULT_ACCESS_CONTROL_LIST procedure get_default_access_control_list ( acl : in out Pcte_discretionary.object.acl_entries.sequence; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end get_default_access_control_list; -- 13.4.4 PROCESS_GET_DEFAULT_OWNER function get_default_owner ( status : Pcte_error.handle := EXCEPTION_ONLY) return Pcte.natural is dummy : Pcte.natural := 0; begin return dummy; -- STUB end get_default_owner; -- 13.4.5 PROCESS_SET_CONFIDENTIALITY_LABEL procedure set_confidentiality_label ( confidentiality_label : in Pcte_mandatory.security_label; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_confidentiality_label; -- 13.4.6 PROCESS_SET_DEFAULT_ACL_ENTRY procedure set_default_acl_entry ( group : in Pcte.natural; modes : in Pcte_discretionary.object.access_rights; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_default_acl_entry; -- 13.4.7 PROCESS_SET_DEFAULT_OWNER procedure set_default_owner ( group : in Pcte.natural; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_default_owner; -- 13.4.8 PROCESS_SET_FLOATING_CONFIDENTIALITY_LEVEL procedure set_floating_confidentiality_level ( floating_mode : in Pcte_mandatory.floating_level; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_floating_confidentiality_level; -- 13.4.9 PROCESS_SET_FLOATING_INTEGRITY_LEVEL procedure set_floating_integrity_level ( floating_mode : in Pcte_mandatory.floating_level; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_floating_integrity_level; -- 13.4.10 PROCESS_SET_INTEGRITY_LABEL procedure set_integrity_label ( integrity_label : in Pcte_mandatory.security_label; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_integrity_label; -- 13.4.11 PROCESS_SET_USER_AND_USER_GROUP_IDENTITY procedure set_user_and_user_group_identity ( user : in Pcte.object_reference; user_group : in Pcte.object_reference; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end set_user_and_user_group_identity; -- 13.5.1 PROCESS_PROFILING_OFF procedure profiling_off ( handle : in Pcte_process.profile_handle; buffer : in out Pcte_process.profile_buffer.sequence; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end profiling_off; -- 13.5.2 PROCESS_PROFILING_ON procedure profiling_on ( handle : out Pcte_process.profile_handle; start : in Pcte_process.address; pcte_end : in Pcte_process.address; count : in Pcte.natural; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end profiling_on; -- 13.6.1 PROCESS_ADD_BREAKPOINT -- generic -- type element_address is private ; procedure add_breakpoint ( breakpoint : in element_address; process : in Pcte.object_reference := CURRENT_PROCESS; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end add_breakpoint; -- 13.6.2 PROCESS_CONTINUE procedure continue ( process : in Pcte.object_reference; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end continue; -- 13.6.3 PROCESS_PEEK -- generic -- type element_type is private ; -- type element_address is private ; function peek ( process : Pcte.object_reference; address : element_address; status : Pcte_error.handle := EXCEPTION_ONLY) return element_type is dummy : element_type; begin return dummy; -- STUB end peek; -- 13.6.4 PROCESS_POKE -- generic -- type element_type is private ; -- type element_address is private ; procedure poke ( process : in Pcte.object_reference; address : in element_address; value : in element_type; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end poke; -- 13.6.5 PROCESS_REMOVE_BREAKPOINT -- generic -- type element_address is private ; procedure remove_breakpoint ( process : in Pcte.object_reference; breakpoint : in element_address; status : in Pcte_error.handle := EXCEPTION_ONLY) is begin null; -- STUB end remove_breakpoint; end Pcte_process;