648 lines
27 KiB
Ada
648 lines
27 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT LIBRARY COMPONENTS --
|
|
-- --
|
|
-- G N A T . E X P E C T --
|
|
-- --
|
|
-- S p e c --
|
|
-- --
|
|
-- Copyright (C) 2000-2014, AdaCore --
|
|
-- --
|
|
-- GNAT is free software; you can redistribute it and/or modify it under --
|
|
-- terms of the GNU General Public License as published by the Free Soft- --
|
|
-- ware Foundation; either version 3, or (at your option) any later ver- --
|
|
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
|
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
|
-- or FITNESS FOR A PARTICULAR PURPOSE. --
|
|
-- --
|
|
-- As a special exception under Section 7 of GPL version 3, you are granted --
|
|
-- additional permissions described in the GCC Runtime Library Exception, --
|
|
-- version 3.1, as published by the Free Software Foundation. --
|
|
-- --
|
|
-- You should have received a copy of the GNU General Public License and --
|
|
-- a copy of the GCC Runtime Library Exception along with this program; --
|
|
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
|
-- <http://www.gnu.org/licenses/>. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
-- Currently this package is implemented on all native GNAT ports. It is not
|
|
-- yet implemented for any of the cross-ports (e.g. it is not available for
|
|
-- VxWorks or LynxOS).
|
|
|
|
-- -----------
|
|
-- -- Usage --
|
|
-- -----------
|
|
|
|
-- This package provides a set of subprograms similar to what is available
|
|
-- with the standard Tcl Expect tool.
|
|
|
|
-- It allows you to easily spawn and communicate with an external process.
|
|
-- You can send commands or inputs to the process, and compare the output
|
|
-- with some expected regular expression.
|
|
|
|
-- Usage example:
|
|
|
|
-- Non_Blocking_Spawn
|
|
-- (Fd, "ftp",
|
|
-- (1 => new String' ("machine@domain")));
|
|
-- Timeout := 10_000; -- 10 seconds
|
|
-- Expect (Fd, Result, Regexp_Array'(+"\(user\)", +"\(passwd\)"),
|
|
-- Timeout);
|
|
-- case Result is
|
|
-- when 1 => Send (Fd, "my_name"); -- matched "user"
|
|
-- when 2 => Send (Fd, "my_passwd"); -- matched "passwd"
|
|
-- when Expect_Timeout => null; -- timeout
|
|
-- when others => null;
|
|
-- end case;
|
|
-- Close (Fd);
|
|
|
|
-- You can also combine multiple regular expressions together, and get the
|
|
-- specific string matching a parenthesis pair by doing something like this:
|
|
-- If you expect either "lang=optional ada" or "lang=ada" from the external
|
|
-- process, you can group the two together, which is more efficient, and
|
|
-- simply get the name of the language by doing:
|
|
|
|
-- declare
|
|
-- Matched : Match_Array (0 .. 2);
|
|
-- begin
|
|
-- Expect (Fd, Result, "lang=(optional)? ([a-z]+)", Matched);
|
|
-- Put_Line ("Seen: " &
|
|
-- Expect_Out (Fd) (Matched (2).First .. Matched (2).Last));
|
|
-- end;
|
|
|
|
-- Alternatively, you might choose to use a lower-level interface to the
|
|
-- processes, where you can give your own input and output filters every
|
|
-- time characters are read from or written to the process.
|
|
|
|
-- procedure My_Filter
|
|
-- (Descriptor : Process_Descriptor'Class;
|
|
-- Str : String;
|
|
-- User_Data : System.Address)
|
|
-- is
|
|
-- begin
|
|
-- Put_Line (Str);
|
|
-- end;
|
|
|
|
-- Non_Blocking_Spawn
|
|
-- (Fd, "tail",
|
|
-- (new String' ("-f"), new String' ("a_file")));
|
|
-- Add_Filter (Fd, My_Filter'Access, Output);
|
|
-- Expect (Fd, Result, "", 0); -- wait forever
|
|
|
|
-- The above example should probably be run in a separate task, since it is
|
|
-- blocking on the call to Expect.
|
|
|
|
-- Both examples can be combined, for instance to systematically print the
|
|
-- output seen by expect, even though you still want to let Expect do the
|
|
-- filtering. You can use the Trace_Filter subprogram for such a filter.
|
|
|
|
-- If you want to get the output of a simple command, and ignore any previous
|
|
-- existing output, it is recommended to do something like:
|
|
|
|
-- Expect (Fd, Result, ".*", Timeout => 0);
|
|
-- -- Empty the buffer, by matching everything (after checking
|
|
-- -- if there was any input).
|
|
|
|
-- Send (Fd, "command");
|
|
-- Expect (Fd, Result, ".."); -- match only on the output of command
|
|
|
|
-- -----------------
|
|
-- -- Task Safety --
|
|
-- -----------------
|
|
|
|
-- This package is not task-safe: there should not be concurrent calls to the
|
|
-- functions defined in this package. In other words, separate tasks must not
|
|
-- access the facilities of this package without synchronization that
|
|
-- serializes access.
|
|
|
|
with System;
|
|
with GNAT.OS_Lib;
|
|
with GNAT.Regpat;
|
|
|
|
package GNAT.Expect is
|
|
|
|
type Process_Id is new Integer;
|
|
Invalid_Pid : constant Process_Id := -1;
|
|
Null_Pid : constant Process_Id := 0;
|
|
|
|
type Filter_Type is (Output, Input, Died);
|
|
-- The signals that are emitted by the Process_Descriptor upon state change
|
|
-- in the child. One can connect to any of these signals through the
|
|
-- Add_Filter subprograms.
|
|
--
|
|
-- Output => Every time new characters are read from the process
|
|
-- associated with Descriptor, the filter is called with
|
|
-- these new characters in the argument.
|
|
--
|
|
-- Note that output is generated only when the program is
|
|
-- blocked in a call to Expect.
|
|
--
|
|
-- Input => Every time new characters are written to the process
|
|
-- associated with Descriptor, the filter is called with
|
|
-- these new characters in the argument.
|
|
-- Note that input is generated only by calls to Send.
|
|
--
|
|
-- Died => The child process has died, or was explicitly killed
|
|
|
|
type Process_Descriptor is tagged private;
|
|
-- Contains all the components needed to describe a process handled
|
|
-- in this package, including a process identifier, file descriptors
|
|
-- associated with the standard input, output and error, and the buffer
|
|
-- needed to handle the expect calls.
|
|
|
|
type Process_Descriptor_Access is access Process_Descriptor'Class;
|
|
|
|
------------------------
|
|
-- Spawning a process --
|
|
------------------------
|
|
|
|
procedure Non_Blocking_Spawn
|
|
(Descriptor : out Process_Descriptor'Class;
|
|
Command : String;
|
|
Args : GNAT.OS_Lib.Argument_List;
|
|
Buffer_Size : Natural := 4096;
|
|
Err_To_Out : Boolean := False);
|
|
-- This call spawns a new process and allows sending commands to
|
|
-- the process and/or automatic parsing of the output.
|
|
--
|
|
-- The expect buffer associated with that process can contain at most
|
|
-- Buffer_Size characters. Older characters are simply discarded when this
|
|
-- buffer is full. Beware that if the buffer is too big, this could slow
|
|
-- down the Expect calls if the output not is matched, since Expect has to
|
|
-- match all the regexp against all the characters in the buffer. If
|
|
-- Buffer_Size is 0, there is no limit (i.e. all the characters are kept
|
|
-- till Expect matches), but this is slower.
|
|
--
|
|
-- If Err_To_Out is True, then the standard error of the spawned process is
|
|
-- connected to the standard output. This is the only way to get the Expect
|
|
-- subprograms to also match on output on standard error.
|
|
--
|
|
-- Invalid_Process is raised if the process could not be spawned.
|
|
--
|
|
-- For information about spawning processes from tasking programs, see the
|
|
-- "NOTE: Spawn in tasking programs" in System.OS_Lib (s-os_lib.ads).
|
|
|
|
procedure Close (Descriptor : in out Process_Descriptor);
|
|
-- Terminate the process and close the pipes to it. It implicitly does the
|
|
-- 'wait' command required to clean up the process table. This also frees
|
|
-- the buffer associated with the process id. Raise Invalid_Process if the
|
|
-- process id is invalid.
|
|
|
|
procedure Close
|
|
(Descriptor : in out Process_Descriptor;
|
|
Status : out Integer);
|
|
-- Same as above, but also returns the exit status of the process, as set
|
|
-- for example by the procedure GNAT.OS_Lib.OS_Exit.
|
|
|
|
procedure Send_Signal
|
|
(Descriptor : Process_Descriptor;
|
|
Signal : Integer);
|
|
-- Send a given signal to the process. Raise Invalid_Process if the process
|
|
-- id is invalid.
|
|
|
|
procedure Interrupt (Descriptor : in out Process_Descriptor);
|
|
-- Interrupt the process (the equivalent of Ctrl-C on unix and windows)
|
|
-- and call close if the process dies.
|
|
|
|
function Get_Input_Fd
|
|
(Descriptor : Process_Descriptor) return GNAT.OS_Lib.File_Descriptor;
|
|
-- Return the input file descriptor associated with Descriptor
|
|
|
|
function Get_Output_Fd
|
|
(Descriptor : Process_Descriptor) return GNAT.OS_Lib.File_Descriptor;
|
|
-- Return the output file descriptor associated with Descriptor
|
|
|
|
function Get_Error_Fd
|
|
(Descriptor : Process_Descriptor) return GNAT.OS_Lib.File_Descriptor;
|
|
-- Return the error output file descriptor associated with Descriptor
|
|
|
|
function Get_Pid
|
|
(Descriptor : Process_Descriptor) return Process_Id;
|
|
-- Return the process id associated with a given process descriptor
|
|
|
|
function Get_Command_Output
|
|
(Command : String;
|
|
Arguments : GNAT.OS_Lib.Argument_List;
|
|
Input : String;
|
|
Status : not null access Integer;
|
|
Err_To_Out : Boolean := False) return String;
|
|
-- Execute Command with the specified Arguments and Input, and return the
|
|
-- generated standard output data as a single string. If Err_To_Out is
|
|
-- True, generated standard error output is included as well. On return,
|
|
-- Status is set to the command's exit status.
|
|
|
|
--------------------
|
|
-- Adding filters --
|
|
--------------------
|
|
|
|
-- This is a rather low-level interface to subprocesses, since basically
|
|
-- the filtering is left entirely to the user. See the Expect subprograms
|
|
-- below for higher level functions.
|
|
|
|
type Filter_Function is access
|
|
procedure
|
|
(Descriptor : Process_Descriptor'Class;
|
|
Str : String;
|
|
User_Data : System.Address := System.Null_Address);
|
|
-- Function called every time new characters are read from or written to
|
|
-- the process.
|
|
--
|
|
-- Str is a string of all these characters.
|
|
--
|
|
-- User_Data, if specified, is user specific data that will be passed to
|
|
-- the filter. Note that no checks are done on this parameter, so it should
|
|
-- be used with caution.
|
|
|
|
procedure Add_Filter
|
|
(Descriptor : in out Process_Descriptor;
|
|
Filter : Filter_Function;
|
|
Filter_On : Filter_Type := Output;
|
|
User_Data : System.Address := System.Null_Address;
|
|
After : Boolean := False);
|
|
-- Add a new filter for one of the filter types. This filter will be run
|
|
-- before all the existing filters, unless After is set True, in which case
|
|
-- it will be run after existing filters. User_Data is passed as is to the
|
|
-- filter procedure.
|
|
|
|
procedure Remove_Filter
|
|
(Descriptor : in out Process_Descriptor;
|
|
Filter : Filter_Function);
|
|
-- Remove a filter from the list of filters (whatever the type of the
|
|
-- filter).
|
|
|
|
procedure Trace_Filter
|
|
(Descriptor : Process_Descriptor'Class;
|
|
Str : String;
|
|
User_Data : System.Address := System.Null_Address);
|
|
-- Function that can be used as a filter and that simply outputs Str on
|
|
-- Standard_Output. This is mainly used for debugging purposes.
|
|
-- User_Data is ignored.
|
|
|
|
procedure Lock_Filters (Descriptor : in out Process_Descriptor);
|
|
-- Temporarily disables all output and input filters. They will be
|
|
-- reactivated only when Unlock_Filters has been called as many times as
|
|
-- Lock_Filters.
|
|
|
|
procedure Unlock_Filters (Descriptor : in out Process_Descriptor);
|
|
-- Unlocks the filters. They are reactivated only if Unlock_Filters
|
|
-- has been called as many times as Lock_Filters.
|
|
|
|
------------------
|
|
-- Sending data --
|
|
------------------
|
|
|
|
procedure Send
|
|
(Descriptor : in out Process_Descriptor;
|
|
Str : String;
|
|
Add_LF : Boolean := True;
|
|
Empty_Buffer : Boolean := False);
|
|
-- Send a string to the file descriptor.
|
|
--
|
|
-- The string is not formatted in any way, except if Add_LF is True, in
|
|
-- which case an ASCII.LF is added at the end, so that Str is recognized
|
|
-- as a command by the external process.
|
|
--
|
|
-- If Empty_Buffer is True, any input waiting from the process (or in the
|
|
-- buffer) is first discarded before the command is sent. The output
|
|
-- filters are of course called as usual.
|
|
|
|
-----------------------------------------------------------
|
|
-- Working on the output (single process, simple regexp) --
|
|
-----------------------------------------------------------
|
|
|
|
type Expect_Match is new Integer;
|
|
Expect_Full_Buffer : constant Expect_Match := -1;
|
|
-- If the buffer was full and some characters were discarded
|
|
|
|
Expect_Timeout : constant Expect_Match := -2;
|
|
-- If no output matching the regexps was found before the timeout
|
|
|
|
function "+" (S : String) return GNAT.OS_Lib.String_Access;
|
|
-- Allocate some memory for the string. This is merely a convenience
|
|
-- function to help create the array of regexps in the call to Expect.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexp : String;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Wait till a string matching Fd can be read from Fd, and return 1 if a
|
|
-- match was found.
|
|
--
|
|
-- It consumes all the characters read from Fd until a match found, and
|
|
-- then sets the return values for the subprograms Expect_Out and
|
|
-- Expect_Out_Match.
|
|
--
|
|
-- The empty string "" will never match, and can be used if you only want
|
|
-- to match after a specific timeout. Beware that if Timeout is -1 at the
|
|
-- time, the current task will be blocked forever.
|
|
--
|
|
-- This command times out after Timeout milliseconds (or never if Timeout
|
|
-- is -1). In that case, Expect_Timeout is returned. The value returned by
|
|
-- Expect_Out and Expect_Out_Match are meaningless in that case.
|
|
--
|
|
-- Note that using a timeout of 0ms leads to unpredictable behavior, since
|
|
-- the result depends on whether the process has already sent some output
|
|
-- the first time Expect checks, and this depends on the operating system.
|
|
--
|
|
-- The regular expression must obey the syntax described in GNAT.Regpat.
|
|
--
|
|
-- If Full_Buffer is True, then Expect will match if the buffer was too
|
|
-- small and some characters were about to be discarded. In that case,
|
|
-- Expect_Full_Buffer is returned.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexp : GNAT.Regpat.Pattern_Matcher;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as the previous one, but with a precompiled regular expression.
|
|
-- This is more efficient however, especially if you are using this
|
|
-- expression multiple times, since this package won't need to recompile
|
|
-- the regexp every time.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexp : String;
|
|
Matched : out GNAT.Regpat.Match_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as above, but it is now possible to get the indexes of the
|
|
-- substrings for the parentheses in the regexp (see the example at the
|
|
-- top of this package, as well as the documentation in the package
|
|
-- GNAT.Regpat).
|
|
--
|
|
-- Matched'First should be 0, and this index will contain the indexes for
|
|
-- the whole string that was matched. The index 1 will contain the indexes
|
|
-- for the first parentheses-pair, and so on.
|
|
|
|
------------
|
|
-- Expect --
|
|
------------
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexp : GNAT.Regpat.Pattern_Matcher;
|
|
Matched : out GNAT.Regpat.Match_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as above, but with a precompiled regular expression
|
|
|
|
-------------------------------------------------------------
|
|
-- Working on the output (single process, multiple regexp) --
|
|
-------------------------------------------------------------
|
|
|
|
type Regexp_Array is array (Positive range <>) of GNAT.OS_Lib.String_Access;
|
|
|
|
type Pattern_Matcher_Access is access all GNAT.Regpat.Pattern_Matcher;
|
|
type Compiled_Regexp_Array is
|
|
array (Positive range <>) of Pattern_Matcher_Access;
|
|
|
|
function "+"
|
|
(P : GNAT.Regpat.Pattern_Matcher) return Pattern_Matcher_Access;
|
|
-- Allocate some memory for the pattern matcher. This is only a convenience
|
|
-- function to help create the array of compiled regular expressions.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexps : Regexp_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Wait till a string matching one of the regular expressions in Regexps
|
|
-- is found. This function returns the index of the regexp that matched.
|
|
-- This command is blocking, but will timeout after Timeout milliseconds.
|
|
-- In that case, Timeout is returned.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexps : Compiled_Regexp_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as the previous one, but with precompiled regular expressions.
|
|
-- This can be much faster if you are using them multiple times.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexps : Regexp_Array;
|
|
Matched : out GNAT.Regpat.Match_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as above, except that you can also access the parenthesis
|
|
-- groups inside the matching regular expression.
|
|
--
|
|
-- The first index in Matched must be 0, or Constraint_Error will be
|
|
-- raised. The index 0 contains the indexes for the whole string that was
|
|
-- matched, the index 1 contains the indexes for the first parentheses
|
|
-- pair, and so on.
|
|
|
|
procedure Expect
|
|
(Descriptor : in out Process_Descriptor;
|
|
Result : out Expect_Match;
|
|
Regexps : Compiled_Regexp_Array;
|
|
Matched : out GNAT.Regpat.Match_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as above, but with precompiled regular expressions. The first index
|
|
-- in Matched must be 0, or Constraint_Error will be raised.
|
|
|
|
-------------------------------------------
|
|
-- Working on the output (multi-process) --
|
|
-------------------------------------------
|
|
|
|
type Multiprocess_Regexp is record
|
|
Descriptor : Process_Descriptor_Access;
|
|
Regexp : Pattern_Matcher_Access;
|
|
end record;
|
|
|
|
type Multiprocess_Regexp_Array is
|
|
array (Positive range <>) of Multiprocess_Regexp;
|
|
|
|
procedure Free (Regexp : in out Multiprocess_Regexp);
|
|
-- Free the memory occupied by Regexp
|
|
|
|
function Has_Process (Regexp : Multiprocess_Regexp_Array) return Boolean;
|
|
-- Return True if at least one entry in Regexp is non-null, ie there is
|
|
-- still at least one process to monitor
|
|
|
|
function First_Dead_Process
|
|
(Regexp : Multiprocess_Regexp_Array) return Natural;
|
|
-- Find the first entry in Regexp that corresponds to a dead process that
|
|
-- wasn't Free-d yet. This function is called in general when Expect
|
|
-- (below) raises the exception Process_Died. This returns 0 if no process
|
|
-- has died yet.
|
|
|
|
procedure Expect
|
|
(Result : out Expect_Match;
|
|
Regexps : Multiprocess_Regexp_Array;
|
|
Matched : out GNAT.Regpat.Match_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as above, but for multi processes. Any of the entries in
|
|
-- Regexps can have a null Descriptor or Regexp. Such entries will
|
|
-- simply be ignored. Therefore when a process terminates, you can
|
|
-- simply reset its entry.
|
|
--
|
|
-- The expect loop would therefore look like:
|
|
--
|
|
-- Processes : Multiprocess_Regexp_Array (...) := ...;
|
|
-- R : Natural;
|
|
--
|
|
-- while Has_Process (Processes) loop
|
|
-- begin
|
|
-- Expect (Result, Processes, Timeout => -1);
|
|
-- ... process output of process Result (output, full buffer,...)
|
|
--
|
|
-- exception
|
|
-- when Process_Died =>
|
|
-- -- Free memory
|
|
-- R := First_Dead_Process (Processes);
|
|
-- Close (Processes (R).Descriptor.all, Status);
|
|
-- Free (Processes (R));
|
|
-- end;
|
|
-- end loop;
|
|
|
|
procedure Expect
|
|
(Result : out Expect_Match;
|
|
Regexps : Multiprocess_Regexp_Array;
|
|
Timeout : Integer := 10_000;
|
|
Full_Buffer : Boolean := False);
|
|
-- Same as the previous one, but for multiple processes. This procedure
|
|
-- finds the first regexp that match the associated process.
|
|
|
|
------------------------
|
|
-- Getting the output --
|
|
------------------------
|
|
|
|
procedure Flush
|
|
(Descriptor : in out Process_Descriptor;
|
|
Timeout : Integer := 0);
|
|
-- Discard all output waiting from the process.
|
|
--
|
|
-- This output is simply discarded, and no filter is called. This output
|
|
-- will also not be visible by the next call to Expect, nor will any output
|
|
-- currently buffered.
|
|
--
|
|
-- Timeout is the delay for which we wait for output to be available from
|
|
-- the process. If 0, we only get what is immediately available.
|
|
|
|
function Expect_Out (Descriptor : Process_Descriptor) return String;
|
|
-- Return the string matched by the last Expect call.
|
|
--
|
|
-- The returned string is in fact the concatenation of all the strings read
|
|
-- from the file descriptor up to, and including, the characters that
|
|
-- matched the regular expression.
|
|
--
|
|
-- For instance, with an input "philosophic", and a regular expression "hi"
|
|
-- in the call to expect, the strings returned the first and second time
|
|
-- would be respectively "phi" and "losophi".
|
|
|
|
function Expect_Out_Match (Descriptor : Process_Descriptor) return String;
|
|
-- Return the string matched by the last Expect call.
|
|
--
|
|
-- The returned string includes only the character that matched the
|
|
-- specific regular expression. All the characters that came before are
|
|
-- simply discarded.
|
|
--
|
|
-- For instance, with an input "philosophic", and a regular expression
|
|
-- "hi" in the call to expect, the strings returned the first and second
|
|
-- time would both be "hi".
|
|
|
|
----------------
|
|
-- Exceptions --
|
|
----------------
|
|
|
|
Invalid_Process : exception;
|
|
-- Raised by most subprograms above when the parameter Descriptor is not a
|
|
-- valid process or is a closed process.
|
|
|
|
Process_Died : exception;
|
|
-- Raised by all the expect subprograms if Descriptor was originally a
|
|
-- valid process that died while Expect was executing. It is also raised
|
|
-- when Expect receives an end-of-file.
|
|
|
|
private
|
|
type Filter_List_Elem;
|
|
type Filter_List is access Filter_List_Elem;
|
|
type Filter_List_Elem is record
|
|
Filter : Filter_Function;
|
|
User_Data : System.Address;
|
|
Filter_On : Filter_Type;
|
|
Next : Filter_List;
|
|
end record;
|
|
|
|
type Pipe_Type is record
|
|
Input, Output : GNAT.OS_Lib.File_Descriptor;
|
|
end record;
|
|
-- This type represents a pipe, used to communicate between two processes
|
|
|
|
procedure Set_Up_Communications
|
|
(Pid : in out Process_Descriptor;
|
|
Err_To_Out : Boolean;
|
|
Pipe1 : not null access Pipe_Type;
|
|
Pipe2 : not null access Pipe_Type;
|
|
Pipe3 : not null access Pipe_Type);
|
|
-- Set up all the communication pipes and file descriptors prior to
|
|
-- spawning the child process.
|
|
|
|
procedure Set_Up_Parent_Communications
|
|
(Pid : in out Process_Descriptor;
|
|
Pipe1 : in out Pipe_Type;
|
|
Pipe2 : in out Pipe_Type;
|
|
Pipe3 : in out Pipe_Type);
|
|
-- Finish the set up of the pipes while in the parent process
|
|
|
|
procedure Set_Up_Child_Communications
|
|
(Pid : in out Process_Descriptor;
|
|
Pipe1 : in out Pipe_Type;
|
|
Pipe2 : in out Pipe_Type;
|
|
Pipe3 : in out Pipe_Type;
|
|
Cmd : String;
|
|
Args : System.Address);
|
|
-- Finish the set up of the pipes while in the child process This also
|
|
-- spawns the child process (based on Cmd). On systems that support fork,
|
|
-- this procedure is executed inside the newly created process.
|
|
|
|
type Process_Descriptor is tagged record
|
|
Pid : aliased Process_Id := Invalid_Pid;
|
|
Input_Fd : GNAT.OS_Lib.File_Descriptor := GNAT.OS_Lib.Invalid_FD;
|
|
Output_Fd : GNAT.OS_Lib.File_Descriptor := GNAT.OS_Lib.Invalid_FD;
|
|
Error_Fd : GNAT.OS_Lib.File_Descriptor := GNAT.OS_Lib.Invalid_FD;
|
|
Filters_Lock : Integer := 0;
|
|
|
|
Filters : Filter_List := null;
|
|
|
|
Buffer : GNAT.OS_Lib.String_Access := null;
|
|
Buffer_Size : Natural := 0;
|
|
Buffer_Index : Natural := 0;
|
|
|
|
Last_Match_Start : Natural := 0;
|
|
Last_Match_End : Natural := 0;
|
|
end record;
|
|
|
|
-- The following subprogram is provided for use in the body, and also
|
|
-- possibly in future child units providing extensions to this package.
|
|
|
|
procedure Portable_Execvp
|
|
(Pid : not null access Process_Id;
|
|
Cmd : String;
|
|
Args : System.Address);
|
|
pragma Import (C, Portable_Execvp, "__gnat_expect_portable_execvp");
|
|
-- Executes, in a portable way, the command Cmd (full path must be
|
|
-- specified), with the given Args, which must be an array of string
|
|
-- pointers. Note that the first element in Args must be the executable
|
|
-- name, and the last element must be a null pointer. The returned value
|
|
-- in Pid is the process ID, or zero if not supported on the platform.
|
|
|
|
end GNAT.Expect;
|