The eazy-process Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The eazy-process Reference Manual

This is the eazy-process Reference Manual, version 0.1, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:43:46 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction


#+startup: showall

+ Simplified API/implementation, achieved by *REMOVING* some features in run-program
+ Declarative process handling
+ Subprocesses spawned by POSIX fork&exec, no impl-specific interface
+ Memory / CPU-time management of the child processes
+ [-] Compatibility layer to the existing State-of-the-Art libraries 
  + [X] trivial-shell
  + [ ] inferior-shell
  + [ ] sb-ext:run-program

* Usage

#+BEGIN_SRC lisp
(defvar pipe (pipe))
(defvar in "t/test-input")
(defvar out "t/test-output")

(defvar p1 (shell '("cat") `(,in  ,pipe))) ; fd 0:pathname, 1:pipe
(defvar p2 (shell '("cat") `(,pipe ,out))) ; fd 0:pipe, 1:pathname

(wait p1)
(wait p2)
#+END_SRC

Processes are async by default.
Even if you forget waiting the process, it is handled by trivial-garbage
--- when a process object (here, p1 and p2) is GC-ed, it is automatically
finalized -- killed and waited.

To ensure the process is finalized, =with-process= might help you.
It ensures the subprocess is terminated and no zombie
remains. However, it does not synchronize with the subprocess by itself ---
synchronization should be done manually.

#+BEGIN_SRC lisp
(with-process (p1 '("sleep" "3"))
  (print :x))
;; p1 is killed right after the execution of (print :x),
;; which means that the subprocess does not actually run for 3 seconds.

(with-process (p1 '("sleep" "3"))
  (print :x)
  (wait p1)) ;; synchronization. Waits for 3 sec
#+END_SRC

Note that if you leave too many processes alive, the total number of file
descriptors might hit the system-provided limit (around 1000 by default).

** Implicit Piping

If you do not specify pipes nor pathnames, a new pipe is created for each
fd, and the /other/ end of the pipe is accessible with =(fd process
fdnum)=. When =nil= is specified, it means /dev/null.

#+BEGIN_SRC lisp
    (let* ((in "t/test-input")
           (p1 (shell '("cat") `(,in :output))) ; fd 0,1 where 1 is an implicit pipe
           (p2 (shell '("cat") `(,(fd p1 1) :out :o :input :in :i nil)))) ; fd 0-6
      (wait p1)
      (wait p2))
#+END_SRC

** Reading the output

The output of the subprocess is *NOT directly accessible with EAZY-PROCESS*.
Instead, open the pathname returned by =fd-as-pathname=, which is =/dev/fd/[fd]=.

#+BEGIN_SRC lisp
(test read
  (let ((p1 (shell `("hostname"))))
    (with-open-file (s (fd-as-pathname p1 1))
      (is (string= (machine-instance)
                   (read-line s))))))
#+END_SRC

This has greatly simplified the API of eazy-process.

** Resource management

Macro =with-rlimit= dynamically binds the current rlimit resource limitation. 
As noted in =*rlimit-resources*= docstring, this does not affect the lisp process itself.
--- It only affect the new child processes spawned by =shell=.

Example below shows the usecase where =*spendtime*= contains a path to a
simple C program that busy-waits for 10 seconds. The execution is
terminated in 3 seconds. TERMSIG is set to 24 because the program
is killed by SIGXCPU.

#+BEGIN_SRC lisp
 (with-rlimit ((+rlimit-cpu-time+ 3)) ; 3 sec
   (let ((p (shell `(,(namestring *spendtime*))))) 
     (multiple-value-bind
            (exited exitstatus ifsignalled termsig ...)
            (wait p)
       (is-false exited)
       (is-false exitstatus)
       (is-true ifsignalled)
       (is (= 24 termsig)))))
#+END_SRC

This macro can be nested, and the new subprocess reflects the inntermost limitation.

#+BEGIN_SRC lisp
(with-rlimit ((+rlimit-cpu-time+ 3))
  (shell ...) ; 3 sec
  (with-rlimit ((+rlimit-cpu-time+ 5)
                (+rlimit-as+ 500000))
    (shell ...))) ; 5 sec, 500 MB
#+END_SRC

* Somewhat Longer Description

In `run-program` interface in the popular implementations, piping between
subprocesses are hard. It requires either reading the entire output stream
and packing the contents as a new string-input-stream, or using some other
implementation-specific functions. Also, compatibility libraries e.g.
trivial-shell or inferior-shell, often depend on these functions, implying
the same problem.

Iolib also has `run-program` that allows easy piping, but it is restricted
to 3 fds: `input,output,error`.

Eazy-process provides a clean, declarative and thin layer for the
processes. It depends on the concept of "everything is a file" and do not
provide interfaces to streams.

* Tested Impl

This library is at least tested on implementation listed below:

+ SBCL 1.2.1 on X86-64 Linux 3.13.0-39-generic (author's environment)
+ SBCL 1.1.14 on X86 Linux 3.13.0-44-generic (author's environment)
+ CCL 1.10 on linux currently has a problem reading =/dev/fd/[fd]=, which
  is actually a symlink to =/proc/[pid]/fd/[fd]=, and the test does not
  pass. Do not use =(fd-as-pathname process fd)= and use temorary
  files instead.
+ ECL opens =/dev/fd/[fd]= correctly, but it fails to load CFFI...
+ ABCL has more problems than CCL. It fails to open =/proc/[pid]/fd/[fd]=
  and also have problems with CFFI.

Test reports on other OS'es/impls are greatly appreciated.
Run =./simple-build-test.sh=, assuming it already loads quicklisp in your
init files.

* Dependencies

It depends on the latest libfixposix available at
https://github.com/sionescu/libfixposix .

Also, it depends on the following libraries:

+ iterate by *Jonathan Amsterdam* :
    Jonathan Amsterdam's iterator/gatherer/accumulator facility
+ Alexandria by ** :
    Alexandria is a collection of portable public domain utilities.
+ cffi by *James Bielman  * :
    The Common Foreign Function Interface
+ optima by *Tomohiro Matsuyama* :
    Optimized Pattern Matching Library
+ iolib
+ trivial-garbage
+ cl-rlimit

* Syntax

#+BEGIN_SRC lisp
(defun shell (argv &optional
               (fdspecs '(:input :output :output))
               (environments nil env-p)
               (search t))
    ...)
#+END_SRC

When =search= is nil, it disables the pathname resolving using PATH.

** Fdspecs

#+BEGIN_SRC 
fdspecs := {fdspec}*
fdspec  := output | input | fd | path-or-pipe | openspec
output  := :output | :out | :o
input   := :input | :in | :i
fd      := 
openspec := (path-or-pipe &key direction if-exists if-does-not-exist)
path-or-pipe :=  | 
direction := :input | :output | :io | :probe
if-exists := :overwrite | :supersede | :append | :error
if-does-not-exist := :create | :error
#+END_SRC

+ =output= form and =input= form implicitly create a new pipe.
+ The fixnum =fd= should be a value of function =(fd process fdnum)=.
+ Openfilespec is almost identical to the argument list of =OPEN= in ANSI
  spec, however =:rename=, =:rename-and-delete=, =:new-version= are not
  supported and signals an error.
+ Function =pipe= generates a new pipe object that can be used in an fdspec.
+ If a == or a == are given without options, it uses
  a default direction, which is =:input= for fd 0 and =:output= for fd 1
  and fd 2. For fd > 2, missing direction signals an error.
+ Be careful when you open a fifo, the process will be blocked.

** Environments

: environments := {environment}*
: environment  := env-pair | env-string
: env-pair     := (name . value)
: env-string   := "name=value"
: name, value -- string

If we omit the second argument =environments=,
the subprocess inherits the environment of the parent lisp process.
=unset= -ting the environment value is not available.

* Compatibility Layers

There are compatibility layers for /trivial-shell/ and /inferior-shell/.
For documentation, see [[compat/README.org]] .

** /run-program/ compatibility

*Abandoned* , since the design of =run-program= is not thoroughly
delibelated, and any form of its descendants is not acceptable.
It is a mistake to combine processes with streams in a
tightly coupled manner.

* Author & Copyright

Copyright (c) 2014 Masataro Asai (guicho2.71828@gmail.com)



Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 eazy-process

Author

Masataro Asai

Contact

guicho2.71828@gmail.com

License

MIT

Description

Yet Another Portable Library for Process Handling / Subshell Invokation

Long Description

In ‘run-program‘ interface in the popular
implementations, piping between subprocesses are hard. It requires either reading the entire output stream and packing the contents as a new string-input-stream, or using some other implementation-specific functions. Also, compatibility libraries e.g. trivial-shell or inferior-shell, often depend on these functions, implying the same problem. Iolib also has ‘run-program‘ that allows easy piping, but it is restricted to 3 fds: ‘input,output,error‘.

Eazy-process provides a clean, declarative and thin layer to the processes. It depends on the concept of ’everything is a file’ and do not provide interfaces to streams.

Version

0.1

Dependencies
Source

eazy-process.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 eazy-process/src

Parent

eazy-process (system)

Location

src/

Components

Previous: , Up: Modules   [Contents][Index]

3.2 eazy-process/compat

Dependency

src (module)

Parent

eazy-process (system)

Location

compat/

Component

trivial-shell.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 eazy-process.asd

Location

eazy-process.asd

Systems

eazy-process (system)

Packages

eazy-process-asd


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 eazy-process/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

eazy-process


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 eazy-process/src/mktempfifo.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/mktempfifo.lisp

Internal Definitions

mktempfifo (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 eazy-process/src/pipe.lisp

Dependency

mktempfifo.lisp (file)

Parent

src (module)

Location

src/pipe.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 eazy-process/src/environ.lisp

Dependency

pipe.lisp (file)

Parent

src (module)

Location

src/environ.lisp

Exported Definitions

environment (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 eazy-process/src/specials.lisp

Dependency

environ.lisp (file)

Parent

src (module)

Location

src/specials.lisp

Exported Definitions
Internal Definitions

+max-rlimit-constant+ (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 eazy-process/src/fdspec.lisp

Dependency

specials.lisp (file)

Parent

src (module)

Location

src/fdspec.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 eazy-process/src/shell.lisp

Dependency

fdspec.lisp (file)

Parent

src (module)

Location

src/shell.lisp

Exported Definitions

shell (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 eazy-process/src/process.lisp

Dependency

shell.lisp (file)

Parent

src (module)

Location

src/process.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 eazy-process/src/macros.lisp

Dependency

process.lisp (file)

Parent

src (module)

Location

src/macros.lisp

Exported Definitions

with-process (macro)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 eazy-process/src/resources.lisp

Dependency

macros.lisp (file)

Parent

src (module)

Location

src/resources.lisp

Exported Definitions

with-rlimit (macro)


Previous: , Up: Lisp files   [Contents][Index]

4.1.12 eazy-process/compat/trivial-shell.lisp

Parent

compat (module)

Location

compat/trivial-shell.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 eazy-process-asd

Source

eazy-process.asd

Use List

Previous: , Up: Packages   [Contents][Index]

5.2 eazy-process

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *interpreter*

Command line string which is invoked in order to run the subshell. Default value is "sh -c". The value is then followed by the command specified in shell-command, e.g. ,
when command = ’ls -la’, the running command is "sh -c ’ls -la’".
It provides the ability to call the interpreters like perl/AWK easily.

The name/path of the interpreter must be separated by spaces from the options like ’-c’.
Do not use complex things like — LANG=C sh . The first word is always considered the pathname. If you want to do complicated stuff, then do it inside the interpreter.

The process is forked, then the child process calls execvp with the name of
the interpreter. (This is defined in function ‘eazy-process:shell’.) The
actual pathname of the intepreter can be resolved using PATH environment
variable.

Package

eazy-process

Source

trivial-shell.lisp (file)

Special Variable: *rlimit-resources*

A vector of rlimit resource value, where the index suggests +rlimit-XXX+, which is an integer (usually below 16) This value does not affect the lisp process itself; The effect is applied to the child process only.
Rather than modifying this variable directly, use ‘with-rlimit’ instead.

Package

eazy-process

Source

specials.lisp (file)

Special Variable: +fdspecs-default+
Package

eazy-process

Source

specials.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Symbol macros

Symbol Macro: *bourne-compatible-shell*
Package

eazy-process

Source

trivial-shell.lisp (file)

Expansion

eazy-process:*interpreter*


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Macros

Macro: with-process (PROCESS ARGV &optional FDSPECS ENVIRONMENT SEARCH) &body BODY

Spawn a process, bind the process to PROCESS,
execute the body and finalize (= kill and wait w/ nohang) the process.
BODY works as an implicit progn, and the return value is that of the progn.

It does not synchronously wait the process. Therefore, it is the user’s
responsibility to inhibit the early termination of the process.
The aim of finalization is to release the resources of the process e.g. file descriptor and pipes.

Example:

(with-open-process (p ("sleep" "10"))
(print :waiting)
(wait p))

Package

eazy-process

Source

macros.lisp (file)

Macro: with-rlimit PAIRS &body BODY

Append/overwrite the current rlimit resouce limitation. This does not affect the lisp process itself.
Only the spawned child process will be affected.

Package

eazy-process

Source

resources.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Functions

Function: close-pipe PIPE
Package

eazy-process

Source

pipe.lisp (file)

Function: environment ()
Package

eazy-process

Source

environ.lisp (file)

Function: fd PROCESS N

Returns the file descriptor of the lisp process.
The returned fd is connected to the n-th fd of the child process through a pipe. Example:

(fd P 1) ; –> 5

This means that the 5’th fd of the lisp process is connected to the 1st fd of the process P.

Package

eazy-process

Source

process.lisp (file)

Function: fd-as-pathname PROCESS FD

Return the pathname for each file descriptor.
Lisp can read/write to each fd by opening this file.

Since the buffer size of file-stream is implementation-dependent, and the call to cl:read might cache a considerable amount of characters from the file, we are not able to ensure that the same file can be opened more than once.

Even if you just cl:open the file and just cl:read-char the stream,
it might read the entire characters of the file into the buffer as a side-effect. We just advise you not to open the file more than once.

Package

eazy-process

Source

process.lisp (file)

Function: fds PROCESS

Returns an fresh array of fds available from lisp process.

Package

eazy-process

Source

process.lisp (file)

Function: finalize-process PROCESS &optional SIG

Waitpid the process. If the process is alive, kill it with SIG first, then with SIGKILL.

Package

eazy-process

Source

process.lisp (file)

Function: pipe ()
Package

eazy-process

Source

pipe.lisp (file)

Function: shell ARGV &optional FDSPECS ENVIRONMENTS SEARCH

Asynchronously execute ‘argv’ using fork(2) and ‘execve’
family of system calls, returns a process structure object.

ARGV is a sequence of strings. Each string is converted to null-terminated
C strings char* ARGV and passed to execvp. The first element is also
passed to execvp as the pathname of the executable.

FDSPECS is a sequence specifying how the child process should handle its output.
For the documentation of fd-specifier see ‘+fdspecs-default+’.
Example: (:in :out :out) , (5 :out 8)

Each element in FDSPECS corresponds to each file descriptor of the child process.

When an i-th element of FDSPECS is a symbol, then a new pipe(2) is created for each i. The i-th fd of the child process p1 is associated with the correct end of the new pipe, the other end of the pipe is readable/writable from lisp from the process interface.
(see the documentation of class PROCESS.)

When an i-th element of FDSPECS is an integer j,
then it should be the lisp end of a pipe connected to some other child process p2.
(not the normal fd of the lisp process, like 0,1,2)
The i-th fd of p1 is connected to this pipe,
then p1 and p2 can exchange the data each other.
When this happens, lisp process should not read from this pipe
(or the data will not be sent to the destination of the pipe).
For that purpose, add a layer like ‘tee’.

When ENVIRONMENT is specified, it is passed to execve/execvpe.
It should be a list of strings ("NAME1=VALUE1" "NAME2=VALUE2")
or an alist (("NAME1" . "VALUE1") ...).
When SEARCH is t, it uses execvp/execvpe. (==executable is searched through PATH)

On error during system call in the parent process, iolib.syscalls:syscall-error is signalled. In the child process, the system call failure result in error status 203.
FIXME: this might not be good.

Package

eazy-process

Source

shell.lisp (file)

Function: shell-command COMMAND &key INPUT RESULT-TYPE EXTERNAL-FORMAT VERBOSE

simple interface compatible to trivial-shell @ https://github.com/gwkkwg/trivial-shell.git.

returns (values output error-output exit-status).
The input is read from the :input key argument.

Additional functionality:

:external-format — specifies the decoding of the output.

Package

eazy-process

Source

trivial-shell.lisp (file)

Function: wait PROCESS &optional OPTION

option is one of :nohang, :untraced, :continued.
Returns a value of the following signature:

(list (boolean ifexited)
(integer exitstatus)
(boolean ifsignalled)
(integer termsig)
(boolean coredump)
(boolean ifstopped)
(integer stopsig)
(boolean ifcontinued)
(integer status)).

When the value is inappropriate as defined in man wait(2), some integer values may return NIL.
When :nohang is specified but no child has changed its state, then it returns NIL instead.
‘wait(0)’, i.e. wait for any children, is not available.

Package

eazy-process

Source

process.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Generic functions

Generic Function: pid OBJECT
Package

eazy-process

Methods
Method: pid (PROCESS process)

automatically generated reader method

Source

process.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Structures

Structure: pipe ()
Package

eazy-process

Source

pipe.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: read
Type

fixnum

Initform

0

Readers

pipe-read (function)

Writers

(setf pipe-read) (function)

Slot: write
Type

fixnum

Initform

1

Readers

pipe-write (function)

Writers

(setf pipe-write) (function)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.7 Classes

Class: process ()

A class representing a process.

Package

eazy-process

Source

process.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • print-object (method)
  • %fds (method)
  • pid (method)
Direct slots
Slot: pid
Initargs

:pid

Readers

pid (generic function)

Slot: fds
Initargs

:fds

Readers

%fds (generic function)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: +max-rlimit-constant+
Package

eazy-process

Source

specials.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: with-retry-open-file (TAG &key MAX) ARGS &body BODY
Package

eazy-process

Source

trivial-shell.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: %close-fd-safely FD
Package

eazy-process

Source

process.lisp (file)

Function: %exec ARGV ENV SEARCH
Package

eazy-process

Source

shell.lisp (file)

Function: %execv ARGV
Package

eazy-process

Source

shell.lisp (file)

Function: %execvp ARGV
Package

eazy-process

Source

shell.lisp (file)

Function: %finalize-process PID SIG FDS

True finalizer of a process object. However,
This function should not contain reference to the process itself because it prevents process object from GC-ing.

Package

eazy-process

Source

process.lisp (file)

Function: %in-child FDSPECS ARGV ENVIRONMENTS SEARCH

if the child process died of errno, the exit value is that value

Package

eazy-process

Source

shell.lisp (file)

Function: %in-parent FDSPECS PID
Package

eazy-process

Source

shell.lisp (file)

Function: %make-process PID FDS
Package

eazy-process

Source

process.lisp (file)

Function: %open PATH &key DIRECTION IF-EXISTS IF-DOES-NOT-EXIST

ANSI CL standard:

if-does-not-exist—one of :error, :create, or nil.
The default is
:error if direction is :input or if-exists is :overwrite or :append
:create if direction is :output or :io, and if-exists is neither :overwrite nor :append; or nil when direction is :probe.

Package

eazy-process

Source

fdspec.lisp (file)

Function: %pipe PIPE &key DIRECTION
Package

eazy-process

Source

fdspec.lisp (file)

Function: %setenv PAIR
Package

eazy-process

Source

shell.lisp (file)

Function: canonicalize-fdspec FDSPEC &optional FD

Take an fd-specifier and return a cons of (parent-fn . child-fn) where both parent-fn and child-fn are closures of 1 arg, the fd on the child end. Each function runs a job that should be done in the context of parent/child process.

if FD is specified and the direction is not specified, use the default direction of that fd by default. For FD > 2, there is no default direction and it signals an error.

Parent-fn should return the fd of the parent-end.

Package

eazy-process

Source

fdspec.lisp (file)

Function: check-alive PROCESS
Package

eazy-process

Source

trivial-shell.lisp (file)

Function: close-fd FD
Package

eazy-process

Source

trivial-shell.lisp (file)

Function: copy-pipe INSTANCE
Package

eazy-process

Source

pipe.lisp (file)

Function: dclose OLD NEW

Duplicate the old fd, set it to the new fd, then close the old fd

Package

eazy-process

Source

fdspec.lisp (file)

Function: io-loop-string P IN S0 S1 S2
Package

eazy-process

Source

trivial-shell.lisp (file)

Function: make-c-char* LIST-OF-STRING
Package

eazy-process

Source

shell.lisp (file)

Function: make-pipe &key (READ READ) (WRITE WRITE)
Package

eazy-process

Source

pipe.lisp (file)

Function: mktempfifo ()
Package

eazy-process

Source

mktempfifo.lisp (file)

Function: pipe-p OBJECT
Package

eazy-process

Source

pipe.lisp (file)

Function: pipe-read INSTANCE
Function: (setf pipe-read) VALUE INSTANCE
Package

eazy-process

Source

pipe.lisp (file)

Function: pipe-write INSTANCE
Function: (setf pipe-write) VALUE INSTANCE
Package

eazy-process

Source

pipe.lisp (file)

Function: try-read-write-char SIN SOUT FD
Package

eazy-process

Source

trivial-shell.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Generic functions

Generic Function: %fds OBJECT
Package

eazy-process

Methods
Method: %fds (PROCESS process)

automatically generated reader method

Source

process.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   E   F   L   M  
Index Entry  Section

E
eazy-process.asd: The eazy-process<dot>asd file
eazy-process/compat: The eazy-process/compat module
eazy-process/compat/trivial-shell.lisp: The eazy-process/compat/trivial-shell<dot>lisp file
eazy-process/src: The eazy-process/src module
eazy-process/src/environ.lisp: The eazy-process/src/environ<dot>lisp file
eazy-process/src/fdspec.lisp: The eazy-process/src/fdspec<dot>lisp file
eazy-process/src/macros.lisp: The eazy-process/src/macros<dot>lisp file
eazy-process/src/mktempfifo.lisp: The eazy-process/src/mktempfifo<dot>lisp file
eazy-process/src/package.lisp: The eazy-process/src/package<dot>lisp file
eazy-process/src/pipe.lisp: The eazy-process/src/pipe<dot>lisp file
eazy-process/src/process.lisp: The eazy-process/src/process<dot>lisp file
eazy-process/src/resources.lisp: The eazy-process/src/resources<dot>lisp file
eazy-process/src/shell.lisp: The eazy-process/src/shell<dot>lisp file
eazy-process/src/specials.lisp: The eazy-process/src/specials<dot>lisp file

F
File, Lisp, eazy-process.asd: The eazy-process<dot>asd file
File, Lisp, eazy-process/compat/trivial-shell.lisp: The eazy-process/compat/trivial-shell<dot>lisp file
File, Lisp, eazy-process/src/environ.lisp: The eazy-process/src/environ<dot>lisp file
File, Lisp, eazy-process/src/fdspec.lisp: The eazy-process/src/fdspec<dot>lisp file
File, Lisp, eazy-process/src/macros.lisp: The eazy-process/src/macros<dot>lisp file
File, Lisp, eazy-process/src/mktempfifo.lisp: The eazy-process/src/mktempfifo<dot>lisp file
File, Lisp, eazy-process/src/package.lisp: The eazy-process/src/package<dot>lisp file
File, Lisp, eazy-process/src/pipe.lisp: The eazy-process/src/pipe<dot>lisp file
File, Lisp, eazy-process/src/process.lisp: The eazy-process/src/process<dot>lisp file
File, Lisp, eazy-process/src/resources.lisp: The eazy-process/src/resources<dot>lisp file
File, Lisp, eazy-process/src/shell.lisp: The eazy-process/src/shell<dot>lisp file
File, Lisp, eazy-process/src/specials.lisp: The eazy-process/src/specials<dot>lisp file

L
Lisp File, eazy-process.asd: The eazy-process<dot>asd file
Lisp File, eazy-process/compat/trivial-shell.lisp: The eazy-process/compat/trivial-shell<dot>lisp file
Lisp File, eazy-process/src/environ.lisp: The eazy-process/src/environ<dot>lisp file
Lisp File, eazy-process/src/fdspec.lisp: The eazy-process/src/fdspec<dot>lisp file
Lisp File, eazy-process/src/macros.lisp: The eazy-process/src/macros<dot>lisp file
Lisp File, eazy-process/src/mktempfifo.lisp: The eazy-process/src/mktempfifo<dot>lisp file
Lisp File, eazy-process/src/package.lisp: The eazy-process/src/package<dot>lisp file
Lisp File, eazy-process/src/pipe.lisp: The eazy-process/src/pipe<dot>lisp file
Lisp File, eazy-process/src/process.lisp: The eazy-process/src/process<dot>lisp file
Lisp File, eazy-process/src/resources.lisp: The eazy-process/src/resources<dot>lisp file
Lisp File, eazy-process/src/shell.lisp: The eazy-process/src/shell<dot>lisp file
Lisp File, eazy-process/src/specials.lisp: The eazy-process/src/specials<dot>lisp file

M
Module, eazy-process/compat: The eazy-process/compat module
Module, eazy-process/src: The eazy-process/src module

Jump to:   E   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
C   D   E   F   G   I   M   P   S   T   W  
Index Entry  Section

%
%close-fd-safely: Internal functions
%exec: Internal functions
%execv: Internal functions
%execvp: Internal functions
%fds: Internal generic functions
%fds: Internal generic functions
%finalize-process: Internal functions
%in-child: Internal functions
%in-parent: Internal functions
%make-process: Internal functions
%open: Internal functions
%pipe: Internal functions
%setenv: Internal functions

(
(setf pipe-read): Internal functions
(setf pipe-write): Internal functions

C
canonicalize-fdspec: Internal functions
check-alive: Internal functions
close-fd: Internal functions
close-pipe: Exported functions
copy-pipe: Internal functions

D
dclose: Internal functions

E
environment: Exported functions

F
fd: Exported functions
fd-as-pathname: Exported functions
fds: Exported functions
finalize-process: Exported functions
Function, %close-fd-safely: Internal functions
Function, %exec: Internal functions
Function, %execv: Internal functions
Function, %execvp: Internal functions
Function, %finalize-process: Internal functions
Function, %in-child: Internal functions
Function, %in-parent: Internal functions
Function, %make-process: Internal functions
Function, %open: Internal functions
Function, %pipe: Internal functions
Function, %setenv: Internal functions
Function, (setf pipe-read): Internal functions
Function, (setf pipe-write): Internal functions
Function, canonicalize-fdspec: Internal functions
Function, check-alive: Internal functions
Function, close-fd: Internal functions
Function, close-pipe: Exported functions
Function, copy-pipe: Internal functions
Function, dclose: Internal functions
Function, environment: Exported functions
Function, fd: Exported functions
Function, fd-as-pathname: Exported functions
Function, fds: Exported functions
Function, finalize-process: Exported functions
Function, io-loop-string: Internal functions
Function, make-c-char*: Internal functions
Function, make-pipe: Internal functions
Function, mktempfifo: Internal functions
Function, pipe: Exported functions
Function, pipe-p: Internal functions
Function, pipe-read: Internal functions
Function, pipe-write: Internal functions
Function, shell: Exported functions
Function, shell-command: Exported functions
Function, try-read-write-char: Internal functions
Function, wait: Exported functions

G
Generic Function, %fds: Internal generic functions
Generic Function, pid: Exported generic functions

I
io-loop-string: Internal functions

M
Macro, with-process: Exported macros
Macro, with-retry-open-file: Internal macros
Macro, with-rlimit: Exported macros
make-c-char*: Internal functions
make-pipe: Internal functions
Method, %fds: Internal generic functions
Method, pid: Exported generic functions
mktempfifo: Internal functions

P
pid: Exported generic functions
pid: Exported generic functions
pipe: Exported functions
pipe-p: Internal functions
pipe-read: Internal functions
pipe-write: Internal functions

S
shell: Exported functions
shell-command: Exported functions

T
try-read-write-char: Internal functions

W
wait: Exported functions
with-process: Exported macros
with-retry-open-file: Internal macros
with-rlimit: Exported macros

Jump to:   %   (  
C   D   E   F   G   I   M   P   S   T   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
F   P   R   S   W  
Index Entry  Section

*
*bourne-compatible-shell*: Exported symbol macros
*interpreter*: Exported special variables
*rlimit-resources*: Exported special variables

+
+fdspecs-default+: Exported special variables
+max-rlimit-constant+: Internal special variables

F
fds: Exported classes

P
pid: Exported classes

R
read: Exported structures

S
Slot, fds: Exported classes
Slot, pid: Exported classes
Slot, read: Exported structures
Slot, write: Exported structures
Special Variable, *interpreter*: Exported special variables
Special Variable, *rlimit-resources*: Exported special variables
Special Variable, +fdspecs-default+: Exported special variables
Special Variable, +max-rlimit-constant+: Internal special variables
Symbol Macro, *bourne-compatible-shell*: Exported symbol macros

W
write: Exported structures

Jump to:   *   +  
F   P   R   S   W  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   E   P   S  
Index Entry  Section

C
Class, process: Exported classes

E
eazy-process: The eazy-process system
eazy-process: The eazy-process package
eazy-process-asd: The eazy-process-asd package

P
Package, eazy-process: The eazy-process package
Package, eazy-process-asd: The eazy-process-asd package
pipe: Exported structures
process: Exported classes

S
Structure, pipe: Exported structures
System, eazy-process: The eazy-process system

Jump to:   C   E   P   S