Gecko [ tsuru-no-tsurugi.tokyo ]

Name	Size	Permission	Date
peg	[ DIR ]	drwxr-xr-x	2025-03-06 19:41
and-let-star.scm	2.53 KB	-rw-r--r--	2021-05-10 17:28
arrays.scm	2.63 KB	-rw-r--r--	2021-05-10 17:28
atomic.scm	1.55 KB	-rw-r--r--	2021-05-10 17:28
binary-ports.scm	2.71 KB	-rw-r--r--	2021-05-10 17:28
boot-9.scm	166.42 KB	-rw-r--r--	2021-05-10 17:28
buffered-input.scm	4.82 KB	-rw-r--r--	2021-05-10 17:28
calling.scm	10.54 KB	-rw-r--r--	2021-05-10 17:28
command-line.scm	18.6 KB	-rw-r--r--	2021-05-10 17:28
common-list.scm	8.95 KB	-rw-r--r--	2021-05-10 17:28
control.scm	4.08 KB	-rw-r--r--	2021-05-10 17:28
copy-tree.scm	3.05 KB	-rw-r--r--	2021-05-10 17:28
curried-definitions.scm	1.79 KB	-rw-r--r--	2021-05-10 17:28
deprecated.scm	1.54 KB	-rw-r--r--	2021-05-10 17:28
documentation.scm	7.41 KB	-rw-r--r--	2021-08-27 06:21
eval-string.scm	2.99 KB	-rw-r--r--	2021-05-10 17:28
eval.scm	25.08 KB	-rw-r--r--	2021-05-10 17:28
exceptions.scm	14.38 KB	-rw-r--r--	2021-05-10 17:28
expect.scm	5.5 KB	-rw-r--r--	2021-05-10 17:28
fdes-finalizers.scm	1.06 KB	-rw-r--r--	2021-05-10 17:28
format.scm	65.47 KB	-rw-r--r--	2021-05-10 17:28
ftw.scm	25.06 KB	-rw-r--r--	2021-05-10 17:28
futures.scm	10.49 KB	-rw-r--r--	2021-05-10 17:28
gap-buffer.scm	9.59 KB	-rw-r--r--	2021-05-10 17:28
getopt-long.scm	16.49 KB	-rw-r--r--	2021-05-10 17:28
hash-table.scm	1.77 KB	-rw-r--r--	2021-05-10 17:28
hcons.scm	2.55 KB	-rw-r--r--	2021-05-10 17:28
history.scm	2.29 KB	-rw-r--r--	2021-05-10 17:28
i18n.scm	20.51 KB	-rw-r--r--	2021-05-10 17:28
iconv.scm	3.19 KB	-rw-r--r--	2021-05-10 17:28
lineio.scm	3.85 KB	-rw-r--r--	2021-05-10 17:28
list.scm	1.29 KB	-rw-r--r--	2021-05-10 17:28
local-eval.scm	9.84 KB	-rw-r--r--	2021-05-10 17:28
ls.scm	3.2 KB	-rw-r--r--	2021-05-10 17:28
match.scm	2.18 KB	-rw-r--r--	2021-05-10 17:28
match.upstream.scm	35.93 KB	-rw-r--r--	2021-05-10 17:28
networking.scm	3.33 KB	-rw-r--r--	2021-05-10 17:28
null.scm	1.21 KB	-rw-r--r--	2021-05-10 17:28
occam-channel.scm	7.26 KB	-rw-r--r--	2021-05-10 17:28
optargs.scm	15.75 KB	-rw-r--r--	2021-05-10 17:28
peg.scm	1.64 KB	-rw-r--r--	2021-05-10 17:28
poe.scm	3.3 KB	-rw-r--r--	2021-05-10 17:28
poll.scm	5.79 KB	-rw-r--r--	2021-05-10 17:28
popen.scm	9.27 KB	-rw-r--r--	2021-05-10 17:28
ports.scm	19.08 KB	-rw-r--r--	2021-05-10 17:28
posix.scm	2.73 KB	-rw-r--r--	2021-05-10 17:28
pretty-print.scm	16.88 KB	-rw-r--r--	2021-05-10 17:28
psyntax-pp.scm	182.88 KB	-rw-r--r--	2021-05-10 17:28
psyntax.scm	148.97 KB	-rw-r--r--	2021-08-27 06:21
q.scm	4.2 KB	-rw-r--r--	2021-05-10 17:28
quasisyntax.scm	5.22 KB	-rw-r--r--	2021-05-10 17:28
r5rs.scm	1.56 KB	-rw-r--r--	2021-05-10 17:28
r6rs-libraries.scm	10.38 KB	-rw-r--r--	2021-05-10 17:28
r7rs-libraries.scm	4.28 KB	-rw-r--r--	2021-05-10 17:28
rdelim.scm	7.72 KB	-rw-r--r--	2021-05-10 17:28
read.scm	32.52 KB	-rw-r--r--	2021-05-10 17:28
readline.scm	9.56 KB	-rw-r--r--	2021-05-10 17:28
receive.scm	1.06 KB	-rw-r--r--	2021-05-10 17:28
regex.scm	8.87 KB	-rw-r--r--	2021-05-10 17:28
runq.scm	8.18 KB	-rw-r--r--	2021-05-10 17:28
rw.scm	1.02 KB	-rw-r--r--	2021-05-10 17:28
safe-r5rs.scm	7.5 KB	-rw-r--r--	2021-05-10 17:28
safe.scm	1.25 KB	-rw-r--r--	2021-05-10 17:28
sandbox.scm	34.24 KB	-rw-r--r--	2021-05-10 17:28
save-stack.scm	2.15 KB	-rw-r--r--	2021-05-10 17:28
scm-style-repl.scm	11.62 KB	-rw-r--r--	2021-05-10 17:28
serialize.scm	3.78 KB	-rw-r--r--	2021-05-10 17:28
session.scm	17.72 KB	-rw-r--r--	2021-05-10 17:28
slib.scm	1.55 KB	-rw-r--r--	2021-05-10 17:28
stack-catch.scm	1.94 KB	-rw-r--r--	2021-05-10 17:28
streams.scm	5.86 KB	-rw-r--r--	2021-05-10 17:28
string-fun.scm	9.68 KB	-rw-r--r--	2021-05-10 17:28
suspendable-ports.scm	29.86 KB	-rw-r--r--	2021-05-10 17:28
textual-ports.scm	2.29 KB	-rw-r--r--	2021-05-10 17:28
threads.scm	12.54 KB	-rw-r--r--	2021-05-10 17:28
time.scm	2.07 KB	-rw-r--r--	2021-05-10 17:28
top-repl.scm	2.63 KB	-rw-r--r--	2021-05-10 17:28
unicode.scm	1005 B	-rw-r--r--	2021-05-10 17:28
vlist.scm	21.56 KB	-rw-r--r--	2021-05-10 17:28
weak-vector.scm	1.2 KB	-rw-r--r--	2021-05-10 17:28

Rename

;; popen emulation, for non-stdio based ports.

;;;; Copyright (C) 1998-2001, 2003, 2006, 2010-2013, 2019
;;;;   Free Software Foundation, Inc.
;;;; 
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License as published by the Free Software Foundation; either
;;;; version 3 of the License, or (at your option) any later version.
;;;; 
;;;; This library is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;;; Lesser General Public License for more details.
;;;; 
;;;; You should have received a copy of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;;;;

(define-module (ice-9 popen)
  #:use-module (rnrs bytevectors)
  #:use-module (ice-9 binary-ports)
  #:use-module (ice-9 threads)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-9)
  #:export (port/pid-table open-pipe* open-pipe close-pipe open-input-pipe
            open-output-pipe open-input-output-pipe pipeline))

(eval-when (expand load eval)
  (load-extension (string-append "libguile-" (effective-version))
                  "scm_init_popen"))

(define-record-type <pipe-info>
  (make-pipe-info pid)
  pipe-info?
  (pid pipe-info-pid set-pipe-info-pid!))

(define (make-rw-port read-port write-port)
  (define (read! bv start count)
    (let ((result (get-bytevector-some! read-port bv start count)))
      (if (eof-object? result)
          0
          result)))

(define (write! bv start count)
    (put-bytevector write-port bv start count)
    count)

(define (close)
    (close-port read-port)
    (close-port write-port))

(define rw-port
    (make-custom-binary-input/output-port "ice-9-popen-rw-port"
                                          read!
                                          write!
                                          #f ;get-position
                                          #f ;set-position!
                                          close))
  ;; Enable buffering on 'read-port' so that 'get-bytevector-some' will
  ;; return non-trivial blocks.
  (setvbuf read-port 'block 16384)

;; Inherit the port-encoding from the read-port.
  (set-port-encoding! rw-port (port-encoding read-port))

;; Reset the port encoding on the underlying ports to inhibit BOM
  ;; handling there.  Instead, the BOM handling (if any) will be handled
  ;; in the rw-port.  In the current implementation of Guile ports,
  ;; using binary I/O primitives alone is not enough to reliably inhibit
  ;; BOM handling, if the port encoding is set to UTF-{8,16,32}.
  (set-port-encoding! read-port "ISO-8859-1")
  (set-port-encoding! write-port "ISO-8859-1")

rw-port)

;; a guardian to ensure the cleanup is done correctly when
;; an open pipe is gc'd or a close-port is used.
(define pipe-guardian (make-guardian))

;; a weak hash-table to store the process ids.
;; XXX use of this table is deprecated.  It is no longer used here, and
;; is populated for backward compatibility only (since it is exported).
(define port/pid-table (make-weak-key-hash-table))
(define port/pid-table-mutex (make-mutex))

(define (pipe->fdes)
  (let ((p (pipe)))
   (cons (port->fdes (car p))
         (port->fdes (cdr p)))))

(define (open-process mode command . args)
  "Backwards compatible implementation of the former procedure in
libguile/posix.c (scm_open_process) replaced by
scm_piped_process. Executes the program @var{command} with optional
arguments @var{args} (all strings) in a subprocess.  A port to the
process (based on pipes) is created and returned.  @var{mode} specifies
whether an input, an output or an input-output port to the process is
created: it should be the value of @code{OPEN_READ}, @code{OPEN_WRITE}
or @code{OPEN_BOTH}."
  (define (unbuffered port)
    (setvbuf port 'none)
    port)

(define (fdes-pair ports)
    (and ports
         (cons (port->fdes (car ports)) (port->fdes (cdr ports)))))

(let* ((from (and (or (string=? mode OPEN_READ)
                        (string=? mode OPEN_BOTH))
                    (pipe)))
         (to (and (or (string=? mode OPEN_WRITE)
                      (string=? mode OPEN_BOTH))
                  (pipe)))
         (pid (piped-process command args
                             (fdes-pair from)
                             (fdes-pair to))))
    ;; The original 'open-process' procedure would return unbuffered
    ;; ports; do the same here.
    (values (and from (unbuffered (car from)))
            (and to (unbuffered (cdr to)))
            pid)))

(define (open-pipe* mode command . args)
  "Executes the program @var{command} with optional arguments
@var{args} (all strings) in a subprocess.
A port to the process (based on pipes) is created and returned.
@var{mode} specifies whether an input, an output or an input-output
port to the process is created: it should be the value of
@code{OPEN_READ}, @code{OPEN_WRITE} or @code{OPEN_BOTH}."
  (call-with-values (lambda ()
                      (apply open-process mode command args))
    (lambda (read-port write-port pid)
      (let ((port (or (and read-port write-port
                           (make-rw-port read-port write-port))
                      read-port
                      write-port
                      (%make-void-port mode)))
            (pipe-info (make-pipe-info pid)))

;; Guard the pipe-info instead of the port, so that we can still
        ;; call 'waitpid' even if 'close-port' is called (which clears
        ;; the port entry).
        (pipe-guardian pipe-info)
        (%set-port-property! port 'popen-pipe-info pipe-info)

;; XXX populate port/pid-table for backward compatibility.
        (with-mutex port/pid-table-mutex
          (hashq-set! port/pid-table port pid))

port))))

(define (open-pipe command mode)
  "Executes the shell command @var{command} (a string) in a subprocess.
A port to the process (based on pipes) is created and returned.
@var{mode} specifies whether an input, an output or an input-output
port to the process is created: it should be the value of
@code{OPEN_READ}, @code{OPEN_WRITE} or @code{OPEN_BOTH}."
  (open-pipe* mode "/bin/sh" "-c" command))

(define (fetch-pipe-info port)
  (%port-property port 'popen-pipe-info))

(define (close-process port pid)
  (close-port port)
  (cdr (waitpid pid)))

(define (close-pipe p)
  "Closes the pipe created by @code{open-pipe}, then waits for the process
to terminate and returns its status value, @xref{Processes, waitpid}, for
information on how to interpret this value."
  (let ((pipe-info (fetch-pipe-info p)))
    (unless pipe-info
      (error "close-pipe: port not created by (ice-9 popen)"))
    (let ((pid (pipe-info-pid pipe-info)))
      (unless pid
        (error "close-pipe: pid has already been cleared"))
      ;; clear the pid to avoid repeated calls to 'waitpid'.
      (set-pipe-info-pid! pipe-info #f)
      (close-process p pid))))

(define (reap-pipes)
  (let loop ()
    (let ((pipe-info (pipe-guardian)))
      (when pipe-info
        (let ((pid (pipe-info-pid pipe-info)))
          ;; maybe 'close-pipe' was already called.
          (when pid
            ;; clean up without reporting errors.  also avoids blocking
            ;; the process: if the child isn't ready to be collected,
            ;; puts it back into the guardian's live list so it can be
            ;; tried again the next time the cleanup runs.
            (catch 'system-error
              (lambda ()
                (let ((pid/status (waitpid pid WNOHANG)))
                  (if (zero? (car pid/status))
                      (pipe-guardian pipe-info) ; not ready for collection
                      (set-pipe-info-pid! pipe-info #f))))
              (lambda args #f))))
        (loop)))))

(add-hook! after-gc-hook reap-pipes)

(define (open-input-pipe command)
  "Equivalent to @code{open-pipe} with mode @code{OPEN_READ}"
  (open-pipe command OPEN_READ))

(define (open-output-pipe command)
  "Equivalent to @code{open-pipe} with mode @code{OPEN_WRITE}"
  (open-pipe command OPEN_WRITE))

(define (open-input-output-pipe command)
  "Equivalent to @code{open-pipe} with mode @code{OPEN_BOTH}"
  (open-pipe command OPEN_BOTH))

(define (pipeline commands)
  "Execute a pipeline of @var{commands}, where each command is a list of a
program and its arguments as strings, returning an input port to the
end of the pipeline, an output port to the beginning of the pipeline and
a list of PIDs of the processes executing the @var{commands}."
  (let* ((to (pipe->fdes))
         (pipes (map (lambda _ (pipe->fdes)) commands))
	 (pipeline (fold (lambda (from proc prev)
                           (let* ((to (car prev))
                                  (pids (cdr prev))
                                  (pid (piped-process (car proc)
                                                      (cdr proc)
                                                      from
                                                      to)))
                             (cons from (cons pid pids))))
                         `(,to)
                         pipes
                         commands))
	 (from (car pipeline))
	 (pids (cdr pipeline)))
    (values (fdes->inport (car from)) (fdes->outport (cdr to)) pids)))