[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 01/01: Remove unused doc/maint
|
From: |
Daniel Llorens |
|
Subject: |
[Guile-commits] 01/01: Remove unused doc/maint |
|
Date: |
Thu, 23 Jun 2016 11:22:12 +0000 (UTC) |
lloda pushed a commit to branch master
in repository guile.
commit e7f1038aca62f7318b9a3c93d50293f800462110
Author: Daniel Llorens <address@hidden>
Date: Thu Jun 23 13:21:32 2016 +0200
Remove unused doc/maint
---
doc/maint/ChangeLog-2008 | 75 -
doc/maint/README | 35 -
doc/maint/docstring.el | 622 ---
doc/maint/guile.texi |11091 ----------------------------------------------
4 files changed, 11823 deletions(-)
diff --git a/doc/maint/ChangeLog-2008 b/doc/maint/ChangeLog-2008
deleted file mode 100644
index 0c6e618..0000000
--- a/doc/maint/ChangeLog-2008
+++ /dev/null
@@ -1,75 +0,0 @@
-2004-08-25 Marius Vollmer <address@hidden>
-
- * docstring.el (docstring-process-alist): Consider entries in
- reverse order. That puts them in new-docstrings.texi in the same
- order as in the C source.
-
-2004-08-23 Marius Vollmer <address@hidden>
-
- * docstring.el: Replaced all "@c module" markers with "@c
- module-for-docstring", making it less likely to collide with a
- real commentary.
-
-2002-10-19 Neil Jerram <address@hidden>
-
- * guile.texi: Replaced by regenerated libguile version.
-
-2002-07-10 Gary Houston <address@hidden>
-
- * docstring.el: optional 2nd environment variable to locate
- built files.
-
-2002-07-09 Gary Houston <address@hidden>
-
- * docstring.el: defined caddr, used in several places but missing
- for some reason.
-
-2002-04-02 Thien-Thi Nguyen <address@hidden>
-
- * doctring.el: List commands in commentary; nfc.
-
-2002-03-15 Neil Jerram <address@hidden>
-
- * guile.texi: Replaced by regenerated libguile version.
-
-2002-03-12 Neil Jerram <address@hidden>
-
- * guile.texi: Replaced by regenerated libguile version.
-
-2002-03-08 Neil Jerram <address@hidden>
-
- * docstring.el (docstring-libguile-directory,
- docstring-display-location, docstring-show-source): New.
-
-2001-11-16 Neil Jerram <address@hidden>
-
- * guile.texi: Replaced by regenerated libguile version.
-
- * docstring.el (make-module-description-list): Exclude @deffn's
- with category {C Function}.
- (docstring-process-alist): Bind key "d" to
- docstring-ediff-this-line in the docstring output buffer.
-
-2001-11-13 Neil Jerram <address@hidden>
-
- * guile.texi: Replaced by libguile version (after automatically
- updating docstrings in the reference manual).
-
-2001-11-07 Neil Jerram <address@hidden>
-
- * guile.texi: Replaced by libguile version (after automatically
- updating docstrings in the reference manual).
-
- * docstring.el (docstring-manual-directory): Added "/ref" to end.
- (docstring-manual-files): Now calculated automatically, since by
- definition all the .texi files in doc/ref are reference manual
- files.
-
-2001-04-03 Martin Grabmueller <address@hidden>
-
- * guile.texi: Automated docstring merging.
-
-2001-03-23 Neil Jerram <address@hidden>
-
- * ChangeLog, README, docstring.el, guile.texi: New files.
-
diff --git a/doc/maint/README b/doc/maint/README
deleted file mode 100644
index adfa13f..0000000
--- a/doc/maint/README
+++ /dev/null
@@ -1,35 +0,0 @@
-README for guile-core/doc/maint -*- text -*-
-
-The files in this directory are used by the maintainers to automate
-the process of updating the Guile reference manual when the docstrings
-in the libguile C source change.
-
-- ChangeLog is the change log for files in this directory.
-
-- README is this file.
-
-- docstring.el is a helpful Emacs Lisp library (see source for
- customization). The two key entry points are:
- `docstring-process-module' and
- `docstring-ediff-this-line'.
-
-- guile.texi is a snapshot of the built file libguile/guile.texi,
- copied last time the reference manual was determined to be in sync
- with the libguile source.
-
-docstring.el requires the setting of an environment variable, e.g.,
-
-export GUILE_MAINTAINER_GUILE_CORE_DIR=$HOME/guile/guile-core
-
-If the build directory differs from the source directory, an additional
-variable is required:
-
-export GUILE_MAINTAINER_BUILD_CORE_DIR=$HOME/guile/guile-core-build
-
-If you've just fixed a docstring in, say, ../libguile/strop.c, do in emacs:
-
- M-x load-file RET .../doc/maint/docstring.el RET
- M-x docstring-process-module RET (guile) RET
-
-Save all modified .texi files and copy the current ../libguile/guile.texi
-to ./guile.texi, then commit. See elisp var `docstring-snarfed-roots'.
diff --git a/doc/maint/docstring.el b/doc/maint/docstring.el
deleted file mode 100644
index ef27193..0000000
--- a/doc/maint/docstring.el
+++ /dev/null
@@ -1,622 +0,0 @@
-;;; docstring.el --- utilities for Guile docstring maintenance
-;;;
-;;; Copyright (C) 2001, 2004 Neil Jerram
-;;;
-;;; This file is not part of GUILE, but the same permissions apply.
-;;;
-;;; GUILE 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, or
-;;; (at your option) any later version.
-;;;
-;;; GUILE 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 GUILE; see the file COPYING.LESSER. If not,
-;;; write to the Free Software Foundation, Inc., 51 Franklin Street,
-;;; Fifth Floor, Boston, MA 02110-1301, USA.
-
-;;; Commentary:
-
-;; The basic premise of these utilities is that - at least in the
-;; short term - we can get a lot of reference manual mileage by
-;; co-opting the docstrings that are snarfed automatically from
-;; Guile's C and Scheme source code. But this leads to problems of
-;; synchronization... How do you track when a docstring has been
-;; updated in the source and so needs updating in the reference
-;; manual. What if a procedure is removed from the Guile source? And
-;; so on. To complicate matters, the exact snarfed docstring text
-;; will probably need to be modified so that it fits into the flow of
-;; the manual section in which it appears. Can we design solutions to
-;; synchronization problems that continue to work even when the manual
-;; text has been enhanced in this way?
-;;
-;; This file implements an approach to this problem that I have found
-;; useful. It involves keeping track of three copies of each
-;; docstring:
-;;
-;; "MANUAL" = the docstring as it appears in the reference manual.
-;;
-;; "SNARFED" = the docstring as snarfed from the current C or Scheme
-;; source.
-;;
-;; "TRACKING" = the docstring as it appears in a tracking file whose
-;; purpose is to record the most recent snarfed docstrings
-;; that are known to be in sync with the reference manual.
-;;
-;; The approaches are as follows.
-;;
-;; 1. Comparison of MANUAL-DOC, SOURCE-DOC and TRACK-DOC, to produce a
-;; summary output buffer in which keystrokes are defined to bring up
-;; detailed comparisons.
-;;
-;; 2. Comparison of MANUAL-DOC, SOURCE-DOC and TRACK-DOC using Ediff.
-;;
-;; Here is a brief list of commands available (via "M-x COMMAND"):
-;;
-;; docstring-process-current-buffer
-;; docstring-process-current-region BEG END
-;; docstring-process-module MODULE
-;; docstring-ediff-this-line
-;; docstring-show-source
-
-
-(defvar guile-core-dir (or (getenv "GUILE_MAINTAINER_GUILE_CORE_DIR")
- (error "GUILE_MAINTAINER_GUILE_CORE_DIR not set"))
- "*Full path of guile-core source directory.")
-
-(defvar guile-build-dir (or (getenv "GUILE_MAINTAINER_BUILD_CORE_DIR")
- guile-core-dir)
- "*Full path of guile-core build directory. Defaults to guile-core-dir.")
-
-(defvar docstring-manual-directory (expand-file-name "doc/ref" guile-core-dir)
- "*The directory containing the Texinfo source for the Guile reference
manual.")
-
-(defvar docstring-tracking-root (expand-file-name "doc/maint" guile-core-dir)
- "*Root directory for docstring tracking files. The tracking file
-for module (a b c) is expected to be in the file
-<docstring-tracking-root>/a/b/c.texi.")
-
-(defvar docstring-snarfed-roots (mapcar
- #'(lambda (frag)
- (expand-file-name frag guile-build-dir))
- '("libguile" "ice-9" "oop"))
- "*List of possible root directories for snarfed docstring files.
-For each entry in this list, the snarfed docstring file for module (a
-b c) is looked for in the file <entry>/a/b/c.texi.")
-
-(defvar docstring-manual-files
- (directory-files docstring-manual-directory nil "\\.texi$" t)
- "List of Texinfo source files that comprise the Guile reference manual.")
-
-(defvar docstring-new-docstrings-file "new-docstrings.texi"
- "The name of a file in the Guile reference manual source directory
-to which new docstrings should be added.")
-
-;; Apply FN in turn to each element in the list CANDIDATES until the
-;; first application that returns non-nil.
-(defun or-map (fn candidates args)
- (let ((result nil))
- (while candidates
- (setq result (apply fn (car candidates) args))
- (if result
- (setq result (cons (car candidates) result)
- candidates nil)
- (setq candidates (cdr candidates))))
- result))
-
-;; Return t if the current buffer position is in the scope of the
-;; specified MODULE, as determined by "@c module-for-docstring ..." comments
in the
-;; buffer. DEFAULT-OK specifies the return value in the case that
-;; there are no preceding module comments at all.
-(defun docstring-in-module (module default-ok)
- (save-excursion
- (if (re-search-backward "address@hidden module-for-docstring " nil t)
- (progn
- (search-forward "@c module-for-docstring ")
- (equal module (read (current-buffer))))
- default-ok)))
-
-;; Find a docstring in the specified FILE-NAME for the item in module
-;; MODULE and with description DESCRIPTION. MODULE should be a list
-;; of symbols, Guile-style, for example: '(ice-9 session).
-;; DESCRIPTION should be the string that is expected after the @deffn,
-;; for example "primitive acons" or "syntax let*".
-(defun find-docstring (file-name module description)
- (and (file-exists-p file-name)
- (let ((buf (find-file-noselect file-name))
- (deffn-regexp (concat "address@hidden "
- (regexp-quote description)
- "[ \n\t]"))
- found
- result)
- (save-excursion
- (set-buffer buf)
- (goto-char (point-min))
- (while (and (not found)
- (re-search-forward deffn-regexp nil t))
- (save-excursion
- (goto-char (match-beginning 0))
- (beginning-of-line)
- (if (docstring-in-module module t)
- (setq found t))))
- (if found
- (setq result
- (list (current-buffer)
- (progn
- (re-search-backward "address@hidden ")
- (beginning-of-line)
- (point))
- (progn
- (re-search-forward "address@hidden deffn")
- (forward-line 1)
- (point))))))
- result)))
-
-;; Find the reference manual version of the specified docstring.
-;; MODULE and DESCRIPTION specify the docstring as per
-;; `find-docstring'. The set of files that `find-manual-docstring'
-;; searches is determined by the value of the `docstring-manual-files'
-;; variable.
-(defun find-manual-docstring (module description)
- (let* ((result
- (or-map 'find-docstring
- (mapcar (function (lambda (file-name)
- (concat docstring-manual-directory
- "/"
- file-name)))
- (cons docstring-new-docstrings-file
- docstring-manual-files))
- (list module
- description)))
- (matched-file-name (and (cdr result)
- (file-name-nondirectory (car result)))))
- (if matched-file-name
- (setq docstring-manual-files
- (cons matched-file-name
- (delete matched-file-name docstring-manual-files))))
- (cdr result)))
-
-;; Convert MODULE to a directory subpath.
-(defun module-to-path (module)
- (mapconcat (function (lambda (component)
- (symbol-name component)))
- module
- "/"))
-
-;; Find the current snarfed version of the specified docstring.
-;; MODULE and DESCRIPTION specify the docstring as per
-;; `find-docstring'. The file that `find-snarfed-docstring' looks in
-;; is automatically generated from MODULE.
-(defun find-snarfed-docstring (module description)
- (let ((modpath (module-to-path module)))
- (cdr (or-map (function (lambda (root)
- (find-docstring (concat root
- "/"
- modpath
- ".texi")
- module
- description)))
- docstring-snarfed-roots
- nil))))
-
-;; Find the tracking version of the specified docstring. MODULE and
-;; DESCRIPTION specify the docstring as per `find-docstring'. The
-;; file that `find-tracking-docstring' looks in is automatically
-;; generated from MODULE.
-(defun find-tracking-docstring (module description)
- (find-docstring (concat docstring-tracking-root
- "/"
- (module-to-path module)
- ".texi")
- module
- description))
-
-;; Extract an alist of modules and descriptions from the current
-;; buffer.
-(defun make-module-description-list ()
- (let ((alist nil)
- (module '(guile)))
- (save-excursion
- (goto-char (point-min))
- (while (re-search-forward "^\\(@c module-for-docstring \\|@deffnx?
\\({[^}]+}\\|[^ ]+\\) \\([^ \n]+\\)\\)"
- nil
- t)
- (let ((matched (buffer-substring (match-beginning 1)
- (match-end 1))))
- (if (string-equal matched "@c module-for-docstring ")
- (setq module (read (current-buffer)))
- (let ((type (buffer-substring (match-beginning 2)
- (match-end 2))))
- (if (string-equal type "{C Function}")
- nil
- (setq matched
- (concat type
- " "
- (buffer-substring (match-beginning 3)
- (match-end 3))))
- (message "Found docstring: %S: %s" module matched)
- (let ((descriptions (assoc module alist)))
- (setq alist
- (cons (cons module (cons matched (cdr-safe
descriptions)))
- (if descriptions
- (delete descriptions alist)
- alist))))))))))
- alist))
-
-;; missing in some environments?
-(defun caddr (list)
- (nth 2 list))
-
-;; Return the docstring from the specified LOCATION. LOCATION is a
-;; list of three elements: buffer, start position and end position.
-(defun location-to-docstring (location)
- (and location
- (save-excursion
- (set-buffer (car location))
- (buffer-substring (cadr location) (caddr location)))))
-
-;; Perform a comparison of the specified docstring. MODULE and
-;; DESCRIPTION are as per usual.
-(defun docstring-compare (module description)
- (let* ((manual-location (find-manual-docstring module description))
- (snarf-location (find-snarfed-docstring module description))
- (track-location (find-tracking-docstring module description))
-
- (manual-docstring (location-to-docstring manual-location))
- (snarf-docstring (location-to-docstring snarf-location))
- (track-docstring (location-to-docstring track-location))
-
- action
- issue)
-
- ;; Decide what to do.
- (cond ((null snarf-location)
- (setq action nil
- issue (if manual-location
- 'consider-removal
- nil)))
-
- ((null manual-location)
- (setq action 'add-to-manual issue nil))
-
- ((null track-location)
- (setq action nil
- issue (if (string-equal manual-docstring snarf-docstring)
- nil
- 'check-needed)))
-
- ((string-equal track-docstring snarf-docstring)
- (setq action nil issue nil))
-
- ((string-equal track-docstring manual-docstring)
- (setq action 'auto-update-manual issue nil))
-
- (t
- (setq action nil issue 'update-needed)))
-
- ;; Return a pair indicating any automatic action that can be
- ;; taken, and any issue for resolution.
- (cons action issue)))
-
-;; Add the specified docstring to the manual.
-(defun docstring-add-to-manual (module description)
- (let ((buf (find-file-noselect (concat docstring-manual-directory
- "/"
- docstring-new-docstrings-file))))
- (save-excursion
- (set-buffer buf)
- (goto-char (point-max))
- (or (docstring-in-module module nil)
- (insert "address@hidden module-for-docstring " (prin1-to-string
module) "\n"))
- (insert "\n" (location-to-docstring (find-snarfed-docstring module
-
description))))))
-
-;; Auto-update the specified docstring in the manual.
-(defun docstring-auto-update-manual (module description)
- (let ((manual-location (find-manual-docstring module description))
- (track-location (find-tracking-docstring module description)))
- (save-excursion
- (set-buffer (car manual-location))
- (goto-char (cadr manual-location))
- (delete-region (cadr manual-location) (caddr manual-location))
- (insert (location-to-docstring (find-snarfed-docstring module
- description))))))
-
-;; Process an alist of modules and descriptions, and produce a summary
-;; buffer describing actions taken and issues to be resolved.
-(defun docstring-process-alist (alist)
- (let (check-needed-list
- update-needed-list
- consider-removal-list
- added-to-manual-list
- auto-updated-manual-list)
-
- (mapcar
- (function (lambda (module-list)
- (let ((module (car module-list)))
- (message "Module: %S" module)
- (mapcar
- (function (lambda (description)
- (message "Comparing docstring: %S: %s" module
description)
- (let* ((ai (docstring-compare module
description))
- (action (car ai))
- (issue (cdr ai)))
-
- (cond ((eq action 'add-to-manual)
- (docstring-add-to-manual module
description)
- (setq added-to-manual-list
- (cons (cons module description)
- added-to-manual-list)))
-
- ((eq action 'auto-update-manual)
- (docstring-auto-update-manual module
description)
- (setq auto-updated-manual-list
- (cons (cons module description)
-
auto-updated-manual-list))))
-
- (cond ((eq issue 'check-needed)
- (setq check-needed-list
- (cons (cons module description)
- check-needed-list)))
-
- ((eq issue 'update-needed)
- (setq update-needed-list
- (cons (cons module description)
- update-needed-list)))
-
- ((eq issue 'consider-removal)
- (setq consider-removal-list
- (cons (cons module description)
-
consider-removal-list)))))))
- (reverse (cdr module-list))))))
- alist)
-
- ;; Prepare a buffer describing the results.
- (set-buffer (get-buffer-create "*Docstring Results*"))
- (erase-buffer)
-
- (insert "
-The following items have been automatically added to the manual in
-file `" docstring-manual-directory "/" docstring-new-docstrings-file "'.\n\n")
- (if added-to-manual-list
- (mapcar (function (lambda (moddesc)
- (insert (prin1-to-string (car moddesc))
- ": "
- (cdr moddesc)
- "\n")))
- added-to-manual-list)
- (insert "(none)\n"))
-
- (insert "
-The following items have been automatically updated in the manual.\n\n")
- (if auto-updated-manual-list
- (mapcar (function (lambda (moddesc)
- (insert (prin1-to-string (car moddesc))
- ": "
- (cdr moddesc)
- "\n")))
- auto-updated-manual-list)
- (insert "(none)\n"))
-
- (insert "
-The following items are already documented in the manual but are not
-mentioned in the reference copy of the snarfed docstrings file.
-You should check that the manual documentation matches the docstring
-in the current snarfed docstrings file.\n\n")
- (if check-needed-list
- (mapcar (function (lambda (moddesc)
- (insert (prin1-to-string (car moddesc))
- ": "
- (cdr moddesc)
- "\n")))
- check-needed-list)
- (insert "(none)\n"))
-
- (insert "
-The following items have manual documentation that is different from
-the docstring in the reference copy of the snarfed docstrings file,
-and the snarfed docstring has changed. You need to update the manual
-documentation by hand with reference to the snarfed docstring changes.\n\n")
- (if update-needed-list
- (mapcar (function (lambda (moddesc)
- (insert (prin1-to-string (car moddesc))
- ": "
- (cdr moddesc)
- "\n")))
- update-needed-list)
- (insert "(none)\n"))
-
- (insert "
-The following items are documented in the manual but are no longer
-present in the snarfed docstrings file. You should consider whether
-the existing manual documentation is still pertinent. If it is, its
-docstring module comment may need updating, to connect it with a
-new snarfed docstring file.\n\n")
- (if consider-removal-list
- (mapcar (function (lambda (moddesc)
- (insert (prin1-to-string (car moddesc))
- ": "
- (cdr moddesc)
- "\n")))
- consider-removal-list)
- (insert "(none)\n"))
- (insert "\n")
-
- (goto-char (point-min))
- (local-set-key "d" 'docstring-ediff-this-line)
-
- ;; Popup the issues buffer.
- (let ((pop-up-frames t))
- (set-window-point (display-buffer (current-buffer))
- (point-min)))))
-
-(defun docstring-process-current-buffer ()
- (interactive)
- (docstring-process-alist (make-module-description-list)))
-
-(defun docstring-process-current-region (beg end)
- (interactive "r")
- (narrow-to-region beg end)
- (unwind-protect
- (save-excursion
- (docstring-process-alist (make-module-description-list)))
- (widen)))
-
-(defun docstring-process-module (module)
- (interactive "xModule: ")
- (let ((modpath (module-to-path module))
- (mdlist nil))
- (mapcar (function (lambda (root)
- (let ((fn (concat root
- "/"
- modpath
- ".texi")))
- (if (file-exists-p fn)
- (save-excursion
- (find-file fn)
- (message "Getting docstring list from %s" fn)
- (setq mdlist
- (append mdlist
-
(make-module-description-list))))))))
- docstring-snarfed-roots)
- (docstring-process-alist mdlist)))
-
-(defun docstring-ediff-this-line ()
- (interactive)
- (let (module
- description)
- (save-excursion
- (beginning-of-line)
- (setq module (read (current-buffer)))
- (forward-char 2)
- (setq description (buffer-substring (point)
- (progn
- (end-of-line)
- (point)))))
-
- (message "Ediff docstring: %S: %s" module description)
-
- (let ((track-location (or (find-tracking-docstring module description)
- (docstring-temp-location "No docstring in
tracking file")))
- (snarf-location (or (find-snarfed-docstring module description)
- (docstring-temp-location "No docstring in
snarfed file")))
- (manual-location (or (find-manual-docstring module description)
- (docstring-temp-location "No docstring in
manual"))))
-
- (setq docstring-ediff-buffers
- (list (car track-location)
- (car snarf-location)
- (car manual-location)))
-
- (docstring-narrow-to-location track-location)
- (docstring-narrow-to-location snarf-location)
- (docstring-narrow-to-location manual-location)
-
- (add-hook 'ediff-quit-hook 'docstring-widen-ediff-buffers)
-
- (ediff-buffers3 (nth 0 docstring-ediff-buffers)
- (nth 1 docstring-ediff-buffers)
- (nth 2 docstring-ediff-buffers)))))
-
-(defun docstring-narrow-to-location (location)
- (save-excursion
- (set-buffer (car location))
- (narrow-to-region (cadr location) (caddr location))))
-
-(defun docstring-temp-location (str)
- (let ((buf (generate-new-buffer "*Docstring Temp*")))
- (save-excursion
- (set-buffer buf)
- (erase-buffer)
- (insert str "\n")
- (list buf (point-min) (point-max)))))
-
-(require 'ediff)
-
-(defvar docstring-ediff-buffers '())
-
-(defun docstring-widen-ediff-buffers ()
- (remove-hook 'ediff-quit-hook 'docstring-widen-ediff-buffers)
- (save-excursion
- (mapcar (function (lambda (buffer)
- (set-buffer buffer)
- (widen)))
- docstring-ediff-buffers)))
-
-
-;;; Tests:
-
-;(find-docstring "/home/neil/Guile/cvs/guile-core/doc/maint/guile.texi" nil
"primitive sloppy-assq")
-;(find-manual-docstring '(guile) "primitive sloppy-assq")
-;(find-tracking-docstring '(guile) "primitive sloppy-assq")
-;(find-snarfed-docstring '(guile) "primitive sloppy-assq")
-
-(defvar docstring-libguile-directory (expand-file-name "libguile"
- guile-core-dir)
- "*The directory containing the C source for libguile.")
-
-(defvar docstring-libguile-build-directory (expand-file-name "libguile"
- guile-build-dir)
- "*The directory containing the libguile build directory.")
-
-(defun docstring-display-location (file line)
- (let ((buffer (find-file-noselect
- (expand-file-name file docstring-libguile-directory))))
- (if buffer
- (let* ((window (or (get-buffer-window buffer)
- (display-buffer buffer)))
- (pos (save-excursion
- (set-buffer buffer)
- (goto-line line)
- (point))))
- (set-window-point window pos)))))
-
-(defun docstring-show-source ()
- "Given that point is sitting in a docstring in one of the Texinfo
-source files for the Guile manual, and that that docstring may be
-snarfed automatically from a libguile C file, determine whether the
-docstring is from libguile and, if it is, display the relevant C file
-at the line from which the docstring was snarfed.
-
-Why? When updating snarfed docstrings, you should usually edit the C
-source rather than the Texinfo source, so that your updates benefit
-Guile's online help as well. This function locates the C source for a
-docstring so that it is easy for you to do this."
- (interactive)
- (let* ((deffn-line
- (save-excursion
- (end-of-line)
- (or (re-search-backward "address@hidden " nil t)
- (error "No docstring here!"))
- (buffer-substring (point)
- (progn
- (end-of-line)
- (point)))))
- (guile-texi-file
- (expand-file-name "guile.texi" docstring-libguile-build-directory))
- (source-location
- (save-excursion
- (set-buffer (find-file-noselect guile-texi-file))
- (save-excursion
- (goto-char (point-min))
- (or (re-search-forward (concat "^"
- (regexp-quote deffn-line)
- "$")
- nil t)
- (error "Docstring not from libguile"))
- (forward-line -1)
- (if (looking-at "address@hidden snarfed from
\\([^:]+\\):\\([0-9]+\\)$")
- (cons (match-string 1)
- (string-to-int (match-string 2)))
- (error "Corrupt docstring entry in guile.texi"))))))
- (docstring-display-location (car source-location)
- (cdr source-location))))
-
-
-(provide 'docstring)
-
-;;; docstring.el ends here
diff --git a/doc/maint/guile.texi b/doc/maint/guile.texi
deleted file mode 100644
index c0570f2..0000000
--- a/doc/maint/guile.texi
+++ /dev/null
@@ -1,11091 +0,0 @@
-
- acons
address@hidden snarfed from alist.c:36
address@hidden {Scheme Procedure} acons key value alist
address@hidden {C Function} scm_acons (key, value, alist)
-Add a new key-value pair to @var{alist}. A new pair is
-created whose car is @var{key} and whose cdr is @var{value}, and the
-pair is consed onto @var{alist}, and the new list is returned. This
-function is @emph{not} destructive; @var{alist} is not modified.
address@hidden deffn
-
- sloppy-assq
address@hidden snarfed from alist.c:50
address@hidden {Scheme Procedure} sloppy-assq key alist
address@hidden {C Function} scm_sloppy_assq (key, alist)
-Behaves like @code{assq} but does not do any error checking.
-Recommended only for use in Guile internals.
address@hidden deffn
-
- sloppy-assv
address@hidden snarfed from alist.c:68
address@hidden {Scheme Procedure} sloppy-assv key alist
address@hidden {C Function} scm_sloppy_assv (key, alist)
-Behaves like @code{assv} but does not do any error checking.
-Recommended only for use in Guile internals.
address@hidden deffn
-
- sloppy-assoc
address@hidden snarfed from alist.c:86
address@hidden {Scheme Procedure} sloppy-assoc key alist
address@hidden {C Function} scm_sloppy_assoc (key, alist)
-Behaves like @code{assoc} but does not do any error checking.
-Recommended only for use in Guile internals.
address@hidden deffn
-
- assq
address@hidden snarfed from alist.c:113
address@hidden {Scheme Procedure} assq key alist
address@hidden {Scheme Procedure} assv key alist
address@hidden {Scheme Procedure} assoc key alist
address@hidden {C Function} scm_assq (key, alist)
-Fetch the entry in @var{alist} that is associated with @var{key}. To
-decide whether the argument @var{key} matches a particular entry in
address@hidden, @code{assq} compares keys with @code{eq?}, @code{assv}
-uses @code{eqv?} and @code{assoc} uses @code{equal?}. If @var{key}
-cannot be found in @var{alist} (according to whichever equality
-predicate is in use), then return @code{#f}. These functions
-return the entire alist entry found (i.e. both the key and the value).
address@hidden deffn
-
- assv
address@hidden snarfed from alist.c:134
address@hidden {Scheme Procedure} assv key alist
address@hidden {C Function} scm_assv (key, alist)
-Behaves like @code{assq} but uses @code{eqv?} for key comparison.
address@hidden deffn
-
- assoc
address@hidden snarfed from alist.c:155
address@hidden {Scheme Procedure} assoc key alist
address@hidden {C Function} scm_assoc (key, alist)
-Behaves like @code{assq} but uses @code{equal?} for key comparison.
address@hidden deffn
-
- assq-ref
address@hidden snarfed from alist.c:199
address@hidden {Scheme Procedure} assq-ref alist key
address@hidden {Scheme Procedure} assv-ref alist key
address@hidden {Scheme Procedure} assoc-ref alist key
address@hidden {C Function} scm_assq_ref (alist, key)
-Like @code{assq}, @code{assv} and @code{assoc}, except that only the
-value associated with @var{key} in @var{alist} is returned. These
-functions are equivalent to
-
address@hidden
-(let ((ent (@var{associator} @var{key} @var{alist})))
- (and ent (cdr ent)))
address@hidden lisp
-
-where @var{associator} is one of @code{assq}, @code{assv} or @code{assoc}.
address@hidden deffn
-
- assv-ref
address@hidden snarfed from alist.c:216
address@hidden {Scheme Procedure} assv-ref alist key
address@hidden {C Function} scm_assv_ref (alist, key)
-Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
address@hidden deffn
-
- assoc-ref
address@hidden snarfed from alist.c:233
address@hidden {Scheme Procedure} assoc-ref alist key
address@hidden {C Function} scm_assoc_ref (alist, key)
-Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
address@hidden deffn
-
- assq-set!
address@hidden snarfed from alist.c:262
address@hidden {Scheme Procedure} assq-set! alist key val
address@hidden {Scheme Procedure} assv-set! alist key value
address@hidden {Scheme Procedure} assoc-set! alist key value
address@hidden {C Function} scm_assq_set_x (alist, key, val)
-Reassociate @var{key} in @var{alist} with @var{value}: find any existing
address@hidden entry for @var{key} and associate it with the new
address@hidden If @var{alist} does not contain an entry for @var{key},
-add a new one. Return the (possibly new) alist.
-
-These functions do not attempt to verify the structure of @var{alist},
-and so may cause unusual results if passed an object that is not an
-association list.
address@hidden deffn
-
- assv-set!
address@hidden snarfed from alist.c:280
address@hidden {Scheme Procedure} assv-set! alist key val
address@hidden {C Function} scm_assv_set_x (alist, key, val)
-Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
address@hidden deffn
-
- assoc-set!
address@hidden snarfed from alist.c:298
address@hidden {Scheme Procedure} assoc-set! alist key val
address@hidden {C Function} scm_assoc_set_x (alist, key, val)
-Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
address@hidden deffn
-
- assq-remove!
address@hidden snarfed from alist.c:322
address@hidden {Scheme Procedure} assq-remove! alist key
address@hidden {Scheme Procedure} assv-remove! alist key
address@hidden {Scheme Procedure} assoc-remove! alist key
address@hidden {C Function} scm_assq_remove_x (alist, key)
-Delete the first entry in @var{alist} associated with @var{key}, and return
-the resulting alist.
address@hidden deffn
-
- assv-remove!
address@hidden snarfed from alist.c:338
address@hidden {Scheme Procedure} assv-remove! alist key
address@hidden {C Function} scm_assv_remove_x (alist, key)
-Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
address@hidden deffn
-
- assoc-remove!
address@hidden snarfed from alist.c:354
address@hidden {Scheme Procedure} assoc-remove! alist key
address@hidden {C Function} scm_assoc_remove_x (alist, key)
-Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
address@hidden deffn
-
- make-arbiter
address@hidden snarfed from arbiters.c:99
address@hidden {Scheme Procedure} make-arbiter name
address@hidden {C Function} scm_make_arbiter (name)
-Return an arbiter object, initially unlocked. Currently
address@hidden is only used for diagnostic output.
address@hidden deffn
-
- try-arbiter
address@hidden snarfed from arbiters.c:116
address@hidden {Scheme Procedure} try-arbiter arb
address@hidden {C Function} scm_try_arbiter (arb)
-If @var{arb} is unlocked, then lock it and return @code{#t}.
-If @var{arb} is already locked, then do nothing and return
address@hidden
address@hidden deffn
-
- release-arbiter
address@hidden snarfed from arbiters.c:142
address@hidden {Scheme Procedure} release-arbiter arb
address@hidden {C Function} scm_release_arbiter (arb)
-If @var{arb} is locked, then unlock it and return @code{#t}.
-If @var{arb} is already unlocked, then do nothing and return
address@hidden
-
-Typical usage is for the thread which locked an arbiter to
-later release it, but that's not required, any thread can
-release it.
address@hidden deffn
-
- async
address@hidden snarfed from async.c:97
address@hidden {Scheme Procedure} async thunk
address@hidden {C Function} scm_async (thunk)
-Create a new async for the procedure @var{thunk}.
address@hidden deffn
-
- async-mark
address@hidden snarfed from async.c:106
address@hidden {Scheme Procedure} async-mark a
address@hidden {C Function} scm_async_mark (a)
-Mark the async @var{a} for future execution.
address@hidden deffn
-
- run-asyncs
address@hidden snarfed from async.c:117
address@hidden {Scheme Procedure} run-asyncs list_of_a
address@hidden {C Function} scm_run_asyncs (list_of_a)
-Execute all thunks from the asyncs of the list @var{list_of_a}.
address@hidden deffn
-
- system-async
address@hidden snarfed from async.c:180
address@hidden {Scheme Procedure} system-async thunk
address@hidden {C Function} scm_system_async (thunk)
-This function is deprecated. You can use @var{thunk} directly
-instead of explicitly creating an async object.
-
address@hidden deffn
-
- system-async-mark
address@hidden snarfed from async.c:296
address@hidden {Scheme Procedure} system-async-mark proc [thread]
address@hidden {C Function} scm_system_async_mark_for_thread (proc, thread)
-Mark @var{proc} (a procedure with zero arguments) for future execution
-in @var{thread}. If @var{proc} has already been marked for
address@hidden but has not been executed yet, this call has no effect.
-If @var{thread} is omitted, the thread that called
address@hidden is used.
-
-This procedure is not safe to be called from C signal handlers. Use
address@hidden or @code{scm_sigaction_for_thread} to install
-signal handlers.
address@hidden deffn
-
- noop
address@hidden snarfed from async.c:335
address@hidden {Scheme Procedure} noop . args
address@hidden {C Function} scm_noop (args)
-Do nothing. When called without arguments, return @code{#f},
-otherwise return the first argument.
address@hidden deffn
-
- unmask-signals
address@hidden snarfed from async.c:350
address@hidden {Scheme Procedure} unmask-signals
address@hidden {C Function} scm_unmask_signals ()
-Unmask signals. The returned value is not specified.
address@hidden deffn
-
- mask-signals
address@hidden snarfed from async.c:370
address@hidden {Scheme Procedure} mask-signals
address@hidden {C Function} scm_mask_signals ()
-Mask signals. The returned value is not specified.
address@hidden deffn
-
- call-with-blocked-asyncs
address@hidden snarfed from async.c:404
address@hidden {Scheme Procedure} call-with-blocked-asyncs proc
address@hidden {C Function} scm_call_with_blocked_asyncs (proc)
-Call @var{proc} with no arguments and block the execution
-of system asyncs by one level for the current thread while
-it is running. Return the value returned by @var{proc}.
-
address@hidden deffn
-
- call-with-unblocked-asyncs
address@hidden snarfed from async.c:430
address@hidden {Scheme Procedure} call-with-unblocked-asyncs proc
address@hidden {C Function} scm_call_with_unblocked_asyncs (proc)
-Call @var{proc} with no arguments and unblock the execution
-of system asyncs by one level for the current thread while
-it is running. Return the value returned by @var{proc}.
-
address@hidden deffn
-
- display-error
address@hidden snarfed from backtrace.c:303
address@hidden {Scheme Procedure} display-error stack port subr message args
rest
address@hidden {C Function} scm_display_error (stack, port, subr, message,
args, rest)
-Display an error message to the output port @var{port}.
address@hidden is the saved stack for the error, @var{subr} is
-the name of the procedure in which the error occurred and
address@hidden is the actual error message, which may contain
-formatting instructions. These will format the arguments in
-the list @var{args} accordingly. @var{rest} is currently
-ignored.
address@hidden deffn
-
- display-application
address@hidden snarfed from backtrace.c:425
address@hidden {Scheme Procedure} display-application frame [port [indent]]
address@hidden {C Function} scm_display_application (frame, port, indent)
-Display a procedure application @var{frame} to the output port
address@hidden @var{indent} specifies the indentation of the
-output.
address@hidden deffn
-
- display-backtrace
address@hidden snarfed from backtrace.c:740
address@hidden {Scheme Procedure} display-backtrace stack port [first [depth
[highlights]]]
address@hidden {C Function} scm_display_backtrace_with_highlights (stack, port,
first, depth, highlights)
-Display a backtrace to the output port @var{port}. @var{stack}
-is the stack to take the backtrace from, @var{first} specifies
-where in the stack to start and @var{depth} how much frames
-to display. Both @var{first} and @var{depth} can be @code{#f},
-which means that default values will be used.
-When @var{highlights} is given,
-it should be a list and all members of it are highligthed in
-the backtrace.
address@hidden deffn
-
- backtrace
address@hidden snarfed from backtrace.c:776
address@hidden {Scheme Procedure} backtrace [highlights]
address@hidden {C Function} scm_backtrace_with_highlights (highlights)
-Display a backtrace of the stack saved by the last error
-to the current output port. When @var{highlights} is given,
-it should be a list and all members of it are highligthed in
-the backtrace.
address@hidden deffn
-
- not
address@hidden snarfed from boolean.c:33
address@hidden {Scheme Procedure} not x
address@hidden {C Function} scm_not (x)
-Return @code{#t} iff @var{x} is @code{#f}, else return @code{#f}.
address@hidden deffn
-
- boolean?
address@hidden snarfed from boolean.c:43
address@hidden {Scheme Procedure} boolean? obj
address@hidden {C Function} scm_boolean_p (obj)
-Return @code{#t} iff @var{obj} is either @code{#t} or @code{#f}.
address@hidden deffn
-
- char?
address@hidden snarfed from chars.c:33
address@hidden {Scheme Procedure} char? x
address@hidden {C Function} scm_char_p (x)
-Return @code{#t} iff @var{x} is a character, else @code{#f}.
address@hidden deffn
-
- char=?
address@hidden snarfed from chars.c:42
address@hidden {Scheme Procedure} char=? x y
-Return @code{#t} iff @var{x} is the same character as @var{y}, else @code{#f}.
address@hidden deffn
-
- char<?
address@hidden snarfed from chars.c:55
address@hidden {Scheme Procedure} char<? x y
-Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence,
-else @code{#f}.
address@hidden deffn
-
- char<=?
address@hidden snarfed from chars.c:67
address@hidden {Scheme Procedure} char<=? x y
-Return @code{#t} iff @var{x} is less than or equal to @var{y} in the
-ASCII sequence, else @code{#f}.
address@hidden deffn
-
- char>?
address@hidden snarfed from chars.c:79
address@hidden {Scheme Procedure} char>? x y
-Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII
-sequence, else @code{#f}.
address@hidden deffn
-
- char>=?
address@hidden snarfed from chars.c:91
address@hidden {Scheme Procedure} char>=? x y
-Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the
-ASCII sequence, else @code{#f}.
address@hidden deffn
-
- char-ci=?
address@hidden snarfed from chars.c:103
address@hidden {Scheme Procedure} char-ci=? x y
-Return @code{#t} iff @var{x} is the same character as @var{y} ignoring
-case, else @code{#f}.
address@hidden deffn
-
- char-ci<?
address@hidden snarfed from chars.c:115
address@hidden {Scheme Procedure} char-ci<? x y
-Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence
-ignoring case, else @code{#f}.
address@hidden deffn
-
- char-ci<=?
address@hidden snarfed from chars.c:127
address@hidden {Scheme Procedure} char-ci<=? x y
-Return @code{#t} iff @var{x} is less than or equal to @var{y} in the
-ASCII sequence ignoring case, else @code{#f}.
address@hidden deffn
-
- char-ci>?
address@hidden snarfed from chars.c:139
address@hidden {Scheme Procedure} char-ci>? x y
-Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII
-sequence ignoring case, else @code{#f}.
address@hidden deffn
-
- char-ci>=?
address@hidden snarfed from chars.c:151
address@hidden {Scheme Procedure} char-ci>=? x y
-Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the
-ASCII sequence ignoring case, else @code{#f}.
address@hidden deffn
-
- char-alphabetic?
address@hidden snarfed from chars.c:163
address@hidden {Scheme Procedure} char-alphabetic? chr
address@hidden {C Function} scm_char_alphabetic_p (chr)
-Return @code{#t} iff @var{chr} is alphabetic, else @code{#f}.
-
address@hidden deffn
-
- char-numeric?
address@hidden snarfed from chars.c:172
address@hidden {Scheme Procedure} char-numeric? chr
address@hidden {C Function} scm_char_numeric_p (chr)
-Return @code{#t} iff @var{chr} is numeric, else @code{#f}.
-
address@hidden deffn
-
- char-whitespace?
address@hidden snarfed from chars.c:181
address@hidden {Scheme Procedure} char-whitespace? chr
address@hidden {C Function} scm_char_whitespace_p (chr)
-Return @code{#t} iff @var{chr} is whitespace, else @code{#f}.
-
address@hidden deffn
-
- char-upper-case?
address@hidden snarfed from chars.c:192
address@hidden {Scheme Procedure} char-upper-case? chr
address@hidden {C Function} scm_char_upper_case_p (chr)
-Return @code{#t} iff @var{chr} is uppercase, else @code{#f}.
-
address@hidden deffn
-
- char-lower-case?
address@hidden snarfed from chars.c:202
address@hidden {Scheme Procedure} char-lower-case? chr
address@hidden {C Function} scm_char_lower_case_p (chr)
-Return @code{#t} iff @var{chr} is lowercase, else @code{#f}.
-
address@hidden deffn
-
- char-is-both?
address@hidden snarfed from chars.c:213
address@hidden {Scheme Procedure} char-is-both? chr
address@hidden {C Function} scm_char_is_both_p (chr)
-Return @code{#t} iff @var{chr} is either uppercase or lowercase, else
@code{#f}.
-
address@hidden deffn
-
- char->integer
address@hidden snarfed from chars.c:228
address@hidden {Scheme Procedure} char->integer chr
address@hidden {C Function} scm_char_to_integer (chr)
-Return the number corresponding to ordinal position of @var{chr} in the
-ASCII sequence.
address@hidden deffn
-
- integer->char
address@hidden snarfed from chars.c:240
address@hidden {Scheme Procedure} integer->char n
address@hidden {C Function} scm_integer_to_char (n)
-Return the character at position @var{n} in the ASCII sequence.
address@hidden deffn
-
- char-upcase
address@hidden snarfed from chars.c:250
address@hidden {Scheme Procedure} char-upcase chr
address@hidden {C Function} scm_char_upcase (chr)
-Return the uppercase character version of @var{chr}.
address@hidden deffn
-
- char-downcase
address@hidden snarfed from chars.c:261
address@hidden {Scheme Procedure} char-downcase chr
address@hidden {C Function} scm_char_downcase (chr)
-Return the lowercase character version of @var{chr}.
address@hidden deffn
-
- with-continuation-barrier
address@hidden snarfed from continuations.c:412
address@hidden {Scheme Procedure} with-continuation-barrier proc
address@hidden {C Function} scm_with_continuation_barrier (proc)
-Call @var{proc} and return its result. Do not allow the invocation of
-continuations that would leave or enter the dynamic extent of the call
-to @code{with-continuation-barrier}. Such an attempt causes an error
-to be signaled.
-
-Throws (such as errors) that are not caught from within @var{proc} are
-caught by @code{with-continuation-barrier}. In that case, a short
-message is printed to the current error port and @code{#f} is returned.
-
-Thus, @code{with-continuation-barrier} returns exactly once.
-
address@hidden deffn
-
- debug-options-interface
address@hidden snarfed from debug.c:54
address@hidden {Scheme Procedure} debug-options-interface [setting]
address@hidden {C Function} scm_debug_options (setting)
-Option interface for the debug options. Instead of using
-this procedure directly, use the procedures @code{debug-enable},
address@hidden, @code{debug-set!} and @code{debug-options}.
address@hidden deffn
-
- with-traps
address@hidden snarfed from debug.c:101
address@hidden {Scheme Procedure} with-traps thunk
address@hidden {C Function} scm_with_traps (thunk)
-Call @var{thunk} with traps enabled.
address@hidden deffn
-
- memoized?
address@hidden snarfed from debug.c:139
address@hidden {Scheme Procedure} memoized? obj
address@hidden {C Function} scm_memoized_p (obj)
-Return @code{#t} if @var{obj} is memoized.
address@hidden deffn
-
- unmemoize-expr
address@hidden snarfed from debug.c:271
address@hidden {Scheme Procedure} unmemoize-expr m
address@hidden {C Function} scm_i_unmemoize_expr (m)
-Unmemoize the memoized expression @var{m},
address@hidden deffn
-
- memoized-environment
address@hidden snarfed from debug.c:281
address@hidden {Scheme Procedure} memoized-environment m
address@hidden {C Function} scm_memoized_environment (m)
-Return the environment of the memoized expression @var{m}.
address@hidden deffn
-
- procedure-name
address@hidden snarfed from debug.c:291
address@hidden {Scheme Procedure} procedure-name proc
address@hidden {C Function} scm_procedure_name (proc)
-Return the name of the procedure @var{proc}
address@hidden deffn
-
- procedure-source
address@hidden snarfed from debug.c:317
address@hidden {Scheme Procedure} procedure-source proc
address@hidden {C Function} scm_procedure_source (proc)
-Return the source of the procedure @var{proc}.
address@hidden deffn
-
- procedure-environment
address@hidden snarfed from debug.c:374
address@hidden {Scheme Procedure} procedure-environment proc
address@hidden {C Function} scm_procedure_environment (proc)
-Return the environment of the procedure @var{proc}.
address@hidden deffn
-
- local-eval
address@hidden snarfed from debug.c:406
address@hidden {Scheme Procedure} local-eval exp [env]
address@hidden {C Function} scm_local_eval (exp, env)
-Evaluate @var{exp} in its environment. If @var{env} is supplied,
-it is the environment in which to evaluate @var{exp}. Otherwise,
address@hidden must be a memoized code object (in which case, its environment
-is implicit).
address@hidden deffn
-
- debug-object?
address@hidden snarfed from debug.c:493
address@hidden {Scheme Procedure} debug-object? obj
address@hidden {C Function} scm_debug_object_p (obj)
-Return @code{#t} if @var{obj} is a debug object.
address@hidden deffn
-
- issue-deprecation-warning
address@hidden snarfed from deprecation.c:99
address@hidden {Scheme Procedure} issue-deprecation-warning . msgs
address@hidden {C Function} scm_issue_deprecation_warning (msgs)
-Output @var{msgs} to @code{(current-error-port)} when this is the first call
to @code{issue-deprecation-warning} with this specific @var{msgs}. Do nothing
otherwise. The argument @var{msgs} should be a list of strings; they are
printed in turn, each one followed by a newline.
address@hidden deffn
-
- include-deprecated-features
address@hidden snarfed from deprecation.c:144
address@hidden {Scheme Procedure} include-deprecated-features
address@hidden {C Function} scm_include_deprecated_features ()
-Return @code{#t} iff deprecated features should be included in public
interfaces.
address@hidden deffn
-
- substring-move-left!
address@hidden snarfed from deprecated.c:73
address@hidden {Scheme Procedure} substring-move-left!
-implemented by the C function "scm_substring_move_x"
address@hidden deffn
-
- substring-move-right!
address@hidden snarfed from deprecated.c:75
address@hidden {Scheme Procedure} substring-move-right!
-implemented by the C function "scm_substring_move_x"
address@hidden deffn
-
- c-registered-modules
address@hidden snarfed from deprecated.c:178
address@hidden {Scheme Procedure} c-registered-modules
address@hidden {C Function} scm_registered_modules ()
-Return a list of the object code modules that have been imported into
-the current Guile process. Each element of the list is a pair whose
-car is the name of the module, and whose cdr is the function handle
-for that module's initializer function. The name is the string that
-has been passed to scm_register_module_xxx.
address@hidden deffn
-
- c-clear-registered-modules
address@hidden snarfed from deprecated.c:199
address@hidden {Scheme Procedure} c-clear-registered-modules
address@hidden {C Function} scm_clear_registered_modules ()
-Destroy the list of modules registered with the current Guile process.
-The return value is unspecified. @strong{Warning:} this function does
-not actually unlink or deallocate these modules, but only destroys the
-records of which modules have been loaded. It should therefore be used
-only by module bookkeeping operations.
address@hidden deffn
-
- close-all-ports-except
address@hidden snarfed from deprecated.c:342
address@hidden {Scheme Procedure} close-all-ports-except . ports
address@hidden {C Function} scm_close_all_ports_except (ports)
-[DEPRECATED] Close all open file ports used by the interpreter
-except for those supplied as arguments. This procedure
-was intended to be used before an exec call to close file descriptors
-which are not needed in the new process. However it has the
-undesirable side effect of flushing buffers, so it's deprecated.
-Use port-for-each instead.
address@hidden deffn
-
- variable-set-name-hint!
address@hidden snarfed from deprecated.c:359
address@hidden {Scheme Procedure} variable-set-name-hint! var hint
address@hidden {C Function} scm_variable_set_name_hint (var, hint)
-Do not use this function.
address@hidden deffn
-
- builtin-variable
address@hidden snarfed from deprecated.c:372
address@hidden {Scheme Procedure} builtin-variable name
address@hidden {C Function} scm_builtin_variable (name)
-Do not use this function.
address@hidden deffn
-
- sloppy-memq
address@hidden snarfed from deprecated.c:446
address@hidden {Scheme Procedure} sloppy-memq x lst
address@hidden {C Function} scm_sloppy_memq (x, lst)
-This procedure behaves like @code{memq}, but does no type or error checking.
-Its use is recommended only in writing Guile internals,
-not for high-level Scheme programs.
address@hidden deffn
-
- sloppy-memv
address@hidden snarfed from deprecated.c:466
address@hidden {Scheme Procedure} sloppy-memv x lst
address@hidden {C Function} scm_sloppy_memv (x, lst)
-This procedure behaves like @code{memv}, but does no type or error checking.
-Its use is recommended only in writing Guile internals,
-not for high-level Scheme programs.
address@hidden deffn
-
- sloppy-member
address@hidden snarfed from deprecated.c:486
address@hidden {Scheme Procedure} sloppy-member x lst
address@hidden {C Function} scm_sloppy_member (x, lst)
-This procedure behaves like @code{member}, but does no type or error checking.
-Its use is recommended only in writing Guile internals,
-not for high-level Scheme programs.
address@hidden deffn
-
- read-and-eval!
address@hidden snarfed from deprecated.c:508
address@hidden {Scheme Procedure} read-and-eval! [port]
address@hidden {C Function} scm_read_and_eval_x (port)
-Read a form from @var{port} (standard input by default), and evaluate it
-(memoizing it in the process) in the top-level environment. If no data
-is left to be read from @var{port}, an @code{end-of-file} error is
-signalled.
address@hidden deffn
-
- string->obarray-symbol
address@hidden snarfed from deprecated.c:825
address@hidden {Scheme Procedure} string->obarray-symbol o s [softp]
address@hidden {C Function} scm_string_to_obarray_symbol (o, s, softp)
-Intern a new symbol in @var{obarray}, a symbol table, with name
address@hidden
-
-If @var{obarray} is @code{#f}, use the default system symbol table. If
address@hidden is @code{#t}, the symbol should not be interned in any
-symbol table; merely return the pair (@var{symbol}
-. @var{#<undefined>}).
-
-The @var{soft?} argument determines whether new symbol table entries
-should be created when the specified symbol is not already present in
address@hidden If @var{soft?} is specified and is a true value, then
-new entries should not be added for symbols not already present in the
-table; instead, simply return @code{#f}.
address@hidden deffn
-
- intern-symbol
address@hidden snarfed from deprecated.c:863
address@hidden {Scheme Procedure} intern-symbol o s
address@hidden {C Function} scm_intern_symbol (o, s)
-Add a new symbol to @var{obarray} with name @var{string}, bound to an
-unspecified initial value. The symbol table is not modified if a symbol
-with this name is already present.
address@hidden deffn
-
- unintern-symbol
address@hidden snarfed from deprecated.c:905
address@hidden {Scheme Procedure} unintern-symbol o s
address@hidden {C Function} scm_unintern_symbol (o, s)
-Remove the symbol with name @var{string} from @var{obarray}. This
-function returns @code{#t} if the symbol was present and @code{#f}
-otherwise.
address@hidden deffn
-
- symbol-binding
address@hidden snarfed from deprecated.c:950
address@hidden {Scheme Procedure} symbol-binding o s
address@hidden {C Function} scm_symbol_binding (o, s)
-Look up in @var{obarray} the symbol whose name is @var{string}, and
-return the value to which it is bound. If @var{obarray} is @code{#f},
-use the global symbol table. If @var{string} is not interned in
address@hidden, an error is signalled.
address@hidden deffn
-
- symbol-bound?
address@hidden snarfed from deprecated.c:1003
address@hidden {Scheme Procedure} symbol-bound? o s
address@hidden {C Function} scm_symbol_bound_p (o, s)
-Return @code{#t} if @var{obarray} contains a symbol with name
address@hidden bound to a defined value. This differs from
address@hidden in that the mere mention of a symbol
-usually causes it to be interned; @code{symbol-bound?}
-determines whether a symbol has been given any meaningful
-value.
address@hidden deffn
-
- symbol-set!
address@hidden snarfed from deprecated.c:1030
address@hidden {Scheme Procedure} symbol-set! o s v
address@hidden {C Function} scm_symbol_set_x (o, s, v)
-Find the symbol in @var{obarray} whose name is @var{string}, and rebind
-it to @var{value}. An error is signalled if @var{string} is not present
-in @var{obarray}.
address@hidden deffn
-
- gentemp
address@hidden snarfed from deprecated.c:1063
address@hidden {Scheme Procedure} gentemp [prefix [obarray]]
address@hidden {C Function} scm_gentemp (prefix, obarray)
-Create a new symbol with a name unique in an obarray.
-The name is constructed from an optional string @var{prefix}
-and a counter value. The default prefix is @code{t}. The
address@hidden is specified as a second optional argument.
-Default is the system obarray where all normal symbols are
-interned. The counter is increased by 1 at each
-call. There is no provision for resetting the counter.
address@hidden deffn
-
- make-keyword-from-dash-symbol
address@hidden snarfed from discouraged.c:161
address@hidden {Scheme Procedure} make-keyword-from-dash-symbol symbol
address@hidden {C Function} scm_make_keyword_from_dash_symbol (symbol)
-Make a keyword object from a @var{symbol} that starts with a dash.
address@hidden deffn
-
- keyword-dash-symbol
address@hidden snarfed from discouraged.c:183
address@hidden {Scheme Procedure} keyword-dash-symbol keyword
address@hidden {C Function} scm_keyword_dash_symbol (keyword)
-Return the dash symbol for @var{keyword}.
-This is the inverse of @code{make-keyword-from-dash-symbol}.
address@hidden deffn
-
- dynamic-link
address@hidden snarfed from dynl.c:149
address@hidden {Scheme Procedure} dynamic-link filename
address@hidden {C Function} scm_dynamic_link (filename)
-Find the shared object (shared library) denoted by
address@hidden and link it into the running Guile
-application. The returned
-scheme object is a ``handle'' for the library which can
-be passed to @code{dynamic-func}, @code{dynamic-call} etc.
-
-Searching for object files is system dependent. Normally,
-if @var{filename} does have an explicit directory it will
-be searched for in locations
-such as @file{/usr/lib} and @file{/usr/local/lib}.
address@hidden deffn
-
- dynamic-object?
address@hidden snarfed from dynl.c:168
address@hidden {Scheme Procedure} dynamic-object? obj
address@hidden {C Function} scm_dynamic_object_p (obj)
-Return @code{#t} if @var{obj} is a dynamic object handle,
-or @code{#f} otherwise.
address@hidden deffn
-
- dynamic-unlink
address@hidden snarfed from dynl.c:182
address@hidden {Scheme Procedure} dynamic-unlink dobj
address@hidden {C Function} scm_dynamic_unlink (dobj)
-Unlink a dynamic object from the application, if possible. The
-object must have been linked by @code{dynamic-link}, with
address@hidden the corresponding handle. After this procedure
-is called, the handle can no longer be used to access the
-object.
address@hidden deffn
-
- dynamic-func
address@hidden snarfed from dynl.c:207
address@hidden {Scheme Procedure} dynamic-func name dobj
address@hidden {C Function} scm_dynamic_func (name, dobj)
-Return a ``handle'' for the function @var{name} in the
-shared object referred to by @var{dobj}. The handle
-can be passed to @code{dynamic-call} to actually
-call the function.
-
-Regardless whether your C compiler prepends an underscore
address@hidden to the global names in a program, you should
address@hidden include this underscore in @var{name}
-since it will be added automatically when necessary.
address@hidden deffn
-
- dynamic-call
address@hidden snarfed from dynl.c:253
address@hidden {Scheme Procedure} dynamic-call func dobj
address@hidden {C Function} scm_dynamic_call (func, dobj)
-Call a C function in a dynamic object. Two styles of
-invocation are supported:
-
address@hidden @bullet
address@hidden @var{func} can be a function handle returned by
address@hidden In this case @var{dobj} is
-ignored
address@hidden @var{func} can be a string with the name of the
-function to call, with @var{dobj} the handle of the
-dynamic object in which to find the function.
-This is equivalent to
address@hidden
-
-(dynamic-call (dynamic-func @var{func} @var{dobj}) #f)
address@hidden smallexample
address@hidden itemize
-
-In either case, the function is passed no arguments
-and its return value is ignored.
address@hidden deffn
-
- dynamic-args-call
address@hidden snarfed from dynl.c:285
address@hidden {Scheme Procedure} dynamic-args-call func dobj args
address@hidden {C Function} scm_dynamic_args_call (func, dobj, args)
-Call the C function indicated by @var{func} and @var{dobj},
-just like @code{dynamic-call}, but pass it some arguments and
-return its return value. The C function is expected to take
-two arguments and return an @code{int}, just like @code{main}:
address@hidden
-int c_func (int argc, char **argv);
address@hidden smallexample
-
-The parameter @var{args} must be a list of strings and is
-converted into an array of @code{char *}. The array is passed
-in @var{argv} and its size in @var{argc}. The return value is
-converted to a Scheme number and returned from the call to
address@hidden
address@hidden deffn
-
- dynamic-wind
address@hidden snarfed from dynwind.c:97
address@hidden {Scheme Procedure} dynamic-wind in_guard thunk out_guard
address@hidden {C Function} scm_dynamic_wind (in_guard, thunk, out_guard)
-All three arguments must be 0-argument procedures.
address@hidden is called, then @var{thunk}, then
address@hidden
-
-If, any time during the execution of @var{thunk}, the
-continuation of the @code{dynamic_wind} expression is escaped
-non-locally, @var{out_guard} is called. If the continuation of
-the dynamic-wind is re-entered, @var{in_guard} is called. Thus
address@hidden and @var{out_guard} may be called any number of
-times.
address@hidden
-(define x 'normal-binding)
address@hidden x
-(define a-cont (call-with-current-continuation
- (lambda (escape)
- (let ((old-x x))
- (dynamic-wind
- ;; in-guard:
- ;;
- (lambda () (set! x 'special-binding))
-
- ;; thunk
- ;;
- (lambda () (display x) (newline)
- (call-with-current-continuation escape)
- (display x) (newline)
- x)
-
- ;; out-guard:
- ;;
- (lambda () (set! x old-x)))))))
-
-;; Prints:
-special-binding
-;; Evaluates to:
address@hidden a-cont
-x
address@hidden normal-binding
-(a-cont #f)
-;; Prints:
-special-binding
-;; Evaluates to:
address@hidden a-cont ;; the value of the (define a-cont...)
-x
address@hidden normal-binding
-a-cont
address@hidden special-binding
address@hidden lisp
address@hidden deffn
-
- environment?
address@hidden snarfed from environments.c:106
address@hidden {Scheme Procedure} environment? obj
address@hidden {C Function} scm_environment_p (obj)
-Return @code{#t} if @var{obj} is an environment, or @code{#f}
-otherwise.
address@hidden deffn
-
- environment-bound?
address@hidden snarfed from environments.c:117
address@hidden {Scheme Procedure} environment-bound? env sym
address@hidden {C Function} scm_environment_bound_p (env, sym)
-Return @code{#t} if @var{sym} is bound in @var{env}, or
address@hidden otherwise.
address@hidden deffn
-
- environment-ref
address@hidden snarfed from environments.c:132
address@hidden {Scheme Procedure} environment-ref env sym
address@hidden {C Function} scm_environment_ref (env, sym)
-Return the value of the location bound to @var{sym} in
address@hidden If @var{sym} is unbound in @var{env}, signal an
address@hidden:unbound} error.
address@hidden deffn
-
- environment-fold
address@hidden snarfed from environments.c:202
address@hidden {Scheme Procedure} environment-fold env proc init
address@hidden {C Function} scm_environment_fold (env, proc, init)
-Iterate over all the bindings in @var{env}, accumulating some
-value.
-For each binding in @var{env}, apply @var{proc} to the symbol
-bound, its value, and the result from the previous application
-of @var{proc}.
-Use @var{init} as @var{proc}'s third argument the first time
address@hidden is applied.
-If @var{env} contains no bindings, this function simply returns
address@hidden
-If @var{env} binds the symbol sym1 to the value val1, sym2 to
-val2, and so on, then this procedure computes:
address@hidden
- (proc sym1 val1
- (proc sym2 val2
- ...
- (proc symn valn
- init)))
address@hidden lisp
-Each binding in @var{env} will be processed exactly once.
address@hidden makes no guarantees about the order in
-which the bindings are processed.
-Here is a function which, given an environment, constructs an
-association list representing that environment's bindings,
-using environment-fold:
address@hidden
- (define (environment->alist env)
- (environment-fold env
- (lambda (sym val tail)
- (cons (cons sym val) tail))
- '()))
address@hidden lisp
address@hidden deffn
-
- environment-define
address@hidden snarfed from environments.c:237
address@hidden {Scheme Procedure} environment-define env sym val
address@hidden {C Function} scm_environment_define (env, sym, val)
-Bind @var{sym} to a new location containing @var{val} in
address@hidden If @var{sym} is already bound to another location
-in @var{env} and the binding is mutable, that binding is
-replaced. The new binding and location are both mutable. The
-return value is unspecified.
-If @var{sym} is already bound in @var{env}, and the binding is
-immutable, signal an @code{environment:immutable-binding} error.
address@hidden deffn
-
- environment-undefine
address@hidden snarfed from environments.c:263
address@hidden {Scheme Procedure} environment-undefine env sym
address@hidden {C Function} scm_environment_undefine (env, sym)
-Remove any binding for @var{sym} from @var{env}. If @var{sym}
-is unbound in @var{env}, do nothing. The return value is
-unspecified.
-If @var{sym} is already bound in @var{env}, and the binding is
-immutable, signal an @code{environment:immutable-binding} error.
address@hidden deffn
-
- environment-set!
address@hidden snarfed from environments.c:291
address@hidden {Scheme Procedure} environment-set! env sym val
address@hidden {C Function} scm_environment_set_x (env, sym, val)
-If @var{env} binds @var{sym} to some location, change that
-location's value to @var{val}. The return value is
-unspecified.
-If @var{sym} is not bound in @var{env}, signal an
address@hidden:unbound} error. If @var{env} binds @var{sym}
-to an immutable location, signal an
address@hidden:immutable-location} error.
address@hidden deffn
-
- environment-cell
address@hidden snarfed from environments.c:326
address@hidden {Scheme Procedure} environment-cell env sym for_write
address@hidden {C Function} scm_environment_cell (env, sym, for_write)
-Return the value cell which @var{env} binds to @var{sym}, or
address@hidden if the binding does not live in a value cell.
-The argument @var{for-write} indicates whether the caller
-intends to modify the variable's value by mutating the value
-cell. If the variable is immutable, then
address@hidden signals an
address@hidden:immutable-location} error.
-If @var{sym} is unbound in @var{env}, signal an
address@hidden:unbound} error.
-If you use this function, you should consider using
address@hidden, to be notified when @var{sym} gets
-re-bound to a new value cell, or becomes undefined.
address@hidden deffn
-
- environment-observe
address@hidden snarfed from environments.c:378
address@hidden {Scheme Procedure} environment-observe env proc
address@hidden {C Function} scm_environment_observe (env, proc)
-Whenever @var{env}'s bindings change, apply @var{proc} to
address@hidden
-This function returns an object, token, which you can pass to
address@hidden to remove @var{proc} from the set
-of procedures observing @var{env}. The type and value of
-token is unspecified.
address@hidden deffn
-
- environment-observe-weak
address@hidden snarfed from environments.c:395
address@hidden {Scheme Procedure} environment-observe-weak env proc
address@hidden {C Function} scm_environment_observe_weak (env, proc)
-This function is the same as environment-observe, except that
-the reference @var{env} retains to @var{proc} is a weak
-reference. This means that, if there are no other live,
-non-weak references to @var{proc}, it will be
-garbage-collected, and dropped from @var{env}'s
-list of observing procedures.
address@hidden deffn
-
- environment-unobserve
address@hidden snarfed from environments.c:431
address@hidden {Scheme Procedure} environment-unobserve token
address@hidden {C Function} scm_environment_unobserve (token)
-Cancel the observation request which returned the value
address@hidden The return value is unspecified.
-If a call @code{(environment-observe env proc)} returns
address@hidden, then the call @code{(environment-unobserve token)}
-will cause @var{proc} to no longer be called when @var{env}'s
-bindings change.
address@hidden deffn
-
- make-leaf-environment
address@hidden snarfed from environments.c:1017
address@hidden {Scheme Procedure} make-leaf-environment
address@hidden {C Function} scm_make_leaf_environment ()
-Create a new leaf environment, containing no bindings.
-All bindings and locations created in the new environment
-will be mutable.
address@hidden deffn
-
- leaf-environment?
address@hidden snarfed from environments.c:1040
address@hidden {Scheme Procedure} leaf-environment? object
address@hidden {C Function} scm_leaf_environment_p (object)
-Return @code{#t} if object is a leaf environment, or @code{#f}
-otherwise.
address@hidden deffn
-
- make-eval-environment
address@hidden snarfed from environments.c:1405
address@hidden {Scheme Procedure} make-eval-environment local imported
address@hidden {C Function} scm_make_eval_environment (local, imported)
-Return a new environment object eval whose bindings are the
-union of the bindings in the environments @var{local} and
address@hidden, with bindings from @var{local} taking
-precedence. Definitions made in eval are placed in @var{local}.
-Applying @code{environment-define} or
address@hidden to eval has the same effect as
-applying the procedure to @var{local}.
-Note that eval incorporates @var{local} and @var{imported} by
-reference:
-If, after creating eval, the program changes the bindings of
address@hidden or @var{imported}, those changes will be visible
-in eval.
-Since most Scheme evaluation takes place in eval environments,
-they transparently cache the bindings received from @var{local}
-and @var{imported}. Thus, the first time the program looks up
-a symbol in eval, eval may make calls to @var{local} or
address@hidden to find their bindings, but subsequent
-references to that symbol will be as fast as references to
-bindings in finite environments.
-In typical use, @var{local} will be a finite environment, and
address@hidden will be an import environment
address@hidden deffn
-
- eval-environment?
address@hidden snarfed from environments.c:1442
address@hidden {Scheme Procedure} eval-environment? object
address@hidden {C Function} scm_eval_environment_p (object)
-Return @code{#t} if object is an eval environment, or @code{#f}
-otherwise.
address@hidden deffn
-
- eval-environment-local
address@hidden snarfed from environments.c:1452
address@hidden {Scheme Procedure} eval-environment-local env
address@hidden {C Function} scm_eval_environment_local (env)
-Return the local environment of eval environment @var{env}.
address@hidden deffn
-
- eval-environment-set-local!
address@hidden snarfed from environments.c:1464
address@hidden {Scheme Procedure} eval-environment-set-local! env local
address@hidden {C Function} scm_eval_environment_set_local_x (env, local)
-Change @var{env}'s local environment to @var{local}.
address@hidden deffn
-
- eval-environment-imported
address@hidden snarfed from environments.c:1490
address@hidden {Scheme Procedure} eval-environment-imported env
address@hidden {C Function} scm_eval_environment_imported (env)
-Return the imported environment of eval environment @var{env}.
address@hidden deffn
-
- eval-environment-set-imported!
address@hidden snarfed from environments.c:1502
address@hidden {Scheme Procedure} eval-environment-set-imported! env imported
address@hidden {C Function} scm_eval_environment_set_imported_x (env, imported)
-Change @var{env}'s imported environment to @var{imported}.
address@hidden deffn
-
- make-import-environment
address@hidden snarfed from environments.c:1825
address@hidden {Scheme Procedure} make-import-environment imports conflict_proc
address@hidden {C Function} scm_make_import_environment (imports, conflict_proc)
-Return a new environment @var{imp} whose bindings are the union
-of the bindings from the environments in @var{imports};
address@hidden must be a list of environments. That is,
address@hidden binds a symbol to a location when some element of
address@hidden does.
-If two different elements of @var{imports} have a binding for
-the same symbol, the @var{conflict-proc} is called with the
-following parameters: the import environment, the symbol and
-the list of the imported environments that bind the symbol.
-If the @var{conflict-proc} returns an environment @var{env},
-the conflict is considered as resolved and the binding from
address@hidden is used. If the @var{conflict-proc} returns some
-non-environment object, the conflict is considered unresolved
-and the symbol is treated as unspecified in the import
-environment.
-The checking for conflicts may be performed lazily, i. e. at
-the moment when a value or binding for a certain symbol is
-requested instead of the moment when the environment is
-created or the bindings of the imports change.
-All bindings in @var{imp} are immutable. If you apply
address@hidden or @code{environment-undefine} to
address@hidden, Guile will signal an
- @code{environment:immutable-binding} error. However,
-notice that the set of bindings in @var{imp} may still change,
-if one of its imported environments changes.
address@hidden deffn
-
- import-environment?
address@hidden snarfed from environments.c:1854
address@hidden {Scheme Procedure} import-environment? object
address@hidden {C Function} scm_import_environment_p (object)
-Return @code{#t} if object is an import environment, or
address@hidden otherwise.
address@hidden deffn
-
- import-environment-imports
address@hidden snarfed from environments.c:1865
address@hidden {Scheme Procedure} import-environment-imports env
address@hidden {C Function} scm_import_environment_imports (env)
-Return the list of environments imported by the import
-environment @var{env}.
address@hidden deffn
-
- import-environment-set-imports!
address@hidden snarfed from environments.c:1878
address@hidden {Scheme Procedure} import-environment-set-imports! env imports
address@hidden {C Function} scm_import_environment_set_imports_x (env, imports)
-Change @var{env}'s list of imported environments to
address@hidden, and check for conflicts.
address@hidden deffn
-
- make-export-environment
address@hidden snarfed from environments.c:2145
address@hidden {Scheme Procedure} make-export-environment private signature
address@hidden {C Function} scm_make_export_environment (private, signature)
-Return a new environment @var{exp} containing only those
-bindings in private whose symbols are present in
address@hidden The @var{private} argument must be an
-environment.
-
-The environment @var{exp} binds symbol to location when
address@hidden does, and symbol is exported by @var{signature}.
-
address@hidden is a list specifying which of the bindings in
address@hidden should be visible in @var{exp}. Each element of
address@hidden should be a list of the form:
- (symbol attribute ...)
-where each attribute is one of the following:
address@hidden @asis
address@hidden the symbol @code{mutable-location}
- @var{exp} should treat the
- location bound to symbol as mutable. That is, @var{exp}
- will pass calls to @code{environment-set!} or
- @code{environment-cell} directly through to private.
address@hidden the symbol @code{immutable-location}
- @var{exp} should treat
- the location bound to symbol as immutable. If the program
- applies @code{environment-set!} to @var{exp} and symbol, or
- calls @code{environment-cell} to obtain a writable value
- cell, @code{environment-set!} will signal an
- @code{environment:immutable-location} error. Note that, even
- if an export environment treats a location as immutable, the
- underlying environment may treat it as mutable, so its
- value may change.
address@hidden table
-It is an error for an element of signature to specify both
address@hidden and @code{immutable-location}. If
-neither is specified, @code{immutable-location} is assumed.
-
-As a special case, if an element of signature is a lone
-symbol @var{sym}, it is equivalent to an element of the form
address@hidden(sym)}.
-
-All bindings in @var{exp} are immutable. If you apply
address@hidden or @code{environment-undefine} to
address@hidden, Guile will signal an
address@hidden:immutable-binding} error. However,
-notice that the set of bindings in @var{exp} may still change,
-if the bindings in private change.
address@hidden deffn
-
- export-environment?
address@hidden snarfed from environments.c:2180
address@hidden {Scheme Procedure} export-environment? object
address@hidden {C Function} scm_export_environment_p (object)
-Return @code{#t} if object is an export environment, or
address@hidden otherwise.
address@hidden deffn
-
- export-environment-private
address@hidden snarfed from environments.c:2190
address@hidden {Scheme Procedure} export-environment-private env
address@hidden {C Function} scm_export_environment_private (env)
-Return the private environment of export environment @var{env}.
address@hidden deffn
-
- export-environment-set-private!
address@hidden snarfed from environments.c:2202
address@hidden {Scheme Procedure} export-environment-set-private! env private
address@hidden {C Function} scm_export_environment_set_private_x (env, private)
-Change the private environment of export environment @var{env}.
address@hidden deffn
-
- export-environment-signature
address@hidden snarfed from environments.c:2224
address@hidden {Scheme Procedure} export-environment-signature env
address@hidden {C Function} scm_export_environment_signature (env)
-Return the signature of export environment @var{env}.
address@hidden deffn
-
- export-environment-set-signature!
address@hidden snarfed from environments.c:2298
address@hidden {Scheme Procedure} export-environment-set-signature! env
signature
address@hidden {C Function} scm_export_environment_set_signature_x (env,
signature)
-Change the signature of export environment @var{env}.
address@hidden deffn
-
- eq?
address@hidden snarfed from eq.c:81
address@hidden {Scheme Procedure} eq? x y
-Return @code{#t} if @var{x} and @var{y} are the same object,
-except for numbers and characters. For example,
-
address@hidden
-(define x (vector 1 2 3))
-(define y (vector 1 2 3))
-
-(eq? x x) @result{} #t
-(eq? x y) @result{} #f
address@hidden example
-
-Numbers and characters are not equal to any other object, but
-the problem is they're not necessarily @code{eq?} to themselves
-either. This is even so when the number comes directly from a
-variable,
-
address@hidden
-(let ((n (+ 2 3)))
- (eq? n n)) @result{} *unspecified*
address@hidden example
-
-Generally @code{eqv?} should be used when comparing numbers or
-characters. @code{=} or @code{char=?} can be used too.
-
-It's worth noting that end-of-list @code{()}, @code{#t},
address@hidden, a symbol of a given name, and a keyword of a given
-name, are unique objects. There's just one of each, so for
-instance no matter how @code{()} arises in a program, it's the
-same object and can be compared with @code{eq?},
-
address@hidden
-(define x (cdr '(123)))
-(define y (cdr '(456)))
-(eq? x y) @result{} #t
-
-(define x (string->symbol "foo"))
-(eq? x 'foo) @result{} #t
address@hidden example
address@hidden deffn
-
- eqv?
address@hidden snarfed from eq.c:116
address@hidden {Scheme Procedure} eqv? x y
-Return @code{#t} if @var{x} and @var{y} are the same object, or
-for characters and numbers the same value.
-
-On objects except characters and numbers, @code{eqv?} is the
-same as @code{eq?}, it's true if @var{x} and @var{y} are the
-same object.
-
-If @var{x} and @var{y} are numbers or characters, @code{eqv?}
-compares their type and value. An exact number is not
address@hidden to an inexact number (even if their value is the
-same).
-
address@hidden
-(eqv? 3 (+ 1 2)) @result{} #t
-(eqv? 1 1.0) @result{} #f
address@hidden example
address@hidden deffn
-
- equal?
address@hidden snarfed from eq.c:212
address@hidden {Scheme Procedure} equal? x y
-Return @code{#t} if @var{x} and @var{y} are the same type, and
-their contents or value are equal.
-
-For a pair, string, vector or array, @code{equal?} compares the
-contents, and does so using using the same @code{equal?}
-recursively, so a deep structure can be traversed.
-
address@hidden
-(equal? (list 1 2 3) (list 1 2 3)) @result{} #t
-(equal? (list 1 2 3) (vector 1 2 3)) @result{} #f
address@hidden example
-
-For other objects, @code{equal?} compares as per @code{eqv?},
-which means characters and numbers are compared by type and
-value (and like @code{eqv?}, exact and inexact numbers are not
address@hidden, even if their value is the same).
-
address@hidden
-(equal? 3 (+ 1 2)) @result{} #t
-(equal? 1 1.0) @result{} #f
address@hidden example
-
-Hash tables are currently only compared as per @code{eq?}, so
-two different tables are not @code{equal?}, even if their
-contents are the same.
-
address@hidden does not support circular data structures, it may
-go into an infinite loop if asked to compare two circular lists
-or similar.
-
-New application-defined object types (Smobs) have an
address@hidden handler which is called by @code{equal?}. This
-lets an application traverse the contents or control what is
-considered @code{equal?} for two such objects. If there's no
-handler, the default is to just compare as per @code{eq?}.
address@hidden deffn
-
- scm-error
address@hidden snarfed from error.c:82
address@hidden {Scheme Procedure} scm-error key subr message args data
address@hidden {C Function} scm_error_scm (key, subr, message, args, data)
-Raise an error with key @var{key}. @var{subr} can be a string
-naming the procedure associated with the error, or @code{#f}.
address@hidden is the error message string, possibly containing
address@hidden and @code{~A} escapes. When an error is reported,
-these are replaced by formatting the corresponding members of
address@hidden: @code{~A} (was @code{%s} in older versions of
-Guile) formats using @code{display} and @code{~S} (was
address@hidden) formats using @code{write}. @var{data} is a list or
address@hidden depending on @var{key}: if @var{key} is
address@hidden then it should be a list containing the
-Unix @code{errno} value; If @var{key} is @code{signal} then it
-should be a list containing the Unix signal number; If
address@hidden is @code{out-of-range} or @code{wrong-type-arg},
-it is a list containing the bad value; otherwise
-it will usually be @code{#f}.
address@hidden deffn
-
- strerror
address@hidden snarfed from error.c:129
address@hidden {Scheme Procedure} strerror err
address@hidden {C Function} scm_strerror (err)
-Return the Unix error message corresponding to @var{err}, which
-must be an integer value.
address@hidden deffn
-
- apply:nconc2last
address@hidden snarfed from eval.c:4686
address@hidden {Scheme Procedure} apply:nconc2last lst
address@hidden {C Function} scm_nconc2last (lst)
-Given a list (@var{arg1} @dots{} @var{args}), this function
-conses the @var{arg1} @dots{} arguments onto the front of
address@hidden, and returns the resulting list. Note that
address@hidden is a list; thus, the argument to this function is
-a list whose last element is a list.
-Note: Rather than do new consing, @code{apply:nconc2last}
-destroys its argument, so use with care.
address@hidden deffn
-
- force
address@hidden snarfed from eval.c:5598
address@hidden {Scheme Procedure} force promise
address@hidden {C Function} scm_force (promise)
-If the promise @var{x} has not been computed yet, compute and
-return @var{x}, otherwise just return the previously computed
-value.
address@hidden deffn
-
- promise?
address@hidden snarfed from eval.c:5621
address@hidden {Scheme Procedure} promise? obj
address@hidden {C Function} scm_promise_p (obj)
-Return true if @var{obj} is a promise, i.e. a delayed computation
-(@pxref{Delayed evaluation,,,r5rs.info,The Revised^5 Report on Scheme}).
address@hidden deffn
-
- cons-source
address@hidden snarfed from eval.c:5633
address@hidden {Scheme Procedure} cons-source xorig x y
address@hidden {C Function} scm_cons_source (xorig, x, y)
-Create and return a new pair whose car and cdr are @var{x} and @var{y}.
-Any source properties associated with @var{xorig} are also associated
-with the new pair.
address@hidden deffn
-
- copy-tree
address@hidden snarfed from eval.c:5790
address@hidden {Scheme Procedure} copy-tree obj
address@hidden {C Function} scm_copy_tree (obj)
-Recursively copy the data tree that is bound to @var{obj}, and return a
-the new data structure. @code{copy-tree} recurses down the
-contents of both pairs and vectors (since both cons cells and vector
-cells may point to arbitrary objects), and stops recursing when it hits
-any other object.
address@hidden deffn
-
- primitive-eval
address@hidden snarfed from eval.c:5878
address@hidden {Scheme Procedure} primitive-eval exp
address@hidden {C Function} scm_primitive_eval (exp)
-Evaluate @var{exp} in the top-level environment specified by
-the current module.
address@hidden deffn
-
- eval
address@hidden snarfed from eval.c:5922
address@hidden {Scheme Procedure} eval exp module_or_state
address@hidden {C Function} scm_eval (exp, module_or_state)
-Evaluate @var{exp}, a list representing a Scheme expression,
-in the top-level environment specified by
address@hidden
-While @var{exp} is evaluated (using @code{primitive-eval}),
address@hidden is made the current module when
-it is a module, or the current dynamic state when it is
-a dynamic state.Example: (eval '(+ 1 2) (interaction-environment))
address@hidden deffn
-
- eval-options-interface
address@hidden snarfed from eval.c:3086
address@hidden {Scheme Procedure} eval-options-interface [setting]
address@hidden {C Function} scm_eval_options_interface (setting)
-Option interface for the evaluation options. Instead of using
-this procedure directly, use the procedures @code{eval-enable},
address@hidden, @code{eval-set!} and @code{eval-options}.
address@hidden deffn
-
- evaluator-traps-interface
address@hidden snarfed from eval.c:3104
address@hidden {Scheme Procedure} evaluator-traps-interface [setting]
address@hidden {C Function} scm_evaluator_traps (setting)
-Option interface for the evaluator trap options.
address@hidden deffn
-
- defined?
address@hidden snarfed from evalext.c:34
address@hidden {Scheme Procedure} defined? sym [env]
address@hidden {C Function} scm_defined_p (sym, env)
-Return @code{#t} if @var{sym} is defined in the lexical environment @var{env}.
When @var{env} is not specified, look in the top-level environment as defined
by the current module.
address@hidden deffn
-
- map-in-order
address@hidden snarfed from evalext.c:80
address@hidden {Scheme Procedure} map-in-order
-implemented by the C function "scm_map"
address@hidden deffn
-
- self-evaluating?
address@hidden snarfed from evalext.c:85
address@hidden {Scheme Procedure} self-evaluating? obj
address@hidden {C Function} scm_self_evaluating_p (obj)
-Return #t for objects which Guile considers self-evaluating
address@hidden deffn
-
- load-extension
address@hidden snarfed from extensions.c:143
address@hidden {Scheme Procedure} load-extension lib init
address@hidden {C Function} scm_load_extension (lib, init)
-Load and initialize the extension designated by LIB and INIT.
-When there is no pre-registered function for LIB/INIT, this is
-equivalent to
-
address@hidden
-(dynamic-call INIT (dynamic-link LIB))
address@hidden lisp
-
-When there is a pre-registered function, that function is called
-instead.
-
-Normally, there is no pre-registered function. This option exists
-only for situations where dynamic linking is unavailable or unwanted.
-In that case, you would statically link your program with the desired
-library, and register its init function right after Guile has been
-initialized.
-
-LIB should be a string denoting a shared library without any file type
-suffix such as ".so". The suffix is provided automatically. It
-should also not contain any directory components. Libraries that
-implement Guile Extensions should be put into the normal locations for
-shared libraries. We recommend to use the naming convention
-libguile-bla-blum for a extension related to a module `(bla blum)'.
-
-The normal way for a extension to be used is to write a small Scheme
-file that defines a module, and to load the extension into this
-module. When the module is auto-loaded, the extension is loaded as
-well. For example,
-
address@hidden
-(define-module (bla blum))
-
-(load-extension "libguile-bla-blum" "bla_init_blum")
address@hidden lisp
address@hidden deffn
-
- program-arguments
address@hidden snarfed from feature.c:57
address@hidden {Scheme Procedure} program-arguments
address@hidden {Scheme Procedure} command-line
address@hidden {C Function} scm_program_arguments ()
-Return the list of command line arguments passed to Guile, as a list of
-strings. The list includes the invoked program name, which is usually
address@hidden"guile"}, but excludes switches and parameters for command line
-options like @code{-e} and @code{-l}.
address@hidden deffn
-
- make-fluid
address@hidden snarfed from fluids.c:260
address@hidden {Scheme Procedure} make-fluid
address@hidden {C Function} scm_make_fluid ()
-Return a newly created fluid.
-Fluids are objects that can hold one
-value per dynamic state. That is, modifications to this value are
-only visible to code that executes with the same dynamic state as
-the modifying code. When a new dynamic state is constructed, it
-inherits the values from its parent. Because each thread normally executes
-with its own dynamic state, you can use fluids for thread local storage.
address@hidden deffn
-
- fluid?
address@hidden snarfed from fluids.c:283
address@hidden {Scheme Procedure} fluid? obj
address@hidden {C Function} scm_fluid_p (obj)
-Return @code{#t} iff @var{obj} is a fluid; otherwise, return
address@hidden
address@hidden deffn
-
- fluid-ref
address@hidden snarfed from fluids.c:306
address@hidden {Scheme Procedure} fluid-ref fluid
address@hidden {C Function} scm_fluid_ref (fluid)
-Return the value associated with @var{fluid} in the current
-dynamic root. If @var{fluid} has not been set, then return
address@hidden
address@hidden deffn
-
- fluid-set!
address@hidden snarfed from fluids.c:325
address@hidden {Scheme Procedure} fluid-set! fluid value
address@hidden {C Function} scm_fluid_set_x (fluid, value)
-Set the value associated with @var{fluid} in the current dynamic root.
address@hidden deffn
-
- with-fluids*
address@hidden snarfed from fluids.c:395
address@hidden {Scheme Procedure} with-fluids* fluids values thunk
address@hidden {C Function} scm_with_fluids (fluids, values, thunk)
-Set @var{fluids} to @var{values} temporary, and call @var{thunk}.
address@hidden must be a list of fluids and @var{values} must be the same
-number of their values to be applied. Each substitution is done
-one after another. @var{thunk} must be a procedure with no argument.
address@hidden deffn
-
- with-fluid*
address@hidden snarfed from fluids.c:434
address@hidden {Scheme Procedure} with-fluid* fluid value thunk
address@hidden {C Function} scm_with_fluid (fluid, value, thunk)
-Set @var{fluid} to @var{value} temporarily, and call @var{thunk}.
address@hidden must be a procedure with no argument.
address@hidden deffn
-
- make-dynamic-state
address@hidden snarfed from fluids.c:487
address@hidden {Scheme Procedure} make-dynamic-state [parent]
address@hidden {C Function} scm_make_dynamic_state (parent)
-Return a copy of the dynamic state object @var{parent}
-or of the current dynamic state when @var{parent} is omitted.
address@hidden deffn
-
- dynamic-state?
address@hidden snarfed from fluids.c:515
address@hidden {Scheme Procedure} dynamic-state? obj
address@hidden {C Function} scm_dynamic_state_p (obj)
-Return @code{#t} if @var{obj} is a dynamic state object;
-return @code{#f} otherwise
address@hidden deffn
-
- current-dynamic-state
address@hidden snarfed from fluids.c:530
address@hidden {Scheme Procedure} current-dynamic-state
address@hidden {C Function} scm_current_dynamic_state ()
-Return the current dynamic state object.
address@hidden deffn
-
- set-current-dynamic-state
address@hidden snarfed from fluids.c:540
address@hidden {Scheme Procedure} set-current-dynamic-state state
address@hidden {C Function} scm_set_current_dynamic_state (state)
-Set the current dynamic state object to @var{state}
-and return the previous current dynamic state object.
address@hidden deffn
-
- with-dynamic-state
address@hidden snarfed from fluids.c:582
address@hidden {Scheme Procedure} with-dynamic-state state proc
address@hidden {C Function} scm_with_dynamic_state (state, proc)
-Call @var{proc} while @var{state} is the current dynamic
-state object.
address@hidden deffn
-
- setvbuf
address@hidden snarfed from fports.c:137
address@hidden {Scheme Procedure} setvbuf port mode [size]
address@hidden {C Function} scm_setvbuf (port, mode, size)
-Set the buffering mode for @var{port}. @var{mode} can be:
address@hidden @code
address@hidden _IONBF
-non-buffered
address@hidden _IOLBF
-line buffered
address@hidden _IOFBF
-block buffered, using a newly allocated buffer of @var{size} bytes.
-If @var{size} is omitted, a default size will be used.
address@hidden table
address@hidden deffn
-
- file-port?
address@hidden snarfed from fports.c:230
address@hidden {Scheme Procedure} file-port? obj
address@hidden {C Function} scm_file_port_p (obj)
-Determine whether @var{obj} is a port that is related to a file.
address@hidden deffn
-
- open-file
address@hidden snarfed from fports.c:284
address@hidden {Scheme Procedure} open-file filename mode
address@hidden {C Function} scm_open_file (filename, mode)
-Open the file whose name is @var{filename}, and return a port
-representing that file. The attributes of the port are
-determined by the @var{mode} string. The way in which this is
-interpreted is similar to C stdio. The first character must be
-one of the following:
address@hidden @samp
address@hidden r
-Open an existing file for input.
address@hidden w
-Open a file for output, creating it if it doesn't already exist
-or removing its contents if it does.
address@hidden a
-Open a file for output, creating it if it doesn't already
-exist. All writes to the port will go to the end of the file.
-The "append mode" can be turned off while the port is in use
address@hidden and File Descriptors, fcntl}
address@hidden table
-The following additional characters can be appended:
address@hidden @samp
address@hidden +
-Open the port for both input and output. E.g., @code{r+}: open
-an existing file for both input and output.
address@hidden 0
-Create an "unbuffered" port. In this case input and output
-operations are passed directly to the underlying port
-implementation without additional buffering. This is likely to
-slow down I/O operations. The buffering mode can be changed
-while a port is in use @pxref{Ports and File Descriptors,
-setvbuf}
address@hidden l
-Add line-buffering to the port. The port output buffer will be
-automatically flushed whenever a newline character is written.
address@hidden table
-In theory we could create read/write ports which were buffered
-in one direction only. However this isn't included in the
-current interfaces. If a file cannot be opened with the access
-requested, @code{open-file} throws an exception.
address@hidden deffn
-
- gc-live-object-stats
address@hidden snarfed from gc.c:276
address@hidden {Scheme Procedure} gc-live-object-stats
address@hidden {C Function} scm_gc_live_object_stats ()
-Return an alist of statistics of the current live objects.
address@hidden deffn
-
- gc-stats
address@hidden snarfed from gc.c:293
address@hidden {Scheme Procedure} gc-stats
address@hidden {C Function} scm_gc_stats ()
-Return an association list of statistics about Guile's current
-use of storage.
-
address@hidden deffn
-
- object-address
address@hidden snarfed from gc.c:429
address@hidden {Scheme Procedure} object-address obj
address@hidden {C Function} scm_object_address (obj)
-Return an integer that for the lifetime of @var{obj} is uniquely
-returned by this function for @var{obj}
address@hidden deffn
-
- gc
address@hidden snarfed from gc.c:440
address@hidden {Scheme Procedure} gc
address@hidden {C Function} scm_gc ()
-Scans all of SCM objects and reclaims for further use those that are
-no longer accessible.
address@hidden deffn
-
- class-of
address@hidden snarfed from goops.c:166
address@hidden {Scheme Procedure} class-of x
address@hidden {C Function} scm_class_of (x)
-Return the class of @var{x}.
address@hidden deffn
-
- %compute-slots
address@hidden snarfed from goops.c:407
address@hidden {Scheme Procedure} %compute-slots class
address@hidden {C Function} scm_sys_compute_slots (class)
-Return a list consisting of the names of all slots belonging to
-class @var{class}, i. e. the slots of @var{class} and of all of
-its superclasses.
address@hidden deffn
-
- get-keyword
address@hidden snarfed from goops.c:498
address@hidden {Scheme Procedure} get-keyword key l default_value
address@hidden {C Function} scm_get_keyword (key, l, default_value)
-Determine an associated value for the keyword @var{key} from
-the list @var{l}. The list @var{l} has to consist of an even
-number of elements, where, starting with the first, every
-second element is a keyword, followed by its associated value.
-If @var{l} does not hold a value for @var{key}, the value
address@hidden is returned.
address@hidden deffn
-
- %initialize-object
address@hidden snarfed from goops.c:521
address@hidden {Scheme Procedure} %initialize-object obj initargs
address@hidden {C Function} scm_sys_initialize_object (obj, initargs)
-Initialize the object @var{obj} with the given arguments
address@hidden
address@hidden deffn
-
- %prep-layout!
address@hidden snarfed from goops.c:619
address@hidden {Scheme Procedure} %prep-layout! class
address@hidden {C Function} scm_sys_prep_layout_x (class)
-
address@hidden deffn
-
- %inherit-magic!
address@hidden snarfed from goops.c:718
address@hidden {Scheme Procedure} %inherit-magic! class dsupers
address@hidden {C Function} scm_sys_inherit_magic_x (class, dsupers)
-
address@hidden deffn
-
- instance?
address@hidden snarfed from goops.c:958
address@hidden {Scheme Procedure} instance? obj
address@hidden {C Function} scm_instance_p (obj)
-Return @code{#t} if @var{obj} is an instance.
address@hidden deffn
-
- class-name
address@hidden snarfed from goops.c:973
address@hidden {Scheme Procedure} class-name obj
address@hidden {C Function} scm_class_name (obj)
-Return the class name of @var{obj}.
address@hidden deffn
-
- class-direct-supers
address@hidden snarfed from goops.c:983
address@hidden {Scheme Procedure} class-direct-supers obj
address@hidden {C Function} scm_class_direct_supers (obj)
-Return the direct superclasses of the class @var{obj}.
address@hidden deffn
-
- class-direct-slots
address@hidden snarfed from goops.c:993
address@hidden {Scheme Procedure} class-direct-slots obj
address@hidden {C Function} scm_class_direct_slots (obj)
-Return the direct slots of the class @var{obj}.
address@hidden deffn
-
- class-direct-subclasses
address@hidden snarfed from goops.c:1003
address@hidden {Scheme Procedure} class-direct-subclasses obj
address@hidden {C Function} scm_class_direct_subclasses (obj)
-Return the direct subclasses of the class @var{obj}.
address@hidden deffn
-
- class-direct-methods
address@hidden snarfed from goops.c:1013
address@hidden {Scheme Procedure} class-direct-methods obj
address@hidden {C Function} scm_class_direct_methods (obj)
-Return the direct methods of the class @var{obj}
address@hidden deffn
-
- class-precedence-list
address@hidden snarfed from goops.c:1023
address@hidden {Scheme Procedure} class-precedence-list obj
address@hidden {C Function} scm_class_precedence_list (obj)
-Return the class precedence list of the class @var{obj}.
address@hidden deffn
-
- class-slots
address@hidden snarfed from goops.c:1033
address@hidden {Scheme Procedure} class-slots obj
address@hidden {C Function} scm_class_slots (obj)
-Return the slot list of the class @var{obj}.
address@hidden deffn
-
- class-environment
address@hidden snarfed from goops.c:1043
address@hidden {Scheme Procedure} class-environment obj
address@hidden {C Function} scm_class_environment (obj)
-Return the environment of the class @var{obj}.
address@hidden deffn
-
- generic-function-name
address@hidden snarfed from goops.c:1054
address@hidden {Scheme Procedure} generic-function-name obj
address@hidden {C Function} scm_generic_function_name (obj)
-Return the name of the generic function @var{obj}.
address@hidden deffn
-
- generic-function-methods
address@hidden snarfed from goops.c:1099
address@hidden {Scheme Procedure} generic-function-methods obj
address@hidden {C Function} scm_generic_function_methods (obj)
-Return the methods of the generic function @var{obj}.
address@hidden deffn
-
- method-generic-function
address@hidden snarfed from goops.c:1112
address@hidden {Scheme Procedure} method-generic-function obj
address@hidden {C Function} scm_method_generic_function (obj)
-Return the generic function for the method @var{obj}.
address@hidden deffn
-
- method-specializers
address@hidden snarfed from goops.c:1122
address@hidden {Scheme Procedure} method-specializers obj
address@hidden {C Function} scm_method_specializers (obj)
-Return specializers of the method @var{obj}.
address@hidden deffn
-
- method-procedure
address@hidden snarfed from goops.c:1132
address@hidden {Scheme Procedure} method-procedure obj
address@hidden {C Function} scm_method_procedure (obj)
-Return the procedure of the method @var{obj}.
address@hidden deffn
-
- accessor-method-slot-definition
address@hidden snarfed from goops.c:1142
address@hidden {Scheme Procedure} accessor-method-slot-definition obj
address@hidden {C Function} scm_accessor_method_slot_definition (obj)
-Return the slot definition of the accessor @var{obj}.
address@hidden deffn
-
- %tag-body
address@hidden snarfed from goops.c:1152
address@hidden {Scheme Procedure} %tag-body body
address@hidden {C Function} scm_sys_tag_body (body)
-Internal GOOPS magic---don't use this function!
address@hidden deffn
-
- make-unbound
address@hidden snarfed from goops.c:1167
address@hidden {Scheme Procedure} make-unbound
address@hidden {C Function} scm_make_unbound ()
-Return the unbound value.
address@hidden deffn
-
- unbound?
address@hidden snarfed from goops.c:1176
address@hidden {Scheme Procedure} unbound? obj
address@hidden {C Function} scm_unbound_p (obj)
-Return @code{#t} if @var{obj} is unbound.
address@hidden deffn
-
- assert-bound
address@hidden snarfed from goops.c:1186
address@hidden {Scheme Procedure} assert-bound value obj
address@hidden {C Function} scm_assert_bound (value, obj)
-Return @var{value} if it is bound, and invoke the
address@hidden method of @var{obj} if it is not.
address@hidden deffn
-
- @@assert-bound-ref
address@hidden snarfed from goops.c:1198
address@hidden {Scheme Procedure} @@assert-bound-ref obj index
address@hidden {C Function} scm_at_assert_bound_ref (obj, index)
-Like @code{assert-bound}, but use @var{index} for accessing
-the value from @var{obj}.
address@hidden deffn
-
- %fast-slot-ref
address@hidden snarfed from goops.c:1210
address@hidden {Scheme Procedure} %fast-slot-ref obj index
address@hidden {C Function} scm_sys_fast_slot_ref (obj, index)
-Return the slot value with index @var{index} from @var{obj}.
address@hidden deffn
-
- %fast-slot-set!
address@hidden snarfed from goops.c:1224
address@hidden {Scheme Procedure} %fast-slot-set! obj index value
address@hidden {C Function} scm_sys_fast_slot_set_x (obj, index, value)
-Set the slot with index @var{index} in @var{obj} to
address@hidden
address@hidden deffn
-
- slot-ref-using-class
address@hidden snarfed from goops.c:1361
address@hidden {Scheme Procedure} slot-ref-using-class class obj slot_name
address@hidden {C Function} scm_slot_ref_using_class (class, obj, slot_name)
-
address@hidden deffn
-
- slot-set-using-class!
address@hidden snarfed from goops.c:1380
address@hidden {Scheme Procedure} slot-set-using-class! class obj slot_name
value
address@hidden {C Function} scm_slot_set_using_class_x (class, obj, slot_name,
value)
-
address@hidden deffn
-
- slot-bound-using-class?
address@hidden snarfed from goops.c:1394
address@hidden {Scheme Procedure} slot-bound-using-class? class obj slot_name
address@hidden {C Function} scm_slot_bound_using_class_p (class, obj, slot_name)
-
address@hidden deffn
-
- slot-exists-using-class?
address@hidden snarfed from goops.c:1409
address@hidden {Scheme Procedure} slot-exists-using-class? class obj slot_name
address@hidden {C Function} scm_slot_exists_using_class_p (class, obj,
slot_name)
-
address@hidden deffn
-
- slot-ref
address@hidden snarfed from goops.c:1425
address@hidden {Scheme Procedure} slot-ref obj slot_name
address@hidden {C Function} scm_slot_ref (obj, slot_name)
-Return the value from @var{obj}'s slot with the name
address@hidden
address@hidden deffn
-
- slot-set!
address@hidden snarfed from goops.c:1442
address@hidden {Scheme Procedure} slot-set! obj slot_name value
address@hidden {C Function} scm_slot_set_x (obj, slot_name, value)
-Set the slot named @var{slot_name} of @var{obj} to @var{value}.
address@hidden deffn
-
- slot-bound?
address@hidden snarfed from goops.c:1459
address@hidden {Scheme Procedure} slot-bound? obj slot_name
address@hidden {C Function} scm_slot_bound_p (obj, slot_name)
-Return @code{#t} if the slot named @var{slot_name} of @var{obj}
-is bound.
address@hidden deffn
-
- slot-exists?
address@hidden snarfed from goops.c:1477
address@hidden {Scheme Procedure} slot-exists? obj slot_name
address@hidden {C Function} scm_slot_exists_p (obj, slot_name)
-Return @code{#t} if @var{obj} has a slot named @var{slot_name}.
address@hidden deffn
-
- %allocate-instance
address@hidden snarfed from goops.c:1516
address@hidden {Scheme Procedure} %allocate-instance class initargs
address@hidden {C Function} scm_sys_allocate_instance (class, initargs)
-Create a new instance of class @var{class} and initialize it
-from the arguments @var{initargs}.
address@hidden deffn
-
- %set-object-setter!
address@hidden snarfed from goops.c:1586
address@hidden {Scheme Procedure} %set-object-setter! obj setter
address@hidden {C Function} scm_sys_set_object_setter_x (obj, setter)
-
address@hidden deffn
-
- %modify-instance
address@hidden snarfed from goops.c:1611
address@hidden {Scheme Procedure} %modify-instance old new
address@hidden {C Function} scm_sys_modify_instance (old, new)
-
address@hidden deffn
-
- %modify-class
address@hidden snarfed from goops.c:1637
address@hidden {Scheme Procedure} %modify-class old new
address@hidden {C Function} scm_sys_modify_class (old, new)
-
address@hidden deffn
-
- %invalidate-class
address@hidden snarfed from goops.c:1661
address@hidden {Scheme Procedure} %invalidate-class class
address@hidden {C Function} scm_sys_invalidate_class (class)
-
address@hidden deffn
-
- %invalidate-method-cache!
address@hidden snarfed from goops.c:1783
address@hidden {Scheme Procedure} %invalidate-method-cache! gf
address@hidden {C Function} scm_sys_invalidate_method_cache_x (gf)
-
address@hidden deffn
-
- generic-capability?
address@hidden snarfed from goops.c:1809
address@hidden {Scheme Procedure} generic-capability? proc
address@hidden {C Function} scm_generic_capability_p (proc)
-
address@hidden deffn
-
- enable-primitive-generic!
address@hidden snarfed from goops.c:1822
address@hidden {Scheme Procedure} enable-primitive-generic! . subrs
address@hidden {C Function} scm_enable_primitive_generic_x (subrs)
-
address@hidden deffn
-
- primitive-generic-generic
address@hidden snarfed from goops.c:1843
address@hidden {Scheme Procedure} primitive-generic-generic subr
address@hidden {C Function} scm_primitive_generic_generic (subr)
-
address@hidden deffn
-
- make
address@hidden snarfed from goops.c:2209
address@hidden {Scheme Procedure} make . args
address@hidden {C Function} scm_make (args)
-Make a new object. @var{args} must contain the class and
-all necessary initialization information.
address@hidden deffn
-
- find-method
address@hidden snarfed from goops.c:2298
address@hidden {Scheme Procedure} find-method . l
address@hidden {C Function} scm_find_method (l)
-
address@hidden deffn
-
- %method-more-specific?
address@hidden snarfed from goops.c:2318
address@hidden {Scheme Procedure} %method-more-specific? m1 m2 targs
address@hidden {C Function} scm_sys_method_more_specific_p (m1, m2, targs)
-Return true if method @var{m1} is more specific than @var{m2} given the
argument types (classes) listed in @var{targs}.
address@hidden deffn
-
- %goops-loaded
address@hidden snarfed from goops.c:2944
address@hidden {Scheme Procedure} %goops-loaded
address@hidden {C Function} scm_sys_goops_loaded ()
-Announce that GOOPS is loaded and perform initialization
-on the C level which depends on the loaded GOOPS modules.
address@hidden deffn
-
- make-guardian
address@hidden snarfed from guardians.c:307
address@hidden {Scheme Procedure} make-guardian [greedy_p]
address@hidden {C Function} scm_make_guardian (greedy_p)
-Create a new guardian.
-A guardian protects a set of objects from garbage collection,
-allowing a program to apply cleanup or other actions.
-
address@hidden returns a procedure representing the guardian.
-Calling the guardian procedure with an argument adds the
-argument to the guardian's set of protected objects.
-Calling the guardian procedure without an argument returns
-one of the protected objects which are ready for garbage
-collection, or @code{#f} if no such object is available.
-Objects which are returned in this way are removed from
-the guardian.
-
address@hidden takes one optional argument that says whether the
-new guardian should be greedy or sharing. If there is any chance
-that any object protected by the guardian may be resurrected,
-then you should make the guardian greedy (this is the default).
-
-See R. Kent Dybvig, Carl Bruggeman, and David Eby (1993)
-"Guardians in a Generation-Based Garbage Collector".
-ACM SIGPLAN Conference on Programming Language Design
-and Implementation, June 1993.
-
-(the semantics are slightly different at this point, but the
-paper still (mostly) accurately describes the interface).
address@hidden deffn
-
- guardian-destroyed?
address@hidden snarfed from guardians.c:335
address@hidden {Scheme Procedure} guardian-destroyed? guardian
address@hidden {C Function} scm_guardian_destroyed_p (guardian)
-Return @code{#t} if @var{guardian} has been destroyed, otherwise @code{#f}.
address@hidden deffn
-
- guardian-greedy?
address@hidden snarfed from guardians.c:353
address@hidden {Scheme Procedure} guardian-greedy? guardian
address@hidden {C Function} scm_guardian_greedy_p (guardian)
-Return @code{#t} if @var{guardian} is a greedy guardian, otherwise @code{#f}.
address@hidden deffn
-
- destroy-guardian!
address@hidden snarfed from guardians.c:364
address@hidden {Scheme Procedure} destroy-guardian! guardian
address@hidden {C Function} scm_destroy_guardian_x (guardian)
-Destroys @var{guardian}, by making it impossible to put any more
-objects in it or get any objects from it. It also unguards any
-objects guarded by @var{guardian}.
address@hidden deffn
-
- hashq
address@hidden snarfed from hash.c:183
address@hidden {Scheme Procedure} hashq key size
address@hidden {C Function} scm_hashq (key, size)
-Determine a hash value for @var{key} that is suitable for
-lookups in a hashtable of size @var{size}, where @code{eq?} is
-used as the equality predicate. The function returns an
-integer in the range 0 to @var{size} - 1. Note that
address@hidden may use internal addresses. Thus two calls to
-hashq where the keys are @code{eq?} are not guaranteed to
-deliver the same value if the key object gets garbage collected
-in between. This can happen, for example with symbols:
address@hidden(hashq 'foo n) (gc) (hashq 'foo n)} may produce two
-different values, since @code{foo} will be garbage collected.
address@hidden deffn
-
- hashv
address@hidden snarfed from hash.c:219
address@hidden {Scheme Procedure} hashv key size
address@hidden {C Function} scm_hashv (key, size)
-Determine a hash value for @var{key} that is suitable for
-lookups in a hashtable of size @var{size}, where @code{eqv?} is
-used as the equality predicate. The function returns an
-integer in the range 0 to @var{size} - 1. Note that
address@hidden(hashv key)} may use internal addresses. Thus two calls
-to hashv where the keys are @code{eqv?} are not guaranteed to
-deliver the same value if the key object gets garbage collected
-in between. This can happen, for example with symbols:
address@hidden(hashv 'foo n) (gc) (hashv 'foo n)} may produce two
-different values, since @code{foo} will be garbage collected.
address@hidden deffn
-
- hash
address@hidden snarfed from hash.c:242
address@hidden {Scheme Procedure} hash key size
address@hidden {C Function} scm_hash (key, size)
-Determine a hash value for @var{key} that is suitable for
-lookups in a hashtable of size @var{size}, where @code{equal?}
-is used as the equality predicate. The function returns an
-integer in the range 0 to @var{size} - 1.
address@hidden deffn
-
- make-hash-table
address@hidden snarfed from hashtab.c:332
address@hidden {Scheme Procedure} make-hash-table [n]
address@hidden {C Function} scm_make_hash_table (n)
-Make a new abstract hash table object with minimum number of buckets @var{n}
-
address@hidden deffn
-
- make-weak-key-hash-table
address@hidden snarfed from hashtab.c:349
address@hidden {Scheme Procedure} make-weak-key-hash-table [n]
address@hidden {Scheme Procedure} make-weak-value-hash-table size
address@hidden {Scheme Procedure} make-doubly-weak-hash-table size
address@hidden {C Function} scm_make_weak_key_hash_table (n)
-Return a weak hash table with @var{size} buckets.
-
-You can modify weak hash tables in exactly the same way you
-would modify regular hash tables. (@pxref{Hash Tables})
address@hidden deffn
-
- make-weak-value-hash-table
address@hidden snarfed from hashtab.c:364
address@hidden {Scheme Procedure} make-weak-value-hash-table [n]
address@hidden {C Function} scm_make_weak_value_hash_table (n)
-Return a hash table with weak values with @var{size} buckets.
-(@pxref{Hash Tables})
address@hidden deffn
-
- make-doubly-weak-hash-table
address@hidden snarfed from hashtab.c:381
address@hidden {Scheme Procedure} make-doubly-weak-hash-table n
address@hidden {C Function} scm_make_doubly_weak_hash_table (n)
-Return a hash table with weak keys and values with @var{size}
-buckets. (@pxref{Hash Tables})
address@hidden deffn
-
- hash-table?
address@hidden snarfed from hashtab.c:400
address@hidden {Scheme Procedure} hash-table? obj
address@hidden {C Function} scm_hash_table_p (obj)
-Return @code{#t} if @var{obj} is an abstract hash table object.
address@hidden deffn
-
- weak-key-hash-table?
address@hidden snarfed from hashtab.c:414
address@hidden {Scheme Procedure} weak-key-hash-table? obj
address@hidden {Scheme Procedure} weak-value-hash-table? obj
address@hidden {Scheme Procedure} doubly-weak-hash-table? obj
address@hidden {C Function} scm_weak_key_hash_table_p (obj)
-Return @code{#t} if @var{obj} is the specified weak hash
-table. Note that a doubly weak hash table is neither a weak key
-nor a weak value hash table.
address@hidden deffn
-
- weak-value-hash-table?
address@hidden snarfed from hashtab.c:424
address@hidden {Scheme Procedure} weak-value-hash-table? obj
address@hidden {C Function} scm_weak_value_hash_table_p (obj)
-Return @code{#t} if @var{obj} is a weak value hash table.
address@hidden deffn
-
- doubly-weak-hash-table?
address@hidden snarfed from hashtab.c:434
address@hidden {Scheme Procedure} doubly-weak-hash-table? obj
address@hidden {C Function} scm_doubly_weak_hash_table_p (obj)
-Return @code{#t} if @var{obj} is a doubly weak hash table.
address@hidden deffn
-
- hash-clear!
address@hidden snarfed from hashtab.c:586
address@hidden {Scheme Procedure} hash-clear! table
address@hidden {C Function} scm_hash_clear_x (table)
-Remove all items from @var{table} (without triggering a resize).
address@hidden deffn
-
- hashq-get-handle
address@hidden snarfed from hashtab.c:607
address@hidden {Scheme Procedure} hashq-get-handle table key
address@hidden {C Function} scm_hashq_get_handle (table, key)
-This procedure returns the @code{(key . value)} pair from the
-hash table @var{table}. If @var{table} does not hold an
-associated value for @var{key}, @code{#f} is returned.
-Uses @code{eq?} for equality testing.
address@hidden deffn
-
- hashq-create-handle!
address@hidden snarfed from hashtab.c:619
address@hidden {Scheme Procedure} hashq-create-handle! table key init
address@hidden {C Function} scm_hashq_create_handle_x (table, key, init)
-This function looks up @var{key} in @var{table} and returns its handle.
-If @var{key} is not already present, a new handle is created which
-associates @var{key} with @var{init}.
address@hidden deffn
-
- hashq-ref
address@hidden snarfed from hashtab.c:632
address@hidden {Scheme Procedure} hashq-ref table key [dflt]
address@hidden {C Function} scm_hashq_ref (table, key, dflt)
-Look up @var{key} in the hash table @var{table}, and return the
-value (if any) associated with it. If @var{key} is not found,
-return @var{default} (or @code{#f} if no @var{default} argument
-is supplied). Uses @code{eq?} for equality testing.
address@hidden deffn
-
- hashq-set!
address@hidden snarfed from hashtab.c:646
address@hidden {Scheme Procedure} hashq-set! table key val
address@hidden {C Function} scm_hashq_set_x (table, key, val)
-Find the entry in @var{table} associated with @var{key}, and
-store @var{value} there. Uses @code{eq?} for equality testing.
address@hidden deffn
-
- hashq-remove!
address@hidden snarfed from hashtab.c:658
address@hidden {Scheme Procedure} hashq-remove! table key
address@hidden {C Function} scm_hashq_remove_x (table, key)
-Remove @var{key} (and any value associated with it) from
address@hidden Uses @code{eq?} for equality tests.
address@hidden deffn
-
- hashv-get-handle
address@hidden snarfed from hashtab.c:673
address@hidden {Scheme Procedure} hashv-get-handle table key
address@hidden {C Function} scm_hashv_get_handle (table, key)
-This procedure returns the @code{(key . value)} pair from the
-hash table @var{table}. If @var{table} does not hold an
-associated value for @var{key}, @code{#f} is returned.
-Uses @code{eqv?} for equality testing.
address@hidden deffn
-
- hashv-create-handle!
address@hidden snarfed from hashtab.c:685
address@hidden {Scheme Procedure} hashv-create-handle! table key init
address@hidden {C Function} scm_hashv_create_handle_x (table, key, init)
-This function looks up @var{key} in @var{table} and returns its handle.
-If @var{key} is not already present, a new handle is created which
-associates @var{key} with @var{init}.
address@hidden deffn
-
- hashv-ref
address@hidden snarfed from hashtab.c:699
address@hidden {Scheme Procedure} hashv-ref table key [dflt]
address@hidden {C Function} scm_hashv_ref (table, key, dflt)
-Look up @var{key} in the hash table @var{table}, and return the
-value (if any) associated with it. If @var{key} is not found,
-return @var{default} (or @code{#f} if no @var{default} argument
-is supplied). Uses @code{eqv?} for equality testing.
address@hidden deffn
-
- hashv-set!
address@hidden snarfed from hashtab.c:713
address@hidden {Scheme Procedure} hashv-set! table key val
address@hidden {C Function} scm_hashv_set_x (table, key, val)
-Find the entry in @var{table} associated with @var{key}, and
-store @var{value} there. Uses @code{eqv?} for equality testing.
address@hidden deffn
-
- hashv-remove!
address@hidden snarfed from hashtab.c:724
address@hidden {Scheme Procedure} hashv-remove! table key
address@hidden {C Function} scm_hashv_remove_x (table, key)
-Remove @var{key} (and any value associated with it) from
address@hidden Uses @code{eqv?} for equality tests.
address@hidden deffn
-
- hash-get-handle
address@hidden snarfed from hashtab.c:738
address@hidden {Scheme Procedure} hash-get-handle table key
address@hidden {C Function} scm_hash_get_handle (table, key)
-This procedure returns the @code{(key . value)} pair from the
-hash table @var{table}. If @var{table} does not hold an
-associated value for @var{key}, @code{#f} is returned.
-Uses @code{equal?} for equality testing.
address@hidden deffn
-
- hash-create-handle!
address@hidden snarfed from hashtab.c:750
address@hidden {Scheme Procedure} hash-create-handle! table key init
address@hidden {C Function} scm_hash_create_handle_x (table, key, init)
-This function looks up @var{key} in @var{table} and returns its handle.
-If @var{key} is not already present, a new handle is created which
-associates @var{key} with @var{init}.
address@hidden deffn
-
- hash-ref
address@hidden snarfed from hashtab.c:763
address@hidden {Scheme Procedure} hash-ref table key [dflt]
address@hidden {C Function} scm_hash_ref (table, key, dflt)
-Look up @var{key} in the hash table @var{table}, and return the
-value (if any) associated with it. If @var{key} is not found,
-return @var{default} (or @code{#f} if no @var{default} argument
-is supplied). Uses @code{equal?} for equality testing.
address@hidden deffn
-
- hash-set!
address@hidden snarfed from hashtab.c:778
address@hidden {Scheme Procedure} hash-set! table key val
address@hidden {C Function} scm_hash_set_x (table, key, val)
-Find the entry in @var{table} associated with @var{key}, and
-store @var{value} there. Uses @code{equal?} for equality
-testing.
address@hidden deffn
-
- hash-remove!
address@hidden snarfed from hashtab.c:790
address@hidden {Scheme Procedure} hash-remove! table key
address@hidden {C Function} scm_hash_remove_x (table, key)
-Remove @var{key} (and any value associated with it) from
address@hidden Uses @code{equal?} for equality tests.
address@hidden deffn
-
- hashx-get-handle
address@hidden snarfed from hashtab.c:831
address@hidden {Scheme Procedure} hashx-get-handle hash assoc table key
address@hidden {C Function} scm_hashx_get_handle (hash, assoc, table, key)
-This behaves the same way as the corresponding
address@hidden function, but uses @var{hash} as a hash
-function and @var{assoc} to compare keys. @code{hash} must be
-a function that takes two arguments, a key to be hashed and a
-table size. @code{assoc} must be an associator function, like
address@hidden, @code{assq} or @code{assv}.
address@hidden deffn
-
- hashx-create-handle!
address@hidden snarfed from hashtab.c:850
address@hidden {Scheme Procedure} hashx-create-handle! hash assoc table key init
address@hidden {C Function} scm_hashx_create_handle_x (hash, assoc, table, key,
init)
-This behaves the same way as the corresponding
address@hidden function, but uses @var{hash} as a hash
-function and @var{assoc} to compare keys. @code{hash} must be
-a function that takes two arguments, a key to be hashed and a
-table size. @code{assoc} must be an associator function, like
address@hidden, @code{assq} or @code{assv}.
address@hidden deffn
-
- hashx-ref
address@hidden snarfed from hashtab.c:873
address@hidden {Scheme Procedure} hashx-ref hash assoc table key [dflt]
address@hidden {C Function} scm_hashx_ref (hash, assoc, table, key, dflt)
-This behaves the same way as the corresponding @code{ref}
-function, but uses @var{hash} as a hash function and
address@hidden to compare keys. @code{hash} must be a function
-that takes two arguments, a key to be hashed and a table size.
address@hidden must be an associator function, like @code{assoc},
address@hidden or @code{assv}.
-
-By way of illustration, @code{hashq-ref table key} is
-equivalent to @code{hashx-ref hashq assq table key}.
address@hidden deffn
-
- hashx-set!
address@hidden snarfed from hashtab.c:899
address@hidden {Scheme Procedure} hashx-set! hash assoc table key val
address@hidden {C Function} scm_hashx_set_x (hash, assoc, table, key, val)
-This behaves the same way as the corresponding @code{set!}
-function, but uses @var{hash} as a hash function and
address@hidden to compare keys. @code{hash} must be a function
-that takes two arguments, a key to be hashed and a table size.
address@hidden must be an associator function, like @code{assoc},
address@hidden or @code{assv}.
-
- By way of illustration, @code{hashq-set! table key} is
-equivalent to @code{hashx-set! hashq assq table key}.
address@hidden deffn
-
- hashx-remove!
address@hidden snarfed from hashtab.c:920
address@hidden {Scheme Procedure} hashx-remove! hash assoc table obj
address@hidden {C Function} scm_hashx_remove_x (hash, assoc, table, obj)
-This behaves the same way as the corresponding @code{remove!}
-function, but uses @var{hash} as a hash function and
address@hidden to compare keys. @code{hash} must be a function
-that takes two arguments, a key to be hashed and a table size.
address@hidden must be an associator function, like @code{assoc},
address@hidden or @code{assv}.
-
- By way of illustration, @code{hashq-remove! table key} is
-equivalent to @code{hashx-remove! hashq assq #f table key}.
address@hidden deffn
-
- hash-fold
address@hidden snarfed from hashtab.c:1009
address@hidden {Scheme Procedure} hash-fold proc init table
address@hidden {C Function} scm_hash_fold (proc, init, table)
-An iterator over hash-table elements.
-Accumulates and returns a result by applying PROC successively.
-The arguments to PROC are "(key value prior-result)" where key
-and value are successive pairs from the hash table TABLE, and
-prior-result is either INIT (for the first application of PROC)
-or the return value of the previous application of PROC.
-For example, @code{(hash-fold acons '() tab)} will convert a hash
-table into an a-list of key-value pairs.
address@hidden deffn
-
- hash-for-each
address@hidden snarfed from hashtab.c:1030
address@hidden {Scheme Procedure} hash-for-each proc table
address@hidden {C Function} scm_hash_for_each (proc, table)
-An iterator over hash-table elements.
-Applies PROC successively on all hash table items.
-The arguments to PROC are "(key value)" where key
-and value are successive pairs from the hash table TABLE.
address@hidden deffn
-
- hash-for-each-handle
address@hidden snarfed from hashtab.c:1047
address@hidden {Scheme Procedure} hash-for-each-handle proc table
address@hidden {C Function} scm_hash_for_each_handle (proc, table)
-An iterator over hash-table elements.
-Applies PROC successively on all hash table handles.
address@hidden deffn
-
- hash-map->list
address@hidden snarfed from hashtab.c:1073
address@hidden {Scheme Procedure} hash-map->list proc table
address@hidden {C Function} scm_hash_map_to_list (proc, table)
-An iterator over hash-table elements.
-Accumulates and returns as a list the results of applying PROC successively.
-The arguments to PROC are "(key value)" where key
-and value are successive pairs from the hash table TABLE.
address@hidden deffn
-
- make-hook
address@hidden snarfed from hooks.c:154
address@hidden {Scheme Procedure} make-hook [n_args]
address@hidden {C Function} scm_make_hook (n_args)
-Create a hook for storing procedure of arity @var{n_args}.
address@hidden defaults to zero. The returned value is a hook
-object to be used with the other hook procedures.
address@hidden deffn
-
- hook?
address@hidden snarfed from hooks.c:171
address@hidden {Scheme Procedure} hook? x
address@hidden {C Function} scm_hook_p (x)
-Return @code{#t} if @var{x} is a hook, @code{#f} otherwise.
address@hidden deffn
-
- hook-empty?
address@hidden snarfed from hooks.c:182
address@hidden {Scheme Procedure} hook-empty? hook
address@hidden {C Function} scm_hook_empty_p (hook)
-Return @code{#t} if @var{hook} is an empty hook, @code{#f}
-otherwise.
address@hidden deffn
-
- add-hook!
address@hidden snarfed from hooks.c:196
address@hidden {Scheme Procedure} add-hook! hook proc [append_p]
address@hidden {C Function} scm_add_hook_x (hook, proc, append_p)
-Add the procedure @var{proc} to the hook @var{hook}. The
-procedure is added to the end if @var{append_p} is true,
-otherwise it is added to the front. The return value of this
-procedure is not specified.
address@hidden deffn
-
- remove-hook!
address@hidden snarfed from hooks.c:223
address@hidden {Scheme Procedure} remove-hook! hook proc
address@hidden {C Function} scm_remove_hook_x (hook, proc)
-Remove the procedure @var{proc} from the hook @var{hook}. The
-return value of this procedure is not specified.
address@hidden deffn
-
- reset-hook!
address@hidden snarfed from hooks.c:237
address@hidden {Scheme Procedure} reset-hook! hook
address@hidden {C Function} scm_reset_hook_x (hook)
-Remove all procedures from the hook @var{hook}. The return
-value of this procedure is not specified.
address@hidden deffn
-
- run-hook
address@hidden snarfed from hooks.c:251
address@hidden {Scheme Procedure} run-hook hook . args
address@hidden {C Function} scm_run_hook (hook, args)
-Apply all procedures from the hook @var{hook} to the arguments
address@hidden The order of the procedure application is first to
-last. The return value of this procedure is not specified.
address@hidden deffn
-
- hook->list
address@hidden snarfed from hooks.c:278
address@hidden {Scheme Procedure} hook->list hook
address@hidden {C Function} scm_hook_to_list (hook)
-Convert the procedure list of @var{hook} to a list.
address@hidden deffn
-
- gettext
address@hidden snarfed from i18n.c:90
address@hidden {Scheme Procedure} gettext msgid [domain [category]]
address@hidden {C Function} scm_gettext (msgid, domain, category)
-Return the translation of @var{msgid} in the message domain @var{domain}.
@var{domain} is optional and defaults to the domain set through (textdomain).
@var{category} is optional and defaults to LC_MESSAGES.
address@hidden deffn
-
- ngettext
address@hidden snarfed from i18n.c:146
address@hidden {Scheme Procedure} ngettext msgid msgid_plural n [domain
[category]]
address@hidden {C Function} scm_ngettext (msgid, msgid_plural, n, domain,
category)
-Return the translation of @var{msgid}/@var{msgid_plural} in the message domain
@var{domain}, with the plural form being chosen appropriately for the number
@var{n}. @var{domain} is optional and defaults to the domain set through
(textdomain). @var{category} is optional and defaults to LC_MESSAGES.
address@hidden deffn
-
- textdomain
address@hidden snarfed from i18n.c:209
address@hidden {Scheme Procedure} textdomain [domainname]
address@hidden {C Function} scm_textdomain (domainname)
-If optional parameter @var{domainname} is supplied, set the textdomain.
Return the textdomain.
address@hidden deffn
-
- bindtextdomain
address@hidden snarfed from i18n.c:241
address@hidden {Scheme Procedure} bindtextdomain domainname [directory]
address@hidden {C Function} scm_bindtextdomain (domainname, directory)
-If optional parameter @var{directory} is supplied, set message catalogs to
directory @var{directory}. Return the directory bound to @var{domainname}.
address@hidden deffn
-
- bind-textdomain-codeset
address@hidden snarfed from i18n.c:280
address@hidden {Scheme Procedure} bind-textdomain-codeset domainname [encoding]
address@hidden {C Function} scm_bind_textdomain_codeset (domainname, encoding)
-If optional parameter @var{encoding} is supplied, set encoding for message
catalogs of @var{domainname}. Return the encoding of @var{domainname}.
address@hidden deffn
-
- ftell
address@hidden snarfed from ioext.c:54
address@hidden {Scheme Procedure} ftell fd_port
address@hidden {C Function} scm_ftell (fd_port)
-Return an integer representing the current position of
address@hidden/port}, measured from the beginning. Equivalent to:
-
address@hidden
-(seek port 0 SEEK_CUR)
address@hidden lisp
address@hidden deffn
-
- redirect-port
address@hidden snarfed from ioext.c:72
address@hidden {Scheme Procedure} redirect-port old new
address@hidden {C Function} scm_redirect_port (old, new)
-This procedure takes two ports and duplicates the underlying file
-descriptor from @var{old-port} into @var{new-port}. The
-current file descriptor in @var{new-port} will be closed.
-After the redirection the two ports will share a file position
-and file status flags.
-
-The return value is unspecified.
-
-Unexpected behaviour can result if both ports are subsequently used
-and the original and/or duplicate ports are buffered.
-
-This procedure does not have any side effects on other ports or
-revealed counts.
address@hidden deffn
-
- dup->fdes
address@hidden snarfed from ioext.c:111
address@hidden {Scheme Procedure} dup->fdes fd_or_port [fd]
address@hidden {C Function} scm_dup_to_fdes (fd_or_port, fd)
-Return a new integer file descriptor referring to the open file
-designated by @var{fd_or_port}, which must be either an open
-file port or a file descriptor.
address@hidden deffn
-
- dup2
address@hidden snarfed from ioext.c:158
address@hidden {Scheme Procedure} dup2 oldfd newfd
address@hidden {C Function} scm_dup2 (oldfd, newfd)
-A simple wrapper for the @code{dup2} system call.
-Copies the file descriptor @var{oldfd} to descriptor
-number @var{newfd}, replacing the previous meaning
-of @var{newfd}. Both @var{oldfd} and @var{newfd} must
-be integers.
-Unlike for dup->fdes or primitive-move->fdes, no attempt
-is made to move away ports which are using @var{newfd}.
-The return value is unspecified.
address@hidden deffn
-
- fileno
address@hidden snarfed from ioext.c:177
address@hidden {Scheme Procedure} fileno port
address@hidden {C Function} scm_fileno (port)
-Return the integer file descriptor underlying @var{port}. Does
-not change its revealed count.
address@hidden deffn
-
- isatty?
address@hidden snarfed from ioext.c:197
address@hidden {Scheme Procedure} isatty? port
address@hidden {C Function} scm_isatty_p (port)
-Return @code{#t} if @var{port} is using a serial non--file
-device, otherwise @code{#f}.
address@hidden deffn
-
- fdopen
address@hidden snarfed from ioext.c:219
address@hidden {Scheme Procedure} fdopen fdes modes
address@hidden {C Function} scm_fdopen (fdes, modes)
-Return a new port based on the file descriptor @var{fdes}.
-Modes are given by the string @var{modes}. The revealed count
-of the port is initialized to zero. The modes string is the
-same as that accepted by @ref{File Ports, open-file}.
address@hidden deffn
-
- primitive-move->fdes
address@hidden snarfed from ioext.c:241
address@hidden {Scheme Procedure} primitive-move->fdes port fd
address@hidden {C Function} scm_primitive_move_to_fdes (port, fd)
-Moves the underlying file descriptor for @var{port} to the integer
-value @var{fdes} without changing the revealed count of @var{port}.
-Any other ports already using this descriptor will be automatically
-shifted to new descriptors and their revealed counts reset to zero.
-The return value is @code{#f} if the file descriptor already had the
-required value or @code{#t} if it was moved.
address@hidden deffn
-
- fdes->ports
address@hidden snarfed from ioext.c:274
address@hidden {Scheme Procedure} fdes->ports fd
address@hidden {C Function} scm_fdes_to_ports (fd)
-Return a list of existing ports which have @var{fdes} as an
-underlying file descriptor, without changing their revealed
-counts.
address@hidden deffn
-
- keyword?
address@hidden snarfed from keywords.c:52
address@hidden {Scheme Procedure} keyword? obj
address@hidden {C Function} scm_keyword_p (obj)
-Return @code{#t} if the argument @var{obj} is a keyword, else
address@hidden
address@hidden deffn
-
- symbol->keyword
address@hidden snarfed from keywords.c:61
address@hidden {Scheme Procedure} symbol->keyword symbol
address@hidden {C Function} scm_symbol_to_keyword (symbol)
-Return the keyword with the same name as @var{symbol}.
address@hidden deffn
-
- keyword->symbol
address@hidden snarfed from keywords.c:82
address@hidden {Scheme Procedure} keyword->symbol keyword
address@hidden {C Function} scm_keyword_to_symbol (keyword)
-Return the symbol with the same name as @var{keyword}.
address@hidden deffn
-
- list
address@hidden snarfed from list.c:104
address@hidden {Scheme Procedure} list . objs
address@hidden {C Function} scm_list (objs)
-Return a list containing @var{objs}, the arguments to
address@hidden
address@hidden deffn
-
- cons*
address@hidden snarfed from list.c:119
address@hidden {Scheme Procedure} cons* arg . rest
address@hidden {C Function} scm_cons_star (arg, rest)
-Like @code{list}, but the last arg provides the tail of the
-constructed list, returning @code{(cons @var{arg1} (cons
address@hidden (cons @dots{} @var{argn})))}. Requires at least one
-argument. If given one argument, that argument is returned as
-result. This function is called @code{list*} in some other
-Schemes and in Common LISP.
address@hidden deffn
-
- null?
address@hidden snarfed from list.c:143
address@hidden {Scheme Procedure} null? x
address@hidden {C Function} scm_null_p (x)
-Return @code{#t} iff @var{x} is the empty list, else @code{#f}.
address@hidden deffn
-
- list?
address@hidden snarfed from list.c:153
address@hidden {Scheme Procedure} list? x
address@hidden {C Function} scm_list_p (x)
-Return @code{#t} iff @var{x} is a proper list, else @code{#f}.
address@hidden deffn
-
- length
address@hidden snarfed from list.c:194
address@hidden {Scheme Procedure} length lst
address@hidden {C Function} scm_length (lst)
-Return the number of elements in list @var{lst}.
address@hidden deffn
-
- append
address@hidden snarfed from list.c:223
address@hidden {Scheme Procedure} append . args
address@hidden {C Function} scm_append (args)
-Return a list consisting of the elements the lists passed as
-arguments.
address@hidden
-(append '(x) '(y)) @result{} (x y)
-(append '(a) '(b c d)) @result{} (a b c d)
-(append '(a (b)) '((c))) @result{} (a (b) (c))
address@hidden lisp
-The resulting list is always newly allocated, except that it
-shares structure with the last list argument. The last
-argument may actually be any object; an improper list results
-if the last argument is not a proper list.
address@hidden
-(append '(a b) '(c . d)) @result{} (a b c . d)
-(append '() 'a) @result{} a
address@hidden lisp
address@hidden deffn
-
- append!
address@hidden snarfed from list.c:259
address@hidden {Scheme Procedure} append! . lists
address@hidden {C Function} scm_append_x (lists)
-A destructive version of @code{append} (@pxref{Pairs and
-Lists,,,r5rs, The Revised^5 Report on Scheme}). The cdr field
-of each list's final pair is changed to point to the head of
-the next list, so no consing is performed. Return
-the mutated list.
address@hidden deffn
-
- last-pair
address@hidden snarfed from list.c:291
address@hidden {Scheme Procedure} last-pair lst
address@hidden {C Function} scm_last_pair (lst)
-Return the last pair in @var{lst}, signalling an error if
address@hidden is circular.
address@hidden deffn
-
- reverse
address@hidden snarfed from list.c:321
address@hidden {Scheme Procedure} reverse lst
address@hidden {C Function} scm_reverse (lst)
-Return a new list that contains the elements of @var{lst} but
-in reverse order.
address@hidden deffn
-
- reverse!
address@hidden snarfed from list.c:355
address@hidden {Scheme Procedure} reverse! lst [new_tail]
address@hidden {C Function} scm_reverse_x (lst, new_tail)
-A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r5rs,
-The Revised^5 Report on Scheme}). The cdr of each cell in @var{lst} is
-modified to point to the previous list element. Return the
-reversed list.
-
-Caveat: because the list is modified in place, the tail of the original
-list now becomes its head, and the head of the original list now becomes
-the tail. Therefore, the @var{lst} symbol to which the head of the
-original list was bound now points to the tail. To ensure that the head
-of the modified list is not lost, it is wise to save the return value of
address@hidden
address@hidden deffn
-
- list-ref
address@hidden snarfed from list.c:381
address@hidden {Scheme Procedure} list-ref list k
address@hidden {C Function} scm_list_ref (list, k)
-Return the @var{k}th element from @var{list}.
address@hidden deffn
-
- list-set!
address@hidden snarfed from list.c:405
address@hidden {Scheme Procedure} list-set! list k val
address@hidden {C Function} scm_list_set_x (list, k, val)
-Set the @var{k}th element of @var{list} to @var{val}.
address@hidden deffn
-
- list-cdr-ref
address@hidden snarfed from list.c:427
address@hidden {Scheme Procedure} list-cdr-ref
-implemented by the C function "scm_list_tail"
address@hidden deffn
-
- list-tail
address@hidden snarfed from list.c:436
address@hidden {Scheme Procedure} list-tail lst k
address@hidden {Scheme Procedure} list-cdr-ref lst k
address@hidden {C Function} scm_list_tail (lst, k)
-Return the "tail" of @var{lst} beginning with its @var{k}th element.
-The first element of the list is considered to be element 0.
-
address@hidden and @code{list-cdr-ref} are identical. It may help to
-think of @code{list-cdr-ref} as accessing the @var{k}th cdr of the list,
-or returning the results of cdring @var{k} times down @var{lst}.
address@hidden deffn
-
- list-cdr-set!
address@hidden snarfed from list.c:451
address@hidden {Scheme Procedure} list-cdr-set! list k val
address@hidden {C Function} scm_list_cdr_set_x (list, k, val)
-Set the @var{k}th cdr of @var{list} to @var{val}.
address@hidden deffn
-
- list-head
address@hidden snarfed from list.c:479
address@hidden {Scheme Procedure} list-head lst k
address@hidden {C Function} scm_list_head (lst, k)
-Copy the first @var{k} elements from @var{lst} into a new list, and
-return it.
address@hidden deffn
-
- list-copy
address@hidden snarfed from list.c:530
address@hidden {Scheme Procedure} list-copy lst
address@hidden {C Function} scm_list_copy (lst)
-Return a (newly-created) copy of @var{lst}.
address@hidden deffn
-
- memq
address@hidden snarfed from list.c:584
address@hidden {Scheme Procedure} memq x lst
address@hidden {C Function} scm_memq (x, lst)
-Return the first sublist of @var{lst} whose car is @code{eq?}
-to @var{x} where the sublists of @var{lst} are the non-empty
-lists returned by @code{(list-tail @var{lst} @var{k})} for
address@hidden less than the length of @var{lst}. If @var{x} does not
-occur in @var{lst}, then @code{#f} (not the empty list) is
-returned.
address@hidden deffn
-
- memv
address@hidden snarfed from list.c:600
address@hidden {Scheme Procedure} memv x lst
address@hidden {C Function} scm_memv (x, lst)
-Return the first sublist of @var{lst} whose car is @code{eqv?}
-to @var{x} where the sublists of @var{lst} are the non-empty
-lists returned by @code{(list-tail @var{lst} @var{k})} for
address@hidden less than the length of @var{lst}. If @var{x} does not
-occur in @var{lst}, then @code{#f} (not the empty list) is
-returned.
address@hidden deffn
-
- member
address@hidden snarfed from list.c:621
address@hidden {Scheme Procedure} member x lst
address@hidden {C Function} scm_member (x, lst)
-Return the first sublist of @var{lst} whose car is
address@hidden to @var{x} where the sublists of @var{lst} are
-the non-empty lists returned by @code{(list-tail @var{lst}
address@hidden)} for @var{k} less than the length of @var{lst}. If
address@hidden does not occur in @var{lst}, then @code{#f} (not the
-empty list) is returned.
address@hidden deffn
-
- delq!
address@hidden snarfed from list.c:646
address@hidden {Scheme Procedure} delq! item lst
address@hidden {Scheme Procedure} delv! item lst
address@hidden {Scheme Procedure} delete! item lst
address@hidden {C Function} scm_delq_x (item, lst)
-These procedures are destructive versions of @code{delq}, @code{delv}
-and @code{delete}: they modify the existing @var{lst}
-rather than creating a new list. Caveat evaluator: Like other
-destructive list functions, these functions cannot modify the binding of
address@hidden, and so cannot be used to delete the first element of
address@hidden destructively.
address@hidden deffn
-
- delv!
address@hidden snarfed from list.c:670
address@hidden {Scheme Procedure} delv! item lst
address@hidden {C Function} scm_delv_x (item, lst)
-Destructively remove all elements from @var{lst} that are
address@hidden to @var{item}.
address@hidden deffn
-
- delete!
address@hidden snarfed from list.c:695
address@hidden {Scheme Procedure} delete! item lst
address@hidden {C Function} scm_delete_x (item, lst)
-Destructively remove all elements from @var{lst} that are
address@hidden to @var{item}.
address@hidden deffn
-
- delq
address@hidden snarfed from list.c:724
address@hidden {Scheme Procedure} delq item lst
address@hidden {C Function} scm_delq (item, lst)
-Return a newly-created copy of @var{lst} with elements
address@hidden to @var{item} removed. This procedure mirrors
address@hidden: @code{delq} compares elements of @var{lst} against
address@hidden with @code{eq?}.
address@hidden deffn
-
- delv
address@hidden snarfed from list.c:737
address@hidden {Scheme Procedure} delv item lst
address@hidden {C Function} scm_delv (item, lst)
-Return a newly-created copy of @var{lst} with elements
address@hidden to @var{item} removed. This procedure mirrors
address@hidden: @code{delv} compares elements of @var{lst} against
address@hidden with @code{eqv?}.
address@hidden deffn
-
- delete
address@hidden snarfed from list.c:750
address@hidden {Scheme Procedure} delete item lst
address@hidden {C Function} scm_delete (item, lst)
-Return a newly-created copy of @var{lst} with elements
address@hidden to @var{item} removed. This procedure mirrors
address@hidden: @code{delete} compares elements of @var{lst}
-against @var{item} with @code{equal?}.
address@hidden deffn
-
- delq1!
address@hidden snarfed from list.c:763
address@hidden {Scheme Procedure} delq1! item lst
address@hidden {C Function} scm_delq1_x (item, lst)
-Like @code{delq!}, but only deletes the first occurrence of
address@hidden from @var{lst}. Tests for equality using
address@hidden See also @code{delv1!} and @code{delete1!}.
address@hidden deffn
-
- delv1!
address@hidden snarfed from list.c:791
address@hidden {Scheme Procedure} delv1! item lst
address@hidden {C Function} scm_delv1_x (item, lst)
-Like @code{delv!}, but only deletes the first occurrence of
address@hidden from @var{lst}. Tests for equality using
address@hidden See also @code{delq1!} and @code{delete1!}.
address@hidden deffn
-
- delete1!
address@hidden snarfed from list.c:819
address@hidden {Scheme Procedure} delete1! item lst
address@hidden {C Function} scm_delete1_x (item, lst)
-Like @code{delete!}, but only deletes the first occurrence of
address@hidden from @var{lst}. Tests for equality using
address@hidden See also @code{delq1!} and @code{delv1!}.
address@hidden deffn
-
- filter
address@hidden snarfed from list.c:851
address@hidden {Scheme Procedure} filter pred list
address@hidden {C Function} scm_filter (pred, list)
-Return all the elements of 2nd arg @var{list} that satisfy predicate
@var{pred}.
-The list is not disordered -- elements that appear in the result list occur
-in the same order as they occur in the argument list. The returned list may
-share a common tail with the argument list. The dynamic order in which the
-various applications of pred are made is not specified.
-
address@hidden
-(filter even? '(0 7 8 8 43 -4)) => (0 8 8 -4)
address@hidden lisp
address@hidden deffn
-
- filter!
address@hidden snarfed from list.c:878
address@hidden {Scheme Procedure} filter! pred list
address@hidden {C Function} scm_filter_x (pred, list)
-Linear-update variant of @code{filter}.
address@hidden deffn
-
- primitive-load
address@hidden snarfed from load.c:72
address@hidden {Scheme Procedure} primitive-load filename
address@hidden {C Function} scm_primitive_load (filename)
-Load the file named @var{filename} and evaluate its contents in
-the top-level environment. The load paths are not searched;
address@hidden must either be a full pathname or be a pathname
-relative to the current directory. If the variable
address@hidden is defined, it should be bound to a procedure
-that will be called before any code is loaded. See the
-documentation for @code{%load-hook} later in this section.
address@hidden deffn
-
- %package-data-dir
address@hidden snarfed from load.c:117
address@hidden {Scheme Procedure} %package-data-dir
address@hidden {C Function} scm_sys_package_data_dir ()
-Return the name of the directory where Scheme packages, modules and
-libraries are kept. On most Unix systems, this will be
address@hidden/usr/local/share/guile}.
address@hidden deffn
-
- %library-dir
address@hidden snarfed from load.c:129
address@hidden {Scheme Procedure} %library-dir
address@hidden {C Function} scm_sys_library_dir ()
-Return the directory where the Guile Scheme library files are installed.
-E.g., may return "/usr/share/guile/1.3.5".
address@hidden deffn
-
- %site-dir
address@hidden snarfed from load.c:141
address@hidden {Scheme Procedure} %site-dir
address@hidden {C Function} scm_sys_site_dir ()
-Return the directory where the Guile site files are installed.
-E.g., may return "/usr/share/guile/site".
address@hidden deffn
-
- parse-path
address@hidden snarfed from load.c:166
address@hidden {Scheme Procedure} parse-path path [tail]
address@hidden {C Function} scm_parse_path (path, tail)
-Parse @var{path}, which is expected to be a colon-separated
-string, into a list and return the resulting list with
address@hidden appended. If @var{path} is @code{#f}, @var{tail}
-is returned.
address@hidden deffn
-
- search-path
address@hidden snarfed from load.c:293
address@hidden {Scheme Procedure} search-path path filename [extensions]
address@hidden {C Function} scm_search_path (path, filename, extensions)
-Search @var{path} for a directory containing a file named
address@hidden The file must be readable, and not a directory.
-If we find one, return its full filename; otherwise, return
address@hidden If @var{filename} is absolute, return it unchanged.
-If given, @var{extensions} is a list of strings; for each
-directory in @var{path}, we search for @var{filename}
-concatenated with each @var{extension}.
address@hidden deffn
-
- %search-load-path
address@hidden snarfed from load.c:430
address@hidden {Scheme Procedure} %search-load-path filename
address@hidden {C Function} scm_sys_search_load_path (filename)
-Search @var{%load-path} for the file named @var{filename},
-which must be readable by the current user. If @var{filename}
-is found in the list of paths to search or is an absolute
-pathname, return its full pathname. Otherwise, return
address@hidden Filenames may have any of the optional extensions
-in the @code{%load-extensions} list; @code{%search-load-path}
-will try each extension automatically.
address@hidden deffn
-
- primitive-load-path
address@hidden snarfed from load.c:451
address@hidden {Scheme Procedure} primitive-load-path filename
address@hidden {C Function} scm_primitive_load_path (filename)
-Search @var{%load-path} for the file named @var{filename} and
-load it into the top-level environment. If @var{filename} is a
-relative pathname and is not found in the list of search paths,
-an error is signalled.
address@hidden deffn
-
- procedure->memoizing-macro
address@hidden snarfed from macros.c:109
address@hidden {Scheme Procedure} procedure->memoizing-macro code
address@hidden {C Function} scm_makmmacro (code)
-Return a @dfn{macro} which, when a symbol defined to this value
-appears as the first symbol in an expression, evaluates the
-result of applying @var{code} to the expression and the
-environment.
-
address@hidden>memoizing-macro} is the same as
address@hidden>macro}, except that the expression returned by
address@hidden replaces the original macro expression in the memoized
-form of the containing code.
address@hidden deffn
-
- procedure->syntax
address@hidden snarfed from macros.c:123
address@hidden {Scheme Procedure} procedure->syntax code
address@hidden {C Function} scm_makacro (code)
-Return a @dfn{macro} which, when a symbol defined to this value
-appears as the first symbol in an expression, returns the
-result of applying @var{code} to the expression and the
-environment.
address@hidden deffn
-
- procedure->macro
address@hidden snarfed from macros.c:146
address@hidden {Scheme Procedure} procedure->macro code
address@hidden {C Function} scm_makmacro (code)
-Return a @dfn{macro} which, when a symbol defined to this value
-appears as the first symbol in an expression, evaluates the
-result of applying @var{code} to the expression and the
-environment. For example:
-
address@hidden
-(define trace
- (procedure->macro
- (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))
-
-(trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).
address@hidden lisp
address@hidden deffn
-
- macro?
address@hidden snarfed from macros.c:165
address@hidden {Scheme Procedure} macro? obj
address@hidden {C Function} scm_macro_p (obj)
-Return @code{#t} if @var{obj} is a regular macro, a memoizing macro, a
-syntax transformer, or a syntax-case macro.
address@hidden deffn
-
- macro-type
address@hidden snarfed from macros.c:186
address@hidden {Scheme Procedure} macro-type m
address@hidden {C Function} scm_macro_type (m)
-Return one of the symbols @code{syntax}, @code{macro},
address@hidden, or @code{syntax-case}, depending on whether
address@hidden is a syntax transformer, a regular macro, a memoizing
-macro, or a syntax-case macro, respectively. If @var{m} is
-not a macro, @code{#f} is returned.
address@hidden deffn
-
- macro-name
address@hidden snarfed from macros.c:207
address@hidden {Scheme Procedure} macro-name m
address@hidden {C Function} scm_macro_name (m)
-Return the name of the macro @var{m}.
address@hidden deffn
-
- macro-transformer
address@hidden snarfed from macros.c:218
address@hidden {Scheme Procedure} macro-transformer m
address@hidden {C Function} scm_macro_transformer (m)
-Return the transformer of the macro @var{m}.
address@hidden deffn
-
- current-module
address@hidden snarfed from modules.c:45
address@hidden {Scheme Procedure} current-module
address@hidden {C Function} scm_current_module ()
-Return the current module.
address@hidden deffn
-
- set-current-module
address@hidden snarfed from modules.c:57
address@hidden {Scheme Procedure} set-current-module module
address@hidden {C Function} scm_set_current_module (module)
-Set the current module to @var{module} and return
-the previous current module.
address@hidden deffn
-
- interaction-environment
address@hidden snarfed from modules.c:80
address@hidden {Scheme Procedure} interaction-environment
address@hidden {C Function} scm_interaction_environment ()
-Return a specifier for the environment that contains
-implementation--defined bindings, typically a superset of those
-listed in the report. The intent is that this procedure will
-return the environment in which the implementation would
-evaluate expressions dynamically typed by the user.
address@hidden deffn
-
- env-module
address@hidden snarfed from modules.c:266
address@hidden {Scheme Procedure} env-module env
address@hidden {C Function} scm_env_module (env)
-Return the module of @var{ENV}, a lexical environment.
address@hidden deffn
-
- standard-eval-closure
address@hidden snarfed from modules.c:342
address@hidden {Scheme Procedure} standard-eval-closure module
address@hidden {C Function} scm_standard_eval_closure (module)
-Return an eval closure for the module @var{module}.
address@hidden deffn
-
- standard-interface-eval-closure
address@hidden snarfed from modules.c:353
address@hidden {Scheme Procedure} standard-interface-eval-closure module
address@hidden {C Function} scm_standard_interface_eval_closure (module)
-Return a interface eval closure for the module @var{module}. Such a closure
does not allow new bindings to be added.
address@hidden deffn
-
- module-import-interface
address@hidden snarfed from modules.c:399
address@hidden {Scheme Procedure} module-import-interface module sym
address@hidden {C Function} scm_module_import_interface (module, sym)
-Return the module or interface from which @var{sym} is imported in
@var{module}. If @var{sym} is not imported (i.e., it is not defined in
@var{module} or it is a module-local binding instead of an imported one), then
@code{#f} is returned.
address@hidden deffn
-
- %get-pre-modules-obarray
address@hidden snarfed from modules.c:616
address@hidden {Scheme Procedure} %get-pre-modules-obarray
address@hidden {C Function} scm_get_pre_modules_obarray ()
-Return the obarray that is used for all new bindings before the module system
is booted. The first call to @code{set-current-module} will boot the module
system.
address@hidden deffn
-
- exact?
address@hidden snarfed from numbers.c:460
address@hidden {Scheme Procedure} exact? x
address@hidden {C Function} scm_exact_p (x)
-Return @code{#t} if @var{x} is an exact number, @code{#f}
-otherwise.
address@hidden deffn
-
- odd?
address@hidden snarfed from numbers.c:479
address@hidden {Scheme Procedure} odd? n
address@hidden {C Function} scm_odd_p (n)
-Return @code{#t} if @var{n} is an odd number, @code{#f}
-otherwise.
address@hidden deffn
-
- even?
address@hidden snarfed from numbers.c:514
address@hidden {Scheme Procedure} even? n
address@hidden {C Function} scm_even_p (n)
-Return @code{#t} if @var{n} is an even number, @code{#f}
-otherwise.
address@hidden deffn
-
- inf?
address@hidden snarfed from numbers.c:548
address@hidden {Scheme Procedure} inf? x
address@hidden {C Function} scm_inf_p (x)
-Return @code{#t} if @var{x} is either @samp{+inf.0}
-or @samp{-inf.0}, @code{#f} otherwise.
address@hidden deffn
-
- nan?
address@hidden snarfed from numbers.c:564
address@hidden {Scheme Procedure} nan? n
address@hidden {C Function} scm_nan_p (n)
-Return @code{#t} if @var{n} is a NaN, @code{#f}
-otherwise.
address@hidden deffn
-
- inf
address@hidden snarfed from numbers.c:634
address@hidden {Scheme Procedure} inf
address@hidden {C Function} scm_inf ()
-Return Inf.
address@hidden deffn
-
- nan
address@hidden snarfed from numbers.c:649
address@hidden {Scheme Procedure} nan
address@hidden {C Function} scm_nan ()
-Return NaN.
address@hidden deffn
-
- abs
address@hidden snarfed from numbers.c:665
address@hidden {Scheme Procedure} abs x
address@hidden {C Function} scm_abs (x)
-Return the absolute value of @var{x}.
address@hidden deffn
-
- logand
address@hidden snarfed from numbers.c:1201
address@hidden {Scheme Procedure} logand n1 n2
-Return the bitwise AND of the integer arguments.
-
address@hidden
-(logand) @result{} -1
-(logand 7) @result{} 7
-(logand #b111 #b011 #b001) @result{} 1
address@hidden lisp
address@hidden deffn
-
- logior
address@hidden snarfed from numbers.c:1277
address@hidden {Scheme Procedure} logior n1 n2
-Return the bitwise OR of the integer arguments.
-
address@hidden
-(logior) @result{} 0
-(logior 7) @result{} 7
-(logior #b000 #b001 #b011) @result{} 3
address@hidden lisp
address@hidden deffn
-
- logxor
address@hidden snarfed from numbers.c:1353
address@hidden {Scheme Procedure} logxor n1 n2
-Return the bitwise XOR of the integer arguments. A bit is
-set in the result if it is set in an odd number of arguments.
address@hidden
-(logxor) @result{} 0
-(logxor 7) @result{} 7
-(logxor #b000 #b001 #b011) @result{} 2
-(logxor #b000 #b001 #b011 #b011) @result{} 1
address@hidden lisp
address@hidden deffn
-
- logtest
address@hidden snarfed from numbers.c:1428
address@hidden {Scheme Procedure} logtest j k
address@hidden {C Function} scm_logtest (j, k)
-Test whether @var{j} and @var{k} have any 1 bits in common.
-This is equivalent to @code{(not (zero? (logand j k)))}, but
-without actually calculating the @code{logand}, just testing
-for non-zero.
-
address@hidden
-(logtest #b0100 #b1011) @result{} #f
-(logtest #b0100 #b0111) @result{} #t
address@hidden lisp
address@hidden deffn
-
- logbit?
address@hidden snarfed from numbers.c:1501
address@hidden {Scheme Procedure} logbit? index j
address@hidden {C Function} scm_logbit_p (index, j)
-Test whether bit number @var{index} in @var{j} is set.
address@hidden starts from 0 for the least significant bit.
-
address@hidden
-(logbit? 0 #b1101) @result{} #t
-(logbit? 1 #b1101) @result{} #f
-(logbit? 2 #b1101) @result{} #t
-(logbit? 3 #b1101) @result{} #t
-(logbit? 4 #b1101) @result{} #f
address@hidden lisp
address@hidden deffn
-
- lognot
address@hidden snarfed from numbers.c:1535
address@hidden {Scheme Procedure} lognot n
address@hidden {C Function} scm_lognot (n)
-Return the integer which is the ones-complement of the integer
-argument.
-
address@hidden
-(number->string (lognot #b10000000) 2)
- @result{} "-10000001"
-(number->string (lognot #b0) 2)
- @result{} "-1"
address@hidden lisp
address@hidden deffn
-
- modulo-expt
address@hidden snarfed from numbers.c:1580
address@hidden {Scheme Procedure} modulo-expt n k m
address@hidden {C Function} scm_modulo_expt (n, k, m)
-Return @var{n} raised to the integer exponent
address@hidden, modulo @var{m}.
-
address@hidden
-(modulo-expt 2 3 5)
- @result{} 3
address@hidden lisp
address@hidden deffn
-
- integer-expt
address@hidden snarfed from numbers.c:1689
address@hidden {Scheme Procedure} integer-expt n k
address@hidden {C Function} scm_integer_expt (n, k)
-Return @var{n} raised to the power @var{k}. @var{k} must be an
-exact integer, @var{n} can be any number.
-
-Negative @var{k} is supported, and results in @math{1/n^abs(k)}
-in the usual way. @address@hidden is 1, as usual, and that
-includes @math{0^0} is 1.
-
address@hidden
-(integer-expt 2 5) @result{} 32
-(integer-expt -3 3) @result{} -27
-(integer-expt 5 -3) @result{} 1/125
-(integer-expt 0 0) @result{} 1
address@hidden lisp
address@hidden deffn
-
- ash
address@hidden snarfed from numbers.c:1779
address@hidden {Scheme Procedure} ash n cnt
address@hidden {C Function} scm_ash (n, cnt)
-Return @var{n} shifted left by @var{cnt} bits, or shifted right
-if @var{cnt} is negative. This is an ``arithmetic'' shift.
-
-This is effectively a multiplication by address@hidden, and when
address@hidden is negative it's a division, rounded towards negative
-infinity. (Note that this is not the same rounding as
address@hidden does.)
-
-With @var{n} viewed as an infinite precision twos complement,
address@hidden means a left shift introducing zero bits, or a right
-shift dropping bits.
-
address@hidden
-(number->string (ash #b1 3) 2) @result{} "1000"
-(number->string (ash #b1010 -1) 2) @result{} "101"
-
-;; -23 is bits ...11101001, -6 is bits ...111010
-(ash -23 -2) @result{} -6
address@hidden lisp
address@hidden deffn
-
- bit-extract
address@hidden snarfed from numbers.c:1870
address@hidden {Scheme Procedure} bit-extract n start end
address@hidden {C Function} scm_bit_extract (n, start, end)
-Return the integer composed of the @var{start} (inclusive)
-through @var{end} (exclusive) bits of @var{n}. The
address@hidden bit becomes the 0-th bit in the result.
-
address@hidden
-(number->string (bit-extract #b1101101010 0 4) 2)
- @result{} "1010"
-(number->string (bit-extract #b1101101010 4 9) 2)
- @result{} "10110"
address@hidden lisp
address@hidden deffn
-
- logcount
address@hidden snarfed from numbers.c:1949
address@hidden {Scheme Procedure} logcount n
address@hidden {C Function} scm_logcount (n)
-Return the number of bits in integer @var{n}. If integer is
-positive, the 1-bits in its binary representation are counted.
-If negative, the 0-bits in its two's-complement binary
-representation are counted. If 0, 0 is returned.
-
address@hidden
-(logcount #b10101010)
- @result{} 4
-(logcount 0)
- @result{} 0
-(logcount -2)
- @result{} 1
address@hidden lisp
address@hidden deffn
-
- integer-length
address@hidden snarfed from numbers.c:1997
address@hidden {Scheme Procedure} integer-length n
address@hidden {C Function} scm_integer_length (n)
-Return the number of bits necessary to represent @var{n}.
-
address@hidden
-(integer-length #b10101010)
- @result{} 8
-(integer-length 0)
- @result{} 0
-(integer-length #b1111)
- @result{} 4
address@hidden lisp
address@hidden deffn
-
- number->string
address@hidden snarfed from numbers.c:2337
address@hidden {Scheme Procedure} number->string n [radix]
address@hidden {C Function} scm_number_to_string (n, radix)
-Return a string holding the external representation of the
-number @var{n} in the given @var{radix}. If @var{n} is
-inexact, a radix of 10 will be used.
address@hidden deffn
-
- string->number
address@hidden snarfed from numbers.c:3034
address@hidden {Scheme Procedure} string->number string [radix]
address@hidden {C Function} scm_string_to_number (string, radix)
-Return a number of the maximally precise representation
-expressed by the given @var{string}. @var{radix} must be an
-exact integer, either 2, 8, 10, or 16. If supplied, @var{radix}
-is a default radix that may be overridden by an explicit radix
-prefix in @var{string} (e.g. "#o177"). If @var{radix} is not
-supplied, then the default radix is 10. If string is not a
-syntactically valid notation for a number, then
address@hidden>number} returns @code{#f}.
address@hidden deffn
-
- number?
address@hidden snarfed from numbers.c:3097
address@hidden {Scheme Procedure} number? x
address@hidden {C Function} scm_number_p (x)
-Return @code{#t} if @var{x} is a number, @code{#f}
-otherwise.
address@hidden deffn
-
- complex?
address@hidden snarfed from numbers.c:3110
address@hidden {Scheme Procedure} complex? x
address@hidden {C Function} scm_complex_p (x)
-Return @code{#t} if @var{x} is a complex number, @code{#f}
-otherwise. Note that the sets of real, rational and integer
-values form subsets of the set of complex numbers, i. e. the
-predicate will also be fulfilled if @var{x} is a real,
-rational or integer number.
address@hidden deffn
-
- real?
address@hidden snarfed from numbers.c:3123
address@hidden {Scheme Procedure} real? x
address@hidden {C Function} scm_real_p (x)
-Return @code{#t} if @var{x} is a real number, @code{#f}
-otherwise. Note that the set of integer values forms a subset of
-the set of real numbers, i. e. the predicate will also be
-fulfilled if @var{x} is an integer number.
address@hidden deffn
-
- rational?
address@hidden snarfed from numbers.c:3136
address@hidden {Scheme Procedure} rational? x
address@hidden {C Function} scm_rational_p (x)
-Return @code{#t} if @var{x} is a rational number, @code{#f}
-otherwise. Note that the set of integer values forms a subset of
-the set of rational numbers, i. e. the predicate will also be
-fulfilled if @var{x} is an integer number.
address@hidden deffn
-
- integer?
address@hidden snarfed from numbers.c:3159
address@hidden {Scheme Procedure} integer? x
address@hidden {C Function} scm_integer_p (x)
-Return @code{#t} if @var{x} is an integer number, @code{#f}
-else.
address@hidden deffn
-
- inexact?
address@hidden snarfed from numbers.c:3185
address@hidden {Scheme Procedure} inexact? x
address@hidden {C Function} scm_inexact_p (x)
-Return @code{#t} if @var{x} is an inexact number, @code{#f}
-else.
address@hidden deffn
-
- truncate
address@hidden snarfed from numbers.c:5060
address@hidden {Scheme Procedure} truncate x
address@hidden {C Function} scm_truncate_number (x)
-Round the number @var{x} towards zero.
address@hidden deffn
-
- round
address@hidden snarfed from numbers.c:5076
address@hidden {Scheme Procedure} round x
address@hidden {C Function} scm_round_number (x)
-Round the number @var{x} towards the nearest integer. When it is exactly
halfway between two integers, round towards the even one.
address@hidden deffn
-
- floor
address@hidden snarfed from numbers.c:5102
address@hidden {Scheme Procedure} floor x
address@hidden {C Function} scm_floor (x)
-Round the number @var{x} towards minus infinity.
address@hidden deffn
-
- ceiling
address@hidden snarfed from numbers.c:5133
address@hidden {Scheme Procedure} ceiling x
address@hidden {C Function} scm_ceiling (x)
-Round the number @var{x} towards infinity.
address@hidden deffn
-
- $expt
address@hidden snarfed from numbers.c:5242
address@hidden {Scheme Procedure} $expt x y
address@hidden {C Function} scm_sys_expt (x, y)
-Return @var{x} raised to the power of @var{y}. This
-procedure does not accept complex arguments.
address@hidden deffn
-
- $atan2
address@hidden snarfed from numbers.c:5258
address@hidden {Scheme Procedure} $atan2 x y
address@hidden {C Function} scm_sys_atan2 (x, y)
-Return the arc tangent of the two arguments @var{x} and
address@hidden This is similar to calculating the arc tangent of
address@hidden / @var{y}, except that the signs of both arguments
-are used to determine the quadrant of the result. This
-procedure does not accept complex arguments.
address@hidden deffn
-
- make-rectangular
address@hidden snarfed from numbers.c:5286
address@hidden {Scheme Procedure} make-rectangular real_part imaginary_part
address@hidden {C Function} scm_make_rectangular (real_part, imaginary_part)
-Return a complex number constructed of the given @var{real-part} and
@var{imaginary-part} parts.
address@hidden deffn
-
- make-polar
address@hidden snarfed from numbers.c:5310
address@hidden {Scheme Procedure} make-polar x y
address@hidden {C Function} scm_make_polar (x, y)
-Return the complex number @var{x} * e^(i * @var{y}).
address@hidden deffn
-
- inexact->exact
address@hidden snarfed from numbers.c:5513
address@hidden {Scheme Procedure} inexact->exact z
address@hidden {C Function} scm_inexact_to_exact (z)
-Return an exact number that is numerically closest to @var{z}.
address@hidden deffn
-
- rationalize
address@hidden snarfed from numbers.c:5550
address@hidden {Scheme Procedure} rationalize x err
address@hidden {C Function} scm_rationalize (x, err)
-Return an exact number that is within @var{err} of @var{x}.
address@hidden deffn
-
- entity?
address@hidden snarfed from objects.c:192
address@hidden {Scheme Procedure} entity? obj
address@hidden {C Function} scm_entity_p (obj)
-Return @code{#t} if @var{obj} is an entity.
address@hidden deffn
-
- operator?
address@hidden snarfed from objects.c:201
address@hidden {Scheme Procedure} operator? obj
address@hidden {C Function} scm_operator_p (obj)
-Return @code{#t} if @var{obj} is an operator.
address@hidden deffn
-
- valid-object-procedure?
address@hidden snarfed from objects.c:217
address@hidden {Scheme Procedure} valid-object-procedure? proc
address@hidden {C Function} scm_valid_object_procedure_p (proc)
-Return @code{#t} iff @var{proc} is a procedure that can be used with
@code{set-object-procedure}. It is always valid to use a closure constructed
by @code{lambda}.
address@hidden deffn
-
- set-object-procedure!
address@hidden snarfed from objects.c:239
address@hidden {Scheme Procedure} set-object-procedure! obj proc
address@hidden {C Function} scm_set_object_procedure_x (obj, proc)
-Set the object procedure of @var{obj} to @var{proc}.
address@hidden must be either an entity or an operator.
address@hidden deffn
-
- make-class-object
address@hidden snarfed from objects.c:299
address@hidden {Scheme Procedure} make-class-object metaclass layout
address@hidden {C Function} scm_make_class_object (metaclass, layout)
-Create a new class object of class @var{metaclass}, with the
-slot layout specified by @var{layout}.
address@hidden deffn
-
- make-subclass-object
address@hidden snarfed from objects.c:314
address@hidden {Scheme Procedure} make-subclass-object class layout
address@hidden {C Function} scm_make_subclass_object (class, layout)
-Create a subclass object of @var{class}, with the slot layout
-specified by @var{layout}.
address@hidden deffn
-
- object-properties
address@hidden snarfed from objprop.c:36
address@hidden {Scheme Procedure} object-properties obj
address@hidden {C Function} scm_object_properties (obj)
-Return @var{obj}'s property list.
address@hidden deffn
-
- set-object-properties!
address@hidden snarfed from objprop.c:46
address@hidden {Scheme Procedure} set-object-properties! obj alist
address@hidden {C Function} scm_set_object_properties_x (obj, alist)
-Set @var{obj}'s property list to @var{alist}.
address@hidden deffn
-
- object-property
address@hidden snarfed from objprop.c:57
address@hidden {Scheme Procedure} object-property obj key
address@hidden {C Function} scm_object_property (obj, key)
-Return the property of @var{obj} with name @var{key}.
address@hidden deffn
-
- set-object-property!
address@hidden snarfed from objprop.c:69
address@hidden {Scheme Procedure} set-object-property! obj key value
address@hidden {C Function} scm_set_object_property_x (obj, key, value)
-In @var{obj}'s property list, set the property named @var{key}
-to @var{value}.
address@hidden deffn
-
- cons
address@hidden snarfed from pairs.c:56
address@hidden {Scheme Procedure} cons x y
address@hidden {C Function} scm_cons (x, y)
-Return a newly allocated pair whose car is @var{x} and whose
-cdr is @var{y}. The pair is guaranteed to be different (in the
-sense of @code{eq?}) from every previously existing object.
address@hidden deffn
-
- pair?
address@hidden snarfed from pairs.c:74
address@hidden {Scheme Procedure} pair? x
address@hidden {C Function} scm_pair_p (x)
-Return @code{#t} if @var{x} is a pair; otherwise return
address@hidden
address@hidden deffn
-
- set-car!
address@hidden snarfed from pairs.c:120
address@hidden {Scheme Procedure} set-car! pair value
address@hidden {C Function} scm_set_car_x (pair, value)
-Stores @var{value} in the car field of @var{pair}. The value returned
-by @code{set-car!} is unspecified.
address@hidden deffn
-
- set-cdr!
address@hidden snarfed from pairs.c:133
address@hidden {Scheme Procedure} set-cdr! pair value
address@hidden {C Function} scm_set_cdr_x (pair, value)
-Stores @var{value} in the cdr field of @var{pair}. The value returned
-by @code{set-cdr!} is unspecified.
address@hidden deffn
-
- char-ready?
address@hidden snarfed from ports.c:245
address@hidden {Scheme Procedure} char-ready? [port]
address@hidden {C Function} scm_char_ready_p (port)
-Return @code{#t} if a character is ready on input @var{port}
-and return @code{#f} otherwise. If @code{char-ready?} returns
address@hidden then the next @code{read-char} operation on
address@hidden is guaranteed not to hang. If @var{port} is a file
-port at end of file then @code{char-ready?} returns @code{#t}.
-
address@hidden exists to make it possible for a
-program to accept characters from interactive ports without
-getting stuck waiting for input. Any input editors associated
-with such ports must make sure that characters whose existence
-has been asserted by @code{char-ready?} cannot be rubbed out.
-If @code{char-ready?} were to return @code{#f} at end of file,
-a port at end of file would be indistinguishable from an
-interactive port that has no ready characters.
address@hidden deffn
-
- drain-input
address@hidden snarfed from ports.c:322
address@hidden {Scheme Procedure} drain-input port
address@hidden {C Function} scm_drain_input (port)
-This procedure clears a port's input buffers, similar
-to the way that force-output clears the output buffer. The
-contents of the buffers are returned as a single string, e.g.,
-
address@hidden
-(define p (open-input-file ...))
-(drain-input p) => empty string, nothing buffered yet.
-(unread-char (read-char p) p)
-(drain-input p) => initial chars from p, up to the buffer size.
address@hidden lisp
-
-Draining the buffers may be useful for cleanly finishing
-buffered I/O so that the file descriptor can be used directly
-for further input.
address@hidden deffn
-
- current-input-port
address@hidden snarfed from ports.c:355
address@hidden {Scheme Procedure} current-input-port
address@hidden {C Function} scm_current_input_port ()
-Return the current input port. This is the default port used
-by many input procedures. Initially, @code{current-input-port}
-returns the @dfn{standard input} in Unix and C terminology.
address@hidden deffn
-
- current-output-port
address@hidden snarfed from ports.c:367
address@hidden {Scheme Procedure} current-output-port
address@hidden {C Function} scm_current_output_port ()
-Return the current output port. This is the default port used
-by many output procedures. Initially,
address@hidden returns the @dfn{standard output} in
-Unix and C terminology.
address@hidden deffn
-
- current-error-port
address@hidden snarfed from ports.c:377
address@hidden {Scheme Procedure} current-error-port
address@hidden {C Function} scm_current_error_port ()
-Return the port to which errors and warnings should be sent (the
address@hidden error} in Unix and C terminology).
address@hidden deffn
-
- current-load-port
address@hidden snarfed from ports.c:387
address@hidden {Scheme Procedure} current-load-port
address@hidden {C Function} scm_current_load_port ()
-Return the current-load-port.
-The load port is used internally by @code{primitive-load}.
address@hidden deffn
-
- set-current-input-port
address@hidden snarfed from ports.c:400
address@hidden {Scheme Procedure} set-current-input-port port
address@hidden {Scheme Procedure} set-current-output-port port
address@hidden {Scheme Procedure} set-current-error-port port
address@hidden {C Function} scm_set_current_input_port (port)
-Change the ports returned by @code{current-input-port},
address@hidden and @code{current-error-port}, respectively,
-so that they use the supplied @var{port} for input or output.
address@hidden deffn
-
- set-current-output-port
address@hidden snarfed from ports.c:413
address@hidden {Scheme Procedure} set-current-output-port port
address@hidden {C Function} scm_set_current_output_port (port)
-Set the current default output port to @var{port}.
address@hidden deffn
-
- set-current-error-port
address@hidden snarfed from ports.c:427
address@hidden {Scheme Procedure} set-current-error-port port
address@hidden {C Function} scm_set_current_error_port (port)
-Set the current default error port to @var{port}.
address@hidden deffn
-
- port-revealed
address@hidden snarfed from ports.c:625
address@hidden {Scheme Procedure} port-revealed port
address@hidden {C Function} scm_port_revealed (port)
-Return the revealed count for @var{port}.
address@hidden deffn
-
- set-port-revealed!
address@hidden snarfed from ports.c:638
address@hidden {Scheme Procedure} set-port-revealed! port rcount
address@hidden {C Function} scm_set_port_revealed_x (port, rcount)
-Sets the revealed count for a port to a given value.
-The return value is unspecified.
address@hidden deffn
-
- port-mode
address@hidden snarfed from ports.c:699
address@hidden {Scheme Procedure} port-mode port
address@hidden {C Function} scm_port_mode (port)
-Return the port modes associated with the open port @var{port}.
-These will not necessarily be identical to the modes used when
-the port was opened, since modes such as "append" which are
-used only during port creation are not retained.
address@hidden deffn
-
- close-port
address@hidden snarfed from ports.c:736
address@hidden {Scheme Procedure} close-port port
address@hidden {C Function} scm_close_port (port)
-Close the specified port object. Return @code{#t} if it
-successfully closes a port or @code{#f} if it was already
-closed. An exception may be raised if an error occurs, for
-example when flushing buffered output. See also @ref{Ports and
-File Descriptors, close}, for a procedure which can close file
-descriptors.
address@hidden deffn
-
- close-input-port
address@hidden snarfed from ports.c:766
address@hidden {Scheme Procedure} close-input-port port
address@hidden {C Function} scm_close_input_port (port)
-Close the specified input port object. The routine has no effect if
-the file has already been closed. An exception may be raised if an
-error occurs. The value returned is unspecified.
-
-See also @ref{Ports and File Descriptors, close}, for a procedure
-which can close file descriptors.
address@hidden deffn
-
- close-output-port
address@hidden snarfed from ports.c:781
address@hidden {Scheme Procedure} close-output-port port
address@hidden {C Function} scm_close_output_port (port)
-Close the specified output port object. The routine has no effect if
-the file has already been closed. An exception may be raised if an
-error occurs. The value returned is unspecified.
-
-See also @ref{Ports and File Descriptors, close}, for a procedure
-which can close file descriptors.
address@hidden deffn
-
- port-for-each
address@hidden snarfed from ports.c:827
address@hidden {Scheme Procedure} port-for-each proc
address@hidden {C Function} scm_port_for_each (proc)
-Apply @var{proc} to each port in the Guile port table
-in turn. The return value is unspecified. More specifically,
address@hidden is applied exactly once to every port that exists
-in the system at the time @var{port-for-each} is invoked.
-Changes to the port table while @var{port-for-each} is running
-have no effect as far as @var{port-for-each} is concerned.
address@hidden deffn
-
- input-port?
address@hidden snarfed from ports.c:845
address@hidden {Scheme Procedure} input-port? x
address@hidden {C Function} scm_input_port_p (x)
-Return @code{#t} if @var{x} is an input port, otherwise return
address@hidden Any object satisfying this predicate also satisfies
address@hidden
address@hidden deffn
-
- output-port?
address@hidden snarfed from ports.c:856
address@hidden {Scheme Procedure} output-port? x
address@hidden {C Function} scm_output_port_p (x)
-Return @code{#t} if @var{x} is an output port, otherwise return
address@hidden Any object satisfying this predicate also satisfies
address@hidden
address@hidden deffn
-
- port?
address@hidden snarfed from ports.c:868
address@hidden {Scheme Procedure} port? x
address@hidden {C Function} scm_port_p (x)
-Return a boolean indicating whether @var{x} is a port.
-Equivalent to @code{(or (input-port? @var{x}) (output-port?
address@hidden))}.
address@hidden deffn
-
- port-closed?
address@hidden snarfed from ports.c:878
address@hidden {Scheme Procedure} port-closed? port
address@hidden {C Function} scm_port_closed_p (port)
-Return @code{#t} if @var{port} is closed or @code{#f} if it is
-open.
address@hidden deffn
-
- eof-object?
address@hidden snarfed from ports.c:889
address@hidden {Scheme Procedure} eof-object? x
address@hidden {C Function} scm_eof_object_p (x)
-Return @code{#t} if @var{x} is an end-of-file object; otherwise
-return @code{#f}.
address@hidden deffn
-
- force-output
address@hidden snarfed from ports.c:903
address@hidden {Scheme Procedure} force-output [port]
address@hidden {C Function} scm_force_output (port)
-Flush the specified output port, or the current output port if @var{port}
-is omitted. The current output buffer contents are passed to the
-underlying port implementation (e.g., in the case of fports, the
-data will be written to the file and the output buffer will be cleared.)
-It has no effect on an unbuffered port.
-
-The return value is unspecified.
address@hidden deffn
-
- flush-all-ports
address@hidden snarfed from ports.c:921
address@hidden {Scheme Procedure} flush-all-ports
address@hidden {C Function} scm_flush_all_ports ()
-Equivalent to calling @code{force-output} on
-all open output ports. The return value is unspecified.
address@hidden deffn
-
- read-char
address@hidden snarfed from ports.c:941
address@hidden {Scheme Procedure} read-char [port]
address@hidden {C Function} scm_read_char (port)
-Return the next character available from @var{port}, updating
address@hidden to point to the following character. If no more
-characters are available, the end-of-file object is returned.
address@hidden deffn
-
- peek-char
address@hidden snarfed from ports.c:1283
address@hidden {Scheme Procedure} peek-char [port]
address@hidden {C Function} scm_peek_char (port)
-Return the next character available from @var{port},
address@hidden updating @var{port} to point to the following
-character. If no more characters are available, the
-end-of-file object is returned.
-
-The value returned by
-a call to @code{peek-char} is the same as the value that would
-have been returned by a call to @code{read-char} on the same
-port. The only difference is that the very next call to
address@hidden or @code{peek-char} on that @var{port} will
-return the value returned by the preceding call to
address@hidden In particular, a call to @code{peek-char} on
-an interactive port will hang waiting for input whenever a call
-to @code{read-char} would have hung.
address@hidden deffn
-
- unread-char
address@hidden snarfed from ports.c:1306
address@hidden {Scheme Procedure} unread-char cobj [port]
address@hidden {C Function} scm_unread_char (cobj, port)
-Place @var{char} in @var{port} so that it will be read by the
-next read operation. If called multiple times, the unread characters
-will be read again in last-in first-out order. If @var{port} is
-not supplied, the current input port is used.
address@hidden deffn
-
- unread-string
address@hidden snarfed from ports.c:1329
address@hidden {Scheme Procedure} unread-string str port
address@hidden {C Function} scm_unread_string (str, port)
-Place the string @var{str} in @var{port} so that its characters will be
-read in subsequent read operations. If called multiple times, the
-unread characters will be read again in last-in first-out order. If
address@hidden is not supplied, the current-input-port is used.
address@hidden deffn
-
- seek
address@hidden snarfed from ports.c:1368
address@hidden {Scheme Procedure} seek fd_port offset whence
address@hidden {C Function} scm_seek (fd_port, offset, whence)
-Sets the current position of @var{fd/port} to the integer
address@hidden, which is interpreted according to the value of
address@hidden
-
-One of the following variables should be supplied for
address@hidden:
address@hidden SEEK_SET
-Seek from the beginning of the file.
address@hidden defvar
address@hidden SEEK_CUR
-Seek from the current position.
address@hidden defvar
address@hidden SEEK_END
-Seek from the end of the file.
address@hidden defvar
-If @var{fd/port} is a file descriptor, the underlying system
-call is @code{lseek}. @var{port} may be a string port.
-
-The value returned is the new position in the file. This means
-that the current position of a port can be obtained using:
address@hidden
-(seek port 0 SEEK_CUR)
address@hidden lisp
address@hidden deffn
-
- truncate-file
address@hidden snarfed from ports.c:1426
address@hidden {Scheme Procedure} truncate-file object [length]
address@hidden {C Function} scm_truncate_file (object, length)
-Truncates the object referred to by @var{object} to at most
address@hidden bytes. @var{object} can be a string containing a
-file name or an integer file descriptor or a port.
address@hidden may be omitted if @var{object} is not a file name,
-in which case the truncation occurs at the current port
-position. The return value is unspecified.
address@hidden deffn
-
- port-line
address@hidden snarfed from ports.c:1486
address@hidden {Scheme Procedure} port-line port
address@hidden {C Function} scm_port_line (port)
-Return the current line number for @var{port}.
-
-The first line of a file is 0. But you might want to add 1
-when printing line numbers, since starting from 1 is
-traditional in error messages, and likely to be more natural to
-non-programmers.
address@hidden deffn
-
- set-port-line!
address@hidden snarfed from ports.c:1498
address@hidden {Scheme Procedure} set-port-line! port line
address@hidden {C Function} scm_set_port_line_x (port, line)
-Set the current line number for @var{port} to @var{line}. The
-first line of a file is 0.
address@hidden deffn
-
- port-column
address@hidden snarfed from ports.c:1517
address@hidden {Scheme Procedure} port-column port
address@hidden {C Function} scm_port_column (port)
-Return the current column number of @var{port}.
-If the number is
-unknown, the result is #f. Otherwise, the result is a 0-origin integer
-- i.e. the first character of the first line is line 0, column 0.
-(However, when you display a file position, for example in an error
-message, we recommend you add 1 to get 1-origin integers. This is
-because lines and column numbers traditionally start with 1, and that is
-what non-programmers will find most natural.)
address@hidden deffn
-
- set-port-column!
address@hidden snarfed from ports.c:1529
address@hidden {Scheme Procedure} set-port-column! port column
address@hidden {C Function} scm_set_port_column_x (port, column)
-Set the current column of @var{port}. Before reading the first
-character on a line the column should be 0.
address@hidden deffn
-
- port-filename
address@hidden snarfed from ports.c:1543
address@hidden {Scheme Procedure} port-filename port
address@hidden {C Function} scm_port_filename (port)
-Return the filename associated with @var{port}. This function returns
-the strings "standard input", "standard output" and "standard error"
-when called on the current input, output and error ports respectively.
address@hidden deffn
-
- set-port-filename!
address@hidden snarfed from ports.c:1557
address@hidden {Scheme Procedure} set-port-filename! port filename
address@hidden {C Function} scm_set_port_filename_x (port, filename)
-Change the filename associated with @var{port}, using the current input
-port if none is specified. Note that this does not change the port's
-source of data, but only the value that is returned by
address@hidden and reported in diagnostic output.
address@hidden deffn
-
- %make-void-port
address@hidden snarfed from ports.c:1651
address@hidden {Scheme Procedure} %make-void-port mode
address@hidden {C Function} scm_sys_make_void_port (mode)
-Create and return a new void port. A void port acts like
address@hidden/dev/null}. The @var{mode} argument
-specifies the input/output modes for this port: see the
-documentation for @code{open-file} in @ref{File Ports}.
address@hidden deffn
-
- print-options-interface
address@hidden snarfed from print.c:87
address@hidden {Scheme Procedure} print-options-interface [setting]
address@hidden {C Function} scm_print_options (setting)
-Option interface for the print options. Instead of using
-this procedure directly, use the procedures
address@hidden, @code{print-disable}, @code{print-set!}
-and @code{print-options}.
address@hidden deffn
-
- simple-format
address@hidden snarfed from print.c:929
address@hidden {Scheme Procedure} simple-format destination message . args
address@hidden {C Function} scm_simple_format (destination, message, args)
-Write @var{message} to @var{destination}, defaulting to
-the current output port.
address@hidden can contain @code{~A} (was @code{%s}) and
address@hidden (was @code{%S}) escapes. When printed,
-the escapes are replaced with corresponding members of
address@hidden:
address@hidden formats using @code{display} and @code{~S} formats
-using @code{write}.
-If @var{destination} is @code{#t}, then use the current output
-port, if @var{destination} is @code{#f}, then return a string
-containing the formatted text. Does not add a trailing newline.
address@hidden deffn
-
- newline
address@hidden snarfed from print.c:1019
address@hidden {Scheme Procedure} newline [port]
address@hidden {C Function} scm_newline (port)
-Send a newline to @var{port}.
-If @var{port} is omitted, send to the current output port.
address@hidden deffn
-
- write-char
address@hidden snarfed from print.c:1034
address@hidden {Scheme Procedure} write-char chr [port]
address@hidden {C Function} scm_write_char (chr, port)
-Send character @var{chr} to @var{port}.
address@hidden deffn
-
- port-with-print-state
address@hidden snarfed from print.c:1088
address@hidden {Scheme Procedure} port-with-print-state port [pstate]
address@hidden {C Function} scm_port_with_print_state (port, pstate)
-Create a new port which behaves like @var{port}, but with an
-included print state @var{pstate}. @var{pstate} is optional.
-If @var{pstate} isn't supplied and @var{port} already has
-a print state, the old print state is reused.
address@hidden deffn
-
- get-print-state
address@hidden snarfed from print.c:1101
address@hidden {Scheme Procedure} get-print-state port
address@hidden {C Function} scm_get_print_state (port)
-Return the print state of the port @var{port}. If @var{port}
-has no associated print state, @code{#f} is returned.
address@hidden deffn
-
- procedure-properties
address@hidden snarfed from procprop.c:160
address@hidden {Scheme Procedure} procedure-properties proc
address@hidden {C Function} scm_procedure_properties (proc)
-Return @var{obj}'s property list.
address@hidden deffn
-
- set-procedure-properties!
address@hidden snarfed from procprop.c:173
address@hidden {Scheme Procedure} set-procedure-properties! proc new_val
address@hidden {C Function} scm_set_procedure_properties_x (proc, new_val)
-Set @var{obj}'s property list to @var{alist}.
address@hidden deffn
-
- procedure-property
address@hidden snarfed from procprop.c:186
address@hidden {Scheme Procedure} procedure-property p k
address@hidden {C Function} scm_procedure_property (p, k)
-Return the property of @var{obj} with name @var{key}.
address@hidden deffn
-
- set-procedure-property!
address@hidden snarfed from procprop.c:209
address@hidden {Scheme Procedure} set-procedure-property! p k v
address@hidden {C Function} scm_set_procedure_property_x (p, k, v)
-In @var{obj}'s property list, set the property named @var{key} to
address@hidden
address@hidden deffn
-
- procedure?
address@hidden snarfed from procs.c:162
address@hidden {Scheme Procedure} procedure? obj
address@hidden {C Function} scm_procedure_p (obj)
-Return @code{#t} if @var{obj} is a procedure.
address@hidden deffn
-
- closure?
address@hidden snarfed from procs.c:189
address@hidden {Scheme Procedure} closure? obj
address@hidden {C Function} scm_closure_p (obj)
-Return @code{#t} if @var{obj} is a closure.
address@hidden deffn
-
- thunk?
address@hidden snarfed from procs.c:198
address@hidden {Scheme Procedure} thunk? obj
address@hidden {C Function} scm_thunk_p (obj)
-Return @code{#t} if @var{obj} is a thunk.
address@hidden deffn
-
- procedure-documentation
address@hidden snarfed from procs.c:248
address@hidden {Scheme Procedure} procedure-documentation proc
address@hidden {C Function} scm_procedure_documentation (proc)
-Return the documentation string associated with @code{proc}. By
-convention, if a procedure contains more than one expression and the
-first expression is a string constant, that string is assumed to contain
-documentation for that procedure.
address@hidden deffn
-
- procedure-with-setter?
address@hidden snarfed from procs.c:284
address@hidden {Scheme Procedure} procedure-with-setter? obj
address@hidden {C Function} scm_procedure_with_setter_p (obj)
-Return @code{#t} if @var{obj} is a procedure with an
-associated setter procedure.
address@hidden deffn
-
- make-procedure-with-setter
address@hidden snarfed from procs.c:294
address@hidden {Scheme Procedure} make-procedure-with-setter procedure setter
address@hidden {C Function} scm_make_procedure_with_setter (procedure, setter)
-Create a new procedure which behaves like @var{procedure}, but
-with the associated setter @var{setter}.
address@hidden deffn
-
- procedure
address@hidden snarfed from procs.c:308
address@hidden {Scheme Procedure} procedure proc
address@hidden {C Function} scm_procedure (proc)
-Return the procedure of @var{proc}, which must be an
-applicable struct.
address@hidden deffn
-
- primitive-make-property
address@hidden snarfed from properties.c:40
address@hidden {Scheme Procedure} primitive-make-property not_found_proc
address@hidden {C Function} scm_primitive_make_property (not_found_proc)
-Create a @dfn{property token} that can be used with
address@hidden and @code{primitive-property-set!}.
-See @code{primitive-property-ref} for the significance of
address@hidden
address@hidden deffn
-
- primitive-property-ref
address@hidden snarfed from properties.c:59
address@hidden {Scheme Procedure} primitive-property-ref prop obj
address@hidden {C Function} scm_primitive_property_ref (prop, obj)
-Return the property @var{prop} of @var{obj}.
-
-When no value has yet been associated with @var{prop} and
address@hidden, the @var{not-found-proc} from @var{prop} is used. A
-call @code{(@var{not-found-proc} @var{prop} @var{obj})} is made
-and the result set as the property value. If
address@hidden is @code{#f} then @code{#f} is the
-property value.
address@hidden deffn
-
- primitive-property-set!
address@hidden snarfed from properties.c:90
address@hidden {Scheme Procedure} primitive-property-set! prop obj val
address@hidden {C Function} scm_primitive_property_set_x (prop, obj, val)
-Set the property @var{prop} of @var{obj} to @var{val}.
address@hidden deffn
-
- primitive-property-del!
address@hidden snarfed from properties.c:111
address@hidden {Scheme Procedure} primitive-property-del! prop obj
address@hidden {C Function} scm_primitive_property_del_x (prop, obj)
-Remove any value associated with @var{prop} and @var{obj}.
address@hidden deffn
-
- random
address@hidden snarfed from random.c:347
address@hidden {Scheme Procedure} random n [state]
address@hidden {C Function} scm_random (n, state)
-Return a number in [0, N).
-
-Accepts a positive integer or real n and returns a
-number of the same type between zero (inclusive) and
-N (exclusive). The values returned have a uniform
-distribution.
-
-The optional argument @var{state} must be of the type produced
-by @code{seed->random-state}. It defaults to the value of the
-variable @var{*random-state*}. This object is used to maintain
-the state of the pseudo-random-number generator and is altered
-as a side effect of the random operation.
address@hidden deffn
-
- copy-random-state
address@hidden snarfed from random.c:372
address@hidden {Scheme Procedure} copy-random-state [state]
address@hidden {C Function} scm_copy_random_state (state)
-Return a copy of the random state @var{state}.
address@hidden deffn
-
- seed->random-state
address@hidden snarfed from random.c:384
address@hidden {Scheme Procedure} seed->random-state seed
address@hidden {C Function} scm_seed_to_random_state (seed)
-Return a new random state using @var{seed}.
address@hidden deffn
-
- random:uniform
address@hidden snarfed from random.c:402
address@hidden {Scheme Procedure} random:uniform [state]
address@hidden {C Function} scm_random_uniform (state)
-Return a uniformly distributed inexact real random number in
-[0,1).
address@hidden deffn
-
- random:normal
address@hidden snarfed from random.c:417
address@hidden {Scheme Procedure} random:normal [state]
address@hidden {C Function} scm_random_normal (state)
-Return an inexact real in a normal distribution. The
-distribution used has mean 0 and standard deviation 1. For a
-normal distribution with mean m and standard deviation d use
address@hidden(+ m (* d (random:normal)))}.
address@hidden deffn
-
- random:solid-sphere!
address@hidden snarfed from random.c:500
address@hidden {Scheme Procedure} random:solid-sphere! v [state]
address@hidden {C Function} scm_random_solid_sphere_x (v, state)
-Fills @var{vect} with inexact real random numbers the sum of
-whose squares is less than 1.0. Thinking of @var{vect} as
-coordinates in space of dimension @var{n} @math{=}
address@hidden(vector-length @var{vect})}, the coordinates are
-uniformly distributed within the unit @var{n}-sphere.
address@hidden deffn
-
- random:hollow-sphere!
address@hidden snarfed from random.c:522
address@hidden {Scheme Procedure} random:hollow-sphere! v [state]
address@hidden {C Function} scm_random_hollow_sphere_x (v, state)
-Fills vect with inexact real random numbers
-the sum of whose squares is equal to 1.0.
-Thinking of vect as coordinates in space of
-dimension n = (vector-length vect), the coordinates
-are uniformly distributed over the surface of the
-unit n-sphere.
address@hidden deffn
-
- random:normal-vector!
address@hidden snarfed from random.c:539
address@hidden {Scheme Procedure} random:normal-vector! v [state]
address@hidden {C Function} scm_random_normal_vector_x (v, state)
-Fills vect with inexact real random numbers that are
-independent and standard normally distributed
-(i.e., with mean 0 and variance 1).
address@hidden deffn
-
- random:exp
address@hidden snarfed from random.c:577
address@hidden {Scheme Procedure} random:exp [state]
address@hidden {C Function} scm_random_exp (state)
-Return an inexact real in an exponential distribution with mean
-1. For an exponential distribution with mean u use (* u
-(random:exp)).
address@hidden deffn
-
- %read-delimited!
address@hidden snarfed from rdelim.c:55
address@hidden {Scheme Procedure} %read-delimited! delims str gobble [port
[start [end]]]
address@hidden {C Function} scm_read_delimited_x (delims, str, gobble, port,
start, end)
-Read characters from @var{port} into @var{str} until one of the
-characters in the @var{delims} string is encountered. If
address@hidden is true, discard the delimiter character;
-otherwise, leave it in the input stream for the next read. If
address@hidden is not specified, use the value of
address@hidden(current-input-port)}. If @var{start} or @var{end} are
-specified, store data only into the substring of @var{str}
-bounded by @var{start} and @var{end} (which default to the
-beginning and end of the string, respectively).
-
- Return a pair consisting of the delimiter that terminated the
-string and the number of characters read. If reading stopped
-at the end of file, the delimiter returned is the
address@hidden; if the string was filled without encountering
-a delimiter, this value is @code{#f}.
address@hidden deffn
-
- %read-line
address@hidden snarfed from rdelim.c:202
address@hidden {Scheme Procedure} %read-line [port]
address@hidden {C Function} scm_read_line (port)
-Read a newline-terminated line from @var{port}, allocating storage as
-necessary. The newline terminator (if any) is removed from the string,
-and a pair consisting of the line and its delimiter is returned. The
-delimiter may be either a newline or the @var{eof-object}; if
address@hidden is called at the end of file, it returns the pair
address@hidden(#<eof> . #<eof>)}.
address@hidden deffn
-
- write-line
address@hidden snarfed from rdelim.c:255
address@hidden {Scheme Procedure} write-line obj [port]
address@hidden {C Function} scm_write_line (obj, port)
-Display @var{obj} and a newline character to @var{port}. If
address@hidden is not specified, @code{(current-output-port)} is
-used. This function is equivalent to:
address@hidden
-(display obj [port])
-(newline [port])
address@hidden lisp
address@hidden deffn
-
- read-options-interface
address@hidden snarfed from read.c:110
address@hidden {Scheme Procedure} read-options-interface [setting]
address@hidden {C Function} scm_read_options (setting)
-Option interface for the read options. Instead of using
-this procedure directly, use the procedures @code{read-enable},
address@hidden, @code{read-set!} and @code{read-options}.
address@hidden deffn
-
- read
address@hidden snarfed from read.c:130
address@hidden {Scheme Procedure} read [port]
address@hidden {C Function} scm_read (port)
-Read an s-expression from the input port @var{port}, or from
-the current input port if @var{port} is not specified.
-Any whitespace before the next token is discarded.
address@hidden deffn
-
- read-hash-extend
address@hidden snarfed from read.c:898
address@hidden {Scheme Procedure} read-hash-extend chr proc
address@hidden {C Function} scm_read_hash_extend (chr, proc)
-Install the procedure @var{proc} for reading expressions
-starting with the character sequence @code{#} and @var{chr}.
address@hidden will be called with two arguments: the character
address@hidden and the port to read further data from. The object
-returned will be the return value of @code{read}.
-Passing @code{#f} for @var{proc} will remove a previous setting.
-
address@hidden deffn
-
- call-with-dynamic-root
address@hidden snarfed from root.c:160
address@hidden {Scheme Procedure} call-with-dynamic-root thunk handler
address@hidden {C Function} scm_call_with_dynamic_root (thunk, handler)
-Call @var{thunk} with a new dynamic state and withina continuation barrier.
The @var{handler} catches allotherwise uncaught throws and executes within the
samedynamic context as @var{thunk}.
address@hidden deffn
-
- dynamic-root
address@hidden snarfed from root.c:171
address@hidden {Scheme Procedure} dynamic-root
address@hidden {C Function} scm_dynamic_root ()
-Return an object representing the current dynamic root.
-
-These objects are only useful for comparison using @code{eq?}.
-
address@hidden deffn
-
- read-string!/partial
address@hidden snarfed from rw.c:101
address@hidden {Scheme Procedure} read-string!/partial str [port_or_fdes [start
[end]]]
address@hidden {C Function} scm_read_string_x_partial (str, port_or_fdes,
start, end)
-Read characters from a port or file descriptor into a
-string @var{str}. A port must have an underlying file
-descriptor --- a so-called fport. This procedure is
-scsh-compatible and can efficiently read large strings.
-It will:
-
address@hidden
address@hidden
-attempt to fill the entire string, unless the @var{start}
-and/or @var{end} arguments are supplied. i.e., @var{start}
-defaults to 0 and @var{end} defaults to
address@hidden(string-length str)}
address@hidden
-use the current input port if @var{port_or_fdes} is not
-supplied.
address@hidden
-return fewer than the requested number of characters in some
-cases, e.g., on end of file, if interrupted by a signal, or if
-not all the characters are immediately available.
address@hidden
-wait indefinitely for some input if no characters are
-currently available,
-unless the port is in non-blocking mode.
address@hidden
-read characters from the port's input buffers if available,
-instead from the underlying file descriptor.
address@hidden
-return @code{#f} if end-of-file is encountered before reading
-any characters, otherwise return the number of characters
-read.
address@hidden
-return 0 if the port is in non-blocking mode and no characters
-are immediately available.
address@hidden
-return 0 if the request is for 0 bytes, with no
-end-of-file check.
address@hidden itemize
address@hidden deffn
-
- write-string/partial
address@hidden snarfed from rw.c:205
address@hidden {Scheme Procedure} write-string/partial str [port_or_fdes [start
[end]]]
address@hidden {C Function} scm_write_string_partial (str, port_or_fdes, start,
end)
-Write characters from a string @var{str} to a port or file
-descriptor. A port must have an underlying file descriptor
---- a so-called fport. This procedure is
-scsh-compatible and can efficiently write large strings.
-It will:
-
address@hidden
address@hidden
-attempt to write the entire string, unless the @var{start}
-and/or @var{end} arguments are supplied. i.e., @var{start}
-defaults to 0 and @var{end} defaults to
address@hidden(string-length str)}
address@hidden
-use the current output port if @var{port_of_fdes} is not
-supplied.
address@hidden
-in the case of a buffered port, store the characters in the
-port's output buffer, if all will fit. If they will not fit
-then any existing buffered characters will be flushed
-before attempting
-to write the new characters directly to the underlying file
-descriptor. If the port is in non-blocking mode and
-buffered characters can not be flushed immediately, then an
address@hidden system-error exception will be raised (Note:
-scsh does not support the use of non-blocking buffered ports.)
address@hidden
-write fewer than the requested number of
-characters in some cases, e.g., if interrupted by a signal or
-if not all of the output can be accepted immediately.
address@hidden
-wait indefinitely for at least one character
-from @var{str} to be accepted by the port, unless the port is
-in non-blocking mode.
address@hidden
-return the number of characters accepted by the port.
address@hidden
-return 0 if the port is in non-blocking mode and can not accept
-at least one character from @var{str} immediately
address@hidden
-return 0 immediately if the request size is 0 bytes.
address@hidden itemize
address@hidden deffn
-
- sigaction
address@hidden snarfed from scmsigs.c:253
address@hidden {Scheme Procedure} sigaction signum [handler [flags [thread]]]
address@hidden {C Function} scm_sigaction_for_thread (signum, handler, flags,
thread)
-Install or report the signal handler for a specified signal.
-
address@hidden is the signal number, which can be specified using the value
-of variables such as @code{SIGINT}.
-
-If @var{handler} is omitted, @code{sigaction} returns a pair: the
-CAR is the current
-signal hander, which will be either an integer with the value @code{SIG_DFL}
-(default action) or @code{SIG_IGN} (ignore), or the Scheme procedure which
-handles the signal, or @code{#f} if a non-Scheme procedure handles the
-signal. The CDR contains the current @code{sigaction} flags for the handler.
-
-If @var{handler} is provided, it is installed as the new handler for
address@hidden @var{handler} can be a Scheme procedure taking one
-argument, or the value of @code{SIG_DFL} (default action) or
address@hidden (ignore), or @code{#f} to restore whatever signal handler
-was installed before @code{sigaction} was first used. When
-a scheme procedure has been specified, that procedure will run
-in the given @var{thread}. When no thread has been given, the
-thread that made this call to @code{sigaction} is used.
-Flags can optionally be specified for the new handler (@code{SA_RESTART} will
-always be added if it's available and the system is using restartable
-system calls.) The return value is a pair with information about the
-old handler as described above.
-
-This interface does not provide access to the "signal blocking"
-facility. Maybe this is not needed, since the thread support may
-provide solutions to the problem of consistent access to data
-structures.
address@hidden deffn
-
- restore-signals
address@hidden snarfed from scmsigs.c:427
address@hidden {Scheme Procedure} restore-signals
address@hidden {C Function} scm_restore_signals ()
-Return all signal handlers to the values they had before any call to
address@hidden was made. The return value is unspecified.
address@hidden deffn
-
- alarm
address@hidden snarfed from scmsigs.c:464
address@hidden {Scheme Procedure} alarm i
address@hidden {C Function} scm_alarm (i)
-Set a timer to raise a @code{SIGALRM} signal after the specified
-number of seconds (an integer). It's advisable to install a signal
-handler for
address@hidden beforehand, since the default action is to terminate
-the process.
-
-The return value indicates the time remaining for the previous alarm,
-if any. The new value replaces the previous alarm. If there was
-no previous alarm, the return value is zero.
address@hidden deffn
-
- setitimer
address@hidden snarfed from scmsigs.c:491
address@hidden {Scheme Procedure} setitimer which_timer interval_seconds
interval_microseconds value_seconds value_microseconds
address@hidden {C Function} scm_setitimer (which_timer, interval_seconds,
interval_microseconds, value_seconds, value_microseconds)
-Set the timer specified by @var{which_timer} according to the given
address@hidden, @var{interval_microseconds},
address@hidden, and @var{value_microseconds} values.
-
-Return information about the timer's previous setting.
-Errors are handled as described in the guile info pages under ``POSIX
-Interface Conventions''.
-
-The timers available are: @code{ITIMER_REAL}, @code{ITIMER_VIRTUAL},
-and @code{ITIMER_PROF}.
-
-The return value will be a list of two cons pairs representing the
-current state of the given timer. The first pair is the seconds and
-microseconds of the timer @code{it_interval}, and the second pair is
-the seconds and microseconds of the timer @code{it_value}.
address@hidden deffn
-
- getitimer
address@hidden snarfed from scmsigs.c:532
address@hidden {Scheme Procedure} getitimer which_timer
address@hidden {C Function} scm_getitimer (which_timer)
-Return information about the timer specified by @var{which_timer}
-Errors are handled as described in the guile info pages under ``POSIX
-Interface Conventions''.
-
-The timers available are: @code{ITIMER_REAL}, @code{ITIMER_VIRTUAL},
-and @code{ITIMER_PROF}.
-
-The return value will be a list of two cons pairs representing the
-current state of the given timer. The first pair is the seconds and
-microseconds of the timer @code{it_interval}, and the second pair is
-the seconds and microseconds of the timer @code{it_value}.
address@hidden deffn
-
- pause
address@hidden snarfed from scmsigs.c:559
address@hidden {Scheme Procedure} pause
address@hidden {C Function} scm_pause ()
-Pause the current process (thread?) until a signal arrives whose
-action is to either terminate the current process or invoke a
-handler procedure. The return value is unspecified.
address@hidden deffn
-
- sleep
address@hidden snarfed from scmsigs.c:572
address@hidden {Scheme Procedure} sleep i
address@hidden {C Function} scm_sleep (i)
-Wait for the given number of seconds (an integer) or until a signal
-arrives. The return value is zero if the time elapses or the number
-of seconds remaining otherwise.
address@hidden deffn
-
- usleep
address@hidden snarfed from scmsigs.c:581
address@hidden {Scheme Procedure} usleep i
address@hidden {C Function} scm_usleep (i)
-Sleep for @var{i} microseconds.
address@hidden deffn
-
- raise
address@hidden snarfed from scmsigs.c:591
address@hidden {Scheme Procedure} raise sig
address@hidden {C Function} scm_raise (sig)
-Sends a specified signal @var{sig} to the current process, where
address@hidden is as described for the kill procedure.
address@hidden deffn
-
- system
address@hidden snarfed from simpos.c:64
address@hidden {Scheme Procedure} system [cmd]
address@hidden {C Function} scm_system (cmd)
-Execute @var{cmd} using the operating system's "command
-processor". Under Unix this is usually the default shell
address@hidden The value returned is @var{cmd}'s exit status as
-returned by @code{waitpid}, which can be interpreted using
address@hidden:exit-val} and friends.
-
-If @code{system} is called without arguments, return a boolean
-indicating whether the command processor is available.
address@hidden deffn
-
- system*
address@hidden snarfed from simpos.c:114
address@hidden {Scheme Procedure} system* . args
address@hidden {C Function} scm_system_star (args)
-Execute the command indicated by @var{args}. The first element must
-be a string indicating the command to be executed, and the remaining
-items must be strings representing each of the arguments to that
-command.
-
-This function returns the exit status of the command as provided by
address@hidden This value can be handled with @code{status:exit-val}
-and the related functions.
-
address@hidden is similar to @code{system}, but accepts only one
-string per-argument, and performs no shell interpretation. The
-command is executed using fork and execlp. Accordingly this function
-may be safer than @code{system} in situations where shell
-interpretation is not required.
-
-Example: (system* "echo" "foo" "bar")
address@hidden deffn
-
- getenv
address@hidden snarfed from simpos.c:184
address@hidden {Scheme Procedure} getenv nam
address@hidden {C Function} scm_getenv (nam)
-Looks up the string @var{name} in the current environment. The return
-value is @code{#f} unless a string of the form @code{NAME=VALUE} is
-found, in which case the string @code{VALUE} is returned.
address@hidden deffn
-
- primitive-exit
address@hidden snarfed from simpos.c:200
address@hidden {Scheme Procedure} primitive-exit [status]
address@hidden {C Function} scm_primitive_exit (status)
-Terminate the current process without unwinding the Scheme stack.
-This is would typically be useful after a fork. The exit status
-is @var{status} if supplied, otherwise zero.
address@hidden deffn
-
- restricted-vector-sort!
address@hidden snarfed from sort.c:78
address@hidden {Scheme Procedure} restricted-vector-sort! vec less startpos
endpos
address@hidden {C Function} scm_restricted_vector_sort_x (vec, less, startpos,
endpos)
-Sort the vector @var{vec}, using @var{less} for comparing
-the vector elements. @var{startpos} (inclusively) and
address@hidden (exclusively) delimit
-the range of the vector which gets sorted. The return value
-is not specified.
address@hidden deffn
-
- sorted?
address@hidden snarfed from sort.c:111
address@hidden {Scheme Procedure} sorted? items less
address@hidden {C Function} scm_sorted_p (items, less)
-Return @code{#t} iff @var{items} is a list or a vector such that
-for all 1 <= i <= m, the predicate @var{less} returns true when
-applied to all elements i - 1 and i
address@hidden deffn
-
- merge
address@hidden snarfed from sort.c:186
address@hidden {Scheme Procedure} merge alist blist less
address@hidden {C Function} scm_merge (alist, blist, less)
-Merge two already sorted lists into one.
-Given two lists @var{alist} and @var{blist}, such that
address@hidden(sorted? alist less?)} and @code{(sorted? blist less?)},
-return a new list in which the elements of @var{alist} and
address@hidden have been stably interleaved so that
address@hidden(sorted? (merge alist blist less?) less?)}.
-Note: this does _not_ accept vectors.
address@hidden deffn
-
- merge!
address@hidden snarfed from sort.c:303
address@hidden {Scheme Procedure} merge! alist blist less
address@hidden {C Function} scm_merge_x (alist, blist, less)
-Takes two lists @var{alist} and @var{blist} such that
address@hidden(sorted? alist less?)} and @code{(sorted? blist less?)} and
-returns a new list in which the elements of @var{alist} and
address@hidden have been stably interleaved so that
- @code{(sorted? (merge alist blist less?) less?)}.
-This is the destructive variant of @code{merge}
-Note: this does _not_ accept vectors.
address@hidden deffn
-
- sort!
address@hidden snarfed from sort.c:373
address@hidden {Scheme Procedure} sort! items less
address@hidden {C Function} scm_sort_x (items, less)
-Sort the sequence @var{items}, which may be a list or a
-vector. @var{less} is used for comparing the sequence
-elements. The sorting is destructive, that means that the
-input sequence is modified to produce the sorted result.
-This is not a stable sort.
address@hidden deffn
-
- sort
address@hidden snarfed from sort.c:404
address@hidden {Scheme Procedure} sort items less
address@hidden {C Function} scm_sort (items, less)
-Sort the sequence @var{items}, which may be a list or a
-vector. @var{less} is used for comparing the sequence
-elements. This is not a stable sort.
address@hidden deffn
-
- stable-sort!
address@hidden snarfed from sort.c:487
address@hidden {Scheme Procedure} stable-sort! items less
address@hidden {C Function} scm_stable_sort_x (items, less)
-Sort the sequence @var{items}, which may be a list or a
-vector. @var{less} is used for comparing the sequence elements.
-The sorting is destructive, that means that the input sequence
-is modified to produce the sorted result.
-This is a stable sort.
address@hidden deffn
-
- stable-sort
address@hidden snarfed from sort.c:531
address@hidden {Scheme Procedure} stable-sort items less
address@hidden {C Function} scm_stable_sort (items, less)
-Sort the sequence @var{items}, which may be a list or a
-vector. @var{less} is used for comparing the sequence elements.
-This is a stable sort.
address@hidden deffn
-
- sort-list!
address@hidden snarfed from sort.c:549
address@hidden {Scheme Procedure} sort-list! items less
address@hidden {C Function} scm_sort_list_x (items, less)
-Sort the list @var{items}, using @var{less} for comparing the
-list elements. The sorting is destructive, that means that the
-input list is modified to produce the sorted result.
-This is a stable sort.
address@hidden deffn
-
- sort-list
address@hidden snarfed from sort.c:564
address@hidden {Scheme Procedure} sort-list items less
address@hidden {C Function} scm_sort_list (items, less)
-Sort the list @var{items}, using @var{less} for comparing the
-list elements. This is a stable sort.
address@hidden deffn
-
- source-properties
address@hidden snarfed from srcprop.c:153
address@hidden {Scheme Procedure} source-properties obj
address@hidden {C Function} scm_source_properties (obj)
-Return the source property association list of @var{obj}.
address@hidden deffn
-
- set-source-properties!
address@hidden snarfed from srcprop.c:176
address@hidden {Scheme Procedure} set-source-properties! obj plist
address@hidden {C Function} scm_set_source_properties_x (obj, plist)
-Install the association list @var{plist} as the source property
-list for @var{obj}.
address@hidden deffn
-
- source-property
address@hidden snarfed from srcprop.c:194
address@hidden {Scheme Procedure} source-property obj key
address@hidden {C Function} scm_source_property (obj, key)
-Return the source property specified by @var{key} from
address@hidden's source property list.
address@hidden deffn
-
- set-source-property!
address@hidden snarfed from srcprop.c:225
address@hidden {Scheme Procedure} set-source-property! obj key datum
address@hidden {C Function} scm_set_source_property_x (obj, key, datum)
-Set the source property of object @var{obj}, which is specified by
address@hidden to @var{datum}. Normally, the key will be a symbol.
address@hidden deffn
-
- stack?
address@hidden snarfed from stacks.c:391
address@hidden {Scheme Procedure} stack? obj
address@hidden {C Function} scm_stack_p (obj)
-Return @code{#t} if @var{obj} is a calling stack.
address@hidden deffn
-
- make-stack
address@hidden snarfed from stacks.c:422
address@hidden {Scheme Procedure} make-stack obj . args
address@hidden {C Function} scm_make_stack (obj, args)
-Create a new stack. If @var{obj} is @code{#t}, the current
-evaluation stack is used for creating the stack frames,
-otherwise the frames are taken from @var{obj} (which must be
-either a debug object or a continuation).
-
address@hidden should be a list containing any combination of
-integer, procedure and @code{#t} values.
-
-These values specify various ways of cutting away uninteresting
-stack frames from the top and bottom of the stack that
address@hidden returns. They come in pairs like this:
address@hidden(@var{inner_cut_1} @var{outer_cut_1} @var{inner_cut_2}
address@hidden @dots{})}.
-
-Each @var{inner_cut_N} can be @code{#t}, an integer, or a
-procedure. @code{#t} means to cut away all frames up to but
-excluding the first user module frame. An integer means to cut
-away exactly that number of frames. A procedure means to cut
-away all frames up to but excluding the application frame whose
-procedure matches the specified one.
-
-Each @var{outer_cut_N} can be an integer or a procedure. An
-integer means to cut away that number of frames. A procedure
-means to cut away frames down to but excluding the application
-frame whose procedure matches the specified one.
-
-If the @var{outer_cut_N} of the last pair is missing, it is
-taken as 0.
address@hidden deffn
-
- stack-id
address@hidden snarfed from stacks.c:511
address@hidden {Scheme Procedure} stack-id stack
address@hidden {C Function} scm_stack_id (stack)
-Return the identifier given to @var{stack} by @code{start-stack}.
address@hidden deffn
-
- stack-ref
address@hidden snarfed from stacks.c:549
address@hidden {Scheme Procedure} stack-ref stack index
address@hidden {C Function} scm_stack_ref (stack, index)
-Return the @var{index}'th frame from @var{stack}.
address@hidden deffn
-
- stack-length
address@hidden snarfed from stacks.c:562
address@hidden {Scheme Procedure} stack-length stack
address@hidden {C Function} scm_stack_length (stack)
-Return the length of @var{stack}.
address@hidden deffn
-
- frame?
address@hidden snarfed from stacks.c:575
address@hidden {Scheme Procedure} frame? obj
address@hidden {C Function} scm_frame_p (obj)
-Return @code{#t} if @var{obj} is a stack frame.
address@hidden deffn
-
- last-stack-frame
address@hidden snarfed from stacks.c:586
address@hidden {Scheme Procedure} last-stack-frame obj
address@hidden {C Function} scm_last_stack_frame (obj)
-Return a stack which consists of a single frame, which is the
-last stack frame for @var{obj}. @var{obj} must be either a
-debug object or a continuation.
address@hidden deffn
-
- frame-number
address@hidden snarfed from stacks.c:625
address@hidden {Scheme Procedure} frame-number frame
address@hidden {C Function} scm_frame_number (frame)
-Return the frame number of @var{frame}.
address@hidden deffn
-
- frame-source
address@hidden snarfed from stacks.c:635
address@hidden {Scheme Procedure} frame-source frame
address@hidden {C Function} scm_frame_source (frame)
-Return the source of @var{frame}.
address@hidden deffn
-
- frame-procedure
address@hidden snarfed from stacks.c:646
address@hidden {Scheme Procedure} frame-procedure frame
address@hidden {C Function} scm_frame_procedure (frame)
-Return the procedure for @var{frame}, or @code{#f} if no
-procedure is associated with @var{frame}.
address@hidden deffn
-
- frame-arguments
address@hidden snarfed from stacks.c:658
address@hidden {Scheme Procedure} frame-arguments frame
address@hidden {C Function} scm_frame_arguments (frame)
-Return the arguments of @var{frame}.
address@hidden deffn
-
- frame-previous
address@hidden snarfed from stacks.c:669
address@hidden {Scheme Procedure} frame-previous frame
address@hidden {C Function} scm_frame_previous (frame)
-Return the previous frame of @var{frame}, or @code{#f} if
address@hidden is the first frame in its stack.
address@hidden deffn
-
- frame-next
address@hidden snarfed from stacks.c:685
address@hidden {Scheme Procedure} frame-next frame
address@hidden {C Function} scm_frame_next (frame)
-Return the next frame of @var{frame}, or @code{#f} if
address@hidden is the last frame in its stack.
address@hidden deffn
-
- frame-real?
address@hidden snarfed from stacks.c:700
address@hidden {Scheme Procedure} frame-real? frame
address@hidden {C Function} scm_frame_real_p (frame)
-Return @code{#t} if @var{frame} is a real frame.
address@hidden deffn
-
- frame-procedure?
address@hidden snarfed from stacks.c:710
address@hidden {Scheme Procedure} frame-procedure? frame
address@hidden {C Function} scm_frame_procedure_p (frame)
-Return @code{#t} if a procedure is associated with @var{frame}.
address@hidden deffn
-
- frame-evaluating-args?
address@hidden snarfed from stacks.c:720
address@hidden {Scheme Procedure} frame-evaluating-args? frame
address@hidden {C Function} scm_frame_evaluating_args_p (frame)
-Return @code{#t} if @var{frame} contains evaluated arguments.
address@hidden deffn
-
- frame-overflow?
address@hidden snarfed from stacks.c:730
address@hidden {Scheme Procedure} frame-overflow? frame
address@hidden {C Function} scm_frame_overflow_p (frame)
-Return @code{#t} if @var{frame} is an overflow frame.
address@hidden deffn
-
- get-internal-real-time
address@hidden snarfed from stime.c:133
address@hidden {Scheme Procedure} get-internal-real-time
address@hidden {C Function} scm_get_internal_real_time ()
-Return the number of time units since the interpreter was
-started.
address@hidden deffn
-
- times
address@hidden snarfed from stime.c:180
address@hidden {Scheme Procedure} times
address@hidden {C Function} scm_times ()
-Return an object with information about real and processor
-time. The following procedures accept such an object as an
-argument and return a selected component:
-
address@hidden @code
address@hidden tms:clock
-The current real time, expressed as time units relative to an
-arbitrary base.
address@hidden tms:utime
-The CPU time units used by the calling process.
address@hidden tms:stime
-The CPU time units used by the system on behalf of the calling
-process.
address@hidden tms:cutime
-The CPU time units used by terminated child processes of the
-calling process, whose status has been collected (e.g., using
address@hidden).
address@hidden tms:cstime
-Similarly, the CPU times units used by the system on behalf of
-terminated child processes.
address@hidden table
address@hidden deffn
-
- get-internal-run-time
address@hidden snarfed from stime.c:212
address@hidden {Scheme Procedure} get-internal-run-time
address@hidden {C Function} scm_get_internal_run_time ()
-Return the number of time units of processor time used by the
-interpreter. Both @emph{system} and @emph{user} time are
-included but subprocesses are not.
address@hidden deffn
-
- current-time
address@hidden snarfed from stime.c:229
address@hidden {Scheme Procedure} current-time
address@hidden {C Function} scm_current_time ()
-Return the number of seconds since 1970-01-01 00:00:00 UTC,
-excluding leap seconds.
address@hidden deffn
-
- gettimeofday
address@hidden snarfed from stime.c:248
address@hidden {Scheme Procedure} gettimeofday
address@hidden {C Function} scm_gettimeofday ()
-Return a pair containing the number of seconds and microseconds
-since 1970-01-01 00:00:00 UTC, excluding leap seconds. Note:
-whether true microsecond resolution is available depends on the
-operating system.
address@hidden deffn
-
- localtime
address@hidden snarfed from stime.c:364
address@hidden {Scheme Procedure} localtime time [zone]
address@hidden {C Function} scm_localtime (time, zone)
-Return an object representing the broken down components of
address@hidden, an integer like the one returned by
address@hidden The time zone for the calculation is
-optionally specified by @var{zone} (a string), otherwise the
address@hidden environment variable or the system default is used.
address@hidden deffn
-
- gmtime
address@hidden snarfed from stime.c:449
address@hidden {Scheme Procedure} gmtime time
address@hidden {C Function} scm_gmtime (time)
-Return an object representing the broken down components of
address@hidden, an integer like the one returned by
address@hidden The values are calculated for UTC.
address@hidden deffn
-
- mktime
address@hidden snarfed from stime.c:517
address@hidden {Scheme Procedure} mktime sbd_time [zone]
address@hidden {C Function} scm_mktime (sbd_time, zone)
address@hidden is an object representing broken down time and @code{zone}
-is an optional time zone specifier (otherwise the TZ environment variable
-or the system default is used).
-
-Returns a pair: the car is a corresponding
-integer time value like that returned
-by @code{current-time}; the cdr is a broken down time object, similar to
-as @var{bd-time} but with normalized values.
address@hidden deffn
-
- tzset
address@hidden snarfed from stime.c:603
address@hidden {Scheme Procedure} tzset
address@hidden {C Function} scm_tzset ()
-Initialize the timezone from the TZ environment variable
-or the system default. It's not usually necessary to call this procedure
-since it's done automatically by other procedures that depend on the
-timezone.
address@hidden deffn
-
- strftime
address@hidden snarfed from stime.c:620
address@hidden {Scheme Procedure} strftime format stime
address@hidden {C Function} scm_strftime (format, stime)
-Formats a time specification @var{time} using @var{template}. @var{time}
-is an object with time components in the form returned by @code{localtime}
-or @code{gmtime}. @var{template} is a string which can include formatting
-specifications introduced by a @code{%} character. The formatting of
-month and day names is dependent on the current locale. The value returned
-is the formatted string.
address@hidden Date and Time, , , libc, The GNU C Library Reference Manual}.)
address@hidden deffn
-
- strptime
address@hidden snarfed from stime.c:721
address@hidden {Scheme Procedure} strptime format string
address@hidden {C Function} scm_strptime (format, string)
-Performs the reverse action to @code{strftime}, parsing
address@hidden according to the specification supplied in
address@hidden The interpretation of month and day names is
-dependent on the current locale. The value returned is a pair.
-The car has an object with time components
-in the form returned by @code{localtime} or @code{gmtime},
-but the time zone components
-are not usefully set.
-The cdr reports the number of characters from @var{string}
-which were used for the conversion.
address@hidden deffn
-
- string?
address@hidden snarfed from strings.c:526
address@hidden {Scheme Procedure} string? obj
address@hidden {C Function} scm_string_p (obj)
-Return @code{#t} if @var{obj} is a string, else @code{#f}.
address@hidden deffn
-
- list->string
address@hidden snarfed from strings.c:534
address@hidden {Scheme Procedure} list->string
-implemented by the C function "scm_string"
address@hidden deffn
-
- string
address@hidden snarfed from strings.c:540
address@hidden {Scheme Procedure} string . chrs
address@hidden {Scheme Procedure} list->string chrs
address@hidden {C Function} scm_string (chrs)
-Return a newly allocated string composed of the arguments,
address@hidden
address@hidden deffn
-
- make-string
address@hidden snarfed from strings.c:578
address@hidden {Scheme Procedure} make-string k [chr]
address@hidden {C Function} scm_make_string (k, chr)
-Return a newly allocated string of
-length @var{k}. If @var{chr} is given, then all elements of
-the string are initialized to @var{chr}, otherwise the contents
-of the @var{string} are unspecified.
address@hidden deffn
-
- string-length
address@hidden snarfed from strings.c:604
address@hidden {Scheme Procedure} string-length string
address@hidden {C Function} scm_string_length (string)
-Return the number of characters in @var{string}.
address@hidden deffn
-
- string-ref
address@hidden snarfed from strings.c:623
address@hidden {Scheme Procedure} string-ref str k
address@hidden {C Function} scm_string_ref (str, k)
-Return character @var{k} of @var{str} using zero-origin
-indexing. @var{k} must be a valid index of @var{str}.
address@hidden deffn
-
- string-set!
address@hidden snarfed from strings.c:646
address@hidden {Scheme Procedure} string-set! str k chr
address@hidden {C Function} scm_string_set_x (str, k, chr)
-Store @var{chr} in element @var{k} of @var{str} and return
-an unspecified value. @var{k} must be a valid index of
address@hidden
address@hidden deffn
-
- substring
address@hidden snarfed from strings.c:682
address@hidden {Scheme Procedure} substring str start [end]
address@hidden {C Function} scm_substring (str, start, end)
-Return a newly allocated string formed from the characters
-of @var{str} beginning with index @var{start} (inclusive) and
-ending with index @var{end} (exclusive).
address@hidden must be a string, @var{start} and @var{end} must be
-exact integers satisfying:
-
-0 <= @var{start} <= @var{end} <= (string-length @var{str}).
address@hidden deffn
-
- substring/read-only
address@hidden snarfed from strings.c:708
address@hidden {Scheme Procedure} substring/read-only str start [end]
address@hidden {C Function} scm_substring_read_only (str, start, end)
-Return a newly allocated string formed from the characters
-of @var{str} beginning with index @var{start} (inclusive) and
-ending with index @var{end} (exclusive).
address@hidden must be a string, @var{start} and @var{end} must be
-exact integers satisfying:
-
-0 <= @var{start} <= @var{end} <= (string-length @var{str}).
-
-The returned string is read-only.
-
address@hidden deffn
-
- substring/copy
address@hidden snarfed from strings.c:731
address@hidden {Scheme Procedure} substring/copy str start [end]
address@hidden {C Function} scm_substring_copy (str, start, end)
-Return a newly allocated string formed from the characters
-of @var{str} beginning with index @var{start} (inclusive) and
-ending with index @var{end} (exclusive).
address@hidden must be a string, @var{start} and @var{end} must be
-exact integers satisfying:
-
-0 <= @var{start} <= @var{end} <= (string-length @var{str}).
address@hidden deffn
-
- substring/shared
address@hidden snarfed from strings.c:755
address@hidden {Scheme Procedure} substring/shared str start [end]
address@hidden {C Function} scm_substring_shared (str, start, end)
-Return string that indirectly refers to the characters
-of @var{str} beginning with index @var{start} (inclusive) and
-ending with index @var{end} (exclusive).
address@hidden must be a string, @var{start} and @var{end} must be
-exact integers satisfying:
-
-0 <= @var{start} <= @var{end} <= (string-length @var{str}).
address@hidden deffn
-
- string-append
address@hidden snarfed from strings.c:774
address@hidden {Scheme Procedure} string-append . args
address@hidden {C Function} scm_string_append (args)
-Return a newly allocated string whose characters form the
-concatenation of the given strings, @var{args}.
address@hidden deffn
-
- uniform-vector?
address@hidden snarfed from srfi-4.c:651
address@hidden {Scheme Procedure} uniform-vector? obj
address@hidden {C Function} scm_uniform_vector_p (obj)
-Return @code{#t} if @var{obj} is a uniform vector.
address@hidden deffn
-
- uniform-vector-ref
address@hidden snarfed from srfi-4.c:677
address@hidden {Scheme Procedure} uniform-vector-ref v idx
address@hidden {C Function} scm_uniform_vector_ref (v, idx)
-Return the element at index @var{idx} of the
-homogenous numeric vector @var{v}.
address@hidden deffn
-
- uniform-vector-set!
address@hidden snarfed from srfi-4.c:714
address@hidden {Scheme Procedure} uniform-vector-set! v idx val
address@hidden {C Function} scm_uniform_vector_set_x (v, idx, val)
-Set the element at index @var{idx} of the
-homogenous numeric vector @var{v} to @var{val}.
address@hidden deffn
-
- uniform-vector->list
address@hidden snarfed from srfi-4.c:737
address@hidden {Scheme Procedure} uniform-vector->list uvec
address@hidden {C Function} scm_uniform_vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- uniform-vector-length
address@hidden snarfed from srfi-4.c:820
address@hidden {Scheme Procedure} uniform-vector-length v
address@hidden {C Function} scm_uniform_vector_length (v)
-Return the number of elements in the uniform vector @var{v}.
address@hidden deffn
-
- uniform-vector-read!
address@hidden snarfed from srfi-4.c:845
address@hidden {Scheme Procedure} uniform-array-read! ura [port_or_fd [start
[end]]]
address@hidden {Scheme Procedure} uniform-vector-read! uve [port-or-fdes]
[start] [end]
address@hidden {C Function} scm_uniform_array_read_x (ura, port_or_fd, start,
end)
-Attempt to read all elements of @var{ura}, in lexicographic order, as
-binary objects from @var{port-or-fdes}.
-If an end of file is encountered,
-the objects up to that point are put into @var{ura}
-(starting at the beginning) and the remainder of the array is
-unchanged.
-
-The optional arguments @var{start} and @var{end} allow
-a specified region of a vector (or linearized array) to be read,
-leaving the remainder of the vector unchanged.
-
address@hidden returns the number of objects read.
address@hidden may be omitted, in which case it defaults to the value
-returned by @code{(current-input-port)}.
address@hidden deffn
-
- uniform-vector-write
address@hidden snarfed from srfi-4.c:958
address@hidden {Scheme Procedure} uniform-vector-write uvec [port_or_fd [start
[end]]]
address@hidden {C Function} scm_uniform_vector_write (uvec, port_or_fd, start,
end)
-Write the elements of @var{uvec} as raw bytes to
address@hidden, in the host byte order.
-
-The optional arguments @var{start} (inclusive)
-and @var{end} (exclusive) allow
-a specified region to be written.
-
-When @var{port-or-fdes} is a port, all specified elements
-of @var{uvec} are attempted to be written, potentially blocking
-while waiting for more room.
-When @var{port-or-fd} is an integer, a single call to
-write(2) is made.
-
-An error is signalled when the last element has only
-been partially written in the single call to write(2).
-
-The number of objects actually written is returned.
address@hidden may be
-omitted, in which case it defaults to the value returned by
address@hidden(current-output-port)}.
address@hidden deffn
-
- u8vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} u8vector? obj
address@hidden {C Function} scm_u8vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type u8,
address@hidden otherwise.
address@hidden deffn
-
- make-u8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-u8vector len [fill]
address@hidden {C Function} scm_make_u8vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- u8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} u8vector . l
address@hidden {C Function} scm_u8vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- u8vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} u8vector-length uvec
address@hidden {C Function} scm_u8vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- u8vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} u8vector-ref uvec index
address@hidden {C Function} scm_u8vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- u8vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} u8vector-set! uvec index value
address@hidden {C Function} scm_u8vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- u8vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} u8vector->list uvec
address@hidden {C Function} scm_u8vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->u8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->u8vector l
address@hidden {C Function} scm_list_to_u8vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->u8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->u8vector obj
address@hidden {C Function} scm_any_to_u8vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type u8.
address@hidden deffn
-
- s8vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} s8vector? obj
address@hidden {C Function} scm_s8vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type s8,
address@hidden otherwise.
address@hidden deffn
-
- make-s8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-s8vector len [fill]
address@hidden {C Function} scm_make_s8vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- s8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} s8vector . l
address@hidden {C Function} scm_s8vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- s8vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} s8vector-length uvec
address@hidden {C Function} scm_s8vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- s8vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} s8vector-ref uvec index
address@hidden {C Function} scm_s8vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- s8vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} s8vector-set! uvec index value
address@hidden {C Function} scm_s8vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- s8vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} s8vector->list uvec
address@hidden {C Function} scm_s8vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->s8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->s8vector l
address@hidden {C Function} scm_list_to_s8vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->s8vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->s8vector obj
address@hidden {C Function} scm_any_to_s8vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type s8.
address@hidden deffn
-
- u16vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} u16vector? obj
address@hidden {C Function} scm_u16vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type u16,
address@hidden otherwise.
address@hidden deffn
-
- make-u16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-u16vector len [fill]
address@hidden {C Function} scm_make_u16vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- u16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} u16vector . l
address@hidden {C Function} scm_u16vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- u16vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} u16vector-length uvec
address@hidden {C Function} scm_u16vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- u16vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} u16vector-ref uvec index
address@hidden {C Function} scm_u16vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- u16vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} u16vector-set! uvec index value
address@hidden {C Function} scm_u16vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- u16vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} u16vector->list uvec
address@hidden {C Function} scm_u16vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->u16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->u16vector l
address@hidden {C Function} scm_list_to_u16vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->u16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->u16vector obj
address@hidden {C Function} scm_any_to_u16vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type u16.
address@hidden deffn
-
- s16vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} s16vector? obj
address@hidden {C Function} scm_s16vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type s16,
address@hidden otherwise.
address@hidden deffn
-
- make-s16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-s16vector len [fill]
address@hidden {C Function} scm_make_s16vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- s16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} s16vector . l
address@hidden {C Function} scm_s16vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- s16vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} s16vector-length uvec
address@hidden {C Function} scm_s16vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- s16vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} s16vector-ref uvec index
address@hidden {C Function} scm_s16vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- s16vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} s16vector-set! uvec index value
address@hidden {C Function} scm_s16vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- s16vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} s16vector->list uvec
address@hidden {C Function} scm_s16vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->s16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->s16vector l
address@hidden {C Function} scm_list_to_s16vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->s16vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->s16vector obj
address@hidden {C Function} scm_any_to_s16vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type s16.
address@hidden deffn
-
- u32vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} u32vector? obj
address@hidden {C Function} scm_u32vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type u32,
address@hidden otherwise.
address@hidden deffn
-
- make-u32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-u32vector len [fill]
address@hidden {C Function} scm_make_u32vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- u32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} u32vector . l
address@hidden {C Function} scm_u32vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- u32vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} u32vector-length uvec
address@hidden {C Function} scm_u32vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- u32vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} u32vector-ref uvec index
address@hidden {C Function} scm_u32vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- u32vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} u32vector-set! uvec index value
address@hidden {C Function} scm_u32vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- u32vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} u32vector->list uvec
address@hidden {C Function} scm_u32vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->u32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->u32vector l
address@hidden {C Function} scm_list_to_u32vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->u32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->u32vector obj
address@hidden {C Function} scm_any_to_u32vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type u32.
address@hidden deffn
-
- s32vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} s32vector? obj
address@hidden {C Function} scm_s32vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type s32,
address@hidden otherwise.
address@hidden deffn
-
- make-s32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-s32vector len [fill]
address@hidden {C Function} scm_make_s32vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- s32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} s32vector . l
address@hidden {C Function} scm_s32vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- s32vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} s32vector-length uvec
address@hidden {C Function} scm_s32vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- s32vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} s32vector-ref uvec index
address@hidden {C Function} scm_s32vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- s32vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} s32vector-set! uvec index value
address@hidden {C Function} scm_s32vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- s32vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} s32vector->list uvec
address@hidden {C Function} scm_s32vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->s32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->s32vector l
address@hidden {C Function} scm_list_to_s32vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->s32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->s32vector obj
address@hidden {C Function} scm_any_to_s32vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type s32.
address@hidden deffn
-
- u64vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} u64vector? obj
address@hidden {C Function} scm_u64vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type u64,
address@hidden otherwise.
address@hidden deffn
-
- make-u64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-u64vector len [fill]
address@hidden {C Function} scm_make_u64vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- u64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} u64vector . l
address@hidden {C Function} scm_u64vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- u64vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} u64vector-length uvec
address@hidden {C Function} scm_u64vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- u64vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} u64vector-ref uvec index
address@hidden {C Function} scm_u64vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- u64vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} u64vector-set! uvec index value
address@hidden {C Function} scm_u64vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- u64vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} u64vector->list uvec
address@hidden {C Function} scm_u64vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->u64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->u64vector l
address@hidden {C Function} scm_list_to_u64vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->u64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->u64vector obj
address@hidden {C Function} scm_any_to_u64vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type u64.
address@hidden deffn
-
- s64vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} s64vector? obj
address@hidden {C Function} scm_s64vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type s64,
address@hidden otherwise.
address@hidden deffn
-
- make-s64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-s64vector len [fill]
address@hidden {C Function} scm_make_s64vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- s64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} s64vector . l
address@hidden {C Function} scm_s64vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- s64vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} s64vector-length uvec
address@hidden {C Function} scm_s64vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- s64vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} s64vector-ref uvec index
address@hidden {C Function} scm_s64vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- s64vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} s64vector-set! uvec index value
address@hidden {C Function} scm_s64vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- s64vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} s64vector->list uvec
address@hidden {C Function} scm_s64vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->s64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->s64vector l
address@hidden {C Function} scm_list_to_s64vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->s64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->s64vector obj
address@hidden {C Function} scm_any_to_s64vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type s64.
address@hidden deffn
-
- f32vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} f32vector? obj
address@hidden {C Function} scm_f32vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type f32,
address@hidden otherwise.
address@hidden deffn
-
- make-f32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-f32vector len [fill]
address@hidden {C Function} scm_make_f32vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- f32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} f32vector . l
address@hidden {C Function} scm_f32vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- f32vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} f32vector-length uvec
address@hidden {C Function} scm_f32vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- f32vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} f32vector-ref uvec index
address@hidden {C Function} scm_f32vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- f32vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} f32vector-set! uvec index value
address@hidden {C Function} scm_f32vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- f32vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} f32vector->list uvec
address@hidden {C Function} scm_f32vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->f32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->f32vector l
address@hidden {C Function} scm_list_to_f32vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->f32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->f32vector obj
address@hidden {C Function} scm_any_to_f32vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type f32.
address@hidden deffn
-
- f64vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} f64vector? obj
address@hidden {C Function} scm_f64vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type f64,
address@hidden otherwise.
address@hidden deffn
-
- make-f64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-f64vector len [fill]
address@hidden {C Function} scm_make_f64vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- f64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} f64vector . l
address@hidden {C Function} scm_f64vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- f64vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} f64vector-length uvec
address@hidden {C Function} scm_f64vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- f64vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} f64vector-ref uvec index
address@hidden {C Function} scm_f64vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- f64vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} f64vector-set! uvec index value
address@hidden {C Function} scm_f64vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- f64vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} f64vector->list uvec
address@hidden {C Function} scm_f64vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->f64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->f64vector l
address@hidden {C Function} scm_list_to_f64vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->f64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->f64vector obj
address@hidden {C Function} scm_any_to_f64vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type f64.
address@hidden deffn
-
- c32vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} c32vector? obj
address@hidden {C Function} scm_c32vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type c32,
address@hidden otherwise.
address@hidden deffn
-
- make-c32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-c32vector len [fill]
address@hidden {C Function} scm_make_c32vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- c32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} c32vector . l
address@hidden {C Function} scm_c32vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- c32vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} c32vector-length uvec
address@hidden {C Function} scm_c32vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- c32vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} c32vector-ref uvec index
address@hidden {C Function} scm_c32vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- c32vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} c32vector-set! uvec index value
address@hidden {C Function} scm_c32vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- c32vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} c32vector->list uvec
address@hidden {C Function} scm_c32vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->c32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->c32vector l
address@hidden {C Function} scm_list_to_c32vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->c32vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->c32vector obj
address@hidden {C Function} scm_any_to_c32vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type c32.
address@hidden deffn
-
- c64vector?
address@hidden snarfed from ../libguile/srfi-4.i.c:41
address@hidden {Scheme Procedure} c64vector? obj
address@hidden {C Function} scm_c64vector_p (obj)
-Return @code{#t} if @var{obj} is a vector of type c64,
address@hidden otherwise.
address@hidden deffn
-
- make-c64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:53
address@hidden {Scheme Procedure} make-c64vector len [fill]
address@hidden {C Function} scm_make_c64vector (len, fill)
-Return a newly allocated uniform numeric vector which can
-hold @var{len} elements. If @var{fill} is given, it is used to
-initialize the elements, otherwise the contents of the vector
-is unspecified.
address@hidden deffn
-
- c64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:63
address@hidden {Scheme Procedure} c64vector . l
address@hidden {C Function} scm_c64vector (l)
-Return a newly allocated uniform numeric vector containing
-all argument values.
address@hidden deffn
-
- c64vector-length
address@hidden snarfed from ../libguile/srfi-4.i.c:74
address@hidden {Scheme Procedure} c64vector-length uvec
address@hidden {C Function} scm_c64vector_length (uvec)
-Return the number of elements in the uniform numeric vector
address@hidden
address@hidden deffn
-
- c64vector-ref
address@hidden snarfed from ../libguile/srfi-4.i.c:85
address@hidden {Scheme Procedure} c64vector-ref uvec index
address@hidden {C Function} scm_c64vector_ref (uvec, index)
-Return the element at @var{index} in the uniform numeric
-vector @var{uvec}.
address@hidden deffn
-
- c64vector-set!
address@hidden snarfed from ../libguile/srfi-4.i.c:97
address@hidden {Scheme Procedure} c64vector-set! uvec index value
address@hidden {C Function} scm_c64vector_set_x (uvec, index, value)
-Set the element at @var{index} in the uniform numeric
-vector @var{uvec} to @var{value}. The return value is not
-specified.
address@hidden deffn
-
- c64vector->list
address@hidden snarfed from ../libguile/srfi-4.i.c:107
address@hidden {Scheme Procedure} c64vector->list uvec
address@hidden {C Function} scm_c64vector_to_list (uvec)
-Convert the uniform numeric vector @var{uvec} to a list.
address@hidden deffn
-
- list->c64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:117
address@hidden {Scheme Procedure} list->c64vector l
address@hidden {C Function} scm_list_to_c64vector (l)
-Convert the list @var{l} to a numeric uniform vector.
address@hidden deffn
-
- any->c64vector
address@hidden snarfed from ../libguile/srfi-4.i.c:128
address@hidden {Scheme Procedure} any->c64vector obj
address@hidden {C Function} scm_any_to_c64vector (obj)
-Convert @var{obj}, which can be a list, vector, or
-uniform vector, to a numeric uniform vector of
-type c64.
address@hidden deffn
-
- string-null?
address@hidden snarfed from srfi-13.c:62
address@hidden {Scheme Procedure} string-null? str
address@hidden {C Function} scm_string_null_p (str)
-Return @code{#t} if @var{str}'s length is zero, and
address@hidden otherwise.
address@hidden
-(string-null? "") @result{} #t
-y @result{} "foo"
-(string-null? y) @result{} #f
address@hidden lisp
address@hidden deffn
-
- string-any-c-code
address@hidden snarfed from srfi-13.c:94
address@hidden {Scheme Procedure} string-any-c-code char_pred s [start [end]]
address@hidden {C Function} scm_string_any (char_pred, s, start, end)
-Check if @var{char_pred} is true for any character in string @var{s}.
-
address@hidden can be a character to check for any equal to that, or
-a character set (@pxref{Character Sets}) to check for any in that set,
-or a predicate procedure to call.
-
-For a procedure, calls @code{(@var{char_pred} c)} are made
-successively on the characters from @var{start} to @var{end}. If
address@hidden returns true (ie.@: address@hidden), @code{string-any}
-stops and that return value is the return from @code{string-any}. The
-call on the last character (ie.@: at @address@hidden), if that
-point is reached, is a tail call.
-
-If there are no characters in @var{s} (ie.@: @var{start} equals
address@hidden) then the return is @code{#f}.
-
address@hidden deffn
-
- string-every-c-code
address@hidden snarfed from srfi-13.c:158
address@hidden {Scheme Procedure} string-every-c-code char_pred s [start [end]]
address@hidden {C Function} scm_string_every (char_pred, s, start, end)
-Check if @var{char_pred} is true for every character in string
address@hidden
-
address@hidden can be a character to check for every character equal
-to that, or a character set (@pxref{Character Sets}) to check for
-every character being in that set, or a predicate procedure to call.
-
-For a procedure, calls @code{(@var{char_pred} c)} are made
-successively on the characters from @var{start} to @var{end}. If
address@hidden returns @code{#f}, @code{string-every} stops and
-returns @code{#f}. The call on the last character (ie.@: at
address@hidden@var{end}-1}), if that point is reached, is a tail call and the
-return from that call is the return from @code{string-every}.
-
-If there are no characters in @var{s} (ie.@: @var{start} equals
address@hidden) then the return is @code{#t}.
-
address@hidden deffn
-
- string-tabulate
address@hidden snarfed from srfi-13.c:214
address@hidden {Scheme Procedure} string-tabulate proc len
address@hidden {C Function} scm_string_tabulate (proc, len)
address@hidden is an integer->char procedure. Construct a string
-of size @var{len} by applying @var{proc} to each index to
-produce the corresponding string element. The order in which
address@hidden is applied to the indices is not specified.
address@hidden deffn
-
- string->list
address@hidden snarfed from srfi-13.c:246
address@hidden {Scheme Procedure} string->list str [start [end]]
address@hidden {C Function} scm_substring_to_list (str, start, end)
-Convert the string @var{str} into a list of characters.
address@hidden deffn
-
- reverse-list->string
address@hidden snarfed from srfi-13.c:285
address@hidden {Scheme Procedure} reverse-list->string chrs
address@hidden {C Function} scm_reverse_list_to_string (chrs)
-An efficient implementation of @code{(compose string->list
-reverse)}:
-
address@hidden
-(reverse-list->string '(#\a #\B #\c)) @result{} "cBa"
address@hidden smalllisp
address@hidden deffn
-
- string-join
address@hidden snarfed from srfi-13.c:352
address@hidden {Scheme Procedure} string-join ls [delimiter [grammar]]
address@hidden {C Function} scm_string_join (ls, delimiter, grammar)
-Append the string in the string list @var{ls}, using the string
address@hidden as a delimiter between the elements of @var{ls}.
address@hidden is a symbol which specifies how the delimiter is
-placed between the strings, and defaults to the symbol
address@hidden
-
address@hidden @code
address@hidden infix
-Insert the separator between list elements. An empty string
-will produce an empty list.
address@hidden string-infix
-Like @code{infix}, but will raise an error if given the empty
-list.
address@hidden suffix
-Insert the separator after every list element.
address@hidden prefix
-Insert the separator before each list element.
address@hidden table
address@hidden deffn
-
- string-copy
address@hidden snarfed from srfi-13.c:486
address@hidden {Scheme Procedure} string-copy str [start [end]]
address@hidden {C Function} scm_srfi13_substring_copy (str, start, end)
-Return a freshly allocated copy of the string @var{str}. If
-given, @var{start} and @var{end} delimit the portion of
address@hidden which is copied.
address@hidden deffn
-
- string-copy!
address@hidden snarfed from srfi-13.c:513
address@hidden {Scheme Procedure} string-copy! target tstart s [start [end]]
address@hidden {C Function} scm_string_copy_x (target, tstart, s, start, end)
-Copy the sequence of characters from index range address@hidden,
address@hidden) in string @var{s} to string @var{target}, beginning
-at index @var{tstart}. The characters are copied left-to-right
-or right-to-left as needed -- the copy is guaranteed to work,
-even if @var{target} and @var{s} are the same string. It is an
-error if the copy operation runs off the end of the target
-string.
address@hidden deffn
-
- substring-move!
address@hidden snarfed from srfi-13.c:543
address@hidden {Scheme Procedure} substring-move! str1 start1 end1 str2 start2
address@hidden {C Function} scm_substring_move_x (str1, start1, end1, str2,
start2)
-Copy the substring of @var{str1} bounded by @var{start1} and @var{end1}
-into @var{str2} beginning at position @var{start2}.
address@hidden and @var{str2} can be the same string.
address@hidden deffn
-
- string-take
address@hidden snarfed from srfi-13.c:552
address@hidden {Scheme Procedure} string-take s n
address@hidden {C Function} scm_string_take (s, n)
-Return the @var{n} first characters of @var{s}.
address@hidden deffn
-
- string-drop
address@hidden snarfed from srfi-13.c:562
address@hidden {Scheme Procedure} string-drop s n
address@hidden {C Function} scm_string_drop (s, n)
-Return all but the first @var{n} characters of @var{s}.
address@hidden deffn
-
- string-take-right
address@hidden snarfed from srfi-13.c:572
address@hidden {Scheme Procedure} string-take-right s n
address@hidden {C Function} scm_string_take_right (s, n)
-Return the @var{n} last characters of @var{s}.
address@hidden deffn
-
- string-drop-right
address@hidden snarfed from srfi-13.c:584
address@hidden {Scheme Procedure} string-drop-right s n
address@hidden {C Function} scm_string_drop_right (s, n)
-Return all but the last @var{n} characters of @var{s}.
address@hidden deffn
-
- string-pad
address@hidden snarfed from srfi-13.c:599
address@hidden {Scheme Procedure} string-pad s len [chr [start [end]]]
address@hidden {C Function} scm_string_pad (s, len, chr, start, end)
-Take that characters from @var{start} to @var{end} from the
-string @var{s} and return a new string, right-padded by the
-character @var{chr} to length @var{len}. If the resulting
-string is longer than @var{len}, it is truncated on the right.
address@hidden deffn
-
- string-pad-right
address@hidden snarfed from srfi-13.c:639
address@hidden {Scheme Procedure} string-pad-right s len [chr [start [end]]]
address@hidden {C Function} scm_string_pad_right (s, len, chr, start, end)
-Take that characters from @var{start} to @var{end} from the
-string @var{s} and return a new string, left-padded by the
-character @var{chr} to length @var{len}. If the resulting
-string is longer than @var{len}, it is truncated on the left.
address@hidden deffn
-
- string-trim
address@hidden snarfed from srfi-13.c:692
address@hidden {Scheme Procedure} string-trim s [char_pred [start [end]]]
address@hidden {C Function} scm_string_trim (s, char_pred, start, end)
-Trim @var{s} by skipping over all characters on the left
-that satisfy the parameter @var{char_pred}:
-
address@hidden @bullet
address@hidden
-if it is the character @var{ch}, characters equal to
address@hidden are trimmed,
-
address@hidden
-if it is a procedure @var{pred} characters that
-satisfy @var{pred} are trimmed,
-
address@hidden
-if it is a character set, characters in that set are trimmed.
address@hidden itemize
-
-If called without a @var{char_pred} argument, all whitespace is
-trimmed.
address@hidden deffn
-
- string-trim-right
address@hidden snarfed from srfi-13.c:768
address@hidden {Scheme Procedure} string-trim-right s [char_pred [start [end]]]
address@hidden {C Function} scm_string_trim_right (s, char_pred, start, end)
-Trim @var{s} by skipping over all characters on the rightt
-that satisfy the parameter @var{char_pred}:
-
address@hidden @bullet
address@hidden
-if it is the character @var{ch}, characters equal to @var{ch}
-are trimmed,
-
address@hidden
-if it is a procedure @var{pred} characters that satisfy
address@hidden are trimmed,
-
address@hidden
-if it is a character sets, all characters in that set are
-trimmed.
address@hidden itemize
-
-If called without a @var{char_pred} argument, all whitespace is
-trimmed.
address@hidden deffn
-
- string-trim-both
address@hidden snarfed from srfi-13.c:844
address@hidden {Scheme Procedure} string-trim-both s [char_pred [start [end]]]
address@hidden {C Function} scm_string_trim_both (s, char_pred, start, end)
-Trim @var{s} by skipping over all characters on both sides of
-the string that satisfy the parameter @var{char_pred}:
-
address@hidden @bullet
address@hidden
-if it is the character @var{ch}, characters equal to @var{ch}
-are trimmed,
-
address@hidden
-if it is a procedure @var{pred} characters that satisfy
address@hidden are trimmed,
-
address@hidden
-if it is a character set, the characters in the set are
-trimmed.
address@hidden itemize
-
-If called without a @var{char_pred} argument, all whitespace is
-trimmed.
address@hidden deffn
-
- string-fill!
address@hidden snarfed from srfi-13.c:931
address@hidden {Scheme Procedure} string-fill! str chr [start [end]]
address@hidden {C Function} scm_substring_fill_x (str, chr, start, end)
-Stores @var{chr} in every element of the given @var{str} and
-returns an unspecified value.
address@hidden deffn
-
- string-compare
address@hidden snarfed from srfi-13.c:983
address@hidden {Scheme Procedure} string-compare s1 s2 proc_lt proc_eq proc_gt
[start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_compare (s1, s2, proc_lt, proc_eq,
proc_gt, start1, end1, start2, end2)
-Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
-mismatch index, depending upon whether @var{s1} is less than,
-equal to, or greater than @var{s2}. The mismatch index is the
-largest index @var{i} such that for every 0 <= @var{j} <
address@hidden, @address@hidden = @address@hidden -- that is,
address@hidden is the first position that does not match.
address@hidden deffn
-
- string-compare-ci
address@hidden snarfed from srfi-13.c:1037
address@hidden {Scheme Procedure} string-compare-ci s1 s2 proc_lt proc_eq
proc_gt [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_compare_ci (s1, s2, proc_lt, proc_eq,
proc_gt, start1, end1, start2, end2)
-Apply @var{proc_lt}, @var{proc_eq}, @var{proc_gt} to the
-mismatch index, depending upon whether @var{s1} is less than,
-equal to, or greater than @var{s2}. The mismatch index is the
-largest index @var{i} such that for every 0 <= @var{j} <
address@hidden, @address@hidden = @address@hidden -- that is,
address@hidden is the first position where the lowercased letters
-do not match.
-
address@hidden deffn
-
- string=
address@hidden snarfed from srfi-13.c:1088
address@hidden {Scheme Procedure} string= s1 s2 [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_eq (s1, s2, start1, end1, start2, end2)
-Return @code{#f} if @var{s1} and @var{s2} are not equal, a true
-value otherwise.
address@hidden deffn
-
- string<>
address@hidden snarfed from srfi-13.c:1127
address@hidden {Scheme Procedure} string<> s1 s2 [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_neq (s1, s2, start1, end1, start2, end2)
-Return @code{#f} if @var{s1} and @var{s2} are equal, a true
-value otherwise.
address@hidden deffn
-
- string<
address@hidden snarfed from srfi-13.c:1170
address@hidden {Scheme Procedure} string< s1 s2 [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_lt (s1, s2, start1, end1, start2, end2)
-Return @code{#f} if @var{s1} is greater or equal to @var{s2}, a
-true value otherwise.
address@hidden deffn
-
- string>
address@hidden snarfed from srfi-13.c:1213
address@hidden {Scheme Procedure} string> s1 s2 [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_gt (s1, s2, start1, end1, start2, end2)
-Return @code{#f} if @var{s1} is less or equal to @var{s2}, a
-true value otherwise.
address@hidden deffn
-
- string<=
address@hidden snarfed from srfi-13.c:1256
address@hidden {Scheme Procedure} string<= s1 s2 [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_le (s1, s2, start1, end1, start2, end2)
-Return @code{#f} if @var{s1} is greater to @var{s2}, a true
-value otherwise.
address@hidden deffn
-
- string>=
address@hidden snarfed from srfi-13.c:1299
address@hidden {Scheme Procedure} string>= s1 s2 [start1 [end1 [start2 [end2]]]]
address@hidden {C Function} scm_string_ge (s1, s2, start1, end1, start2, end2)
-Return @code{#f} if @var{s1} is less to @var{s2}, a true value
-otherwise.
address@hidden deffn
-
- string-ci=
address@hidden snarfed from srfi-13.c:1343
address@hidden {Scheme Procedure} string-ci= s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_ci_eq (s1, s2, start1, end1, start2,
end2)
-Return @code{#f} if @var{s1} and @var{s2} are not equal, a true
-value otherwise. The character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-ci<>
address@hidden snarfed from srfi-13.c:1387
address@hidden {Scheme Procedure} string-ci<> s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_ci_neq (s1, s2, start1, end1, start2,
end2)
-Return @code{#f} if @var{s1} and @var{s2} are equal, a true
-value otherwise. The character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-ci<
address@hidden snarfed from srfi-13.c:1431
address@hidden {Scheme Procedure} string-ci< s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_ci_lt (s1, s2, start1, end1, start2,
end2)
-Return @code{#f} if @var{s1} is greater or equal to @var{s2}, a
-true value otherwise. The character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-ci>
address@hidden snarfed from srfi-13.c:1475
address@hidden {Scheme Procedure} string-ci> s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_ci_gt (s1, s2, start1, end1, start2,
end2)
-Return @code{#f} if @var{s1} is less or equal to @var{s2}, a
-true value otherwise. The character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-ci<=
address@hidden snarfed from srfi-13.c:1519
address@hidden {Scheme Procedure} string-ci<= s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_ci_le (s1, s2, start1, end1, start2,
end2)
-Return @code{#f} if @var{s1} is greater to @var{s2}, a true
-value otherwise. The character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-ci>=
address@hidden snarfed from srfi-13.c:1563
address@hidden {Scheme Procedure} string-ci>= s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_ci_ge (s1, s2, start1, end1, start2,
end2)
-Return @code{#f} if @var{s1} is less to @var{s2}, a true value
-otherwise. The character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-hash
address@hidden snarfed from srfi-13.c:1608
address@hidden {Scheme Procedure} string-hash s [bound [start [end]]]
address@hidden {C Function} scm_substring_hash (s, bound, start, end)
-Compute a hash value for @var{S}. the optional argument @var{bound} is a
non-negative exact integer specifying the range of the hash function. A
positive value restricts the return value to the range [0,bound).
address@hidden deffn
-
- string-hash-ci
address@hidden snarfed from srfi-13.c:1625
address@hidden {Scheme Procedure} string-hash-ci s [bound [start [end]]]
address@hidden {C Function} scm_substring_hash_ci (s, bound, start, end)
-Compute a hash value for @var{S}. the optional argument @var{bound} is a
non-negative exact integer specifying the range of the hash function. A
positive value restricts the return value to the range [0,bound).
address@hidden deffn
-
- string-prefix-length
address@hidden snarfed from srfi-13.c:1637
address@hidden {Scheme Procedure} string-prefix-length s1 s2 [start1 [end1
[start2 [end2]]]]
address@hidden {C Function} scm_string_prefix_length (s1, s2, start1, end1,
start2, end2)
-Return the length of the longest common prefix of the two
-strings.
address@hidden deffn
-
- string-prefix-length-ci
address@hidden snarfed from srfi-13.c:1669
address@hidden {Scheme Procedure} string-prefix-length-ci s1 s2 [start1 [end1
[start2 [end2]]]]
address@hidden {C Function} scm_string_prefix_length_ci (s1, s2, start1, end1,
start2, end2)
-Return the length of the longest common prefix of the two
-strings, ignoring character case.
address@hidden deffn
-
- string-suffix-length
address@hidden snarfed from srfi-13.c:1701
address@hidden {Scheme Procedure} string-suffix-length s1 s2 [start1 [end1
[start2 [end2]]]]
address@hidden {C Function} scm_string_suffix_length (s1, s2, start1, end1,
start2, end2)
-Return the length of the longest common suffix of the two
-strings.
address@hidden deffn
-
- string-suffix-length-ci
address@hidden snarfed from srfi-13.c:1733
address@hidden {Scheme Procedure} string-suffix-length-ci s1 s2 [start1 [end1
[start2 [end2]]]]
address@hidden {C Function} scm_string_suffix_length_ci (s1, s2, start1, end1,
start2, end2)
-Return the length of the longest common suffix of the two
-strings, ignoring character case.
address@hidden deffn
-
- string-prefix?
address@hidden snarfed from srfi-13.c:1764
address@hidden {Scheme Procedure} string-prefix? s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_prefix_p (s1, s2, start1, end1, start2,
end2)
-Is @var{s1} a prefix of @var{s2}?
address@hidden deffn
-
- string-prefix-ci?
address@hidden snarfed from srfi-13.c:1796
address@hidden {Scheme Procedure} string-prefix-ci? s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_prefix_ci_p (s1, s2, start1, end1,
start2, end2)
-Is @var{s1} a prefix of @var{s2}, ignoring character case?
address@hidden deffn
-
- string-suffix?
address@hidden snarfed from srfi-13.c:1828
address@hidden {Scheme Procedure} string-suffix? s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_suffix_p (s1, s2, start1, end1, start2,
end2)
-Is @var{s1} a suffix of @var{s2}?
address@hidden deffn
-
- string-suffix-ci?
address@hidden snarfed from srfi-13.c:1860
address@hidden {Scheme Procedure} string-suffix-ci? s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_suffix_ci_p (s1, s2, start1, end1,
start2, end2)
-Is @var{s1} a suffix of @var{s2}, ignoring character case?
address@hidden deffn
-
- string-index
address@hidden snarfed from srfi-13.c:1904
address@hidden {Scheme Procedure} string-index s char_pred [start [end]]
address@hidden {C Function} scm_string_index (s, char_pred, start, end)
-Search through the string @var{s} from left to right, returning
-the index of the first occurence of a character which
-
address@hidden @bullet
address@hidden
-equals @var{char_pred}, if it is character,
-
address@hidden
-satisifies the predicate @var{char_pred}, if it is a procedure,
-
address@hidden
-is in the set @var{char_pred}, if it is a character set.
address@hidden itemize
address@hidden deffn
-
- string-index-right
address@hidden snarfed from srfi-13.c:1969
address@hidden {Scheme Procedure} string-index-right s char_pred [start [end]]
address@hidden {C Function} scm_string_index_right (s, char_pred, start, end)
-Search through the string @var{s} from right to left, returning
-the index of the last occurence of a character which
-
address@hidden @bullet
address@hidden
-equals @var{char_pred}, if it is character,
-
address@hidden
-satisifies the predicate @var{char_pred}, if it is a procedure,
-
address@hidden
-is in the set if @var{char_pred} is a character set.
address@hidden itemize
address@hidden deffn
-
- string-rindex
address@hidden snarfed from srfi-13.c:2034
address@hidden {Scheme Procedure} string-rindex s char_pred [start [end]]
address@hidden {C Function} scm_string_rindex (s, char_pred, start, end)
-Search through the string @var{s} from right to left, returning
-the index of the last occurence of a character which
-
address@hidden @bullet
address@hidden
-equals @var{char_pred}, if it is character,
-
address@hidden
-satisifies the predicate @var{char_pred}, if it is a procedure,
-
address@hidden
-is in the set if @var{char_pred} is a character set.
address@hidden itemize
address@hidden deffn
-
- string-skip
address@hidden snarfed from srfi-13.c:2056
address@hidden {Scheme Procedure} string-skip s char_pred [start [end]]
address@hidden {C Function} scm_string_skip (s, char_pred, start, end)
-Search through the string @var{s} from left to right, returning
-the index of the first occurence of a character which
-
address@hidden @bullet
address@hidden
-does not equal @var{char_pred}, if it is character,
-
address@hidden
-does not satisify the predicate @var{char_pred}, if it is a
-procedure,
-
address@hidden
-is not in the set if @var{char_pred} is a character set.
address@hidden itemize
address@hidden deffn
-
- string-skip-right
address@hidden snarfed from srfi-13.c:2123
address@hidden {Scheme Procedure} string-skip-right s char_pred [start [end]]
address@hidden {C Function} scm_string_skip_right (s, char_pred, start, end)
-Search through the string @var{s} from right to left, returning
-the index of the last occurence of a character which
-
address@hidden @bullet
address@hidden
-does not equal @var{char_pred}, if it is character,
-
address@hidden
-does not satisfy the predicate @var{char_pred}, if it is a
-procedure,
-
address@hidden
-is not in the set if @var{char_pred} is a character set.
address@hidden itemize
address@hidden deffn
-
- string-count
address@hidden snarfed from srfi-13.c:2190
address@hidden {Scheme Procedure} string-count s char_pred [start [end]]
address@hidden {C Function} scm_string_count (s, char_pred, start, end)
-Return the count of the number of characters in the string
address@hidden which
-
address@hidden @bullet
address@hidden
-equals @var{char_pred}, if it is character,
-
address@hidden
-satisifies the predicate @var{char_pred}, if it is a procedure.
-
address@hidden
-is in the set @var{char_pred}, if it is a character set.
address@hidden itemize
address@hidden deffn
-
- string-contains
address@hidden snarfed from srfi-13.c:2247
address@hidden {Scheme Procedure} string-contains s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_contains (s1, s2, start1, end1, start2,
end2)
-Does string @var{s1} contain string @var{s2}? Return the index
-in @var{s1} where @var{s2} occurs as a substring, or false.
-The optional start/end indices restrict the operation to the
-indicated substrings.
address@hidden deffn
-
- string-contains-ci
address@hidden snarfed from srfi-13.c:2294
address@hidden {Scheme Procedure} string-contains-ci s1 s2 [start1 [end1
[start2 [end2]]]]
address@hidden {C Function} scm_string_contains_ci (s1, s2, start1, end1,
start2, end2)
-Does string @var{s1} contain string @var{s2}? Return the index
-in @var{s1} where @var{s2} occurs as a substring, or false.
-The optional start/end indices restrict the operation to the
-indicated substrings. Character comparison is done
-case-insensitively.
address@hidden deffn
-
- string-upcase!
address@hidden snarfed from srfi-13.c:2359
address@hidden {Scheme Procedure} string-upcase! str [start [end]]
address@hidden {C Function} scm_substring_upcase_x (str, start, end)
-Destructively upcase every character in @code{str}.
-
address@hidden
-(string-upcase! y)
address@hidden "ARRDEFG"
-y
address@hidden "ARRDEFG"
address@hidden lisp
address@hidden deffn
-
- string-upcase
address@hidden snarfed from srfi-13.c:2380
address@hidden {Scheme Procedure} string-upcase str [start [end]]
address@hidden {C Function} scm_substring_upcase (str, start, end)
-Upcase every character in @code{str}.
address@hidden deffn
-
- string-downcase!
address@hidden snarfed from srfi-13.c:2427
address@hidden {Scheme Procedure} string-downcase! str [start [end]]
address@hidden {C Function} scm_substring_downcase_x (str, start, end)
-Destructively downcase every character in @var{str}.
-
address@hidden
-y
address@hidden "ARRDEFG"
-(string-downcase! y)
address@hidden "arrdefg"
-y
address@hidden "arrdefg"
address@hidden lisp
address@hidden deffn
-
- string-downcase
address@hidden snarfed from srfi-13.c:2448
address@hidden {Scheme Procedure} string-downcase str [start [end]]
address@hidden {C Function} scm_substring_downcase (str, start, end)
-Downcase every character in @var{str}.
address@hidden deffn
-
- string-titlecase!
address@hidden snarfed from srfi-13.c:2504
address@hidden {Scheme Procedure} string-titlecase! str [start [end]]
address@hidden {C Function} scm_string_titlecase_x (str, start, end)
-Destructively titlecase every first character in a word in
address@hidden
address@hidden deffn
-
- string-titlecase
address@hidden snarfed from srfi-13.c:2520
address@hidden {Scheme Procedure} string-titlecase str [start [end]]
address@hidden {C Function} scm_string_titlecase (str, start, end)
-Titlecase every first character in a word in @var{str}.
address@hidden deffn
-
- string-capitalize!
address@hidden snarfed from srfi-13.c:2542
address@hidden {Scheme Procedure} string-capitalize! str
address@hidden {C Function} scm_string_capitalize_x (str)
-Upcase the first character of every word in @var{str}
-destructively and return @var{str}.
-
address@hidden
-y @result{} "hello world"
-(string-capitalize! y) @result{} "Hello World"
-y @result{} "Hello World"
address@hidden lisp
address@hidden deffn
-
- string-capitalize
address@hidden snarfed from srfi-13.c:2554
address@hidden {Scheme Procedure} string-capitalize str
address@hidden {C Function} scm_string_capitalize (str)
-Return a freshly allocated string with the characters in
address@hidden, where the first character of every word is
-capitalized.
address@hidden deffn
-
- string-reverse
address@hidden snarfed from srfi-13.c:2588
address@hidden {Scheme Procedure} string-reverse str [start [end]]
address@hidden {C Function} scm_string_reverse (str, start, end)
-Reverse the string @var{str}. The optional arguments
address@hidden and @var{end} delimit the region of @var{str} to
-operate on.
address@hidden deffn
-
- string-reverse!
address@hidden snarfed from srfi-13.c:2613
address@hidden {Scheme Procedure} string-reverse! str [start [end]]
address@hidden {C Function} scm_string_reverse_x (str, start, end)
-Reverse the string @var{str} in-place. The optional arguments
address@hidden and @var{end} delimit the region of @var{str} to
-operate on. The return value is unspecified.
address@hidden deffn
-
- string-append/shared
address@hidden snarfed from srfi-13.c:2635
address@hidden {Scheme Procedure} string-append/shared . rest
address@hidden {C Function} scm_string_append_shared (rest)
-Like @code{string-append}, but the result may share memory
-with the argument strings.
address@hidden deffn
-
- string-concatenate
address@hidden snarfed from srfi-13.c:2656
address@hidden {Scheme Procedure} string-concatenate ls
address@hidden {C Function} scm_string_concatenate (ls)
-Append the elements of @var{ls} (which must be strings)
-together into a single string. Guaranteed to return a freshly
-allocated string.
address@hidden deffn
-
- string-concatenate-reverse
address@hidden snarfed from srfi-13.c:2678
address@hidden {Scheme Procedure} string-concatenate-reverse ls [final_string
[end]]
address@hidden {C Function} scm_string_concatenate_reverse (ls, final_string,
end)
-Without optional arguments, this procedure is equivalent to
-
address@hidden
-(string-concatenate (reverse ls))
address@hidden smalllisp
-
-If the optional argument @var{final_string} is specified, it is
-consed onto the beginning to @var{ls} before performing the
-list-reverse and string-concatenate operations. If @var{end}
-is given, only the characters of @var{final_string} up to index
address@hidden are used.
-
-Guaranteed to return a freshly allocated string.
address@hidden deffn
-
- string-concatenate/shared
address@hidden snarfed from srfi-13.c:2695
address@hidden {Scheme Procedure} string-concatenate/shared ls
address@hidden {C Function} scm_string_concatenate_shared (ls)
-Like @code{string-concatenate}, but the result may share memory
-with the strings in the list @var{ls}.
address@hidden deffn
-
- string-concatenate-reverse/shared
address@hidden snarfed from srfi-13.c:2706
address@hidden {Scheme Procedure} string-concatenate-reverse/shared ls
[final_string [end]]
address@hidden {C Function} scm_string_concatenate_reverse_shared (ls,
final_string, end)
-Like @code{string-concatenate-reverse}, but the result may
-share memory with the strings in the @var{ls} arguments.
address@hidden deffn
-
- string-map
address@hidden snarfed from srfi-13.c:2719
address@hidden {Scheme Procedure} string-map proc s [start [end]]
address@hidden {C Function} scm_string_map (proc, s, start, end)
address@hidden is a char->char procedure, it is mapped over
address@hidden The order in which the procedure is applied to the
-string elements is not specified.
address@hidden deffn
-
- string-map!
address@hidden snarfed from srfi-13.c:2749
address@hidden {Scheme Procedure} string-map! proc s [start [end]]
address@hidden {C Function} scm_string_map_x (proc, s, start, end)
address@hidden is a char->char procedure, it is mapped over
address@hidden The order in which the procedure is applied to the
-string elements is not specified. The string @var{s} is
-modified in-place, the return value is not specified.
address@hidden deffn
-
- string-fold
address@hidden snarfed from srfi-13.c:2776
address@hidden {Scheme Procedure} string-fold kons knil s [start [end]]
address@hidden {C Function} scm_string_fold (kons, knil, s, start, end)
-Fold @var{kons} over the characters of @var{s}, with @var{knil}
-as the terminating element, from left to right. @var{kons}
-must expect two arguments: The actual character and the last
-result of @var{kons}' application.
address@hidden deffn
-
- string-fold-right
address@hidden snarfed from srfi-13.c:2807
address@hidden {Scheme Procedure} string-fold-right kons knil s [start [end]]
address@hidden {C Function} scm_string_fold_right (kons, knil, s, start, end)
-Fold @var{kons} over the characters of @var{s}, with @var{knil}
-as the terminating element, from right to left. @var{kons}
-must expect two arguments: The actual character and the last
-result of @var{kons}' application.
address@hidden deffn
-
- string-unfold
address@hidden snarfed from srfi-13.c:2852
address@hidden {Scheme Procedure} string-unfold p f g seed [base [make_final]]
address@hidden {C Function} scm_string_unfold (p, f, g, seed, base, make_final)
address@hidden @bullet
address@hidden @var{g} is used to generate a series of @emph{seed}
-values from the initial @var{seed}: @var{seed}, (@var{g}
address@hidden), (@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}),
address@hidden
address@hidden @var{p} tells us when to stop -- when it returns true
-when applied to one of these seed values.
address@hidden @var{f} maps each seed value to the corresponding
-character in the result string. These chars are assembled
-into the string in a left-to-right order.
address@hidden @var{base} is the optional initial/leftmost portion
-of the constructed string; it default to the empty
-string.
address@hidden @var{make_final} is applied to the terminal seed
-value (on which @var{p} returns true) to produce
-the final/rightmost portion of the constructed string.
-It defaults to @code{(lambda (x) )}.
address@hidden itemize
address@hidden deffn
-
- string-unfold-right
address@hidden snarfed from srfi-13.c:2915
address@hidden {Scheme Procedure} string-unfold-right p f g seed [base
[make_final]]
address@hidden {C Function} scm_string_unfold_right (p, f, g, seed, base,
make_final)
address@hidden @bullet
address@hidden @var{g} is used to generate a series of @emph{seed}
-values from the initial @var{seed}: @var{seed}, (@var{g}
address@hidden), (@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}),
address@hidden
address@hidden @var{p} tells us when to stop -- when it returns true
-when applied to one of these seed values.
address@hidden @var{f} maps each seed value to the corresponding
-character in the result string. These chars are assembled
-into the string in a right-to-left order.
address@hidden @var{base} is the optional initial/rightmost portion
-of the constructed string; it default to the empty
-string.
address@hidden @var{make_final} is applied to the terminal seed
-value (on which @var{p} returns true) to produce
-the final/leftmost portion of the constructed string.
-It defaults to @code{(lambda (x) )}.
address@hidden itemize
address@hidden deffn
-
- string-for-each
address@hidden snarfed from srfi-13.c:2962
address@hidden {Scheme Procedure} string-for-each proc s [start [end]]
address@hidden {C Function} scm_string_for_each (proc, s, start, end)
address@hidden is mapped over @var{s} in left-to-right order. The
-return value is not specified.
address@hidden deffn
-
- string-for-each-index
address@hidden snarfed from srfi-13.c:2988
address@hidden {Scheme Procedure} string-for-each-index proc s [start [end]]
address@hidden {C Function} scm_string_for_each_index (proc, s, start, end)
address@hidden is mapped over @var{s} in left-to-right order. The
-return value is not specified.
address@hidden deffn
-
- xsubstring
address@hidden snarfed from srfi-13.c:3020
address@hidden {Scheme Procedure} xsubstring s from [to [start [end]]]
address@hidden {C Function} scm_xsubstring (s, from, to, start, end)
-This is the @emph{extended substring} procedure that implements
-replicated copying of a substring of some string.
-
address@hidden is a string, @var{start} and @var{end} are optional
-arguments that demarcate a substring of @var{s}, defaulting to
-0 and the length of @var{s}. Replicate this substring up and
-down index space, in both the positive and negative directions.
address@hidden returns the substring of this string
-beginning at index @var{from}, and ending at @var{to}, which
-defaults to @var{from} + (@var{end} - @var{start}).
address@hidden deffn
-
- string-xcopy!
address@hidden snarfed from srfi-13.c:3067
address@hidden {Scheme Procedure} string-xcopy! target tstart s sfrom [sto
[start [end]]]
address@hidden {C Function} scm_string_xcopy_x (target, tstart, s, sfrom, sto,
start, end)
-Exactly the same as @code{xsubstring}, but the extracted text
-is written into the string @var{target} starting at index
address@hidden The operation is not defined if @code{(eq?
address@hidden @var{s})} or these arguments share storage -- you
-cannot copy a string on top of itself.
address@hidden deffn
-
- string-replace
address@hidden snarfed from srfi-13.c:3117
address@hidden {Scheme Procedure} string-replace s1 s2 [start1 [end1 [start2
[end2]]]]
address@hidden {C Function} scm_string_replace (s1, s2, start1, end1, start2,
end2)
-Return the string @var{s1}, but with the characters
address@hidden @dots{} @var{end1} replaced by the characters
address@hidden @dots{} @var{end2} from @var{s2}.
address@hidden deffn
-
- string-tokenize
address@hidden snarfed from srfi-13.c:3154
address@hidden {Scheme Procedure} string-tokenize s [token_set [start [end]]]
address@hidden {C Function} scm_string_tokenize (s, token_set, start, end)
-Split the string @var{s} into a list of substrings, where each
-substring is a maximal non-empty contiguous sequence of
-characters from the character set @var{token_set}, which
-defaults to @code{char-set:graphic}.
-If @var{start} or @var{end} indices are provided, they restrict
address@hidden to operating on the indicated substring
-of @var{s}.
address@hidden deffn
-
- string-split
address@hidden snarfed from srfi-13.c:3220
address@hidden {Scheme Procedure} string-split str chr
address@hidden {C Function} scm_string_split (str, chr)
-Split the string @var{str} into the a list of the substrings delimited
-by appearances of the character @var{chr}. Note that an empty substring
-between separator characters will result in an empty string in the
-result list.
-
address@hidden
-(string-split "root:x:0:0:root:/root:/bin/bash" #\:)
address@hidden
-("root" "x" "0" "0" "root" "/root" "/bin/bash")
-
-(string-split "::" #\:)
address@hidden
-("" "" "")
-
-(string-split "" #\:)
address@hidden
-("")
address@hidden lisp
address@hidden deffn
-
- string-filter
address@hidden snarfed from srfi-13.c:3258
address@hidden {Scheme Procedure} string-filter s char_pred [start [end]]
address@hidden {C Function} scm_string_filter (s, char_pred, start, end)
-Filter the string @var{s}, retaining only those characters that
-satisfy the @var{char_pred} argument. If the argument is a
-procedure, it is applied to each character as a predicate, if
-it is a character, it is tested for equality and if it is a
-character set, it is tested for membership.
address@hidden deffn
-
- string-delete
address@hidden snarfed from srfi-13.c:3330
address@hidden {Scheme Procedure} string-delete s char_pred [start [end]]
address@hidden {C Function} scm_string_delete (s, char_pred, start, end)
-Filter the string @var{s}, retaining only those characters that
-do not satisfy the @var{char_pred} argument. If the argument
-is a procedure, it is applied to each character as a predicate,
-if it is a character, it is tested for equality and if it is a
-character set, it is tested for membership.
address@hidden deffn
-
- char-set?
address@hidden snarfed from srfi-14.c:85
address@hidden {Scheme Procedure} char-set? obj
address@hidden {C Function} scm_char_set_p (obj)
-Return @code{#t} if @var{obj} is a character set, @code{#f}
-otherwise.
address@hidden deffn
-
- char-set=
address@hidden snarfed from srfi-14.c:95
address@hidden {Scheme Procedure} char-set= . char_sets
address@hidden {C Function} scm_char_set_eq (char_sets)
-Return @code{#t} if all given character sets are equal.
address@hidden deffn
-
- char-set<=
address@hidden snarfed from srfi-14.c:125
address@hidden {Scheme Procedure} char-set<= . char_sets
address@hidden {C Function} scm_char_set_leq (char_sets)
-Return @code{#t} if every character set @var{cs}i is a subset
-of character set @var{cs}i+1.
address@hidden deffn
-
- char-set-hash
address@hidden snarfed from srfi-14.c:163
address@hidden {Scheme Procedure} char-set-hash cs [bound]
address@hidden {C Function} scm_char_set_hash (cs, bound)
-Compute a hash value for the character set @var{cs}. If
address@hidden is given and non-zero, it restricts the
-returned value to the range 0 @dots{} @var{bound - 1}.
address@hidden deffn
-
- char-set-cursor
address@hidden snarfed from srfi-14.c:196
address@hidden {Scheme Procedure} char-set-cursor cs
address@hidden {C Function} scm_char_set_cursor (cs)
-Return a cursor into the character set @var{cs}.
address@hidden deffn
-
- char-set-ref
address@hidden snarfed from srfi-14.c:216
address@hidden {Scheme Procedure} char-set-ref cs cursor
address@hidden {C Function} scm_char_set_ref (cs, cursor)
-Return the character at the current cursor position
address@hidden in the character set @var{cs}. It is an error to
-pass a cursor for which @code{end-of-char-set?} returns true.
address@hidden deffn
-
- char-set-cursor-next
address@hidden snarfed from srfi-14.c:233
address@hidden {Scheme Procedure} char-set-cursor-next cs cursor
address@hidden {C Function} scm_char_set_cursor_next (cs, cursor)
-Advance the character set cursor @var{cursor} to the next
-character in the character set @var{cs}. It is an error if the
-cursor given satisfies @code{end-of-char-set?}.
address@hidden deffn
-
- end-of-char-set?
address@hidden snarfed from srfi-14.c:254
address@hidden {Scheme Procedure} end-of-char-set? cursor
address@hidden {C Function} scm_end_of_char_set_p (cursor)
-Return @code{#t} if @var{cursor} has reached the end of a
-character set, @code{#f} otherwise.
address@hidden deffn
-
- char-set-fold
address@hidden snarfed from srfi-14.c:266
address@hidden {Scheme Procedure} char-set-fold kons knil cs
address@hidden {C Function} scm_char_set_fold (kons, knil, cs)
-Fold the procedure @var{kons} over the character set @var{cs},
-initializing it with @var{knil}.
address@hidden deffn
-
- char-set-unfold
address@hidden snarfed from srfi-14.c:296
address@hidden {Scheme Procedure} char-set-unfold p f g seed [base_cs]
address@hidden {C Function} scm_char_set_unfold (p, f, g, seed, base_cs)
-This is a fundamental constructor for character sets.
address@hidden @bullet
address@hidden @var{g} is used to generate a series of ``seed'' values
-from the initial seed: @var{seed}, (@var{g} @var{seed}),
-(@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}), @dots{}
address@hidden @var{p} tells us when to stop -- when it returns true
-when applied to one of the seed values.
address@hidden @var{f} maps each seed value to a character. These
-characters are added to the base character set @var{base_cs} to
-form the result; @var{base_cs} defaults to the empty set.
address@hidden itemize
address@hidden deffn
-
- char-set-unfold!
address@hidden snarfed from srfi-14.c:340
address@hidden {Scheme Procedure} char-set-unfold! p f g seed base_cs
address@hidden {C Function} scm_char_set_unfold_x (p, f, g, seed, base_cs)
-This is a fundamental constructor for character sets.
address@hidden @bullet
address@hidden @var{g} is used to generate a series of ``seed'' values
-from the initial seed: @var{seed}, (@var{g} @var{seed}),
-(@var{g}^2 @var{seed}), (@var{g}^3 @var{seed}), @dots{}
address@hidden @var{p} tells us when to stop -- when it returns true
-when applied to one of the seed values.
address@hidden @var{f} maps each seed value to a character. These
-characters are added to the base character set @var{base_cs} to
-form the result; @var{base_cs} defaults to the empty set.
address@hidden itemize
address@hidden deffn
-
- char-set-for-each
address@hidden snarfed from srfi-14.c:369
address@hidden {Scheme Procedure} char-set-for-each proc cs
address@hidden {C Function} scm_char_set_for_each (proc, cs)
-Apply @var{proc} to every character in the character set
address@hidden The return value is not specified.
address@hidden deffn
-
- char-set-map
address@hidden snarfed from srfi-14.c:388
address@hidden {Scheme Procedure} char-set-map proc cs
address@hidden {C Function} scm_char_set_map (proc, cs)
-Map the procedure @var{proc} over every character in @var{cs}.
address@hidden must be a character -> character procedure.
address@hidden deffn
-
- char-set-copy
address@hidden snarfed from srfi-14.c:414
address@hidden {Scheme Procedure} char-set-copy cs
address@hidden {C Function} scm_char_set_copy (cs)
-Return a newly allocated character set containing all
-characters in @var{cs}.
address@hidden deffn
-
- char-set
address@hidden snarfed from srfi-14.c:434
address@hidden {Scheme Procedure} char-set . rest
address@hidden {C Function} scm_char_set (rest)
-Return a character set containing all given characters.
address@hidden deffn
-
- list->char-set
address@hidden snarfed from srfi-14.c:462
address@hidden {Scheme Procedure} list->char-set list [base_cs]
address@hidden {C Function} scm_list_to_char_set (list, base_cs)
-Convert the character list @var{list} to a character set. If
-the character set @var{base_cs} is given, the character in this
-set are also included in the result.
address@hidden deffn
-
- list->char-set!
address@hidden snarfed from srfi-14.c:496
address@hidden {Scheme Procedure} list->char-set! list base_cs
address@hidden {C Function} scm_list_to_char_set_x (list, base_cs)
-Convert the character list @var{list} to a character set. The
-characters are added to @var{base_cs} and @var{base_cs} is
-returned.
address@hidden deffn
-
- string->char-set
address@hidden snarfed from srfi-14.c:523
address@hidden {Scheme Procedure} string->char-set str [base_cs]
address@hidden {C Function} scm_string_to_char_set (str, base_cs)
-Convert the string @var{str} to a character set. If the
-character set @var{base_cs} is given, the characters in this
-set are also included in the result.
address@hidden deffn
-
- string->char-set!
address@hidden snarfed from srfi-14.c:557
address@hidden {Scheme Procedure} string->char-set! str base_cs
address@hidden {C Function} scm_string_to_char_set_x (str, base_cs)
-Convert the string @var{str} to a character set. The
-characters from the string are added to @var{base_cs}, and
address@hidden is returned.
address@hidden deffn
-
- char-set-filter
address@hidden snarfed from srfi-14.c:584
address@hidden {Scheme Procedure} char-set-filter pred cs [base_cs]
address@hidden {C Function} scm_char_set_filter (pred, cs, base_cs)
-Return a character set containing every character from @var{cs}
-so that it satisfies @var{pred}. If provided, the characters
-from @var{base_cs} are added to the result.
address@hidden deffn
-
- char-set-filter!
address@hidden snarfed from srfi-14.c:620
address@hidden {Scheme Procedure} char-set-filter! pred cs base_cs
address@hidden {C Function} scm_char_set_filter_x (pred, cs, base_cs)
-Return a character set containing every character from @var{cs}
-so that it satisfies @var{pred}. The characters are added to
address@hidden and @var{base_cs} is returned.
address@hidden deffn
-
- ucs-range->char-set
address@hidden snarfed from srfi-14.c:658
address@hidden {Scheme Procedure} ucs-range->char-set lower upper [error
[base_cs]]
address@hidden {C Function} scm_ucs_range_to_char_set (lower, upper, error,
base_cs)
-Return a character set containing all characters whose
-character codes lie in the half-open range
address@hidden,@var{upper}).
-
-If @var{error} is a true value, an error is signalled if the
-specified range contains characters which are not contained in
-the implemented character range. If @var{error} is @code{#f},
-these characters are silently left out of the resultung
-character set.
-
-The characters in @var{base_cs} are added to the result, if
-given.
address@hidden deffn
-
- ucs-range->char-set!
address@hidden snarfed from srfi-14.c:711
address@hidden {Scheme Procedure} ucs-range->char-set! lower upper error base_cs
address@hidden {C Function} scm_ucs_range_to_char_set_x (lower, upper, error,
base_cs)
-Return a character set containing all characters whose
-character codes lie in the half-open range
address@hidden,@var{upper}).
-
-If @var{error} is a true value, an error is signalled if the
-specified range contains characters which are not contained in
-the implemented character range. If @var{error} is @code{#f},
-these characters are silently left out of the resultung
-character set.
-
-The characters are added to @var{base_cs} and @var{base_cs} is
-returned.
address@hidden deffn
-
- ->char-set
address@hidden snarfed from srfi-14.c:741
address@hidden {Scheme Procedure} ->char-set x
address@hidden {C Function} scm_to_char_set (x)
-Coerces x into a char-set. @var{x} may be a string, character or char-set. A
string is converted to the set of its constituent characters; a character is
converted to a singleton set; a char-set is returned as-is.
address@hidden deffn
-
- char-set-size
address@hidden snarfed from srfi-14.c:757
address@hidden {Scheme Procedure} char-set-size cs
address@hidden {C Function} scm_char_set_size (cs)
-Return the number of elements in character set @var{cs}.
address@hidden deffn
-
- char-set-count
address@hidden snarfed from srfi-14.c:774
address@hidden {Scheme Procedure} char-set-count pred cs
address@hidden {C Function} scm_char_set_count (pred, cs)
-Return the number of the elements int the character set
address@hidden which satisfy the predicate @var{pred}.
address@hidden deffn
-
- char-set->list
address@hidden snarfed from srfi-14.c:797
address@hidden {Scheme Procedure} char-set->list cs
address@hidden {C Function} scm_char_set_to_list (cs)
-Return a list containing the elements of the character set
address@hidden
address@hidden deffn
-
- char-set->string
address@hidden snarfed from srfi-14.c:816
address@hidden {Scheme Procedure} char-set->string cs
address@hidden {C Function} scm_char_set_to_string (cs)
-Return a string containing the elements of the character set
address@hidden The order in which the characters are placed in the
-string is not defined.
address@hidden deffn
-
- char-set-contains?
address@hidden snarfed from srfi-14.c:841
address@hidden {Scheme Procedure} char-set-contains? cs ch
address@hidden {C Function} scm_char_set_contains_p (cs, ch)
-Return @code{#t} iff the character @var{ch} is contained in the
-character set @var{cs}.
address@hidden deffn
-
- char-set-every
address@hidden snarfed from srfi-14.c:854
address@hidden {Scheme Procedure} char-set-every pred cs
address@hidden {C Function} scm_char_set_every (pred, cs)
-Return a true value if every character in the character set
address@hidden satisfies the predicate @var{pred}.
address@hidden deffn
-
- char-set-any
address@hidden snarfed from srfi-14.c:878
address@hidden {Scheme Procedure} char-set-any pred cs
address@hidden {C Function} scm_char_set_any (pred, cs)
-Return a true value if any character in the character set
address@hidden satisfies the predicate @var{pred}.
address@hidden deffn
-
- char-set-adjoin
address@hidden snarfed from srfi-14.c:901
address@hidden {Scheme Procedure} char-set-adjoin cs . rest
address@hidden {C Function} scm_char_set_adjoin (cs, rest)
-Add all character arguments to the first argument, which must
-be a character set.
address@hidden deffn
-
- char-set-delete
address@hidden snarfed from srfi-14.c:929
address@hidden {Scheme Procedure} char-set-delete cs . rest
address@hidden {C Function} scm_char_set_delete (cs, rest)
-Delete all character arguments from the first argument, which
-must be a character set.
address@hidden deffn
-
- char-set-adjoin!
address@hidden snarfed from srfi-14.c:957
address@hidden {Scheme Procedure} char-set-adjoin! cs . rest
address@hidden {C Function} scm_char_set_adjoin_x (cs, rest)
-Add all character arguments to the first argument, which must
-be a character set.
address@hidden deffn
-
- char-set-delete!
address@hidden snarfed from srfi-14.c:984
address@hidden {Scheme Procedure} char-set-delete! cs . rest
address@hidden {C Function} scm_char_set_delete_x (cs, rest)
-Delete all character arguments from the first argument, which
-must be a character set.
address@hidden deffn
-
- char-set-complement
address@hidden snarfed from srfi-14.c:1010
address@hidden {Scheme Procedure} char-set-complement cs
address@hidden {C Function} scm_char_set_complement (cs)
-Return the complement of the character set @var{cs}.
address@hidden deffn
-
- char-set-union
address@hidden snarfed from srfi-14.c:1031
address@hidden {Scheme Procedure} char-set-union . rest
address@hidden {C Function} scm_char_set_union (rest)
-Return the union of all argument character sets.
address@hidden deffn
-
- char-set-intersection
address@hidden snarfed from srfi-14.c:1060
address@hidden {Scheme Procedure} char-set-intersection . rest
address@hidden {C Function} scm_char_set_intersection (rest)
-Return the intersection of all argument character sets.
address@hidden deffn
-
- char-set-difference
address@hidden snarfed from srfi-14.c:1100
address@hidden {Scheme Procedure} char-set-difference cs1 . rest
address@hidden {C Function} scm_char_set_difference (cs1, rest)
-Return the difference of all argument character sets.
address@hidden deffn
-
- char-set-xor
address@hidden snarfed from srfi-14.c:1130
address@hidden {Scheme Procedure} char-set-xor . rest
address@hidden {C Function} scm_char_set_xor (rest)
-Return the exclusive-or of all argument character sets.
address@hidden deffn
-
- char-set-diff+intersection
address@hidden snarfed from srfi-14.c:1171
address@hidden {Scheme Procedure} char-set-diff+intersection cs1 . rest
address@hidden {C Function} scm_char_set_diff_plus_intersection (cs1, rest)
-Return the difference and the intersection of all argument
-character sets.
address@hidden deffn
-
- char-set-complement!
address@hidden snarfed from srfi-14.c:1209
address@hidden {Scheme Procedure} char-set-complement! cs
address@hidden {C Function} scm_char_set_complement_x (cs)
-Return the complement of the character set @var{cs}.
address@hidden deffn
-
- char-set-union!
address@hidden snarfed from srfi-14.c:1226
address@hidden {Scheme Procedure} char-set-union! cs1 . rest
address@hidden {C Function} scm_char_set_union_x (cs1, rest)
-Return the union of all argument character sets.
address@hidden deffn
-
- char-set-intersection!
address@hidden snarfed from srfi-14.c:1254
address@hidden {Scheme Procedure} char-set-intersection! cs1 . rest
address@hidden {C Function} scm_char_set_intersection_x (cs1, rest)
-Return the intersection of all argument character sets.
address@hidden deffn
-
- char-set-difference!
address@hidden snarfed from srfi-14.c:1282
address@hidden {Scheme Procedure} char-set-difference! cs1 . rest
address@hidden {C Function} scm_char_set_difference_x (cs1, rest)
-Return the difference of all argument character sets.
address@hidden deffn
-
- char-set-xor!
address@hidden snarfed from srfi-14.c:1310
address@hidden {Scheme Procedure} char-set-xor! cs1 . rest
address@hidden {C Function} scm_char_set_xor_x (cs1, rest)
-Return the exclusive-or of all argument character sets.
address@hidden deffn
-
- char-set-diff+intersection!
address@hidden snarfed from srfi-14.c:1349
address@hidden {Scheme Procedure} char-set-diff+intersection! cs1 cs2 . rest
address@hidden {C Function} scm_char_set_diff_plus_intersection_x (cs1, cs2,
rest)
-Return the difference and the intersection of all argument
-character sets.
address@hidden deffn
-
- string=?
address@hidden snarfed from strorder.c:50
address@hidden {Scheme Procedure} string=? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_equal_p (s1, s2, rest)
-Lexicographic equality predicate; return @code{#t} if the two
-strings are the same length and contain the same characters in
-the same positions, otherwise return @code{#f}.
-
-The procedure @code{string-ci=?} treats upper and lower case
-letters as though they were the same character, but
address@hidden treats upper and lower case as distinct
-characters.
address@hidden deffn
-
- string-ci=?
address@hidden snarfed from strorder.c:62
address@hidden {Scheme Procedure} string-ci=? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_ci_equal_p (s1, s2, rest)
-Case-insensitive string equality predicate; return @code{#t} if
-the two strings are the same length and their component
-characters match (ignoring case) at each position; otherwise
-return @code{#f}.
address@hidden deffn
-
- string<?
address@hidden snarfed from strorder.c:72
address@hidden {Scheme Procedure} string<? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_less_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically less than @var{s2}.
address@hidden deffn
-
- string<=?
address@hidden snarfed from strorder.c:82
address@hidden {Scheme Procedure} string<=? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_leq_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically less than or equal to @var{s2}.
address@hidden deffn
-
- string>?
address@hidden snarfed from strorder.c:92
address@hidden {Scheme Procedure} string>? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_gr_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically greater than @var{s2}.
address@hidden deffn
-
- string>=?
address@hidden snarfed from strorder.c:102
address@hidden {Scheme Procedure} string>=? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_geq_p (s1, s2, rest)
-Lexicographic ordering predicate; return @code{#t} if @var{s1}
-is lexicographically greater than or equal to @var{s2}.
address@hidden deffn
-
- string-ci<?
address@hidden snarfed from strorder.c:113
address@hidden {Scheme Procedure} string-ci<? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_ci_less_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically less than @var{s2}
-regardless of case.
address@hidden deffn
-
- string-ci<=?
address@hidden snarfed from strorder.c:124
address@hidden {Scheme Procedure} string-ci<=? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_ci_leq_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically less than or equal
-to @var{s2} regardless of case.
address@hidden deffn
-
- string-ci>?
address@hidden snarfed from strorder.c:135
address@hidden {Scheme Procedure} string-ci>? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_ci_gr_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically greater than
address@hidden regardless of case.
address@hidden deffn
-
- string-ci>=?
address@hidden snarfed from strorder.c:146
address@hidden {Scheme Procedure} string-ci>=? [s1 [s2 . rest]]
address@hidden {C Function} scm_i_string_ci_geq_p (s1, s2, rest)
-Case insensitive lexicographic ordering predicate; return
address@hidden if @var{s1} is lexicographically greater than or
-equal to @var{s2} regardless of case.
address@hidden deffn
-
- object->string
address@hidden snarfed from strports.c:332
address@hidden {Scheme Procedure} object->string obj [printer]
address@hidden {C Function} scm_object_to_string (obj, printer)
-Return a Scheme string obtained by printing @var{obj}.
-Printing function can be specified by the optional second
-argument @var{printer} (default: @code{write}).
address@hidden deffn
-
- call-with-output-string
address@hidden snarfed from strports.c:356
address@hidden {Scheme Procedure} call-with-output-string proc
address@hidden {C Function} scm_call_with_output_string (proc)
-Calls the one-argument procedure @var{proc} with a newly created output
-port. When the function returns, the string composed of the characters
-written into the port is returned.
address@hidden deffn
-
- call-with-input-string
address@hidden snarfed from strports.c:375
address@hidden {Scheme Procedure} call-with-input-string string proc
address@hidden {C Function} scm_call_with_input_string (string, proc)
-Calls the one-argument procedure @var{proc} with a newly
-created input port from which @var{string}'s contents may be
-read. The value yielded by the @var{proc} is returned.
address@hidden deffn
-
- open-input-string
address@hidden snarfed from strports.c:388
address@hidden {Scheme Procedure} open-input-string str
address@hidden {C Function} scm_open_input_string (str)
-Take a string and return an input port that delivers characters
-from the string. The port can be closed by
address@hidden, though its storage will be reclaimed
-by the garbage collector if it becomes inaccessible.
address@hidden deffn
-
- open-output-string
address@hidden snarfed from strports.c:402
address@hidden {Scheme Procedure} open-output-string
address@hidden {C Function} scm_open_output_string ()
-Return an output port that will accumulate characters for
-retrieval by @code{get-output-string}. The port can be closed
-by the procedure @code{close-output-port}, though its storage
-will be reclaimed by the garbage collector if it becomes
-inaccessible.
address@hidden deffn
-
- get-output-string
address@hidden snarfed from strports.c:419
address@hidden {Scheme Procedure} get-output-string port
address@hidden {C Function} scm_get_output_string (port)
-Given an output port created by @code{open-output-string},
-return a string consisting of the characters that have been
-output to the port so far.
address@hidden deffn
-
- eval-string
address@hidden snarfed from strports.c:488
address@hidden {Scheme Procedure} eval-string string [module]
address@hidden {C Function} scm_eval_string_in_module (string, module)
-Evaluate @var{string} as the text representation of a Scheme
-form or forms, and return whatever value they produce.
-Evaluation takes place in the given module, or the current
-module when no module is given.
-While the code is evaluated, the given module is made the
-current one. The current module is restored when this
-procedure returns.
address@hidden deffn
-
- make-struct-layout
address@hidden snarfed from struct.c:56
address@hidden {Scheme Procedure} make-struct-layout fields
address@hidden {C Function} scm_make_struct_layout (fields)
-Return a new structure layout object.
-
address@hidden must be a string made up of pairs of characters
-strung together. The first character of each pair describes a field
-type, the second a field protection. Allowed types are 'p' for
-GC-protected Scheme data, 'u' for unprotected binary data, and 's' for
-a field that points to the structure itself. Allowed protections
-are 'w' for mutable fields, 'r' for read-only fields, and 'o' for opaque
-fields. The last field protection specification may be capitalized to
-indicate that the field is a tail-array.
address@hidden deffn
-
- struct?
address@hidden snarfed from struct.c:223
address@hidden {Scheme Procedure} struct? x
address@hidden {C Function} scm_struct_p (x)
-Return @code{#t} iff @var{x} is a structure object, else
address@hidden
address@hidden deffn
-
- struct-vtable?
address@hidden snarfed from struct.c:232
address@hidden {Scheme Procedure} struct-vtable? x
address@hidden {C Function} scm_struct_vtable_p (x)
-Return @code{#t} iff @var{x} is a vtable structure.
address@hidden deffn
-
- make-struct
address@hidden snarfed from struct.c:418
address@hidden {Scheme Procedure} make-struct vtable tail_array_size . init
address@hidden {C Function} scm_make_struct (vtable, tail_array_size, init)
-Create a new structure.
-
address@hidden must be a vtable structure (@pxref{Vtables}).
-
address@hidden must be a non-negative integer. If the layout
-specification indicated by @var{type} includes a tail-array,
-this is the number of elements allocated to that array.
-
-The @var{init1}, @dots{} are optional arguments describing how
-successive fields of the structure should be initialized. Only fields
-with protection 'r' or 'w' can be initialized, except for fields of
-type 's', which are automatically initialized to point to the new
-structure itself; fields with protection 'o' can not be initialized by
-Scheme programs.
-
-If fewer optional arguments than initializable fields are supplied,
-fields of type 'p' get default value #f while fields of type 'u' are
-initialized to 0.
-
-Structs are currently the basic representation for record-like data
-structures in Guile. The plan is to eventually replace them with a
-new representation which will at the same time be easier to use and
-more powerful.
-
-For more information, see the documentation for @code{make-vtable-vtable}.
address@hidden deffn
-
- make-vtable-vtable
address@hidden snarfed from struct.c:502
address@hidden {Scheme Procedure} make-vtable-vtable user_fields
tail_array_size . init
address@hidden {C Function} scm_make_vtable_vtable (user_fields,
tail_array_size, init)
-Return a new, self-describing vtable structure.
-
address@hidden is a string describing user defined fields of the
-vtable beginning at index @code{vtable-offset-user}
-(see @code{make-struct-layout}).
-
address@hidden specifies the size of the tail-array (if any) of
-this vtable.
-
address@hidden, @dots{} are the optional initializers for the fields of
-the vtable.
-
-Vtables have one initializable system field---the struct printer.
-This field comes before the user fields in the initializers passed
-to @code{make-vtable-vtable} and @code{make-struct}, and thus works as
-a third optional argument to @code{make-vtable-vtable} and a fourth to
address@hidden when creating vtables:
-
-If the value is a procedure, it will be called instead of the standard
-printer whenever a struct described by this vtable is printed.
-The procedure will be called with arguments STRUCT and PORT.
-
-The structure of a struct is described by a vtable, so the vtable is
-in essence the type of the struct. The vtable is itself a struct with
-a vtable. This could go on forever if it weren't for the
-vtable-vtables which are self-describing vtables, and thus terminate
-the chain.
-
-There are several potential ways of using structs, but the standard
-one is to use three kinds of structs, together building up a type
-sub-system: one vtable-vtable working as the root and one or several
-"types", each with a set of "instances". (The vtable-vtable should be
-compared to the class <class> which is the class of itself.)
-
address@hidden
-(define ball-root (make-vtable-vtable "pr" 0))
-
-(define (make-ball-type ball-color)
- (make-struct ball-root 0
- (make-struct-layout "pw")
- (lambda (ball port)
- (format port "#<a ~A ball owned by ~A>"
- (color ball)
- (owner ball)))
- ball-color))
-(define (color ball) (struct-ref (struct-vtable ball) vtable-offset-user))
-(define (owner ball) (struct-ref ball 0))
-
-(define red (make-ball-type 'red))
-(define green (make-ball-type 'green))
-
-(define (make-ball type owner) (make-struct type 0 owner))
-
-(define ball (make-ball green 'Nisse))
-ball @result{} #<a green ball owned by Nisse>
address@hidden lisp
address@hidden deffn
-
- struct-ref
address@hidden snarfed from struct.c:542
address@hidden {Scheme Procedure} struct-ref handle pos
address@hidden {Scheme Procedure} struct-set! struct n value
address@hidden {C Function} scm_struct_ref (handle, pos)
-Access (or modify) the @var{n}th field of @var{struct}.
-
-If the field is of type 'p', then it can be set to an arbitrary value.
-
-If the field is of type 'u', then it can only be set to a non-negative
-integer value small enough to fit in one machine word.
address@hidden deffn
-
- struct-set!
address@hidden snarfed from struct.c:621
address@hidden {Scheme Procedure} struct-set! handle pos val
address@hidden {C Function} scm_struct_set_x (handle, pos, val)
-Set the slot of the structure @var{handle} with index @var{pos}
-to @var{val}. Signal an error if the slot can not be written
-to.
address@hidden deffn
-
- struct-vtable
address@hidden snarfed from struct.c:692
address@hidden {Scheme Procedure} struct-vtable handle
address@hidden {C Function} scm_struct_vtable (handle)
-Return the vtable structure that describes the type of @var{struct}.
address@hidden deffn
-
- struct-vtable-tag
address@hidden snarfed from struct.c:703
address@hidden {Scheme Procedure} struct-vtable-tag handle
address@hidden {C Function} scm_struct_vtable_tag (handle)
-Return the vtable tag of the structure @var{handle}.
address@hidden deffn
-
- struct-vtable-name
address@hidden snarfed from struct.c:742
address@hidden {Scheme Procedure} struct-vtable-name vtable
address@hidden {C Function} scm_struct_vtable_name (vtable)
-Return the name of the vtable @var{vtable}.
address@hidden deffn
-
- set-struct-vtable-name!
address@hidden snarfed from struct.c:752
address@hidden {Scheme Procedure} set-struct-vtable-name! vtable name
address@hidden {C Function} scm_set_struct_vtable_name_x (vtable, name)
-Set the name of the vtable @var{vtable} to @var{name}.
address@hidden deffn
-
- symbol?
address@hidden snarfed from symbols.c:156
address@hidden {Scheme Procedure} symbol? obj
address@hidden {C Function} scm_symbol_p (obj)
-Return @code{#t} if @var{obj} is a symbol, otherwise return
address@hidden
address@hidden deffn
-
- symbol-interned?
address@hidden snarfed from symbols.c:166
address@hidden {Scheme Procedure} symbol-interned? symbol
address@hidden {C Function} scm_symbol_interned_p (symbol)
-Return @code{#t} if @var{symbol} is interned, otherwise return
address@hidden
address@hidden deffn
-
- make-symbol
address@hidden snarfed from symbols.c:178
address@hidden {Scheme Procedure} make-symbol name
address@hidden {C Function} scm_make_symbol (name)
-Return a new uninterned symbol with the name @var{name}. The returned symbol
is guaranteed to be unique and future calls to @code{string->symbol} will not
return it.
address@hidden deffn
-
- symbol->string
address@hidden snarfed from symbols.c:210
address@hidden {Scheme Procedure} symbol->string s
address@hidden {C Function} scm_symbol_to_string (s)
-Return the name of @var{symbol} as a string. If the symbol was
-part of an object returned as the value of a literal expression
-(section @pxref{Literal expressions,,,r5rs, The Revised^5
-Report on Scheme}) or by a call to the @code{read} procedure,
-and its name contains alphabetic characters, then the string
-returned will contain characters in the implementation's
-preferred standard case---some implementations will prefer
-upper case, others lower case. If the symbol was returned by
address@hidden>symbol}, the case of characters in the string
-returned will be the same as the case in the string that was
-passed to @code{string->symbol}. It is an error to apply
-mutation procedures like @code{string-set!} to strings returned
-by this procedure.
-
-The following examples assume that the implementation's
-standard case is lower case:
-
address@hidden
-(symbol->string 'flying-fish) @result{} "flying-fish"
-(symbol->string 'Martin) @result{} "martin"
-(symbol->string
- (string->symbol "Malvina")) @result{} "Malvina"
address@hidden lisp
address@hidden deffn
-
- string->symbol
address@hidden snarfed from symbols.c:240
address@hidden {Scheme Procedure} string->symbol string
address@hidden {C Function} scm_string_to_symbol (string)
-Return the symbol whose name is @var{string}. This procedure
-can create symbols with names containing special characters or
-letters in the non-standard case, but it is usually a bad idea
-to create such symbols because in some implementations of
-Scheme they cannot be read as themselves. See
address@hidden>string}.
-
-The following examples assume that the implementation's
-standard case is lower case:
-
address@hidden
-(eq? 'mISSISSIppi 'mississippi) @result{} #t
-(string->symbol "mISSISSIppi") @result{} @r{the symbol with name "mISSISSIppi"}
-(eq? 'bitBlt (string->symbol "bitBlt")) @result{} #f
-(eq? 'JollyWog
- (string->symbol (symbol->string 'JollyWog))) @result{} #t
-(string=? "K. Harper, M.D."
- (symbol->string
- (string->symbol "K. Harper, M.D."))) @result{}#t
address@hidden lisp
address@hidden deffn
-
- string-ci->symbol
address@hidden snarfed from symbols.c:252
address@hidden {Scheme Procedure} string-ci->symbol str
address@hidden {C Function} scm_string_ci_to_symbol (str)
-Return the symbol whose name is @var{str}. @var{str} is
-converted to lowercase before the conversion is done, if Guile
-is currently reading symbols case-insensitively.
address@hidden deffn
-
- gensym
address@hidden snarfed from symbols.c:269
address@hidden {Scheme Procedure} gensym [prefix]
address@hidden {C Function} scm_gensym (prefix)
-Create a new symbol with a name constructed from a prefix and
-a counter value. The string @var{prefix} can be specified as
-an optional argument. Default prefix is @code{ g}. The counter
-is increased by 1 at each call. There is no provision for
-resetting the counter.
address@hidden deffn
-
- symbol-hash
address@hidden snarfed from symbols.c:295
address@hidden {Scheme Procedure} symbol-hash symbol
address@hidden {C Function} scm_symbol_hash (symbol)
-Return a hash value for @var{symbol}.
address@hidden deffn
-
- symbol-fref
address@hidden snarfed from symbols.c:305
address@hidden {Scheme Procedure} symbol-fref s
address@hidden {C Function} scm_symbol_fref (s)
-Return the contents of @var{symbol}'s @dfn{function slot}.
address@hidden deffn
-
- symbol-pref
address@hidden snarfed from symbols.c:316
address@hidden {Scheme Procedure} symbol-pref s
address@hidden {C Function} scm_symbol_pref (s)
-Return the @dfn{property list} currently associated with @var{symbol}.
address@hidden deffn
-
- symbol-fset!
address@hidden snarfed from symbols.c:327
address@hidden {Scheme Procedure} symbol-fset! s val
address@hidden {C Function} scm_symbol_fset_x (s, val)
-Change the binding of @var{symbol}'s function slot.
address@hidden deffn
-
- symbol-pset!
address@hidden snarfed from symbols.c:339
address@hidden {Scheme Procedure} symbol-pset! s val
address@hidden {C Function} scm_symbol_pset_x (s, val)
-Change the binding of @var{symbol}'s property slot.
address@hidden deffn
-
- call-with-new-thread
address@hidden snarfed from threads.c:611
address@hidden {Scheme Procedure} call-with-new-thread thunk [handler]
address@hidden {C Function} scm_call_with_new_thread (thunk, handler)
-Call @code{thunk} in a new thread and with a new dynamic state,
-returning a new thread object representing the thread. The procedure
address@hidden is called via @code{with-continuation-barrier}.
-
-When @var{handler} is specified, then @var{thunk} is called from
-within a @code{catch} with tag @code{#t} that has @var{handler} as its
-handler. This catch is established inside the continuation barrier.
-
-Once @var{thunk} or @var{handler} returns, the return value is made
-the @emph{exit value} of the thread and the thread is terminated.
address@hidden deffn
-
- yield
address@hidden snarfed from threads.c:722
address@hidden {Scheme Procedure} yield
address@hidden {C Function} scm_yield ()
-Move the calling thread to the end of the scheduling queue.
address@hidden deffn
-
- join-thread
address@hidden snarfed from threads.c:732
address@hidden {Scheme Procedure} join-thread thread
address@hidden {C Function} scm_join_thread (thread)
-Suspend execution of the calling thread until the target @var{thread}
terminates, unless the target @var{thread} has already terminated.
address@hidden deffn
-
- make-mutex
address@hidden snarfed from threads.c:828
address@hidden {Scheme Procedure} make-mutex
address@hidden {C Function} scm_make_mutex ()
-Create a new mutex.
address@hidden deffn
-
- make-recursive-mutex
address@hidden snarfed from threads.c:837
address@hidden {Scheme Procedure} make-recursive-mutex
address@hidden {C Function} scm_make_recursive_mutex ()
-Create a new recursive mutex.
address@hidden deffn
-
- lock-mutex
address@hidden snarfed from threads.c:883
address@hidden {Scheme Procedure} lock-mutex mx
address@hidden {C Function} scm_lock_mutex (mx)
-Lock @var{mutex}. If the mutex is already locked, the calling thread blocks
until the mutex becomes available. The function returns when the calling thread
owns the lock on @var{mutex}. Locking a mutex that a thread already owns will
succeed right away and will not block the thread. That is, Guile's mutexes are
@emph{recursive}.
address@hidden deffn
-
- try-mutex
address@hidden snarfed from threads.c:931
address@hidden {Scheme Procedure} try-mutex mutex
address@hidden {C Function} scm_try_mutex (mutex)
-Try to lock @var{mutex}. If the mutex is already locked by someone else,
return @code{#f}. Else lock the mutex and return @code{#t}.
address@hidden deffn
-
- unlock-mutex
address@hidden snarfed from threads.c:976
address@hidden {Scheme Procedure} unlock-mutex mx
address@hidden {C Function} scm_unlock_mutex (mx)
-Unlocks @var{mutex} if the calling thread owns the lock on @var{mutex}.
Calling unlock-mutex on a mutex not owned by the current thread results in
undefined behaviour. Once a mutex has been unlocked, one thread blocked on
@var{mutex} is awakened and grabs the mutex lock. Every call to
@code{lock-mutex} by this thread must be matched with a call to
@code{unlock-mutex}. Only the last call to @code{unlock-mutex} will actually
unlock the mutex.
address@hidden deffn
-
- make-condition-variable
address@hidden snarfed from threads.c:1052
address@hidden {Scheme Procedure} make-condition-variable
address@hidden {C Function} scm_make_condition_variable ()
-Make a new condition variable.
address@hidden deffn
-
- wait-condition-variable
address@hidden snarfed from threads.c:1120
address@hidden {Scheme Procedure} wait-condition-variable cv mx [t]
address@hidden {C Function} scm_timed_wait_condition_variable (cv, mx, t)
-Wait until @var{cond-var} has been signalled. While waiting, @var{mutex} is
atomically unlocked (as with @code{unlock-mutex}) and is locked again when this
function returns. When @var{time} is given, it specifies a point in time where
the waiting should be aborted. It can be either a integer as returned by
@code{current-time} or a pair as returned by @code{gettimeofday}. When the
waiting is aborted the mutex is locked and @code{#f} is returned. When the
condition variable is in fact [...]
address@hidden deffn
-
- signal-condition-variable
address@hidden snarfed from threads.c:1157
address@hidden {Scheme Procedure} signal-condition-variable cv
address@hidden {C Function} scm_signal_condition_variable (cv)
-Wake up one thread that is waiting for @var{cv}
address@hidden deffn
-
- broadcast-condition-variable
address@hidden snarfed from threads.c:1177
address@hidden {Scheme Procedure} broadcast-condition-variable cv
address@hidden {C Function} scm_broadcast_condition_variable (cv)
-Wake up all threads that are waiting for @var{cv}.
address@hidden deffn
-
- current-thread
address@hidden snarfed from threads.c:1354
address@hidden {Scheme Procedure} current-thread
address@hidden {C Function} scm_current_thread ()
-Return the thread that called this function.
address@hidden deffn
-
- all-threads
address@hidden snarfed from threads.c:1372
address@hidden {Scheme Procedure} all-threads
address@hidden {C Function} scm_all_threads ()
-Return a list of all threads.
address@hidden deffn
-
- thread-exited?
address@hidden snarfed from threads.c:1398
address@hidden {Scheme Procedure} thread-exited? thread
address@hidden {C Function} scm_thread_exited_p (thread)
-Return @code{#t} iff @var{thread} has exited.
-
address@hidden deffn
-
- catch
address@hidden snarfed from throw.c:512
address@hidden {Scheme Procedure} catch key thunk handler
address@hidden {C Function} scm_catch (key, thunk, handler)
-Invoke @var{thunk} in the dynamic context of @var{handler} for
-exceptions matching @var{key}. If thunk throws to the symbol
address@hidden, then @var{handler} is invoked this way:
address@hidden
-(handler key args ...)
address@hidden lisp
-
address@hidden is a symbol or @code{#t}.
-
address@hidden takes no arguments. If @var{thunk} returns
-normally, that is the return value of @code{catch}.
-
-Handler is invoked outside the scope of its own @code{catch}.
-If @var{handler} again throws to the same key, a new handler
-from further up the call chain is invoked.
-
-If the key is @code{#t}, then a throw to @emph{any} symbol will
-match this call to @code{catch}.
address@hidden deffn
-
- lazy-catch
address@hidden snarfed from throw.c:540
address@hidden {Scheme Procedure} lazy-catch key thunk handler
address@hidden {C Function} scm_lazy_catch (key, thunk, handler)
-This behaves exactly like @code{catch}, except that it does
-not unwind the stack before invoking @var{handler}.
-The @var{handler} procedure is not allowed to return:
-it must throw to another catch, or otherwise exit non-locally.
address@hidden deffn
-
- throw
address@hidden snarfed from throw.c:573
address@hidden {Scheme Procedure} throw key . args
address@hidden {C Function} scm_throw (key, args)
-Invoke the catch form matching @var{key}, passing @var{args} to the
address@hidden
-
address@hidden is a symbol. It will match catches of the same symbol or of
address@hidden
-
-If there is no handler at all, Guile prints an error and then exits.
address@hidden deffn
-
- values
address@hidden snarfed from values.c:53
address@hidden {Scheme Procedure} values . args
address@hidden {C Function} scm_values (args)
-Delivers all of its arguments to its continuation. Except for
-continuations created by the @code{call-with-values} procedure,
-all continuations take exactly one value. The effect of
-passing no value or more than one value to continuations that
-were not created by @code{call-with-values} is unspecified.
address@hidden deffn
-
- make-variable
address@hidden snarfed from variable.c:52
address@hidden {Scheme Procedure} make-variable init
address@hidden {C Function} scm_make_variable (init)
-Return a variable initialized to value @var{init}.
address@hidden deffn
-
- make-undefined-variable
address@hidden snarfed from variable.c:62
address@hidden {Scheme Procedure} make-undefined-variable
address@hidden {C Function} scm_make_undefined_variable ()
-Return a variable that is initially unbound.
address@hidden deffn
-
- variable?
address@hidden snarfed from variable.c:73
address@hidden {Scheme Procedure} variable? obj
address@hidden {C Function} scm_variable_p (obj)
-Return @code{#t} iff @var{obj} is a variable object, else
-return @code{#f}.
address@hidden deffn
-
- variable-ref
address@hidden snarfed from variable.c:85
address@hidden {Scheme Procedure} variable-ref var
address@hidden {C Function} scm_variable_ref (var)
-Dereference @var{var} and return its value.
address@hidden must be a variable object; see @code{make-variable}
-and @code{make-undefined-variable}.
address@hidden deffn
-
- variable-set!
address@hidden snarfed from variable.c:101
address@hidden {Scheme Procedure} variable-set! var val
address@hidden {C Function} scm_variable_set_x (var, val)
-Set the value of the variable @var{var} to @var{val}.
address@hidden must be a variable object, @var{val} can be any
-value. Return an unspecified value.
address@hidden deffn
-
- variable-bound?
address@hidden snarfed from variable.c:113
address@hidden {Scheme Procedure} variable-bound? var
address@hidden {C Function} scm_variable_bound_p (var)
-Return @code{#t} iff @var{var} is bound to a value.
-Throws an error if @var{var} is not a variable object.
address@hidden deffn
-
- vector?
address@hidden snarfed from vectors.c:91
address@hidden {Scheme Procedure} vector? obj
address@hidden {C Function} scm_vector_p (obj)
-Return @code{#t} if @var{obj} is a vector, otherwise return
address@hidden
address@hidden deffn
-
- list->vector
address@hidden snarfed from vectors.c:123
address@hidden {Scheme Procedure} list->vector
-implemented by the C function "scm_vector"
address@hidden deffn
-
- vector
address@hidden snarfed from vectors.c:140
address@hidden {Scheme Procedure} vector . l
address@hidden {Scheme Procedure} list->vector l
address@hidden {C Function} scm_vector (l)
-Return a newly allocated vector composed of the
-given arguments. Analogous to @code{list}.
-
address@hidden
-(vector 'a 'b 'c) @result{} #(a b c)
address@hidden lisp
address@hidden deffn
-
- make-vector
address@hidden snarfed from vectors.c:276
address@hidden {Scheme Procedure} make-vector k [fill]
address@hidden {C Function} scm_make_vector (k, fill)
-Return a newly allocated vector of @var{k} elements. If a
-second argument is given, then each position is initialized to
address@hidden Otherwise the initial contents of each position is
-unspecified.
address@hidden deffn
-
- vector-copy
address@hidden snarfed from vectors.c:318
address@hidden {Scheme Procedure} vector-copy vec
address@hidden {C Function} scm_vector_copy (vec)
-Return a copy of @var{vec}.
address@hidden deffn
-
- vector->list
address@hidden snarfed from vectors.c:389
address@hidden {Scheme Procedure} vector->list v
address@hidden {C Function} scm_vector_to_list (v)
-Return a newly allocated list composed of the elements of @var{v}.
-
address@hidden
-(vector->list '#(dah dah didah)) @result{} (dah dah didah)
-(list->vector '(dididit dah)) @result{} #(dididit dah)
address@hidden lisp
address@hidden deffn
-
- vector-fill!
address@hidden snarfed from vectors.c:413
address@hidden {Scheme Procedure} vector-fill! v fill
address@hidden {C Function} scm_vector_fill_x (v, fill)
-Store @var{fill} in every position of @var{vector}. The value
-returned by @code{vector-fill!} is unspecified.
address@hidden deffn
-
- vector-move-left!
address@hidden snarfed from vectors.c:450
address@hidden {Scheme Procedure} vector-move-left! vec1 start1 end1 vec2 start2
address@hidden {C Function} scm_vector_move_left_x (vec1, start1, end1, vec2,
start2)
-Copy elements from @var{vec1}, positions @var{start1} to @var{end1},
-to @var{vec2} starting at position @var{start2}. @var{start1} and
address@hidden are inclusive indices; @var{end1} is exclusive.
-
address@hidden copies elements in leftmost order.
-Therefore, in the case where @var{vec1} and @var{vec2} refer to the
-same vector, @code{vector-move-left!} is usually appropriate when
address@hidden is greater than @var{start2}.
address@hidden deffn
-
- vector-move-right!
address@hidden snarfed from vectors.c:488
address@hidden {Scheme Procedure} vector-move-right! vec1 start1 end1 vec2
start2
address@hidden {C Function} scm_vector_move_right_x (vec1, start1, end1, vec2,
start2)
-Copy elements from @var{vec1}, positions @var{start1} to @var{end1},
-to @var{vec2} starting at position @var{start2}. @var{start1} and
address@hidden are inclusive indices; @var{end1} is exclusive.
-
address@hidden copies elements in rightmost order.
-Therefore, in the case where @var{vec1} and @var{vec2} refer to the
-same vector, @code{vector-move-right!} is usually appropriate when
address@hidden is less than @var{start2}.
address@hidden deffn
-
- generalized-vector?
address@hidden snarfed from vectors.c:537
address@hidden {Scheme Procedure} generalized-vector? obj
address@hidden {C Function} scm_generalized_vector_p (obj)
-Return @code{#t} if @var{obj} is a vector, string,
-bitvector, or uniform numeric vector.
address@hidden deffn
-
- generalized-vector-length
address@hidden snarfed from vectors.c:569
address@hidden {Scheme Procedure} generalized-vector-length v
address@hidden {C Function} scm_generalized_vector_length (v)
-Return the length of the generalized vector @var{v}.
address@hidden deffn
-
- generalized-vector-ref
address@hidden snarfed from vectors.c:594
address@hidden {Scheme Procedure} generalized-vector-ref v idx
address@hidden {C Function} scm_generalized_vector_ref (v, idx)
-Return the element at index @var{idx} of the
-generalized vector @var{v}.
address@hidden deffn
-
- generalized-vector-set!
address@hidden snarfed from vectors.c:619
address@hidden {Scheme Procedure} generalized-vector-set! v idx val
address@hidden {C Function} scm_generalized_vector_set_x (v, idx, val)
-Set the element at index @var{idx} of the
-generalized vector @var{v} to @var{val}.
address@hidden deffn
-
- generalized-vector->list
address@hidden snarfed from vectors.c:630
address@hidden {Scheme Procedure} generalized-vector->list v
address@hidden {C Function} scm_generalized_vector_to_list (v)
-Return a new list whose elements are the elements of the
-generalized vector @var{v}.
address@hidden deffn
-
- major-version
address@hidden snarfed from version.c:35
address@hidden {Scheme Procedure} major-version
address@hidden {C Function} scm_major_version ()
-Return a string containing Guile's major version number.
-E.g., the 1 in "1.6.5".
address@hidden deffn
-
- minor-version
address@hidden snarfed from version.c:48
address@hidden {Scheme Procedure} minor-version
address@hidden {C Function} scm_minor_version ()
-Return a string containing Guile's minor version number.
-E.g., the 6 in "1.6.5".
address@hidden deffn
-
- micro-version
address@hidden snarfed from version.c:61
address@hidden {Scheme Procedure} micro-version
address@hidden {C Function} scm_micro_version ()
-Return a string containing Guile's micro version number.
-E.g., the 5 in "1.6.5".
address@hidden deffn
-
- version
address@hidden snarfed from version.c:83
address@hidden {Scheme Procedure} version
address@hidden {Scheme Procedure} major-version
address@hidden {Scheme Procedure} minor-version
address@hidden {Scheme Procedure} micro-version
address@hidden {C Function} scm_version ()
-Return a string describing Guile's version number, or its major, minor
-or micro version number, respectively.
-
address@hidden
-(version) @result{} "1.6.0"
-(major-version) @result{} "1"
-(minor-version) @result{} "6"
-(micro-version) @result{} "0"
address@hidden lisp
address@hidden deffn
-
- effective-version
address@hidden snarfed from version.c:113
address@hidden {Scheme Procedure} effective-version
address@hidden {C Function} scm_effective_version ()
-Return a string describing Guile's effective version number.
address@hidden
-(version) @result{} "1.6.0"
-(effective-version) @result{} "1.6"
-(major-version) @result{} "1"
-(minor-version) @result{} "6"
-(micro-version) @result{} "0"
address@hidden lisp
address@hidden deffn
-
- make-soft-port
address@hidden snarfed from vports.c:185
address@hidden {Scheme Procedure} make-soft-port pv modes
address@hidden {C Function} scm_make_soft_port (pv, modes)
-Return a port capable of receiving or delivering characters as
-specified by the @var{modes} string (@pxref{File Ports,
-open-file}). @var{pv} must be a vector of length 5 or 6. Its
-components are as follows:
-
address@hidden 0
address@hidden
-procedure accepting one character for output
address@hidden
-procedure accepting a string for output
address@hidden
-thunk for flushing output
address@hidden
-thunk for getting one character
address@hidden
-thunk for closing port (not by garbage collection)
address@hidden
-(if present and not @code{#f}) thunk for computing the number of
-characters that can be read from the port without blocking.
address@hidden enumerate
-
-For an output-only port only elements 0, 1, 2, and 4 need be
-procedures. For an input-only port only elements 3 and 4 need
-be procedures. Thunks 2 and 4 can instead be @code{#f} if
-there is no useful operation for them to perform.
-
-If thunk 3 returns @code{#f} or an @code{eof-object}
-(@pxref{Input, eof-object?, ,r5rs, The Revised^5 Report on
-Scheme}) it indicates that the port has reached end-of-file.
-For example:
-
address@hidden
-(define stdout (current-output-port))
-(define p (make-soft-port
- (vector
- (lambda (c) (write c stdout))
- (lambda (s) (display s stdout))
- (lambda () (display "." stdout))
- (lambda () (char-upcase (read-char)))
- (lambda () (display "@@" stdout)))
- "rw"))
-
-(write p p) @result{} #<input-output: soft 8081e20>
address@hidden lisp
address@hidden deffn
-
- make-weak-vector
address@hidden snarfed from weaks.c:74
address@hidden {Scheme Procedure} make-weak-vector size [fill]
address@hidden {C Function} scm_make_weak_vector (size, fill)
-Return a weak vector with @var{size} elements. If the optional
-argument @var{fill} is given, all entries in the vector will be
-set to @var{fill}. The default value for @var{fill} is the
-empty list.
address@hidden deffn
-
- list->weak-vector
address@hidden snarfed from weaks.c:82
address@hidden {Scheme Procedure} list->weak-vector
-implemented by the C function "scm_weak_vector"
address@hidden deffn
-
- weak-vector
address@hidden snarfed from weaks.c:90
address@hidden {Scheme Procedure} weak-vector . l
address@hidden {Scheme Procedure} list->weak-vector l
address@hidden {C Function} scm_weak_vector (l)
-Construct a weak vector from a list: @code{weak-vector} uses
-the list of its arguments while @code{list->weak-vector} uses
-its only argument @var{l} (a list) to construct a weak vector
-the same way @code{list->vector} would.
address@hidden deffn
-
- weak-vector?
address@hidden snarfed from weaks.c:120
address@hidden {Scheme Procedure} weak-vector? obj
address@hidden {C Function} scm_weak_vector_p (obj)
-Return @code{#t} if @var{obj} is a weak vector. Note that all
-weak hashes are also weak vectors.
address@hidden deffn
-
- make-weak-key-alist-vector
address@hidden snarfed from weaks.c:138
address@hidden {Scheme Procedure} make-weak-key-alist-vector [size]
address@hidden {Scheme Procedure} make-weak-value-alist-vector size
address@hidden {Scheme Procedure} make-doubly-weak-alist-vector size
address@hidden {C Function} scm_make_weak_key_alist_vector (size)
-Return a weak hash table with @var{size} buckets. As with any
-hash table, choosing a good size for the table requires some
-caution.
-
-You can modify weak hash tables in exactly the same way you
-would modify regular hash tables. (@pxref{Hash Tables})
address@hidden deffn
-
- make-weak-value-alist-vector
address@hidden snarfed from weaks.c:150
address@hidden {Scheme Procedure} make-weak-value-alist-vector [size]
address@hidden {C Function} scm_make_weak_value_alist_vector (size)
-Return a hash table with weak values with @var{size} buckets.
-(@pxref{Hash Tables})
address@hidden deffn
-
- make-doubly-weak-alist-vector
address@hidden snarfed from weaks.c:162
address@hidden {Scheme Procedure} make-doubly-weak-alist-vector size
address@hidden {C Function} scm_make_doubly_weak_alist_vector (size)
-Return a hash table with weak keys and values with @var{size}
-buckets. (@pxref{Hash Tables})
address@hidden deffn
-
- weak-key-alist-vector?
address@hidden snarfed from weaks.c:177
address@hidden {Scheme Procedure} weak-key-alist-vector? obj
address@hidden {Scheme Procedure} weak-value-alist-vector? obj
address@hidden {Scheme Procedure} doubly-weak-alist-vector? obj
address@hidden {C Function} scm_weak_key_alist_vector_p (obj)
-Return @code{#t} if @var{obj} is the specified weak hash
-table. Note that a doubly weak hash table is neither a weak key
-nor a weak value hash table.
address@hidden deffn
-
- weak-value-alist-vector?
address@hidden snarfed from weaks.c:187
address@hidden {Scheme Procedure} weak-value-alist-vector? obj
address@hidden {C Function} scm_weak_value_alist_vector_p (obj)
-Return @code{#t} if @var{obj} is a weak value hash table.
address@hidden deffn
-
- doubly-weak-alist-vector?
address@hidden snarfed from weaks.c:197
address@hidden {Scheme Procedure} doubly-weak-alist-vector? obj
address@hidden {C Function} scm_doubly_weak_alist_vector_p (obj)
-Return @code{#t} if @var{obj} is a doubly weak hash table.
address@hidden deffn
-
- array-fill!
address@hidden snarfed from ramap.c:352
address@hidden {Scheme Procedure} array-fill! ra fill
address@hidden {C Function} scm_array_fill_x (ra, fill)
-Store @var{fill} in every element of @var{array}. The value returned
-is unspecified.
address@hidden deffn
-
- array-copy-in-order!
address@hidden snarfed from ramap.c:399
address@hidden {Scheme Procedure} array-copy-in-order!
-implemented by the C function "scm_array_copy_x"
address@hidden deffn
-
- array-copy!
address@hidden snarfed from ramap.c:408
address@hidden {Scheme Procedure} array-copy! src dst
address@hidden {Scheme Procedure} array-copy-in-order! src dst
address@hidden {C Function} scm_array_copy_x (src, dst)
-Copy every element from vector or array @var{source} to the
-corresponding element of @var{destination}. @var{destination} must have
-the same rank as @var{source}, and be at least as large in each
-dimension. The order is unspecified.
address@hidden deffn
-
- array-map-in-order!
address@hidden snarfed from ramap.c:798
address@hidden {Scheme Procedure} array-map-in-order!
-implemented by the C function "scm_array_map_x"
address@hidden deffn
-
- array-map!
address@hidden snarfed from ramap.c:809
address@hidden {Scheme Procedure} array-map! ra0 proc . lra
address@hidden {Scheme Procedure} array-map-in-order! ra0 proc . lra
address@hidden {C Function} scm_array_map_x (ra0, proc, lra)
address@hidden, @dots{} must have the same number of dimensions as
address@hidden and have a range for each index which includes the range
-for the corresponding index in @var{array0}. @var{proc} is applied to
-each tuple of elements of @var{array1} @dots{} and the result is stored
-as the corresponding element in @var{array0}. The value returned is
-unspecified. The order of application is unspecified.
address@hidden deffn
-
- array-for-each
address@hidden snarfed from ramap.c:950
address@hidden {Scheme Procedure} array-for-each proc ra0 . lra
address@hidden {C Function} scm_array_for_each (proc, ra0, lra)
-Apply @var{proc} to each tuple of elements of @var{array0} @dots{}
-in row-major order. The value returned is unspecified.
address@hidden deffn
-
- array-index-map!
address@hidden snarfed from ramap.c:978
address@hidden {Scheme Procedure} array-index-map! ra proc
address@hidden {C Function} scm_array_index_map_x (ra, proc)
-Apply @var{proc} to the indices of each element of @var{array} in
-turn, storing the result in the corresponding element. The value
-returned and the order of application are unspecified.
-
-One can implement @var{array-indexes} as
address@hidden
-(define (array-indexes array)
- (let ((ra (apply make-array #f (array-shape array))))
- (array-index-map! ra (lambda x x))
- ra))
address@hidden lisp
-Another example:
address@hidden
-(define (apl:index-generator n)
- (let ((v (make-uniform-vector n 1)))
- (array-index-map! v (lambda (i) i))
- v))
address@hidden lisp
address@hidden deffn
-
- array?
address@hidden snarfed from unif.c:501
address@hidden {Scheme Procedure} array? obj [prot]
address@hidden {C Function} scm_array_p (obj, prot)
-Return @code{#t} if the @var{obj} is an array, and @code{#f} if
-not.
address@hidden deffn
-
- typed-array?
address@hidden snarfed from unif.c:548
address@hidden {Scheme Procedure} typed-array? obj type
address@hidden {C Function} scm_typed_array_p (obj, type)
-Return @code{#t} if the @var{obj} is an array of type
address@hidden, and @code{#f} if not.
address@hidden deffn
-
- array-rank
address@hidden snarfed from unif.c:569
address@hidden {Scheme Procedure} array-rank array
address@hidden {C Function} scm_array_rank (array)
-Return the number of dimensions of the array @var{array.}
-
address@hidden deffn
-
- array-dimensions
address@hidden snarfed from unif.c:583
address@hidden {Scheme Procedure} array-dimensions ra
address@hidden {C Function} scm_array_dimensions (ra)
address@hidden is similar to @code{array-shape} but replaces
-elements with a @code{0} minimum with one greater than the maximum. So:
address@hidden
-(array-dimensions (make-array 'foo '(-1 3) 5)) @result{} ((-1 3) 5)
address@hidden lisp
address@hidden deffn
-
- shared-array-root
address@hidden snarfed from unif.c:611
address@hidden {Scheme Procedure} shared-array-root ra
address@hidden {C Function} scm_shared_array_root (ra)
-Return the root vector of a shared array.
address@hidden deffn
-
- shared-array-offset
address@hidden snarfed from unif.c:625
address@hidden {Scheme Procedure} shared-array-offset ra
address@hidden {C Function} scm_shared_array_offset (ra)
-Return the root vector index of the first element in the array.
address@hidden deffn
-
- shared-array-increments
address@hidden snarfed from unif.c:641
address@hidden {Scheme Procedure} shared-array-increments ra
address@hidden {C Function} scm_shared_array_increments (ra)
-For each dimension, return the distance between elements in the root vector.
address@hidden deffn
-
- make-typed-array
address@hidden snarfed from unif.c:740
address@hidden {Scheme Procedure} make-typed-array type fill . bounds
address@hidden {C Function} scm_make_typed_array (type, fill, bounds)
-Create and return an array of type @var{type}.
address@hidden deffn
-
- make-array
address@hidden snarfed from unif.c:775
address@hidden {Scheme Procedure} make-array fill . bounds
address@hidden {C Function} scm_make_array (fill, bounds)
-Create and return an array.
address@hidden deffn
-
- dimensions->uniform-array
address@hidden snarfed from unif.c:790
address@hidden {Scheme Procedure} dimensions->uniform-array dims prot [fill]
address@hidden {Scheme Procedure} make-uniform-vector length prototype [fill]
address@hidden {C Function} scm_dimensions_to_uniform_array (dims, prot, fill)
-Create and return a uniform array or vector of type
-corresponding to @var{prototype} with dimensions @var{dims} or
-length @var{length}. If @var{fill} is supplied, it's used to
-fill the array, otherwise @var{prototype} is used.
address@hidden deffn
-
- make-shared-array
address@hidden snarfed from unif.c:843
address@hidden {Scheme Procedure} make-shared-array oldra mapfunc . dims
address@hidden {C Function} scm_make_shared_array (oldra, mapfunc, dims)
address@hidden can be used to create shared subarrays of other
-arrays. The @var{mapper} is a function that translates coordinates in
-the new array into coordinates in the old array. A @var{mapper} must be
-linear, and its range must stay within the bounds of the old array, but
-it can be otherwise arbitrary. A simple example:
address@hidden
-(define fred (make-array #f 8 8))
-(define freds-diagonal
- (make-shared-array fred (lambda (i) (list i i)) 8))
-(array-set! freds-diagonal 'foo 3)
-(array-ref fred 3 3) @result{} foo
-(define freds-center
- (make-shared-array fred (lambda (i j) (list (+ 3 i) (+ 3 j))) 2 2))
-(array-ref freds-center 0 0) @result{} foo
address@hidden lisp
address@hidden deffn
-
- transpose-array
address@hidden snarfed from unif.c:961
address@hidden {Scheme Procedure} transpose-array ra . args
address@hidden {C Function} scm_transpose_array (ra, args)
-Return an array sharing contents with @var{array}, but with
-dimensions arranged in a different order. There must be one
address@hidden argument for each dimension of @var{array}.
address@hidden, @var{dim1}, @dots{} should be integers between 0
-and the rank of the array to be returned. Each integer in that
-range must appear at least once in the argument list.
-
-The values of @var{dim0}, @var{dim1}, @dots{} correspond to
-dimensions in the array to be returned, their positions in the
-argument list to dimensions of @var{array}. Several @var{dim}s
-may have the same value, in which case the returned array will
-have smaller rank than @var{array}.
-
address@hidden
-(transpose-array '#2((a b) (c d)) 1 0) @result{} #2((a c) (b d))
-(transpose-array '#2((a b) (c d)) 0 0) @result{} #1(a d)
-(transpose-array '#3(((a b c) (d e f)) ((1 2 3) (4 5 6))) 1 1 0) @result{}
- #2((a 4) (b 5) (c 6))
address@hidden lisp
address@hidden deffn
-
- enclose-array
address@hidden snarfed from unif.c:1059
address@hidden {Scheme Procedure} enclose-array ra . axes
address@hidden {C Function} scm_enclose_array (ra, axes)
address@hidden, @var{dim1} @dots{} should be nonnegative integers less than
-the rank of @var{array}. @var{enclose-array} returns an array
-resembling an array of shared arrays. The dimensions of each shared
-array are the same as the @var{dim}th dimensions of the original array,
-the dimensions of the outer array are the same as those of the original
-array that did not match a @var{dim}.
-
-An enclosed array is not a general Scheme array. Its elements may not
-be set using @code{array-set!}. Two references to the same element of
-an enclosed array will be @code{equal?} but will not in general be
address@hidden The value returned by @var{array-prototype} when given an
-enclosed array is unspecified.
-
-examples:
address@hidden
-(enclose-array '#3(((a b c) (d e f)) ((1 2 3) (4 5 6))) 1) @result{}
- #<enclosed-array (#1(a d) #1(b e) #1(c f)) (#1(1 4) #1(2 5) #1(3 6))>
-
-(enclose-array '#3(((a b c) (d e f)) ((1 2 3) (4 5 6))) 1 0) @result{}
- #<enclosed-array #2((a 1) (d 4)) #2((b 2) (e 5)) #2((c 3) (f 6))>
address@hidden lisp
address@hidden deffn
-
- array-in-bounds?
address@hidden snarfed from unif.c:1132
address@hidden {Scheme Procedure} array-in-bounds? v . args
address@hidden {C Function} scm_array_in_bounds_p (v, args)
-Return @code{#t} if its arguments would be acceptable to
address@hidden
address@hidden deffn
-
- array-ref
address@hidden snarfed from unif.c:1209
address@hidden {Scheme Procedure} array-ref v . args
address@hidden {C Function} scm_array_ref (v, args)
-Return the element at the @code{(index1, index2)} element in
address@hidden
address@hidden deffn
-
- array-set!
address@hidden snarfed from unif.c:1226
address@hidden {Scheme Procedure} array-set! v obj . args
address@hidden {C Function} scm_array_set_x (v, obj, args)
-Set the element at the @code{(index1, index2)} element in @var{array} to
address@hidden The value returned by array-set! is unspecified.
address@hidden deffn
-
- array-contents
address@hidden snarfed from unif.c:1252
address@hidden {Scheme Procedure} array-contents ra [strict]
address@hidden {C Function} scm_array_contents (ra, strict)
-If @var{array} may be @dfn{unrolled} into a one dimensional shared array
-without changing their order (last subscript changing fastest), then
address@hidden returns that shared array, otherwise it returns
address@hidden All arrays made by @var{make-array} and
address@hidden may be unrolled, some arrays made by
address@hidden may not be.
-
-If the optional argument @var{strict} is provided, a shared array will
-be returned only if its elements are stored internally contiguous in
-memory.
address@hidden deffn
-
- uniform-array-read!
address@hidden snarfed from unif.c:1352
address@hidden {Scheme Procedure} uniform-array-read! ura [port_or_fd [start
[end]]]
address@hidden {Scheme Procedure} uniform-vector-read! uve [port-or-fdes]
[start] [end]
address@hidden {C Function} scm_uniform_array_read_x (ura, port_or_fd, start,
end)
-Attempt to read all elements of @var{ura}, in lexicographic order, as
-binary objects from @var{port-or-fdes}.
-If an end of file is encountered,
-the objects up to that point are put into @var{ura}
-(starting at the beginning) and the remainder of the array is
-unchanged.
-
-The optional arguments @var{start} and @var{end} allow
-a specified region of a vector (or linearized array) to be read,
-leaving the remainder of the vector unchanged.
-
address@hidden returns the number of objects read.
address@hidden may be omitted, in which case it defaults to the value
-returned by @code{(current-input-port)}.
address@hidden deffn
-
- uniform-array-write
address@hidden snarfed from unif.c:1406
address@hidden {Scheme Procedure} uniform-array-write ura [port_or_fd [start
[end]]]
address@hidden {C Function} scm_uniform_array_write (ura, port_or_fd, start,
end)
-Writes all elements of @var{ura} as binary objects to
address@hidden
-
-The optional arguments @var{start}
-and @var{end} allow
-a specified region of a vector (or linearized array) to be written.
-
-The number of objects actually written is returned.
address@hidden may be
-omitted, in which case it defaults to the value returned by
address@hidden(current-output-port)}.
address@hidden deffn
-
- bitvector?
address@hidden snarfed from unif.c:1518
address@hidden {Scheme Procedure} bitvector? obj
address@hidden {C Function} scm_bitvector_p (obj)
-Return @code{#t} when @var{obj} is a bitvector, else
-return @code{#f}.
address@hidden deffn
-
- make-bitvector
address@hidden snarfed from unif.c:1545
address@hidden {Scheme Procedure} make-bitvector len [fill]
address@hidden {C Function} scm_make_bitvector (len, fill)
-Create a new bitvector of length @var{len} and
-optionally initialize all elements to @var{fill}.
address@hidden deffn
-
- bitvector
address@hidden snarfed from unif.c:1554
address@hidden {Scheme Procedure} bitvector . bits
address@hidden {C Function} scm_bitvector (bits)
-Create a new bitvector with the arguments as elements.
address@hidden deffn
-
- bitvector-length
address@hidden snarfed from unif.c:1570
address@hidden {Scheme Procedure} bitvector-length vec
address@hidden {C Function} scm_bitvector_length (vec)
-Return the length of the bitvector @var{vec}.
address@hidden deffn
-
- bitvector-ref
address@hidden snarfed from unif.c:1661
address@hidden {Scheme Procedure} bitvector-ref vec idx
address@hidden {C Function} scm_bitvector_ref (vec, idx)
-Return the element at index @var{idx} of the bitvector
address@hidden
address@hidden deffn
-
- bitvector-set!
address@hidden snarfed from unif.c:1704
address@hidden {Scheme Procedure} bitvector-set! vec idx val
address@hidden {C Function} scm_bitvector_set_x (vec, idx, val)
-Set the element at index @var{idx} of the bitvector
address@hidden when @var{val} is true, else clear it.
address@hidden deffn
-
- bitvector-fill!
address@hidden snarfed from unif.c:1715
address@hidden {Scheme Procedure} bitvector-fill! vec val
address@hidden {C Function} scm_bitvector_fill_x (vec, val)
-Set all elements of the bitvector
address@hidden when @var{val} is true, else clear them.
address@hidden deffn
-
- list->bitvector
address@hidden snarfed from unif.c:1760
address@hidden {Scheme Procedure} list->bitvector list
address@hidden {C Function} scm_list_to_bitvector (list)
-Return a new bitvector initialized with the elements
-of @var{list}.
address@hidden deffn
-
- bitvector->list
address@hidden snarfed from unif.c:1790
address@hidden {Scheme Procedure} bitvector->list vec
address@hidden {C Function} scm_bitvector_to_list (vec)
-Return a new list initialized with the elements
-of the bitvector @var{vec}.
address@hidden deffn
-
- bit-count
address@hidden snarfed from unif.c:1854
address@hidden {Scheme Procedure} bit-count b bitvector
address@hidden {C Function} scm_bit_count (b, bitvector)
-Return the number of occurrences of the boolean @var{b} in
address@hidden
address@hidden deffn
-
- bit-position
address@hidden snarfed from unif.c:1923
address@hidden {Scheme Procedure} bit-position item v k
address@hidden {C Function} scm_bit_position (item, v, k)
-Return the index of the first occurrance of @var{item} in bit
-vector @var{v}, starting from @var{k}. If there is no
address@hidden entry between @var{k} and the end of
address@hidden, then return @code{#f}. For example,
-
address@hidden
-(bit-position #t #*000101 0) @result{} 3
-(bit-position #f #*0001111 3) @result{} #f
address@hidden example
address@hidden deffn
-
- bit-set*!
address@hidden snarfed from unif.c:2006
address@hidden {Scheme Procedure} bit-set*! v kv obj
address@hidden {C Function} scm_bit_set_star_x (v, kv, obj)
-Set entries of bit vector @var{v} to @var{obj}, with @var{kv}
-selecting the entries to change. The return value is
-unspecified.
-
-If @var{kv} is a bit vector, then those entries where it has
address@hidden are the ones in @var{v} which are set to @var{obj}.
address@hidden and @var{v} must be the same length. When @var{obj}
-is @code{#t} it's like @var{kv} is OR'ed into @var{v}. Or when
address@hidden is @code{#f} it can be seen as an ANDNOT.
-
address@hidden
-(define bv #*01000010)
-(bit-set*! bv #*10010001 #t)
-bv
address@hidden #*11010011
address@hidden example
-
-If @var{kv} is a u32vector, then its elements are
-indices into @var{v} which are set to @var{obj}.
-
address@hidden
-(define bv #*01000010)
-(bit-set*! bv #u32(5 2 7) #t)
-bv
address@hidden #*01100111
address@hidden example
address@hidden deffn
-
- bit-count*
address@hidden snarfed from unif.c:2109
address@hidden {Scheme Procedure} bit-count* v kv obj
address@hidden {C Function} scm_bit_count_star (v, kv, obj)
-Return a count of how many entries in bit vector @var{v} are
-equal to @var{obj}, with @var{kv} selecting the entries to
-consider.
-
-If @var{kv} is a bit vector, then those entries where it has
address@hidden are the ones in @var{v} which are considered.
address@hidden and @var{v} must be the same length.
-
-If @var{kv} is a u32vector, then it contains
-the indexes in @var{v} to consider.
-
-For example,
-
address@hidden
-(bit-count* #*01110111 #*11001101 #t) @result{} 3
-(bit-count* #*01110111 #u32(7 0 4) #f) @result{} 2
address@hidden example
address@hidden deffn
-
- bit-invert!
address@hidden snarfed from unif.c:2196
address@hidden {Scheme Procedure} bit-invert! v
address@hidden {C Function} scm_bit_invert_x (v)
-Modify the bit vector @var{v} by replacing each element with
-its negation.
address@hidden deffn
-
- array->list
address@hidden snarfed from unif.c:2303
address@hidden {Scheme Procedure} array->list v
address@hidden {C Function} scm_array_to_list (v)
-Return a list consisting of all the elements, in order, of
address@hidden
address@hidden deffn
-
- list->typed-array
address@hidden snarfed from unif.c:2332
address@hidden {Scheme Procedure} list->typed-array type shape lst
address@hidden {C Function} scm_list_to_typed_array (type, shape, lst)
-Return an array of the type @var{type}
-with elements the same as those of @var{lst}.
-
-The argument @var{shape} determines the number of dimensions
-of the array and their shape. It is either an exact integer,
-giving the
-number of dimensions directly, or a list whose length
-specifies the number of dimensions and each element specified
-the lower and optionally the upper bound of the corresponding
-dimension.
-When the element is list of two elements, these elements
-give the lower and upper bounds. When it is an exact
-integer, it gives only the lower bound.
address@hidden deffn
-
- list->array
address@hidden snarfed from unif.c:2390
address@hidden {Scheme Procedure} list->array ndim lst
address@hidden {C Function} scm_list_to_array (ndim, lst)
-Return an array with elements the same as those of @var{lst}.
address@hidden deffn
-
- list->uniform-array
address@hidden snarfed from unif.c:2440
address@hidden {Scheme Procedure} list->uniform-array ndim prot lst
address@hidden {C Function} scm_list_to_uniform_array (ndim, prot, lst)
-Return a uniform array of the type indicated by prototype
address@hidden with elements the same as those of @var{lst}.
-Elements must be of the appropriate type, no coercions are
-done.
-
-The argument @var{ndim} determines the number of dimensions
-of the array. It is either an exact integer, giving the
-number directly, or a list of exact integers, whose length
-specifies the number of dimensions and each element is the
-lower index bound of its dimension.
address@hidden deffn
-
- array-type
address@hidden snarfed from unif.c:2789
address@hidden {Scheme Procedure} array-type ra
address@hidden {C Function} scm_array_type (ra)
-
address@hidden deffn
-
- array-prototype
address@hidden snarfed from unif.c:2809
address@hidden {Scheme Procedure} array-prototype ra
address@hidden {C Function} scm_array_prototype (ra)
-Return an object that would produce an array of the same type
-as @var{array}, if used as the @var{prototype} for
address@hidden
address@hidden deffn
-
- dynamic-link
address@hidden snarfed from dynl.c:149
address@hidden {Scheme Procedure} dynamic-link filename
address@hidden {C Function} scm_dynamic_link (filename)
-Find the shared object (shared library) denoted by
address@hidden and link it into the running Guile
-application. The returned
-scheme object is a ``handle'' for the library which can
-be passed to @code{dynamic-func}, @code{dynamic-call} etc.
-
-Searching for object files is system dependent. Normally,
-if @var{filename} does have an explicit directory it will
-be searched for in locations
-such as @file{/usr/lib} and @file{/usr/local/lib}.
address@hidden deffn
-
- dynamic-object?
address@hidden snarfed from dynl.c:168
address@hidden {Scheme Procedure} dynamic-object? obj
address@hidden {C Function} scm_dynamic_object_p (obj)
-Return @code{#t} if @var{obj} is a dynamic object handle,
-or @code{#f} otherwise.
address@hidden deffn
-
- dynamic-unlink
address@hidden snarfed from dynl.c:182
address@hidden {Scheme Procedure} dynamic-unlink dobj
address@hidden {C Function} scm_dynamic_unlink (dobj)
-Unlink a dynamic object from the application, if possible. The
-object must have been linked by @code{dynamic-link}, with
address@hidden the corresponding handle. After this procedure
-is called, the handle can no longer be used to access the
-object.
address@hidden deffn
-
- dynamic-func
address@hidden snarfed from dynl.c:207
address@hidden {Scheme Procedure} dynamic-func name dobj
address@hidden {C Function} scm_dynamic_func (name, dobj)
-Return a ``handle'' for the function @var{name} in the
-shared object referred to by @var{dobj}. The handle
-can be passed to @code{dynamic-call} to actually
-call the function.
-
-Regardless whether your C compiler prepends an underscore
address@hidden to the global names in a program, you should
address@hidden include this underscore in @var{name}
-since it will be added automatically when necessary.
address@hidden deffn
-
- dynamic-call
address@hidden snarfed from dynl.c:253
address@hidden {Scheme Procedure} dynamic-call func dobj
address@hidden {C Function} scm_dynamic_call (func, dobj)
-Call a C function in a dynamic object. Two styles of
-invocation are supported:
-
address@hidden @bullet
address@hidden @var{func} can be a function handle returned by
address@hidden In this case @var{dobj} is
-ignored
address@hidden @var{func} can be a string with the name of the
-function to call, with @var{dobj} the handle of the
-dynamic object in which to find the function.
-This is equivalent to
address@hidden
-
-(dynamic-call (dynamic-func @var{func} @var{dobj}) #f)
address@hidden smallexample
address@hidden itemize
-
-In either case, the function is passed no arguments
-and its return value is ignored.
address@hidden deffn
-
- dynamic-args-call
address@hidden snarfed from dynl.c:285
address@hidden {Scheme Procedure} dynamic-args-call func dobj args
address@hidden {C Function} scm_dynamic_args_call (func, dobj, args)
-Call the C function indicated by @var{func} and @var{dobj},
-just like @code{dynamic-call}, but pass it some arguments and
-return its return value. The C function is expected to take
-two arguments and return an @code{int}, just like @code{main}:
address@hidden
-int c_func (int argc, char **argv);
address@hidden smallexample
-
-The parameter @var{args} must be a list of strings and is
-converted into an array of @code{char *}. The array is passed
-in @var{argv} and its size in @var{argc}. The return value is
-converted to a Scheme number and returned from the call to
address@hidden
address@hidden deffn
-
- chown
address@hidden snarfed from filesys.c:224
address@hidden {Scheme Procedure} chown object owner group
address@hidden {C Function} scm_chown (object, owner, group)
-Change the ownership and group of the file referred to by @var{object} to
-the integer values @var{owner} and @var{group}. @var{object} can be
-a string containing a file name or, if the platform
-supports fchown, a port or integer file descriptor
-which is open on the file. The return value
-is unspecified.
-
-If @var{object} is a symbolic link, either the
-ownership of the link or the ownership of the referenced file will be
-changed depending on the operating system (lchown is
-unsupported at present). If @var{owner} or @var{group} is specified
-as @code{-1}, then that ID is not changed.
address@hidden deffn
-
- chmod
address@hidden snarfed from filesys.c:262
address@hidden {Scheme Procedure} chmod object mode
address@hidden {C Function} scm_chmod (object, mode)
-Changes the permissions of the file referred to by @var{obj}.
address@hidden can be a string containing a file name or a port or integer file
-descriptor which is open on a file (in which case @code{fchmod} is used
-as the underlying system call).
address@hidden specifies
-the new permissions as a decimal number, e.g., @code{(chmod "foo" #o755)}.
-The return value is unspecified.
address@hidden deffn
-
- umask
address@hidden snarfed from filesys.c:294
address@hidden {Scheme Procedure} umask [mode]
address@hidden {C Function} scm_umask (mode)
-If @var{mode} is omitted, returns a decimal number representing the current
-file creation mask. Otherwise the file creation mask is set to
address@hidden and the previous value is returned.
-
-E.g., @code{(umask #o022)} sets the mask to octal 22, decimal 18.
address@hidden deffn
-
- open-fdes
address@hidden snarfed from filesys.c:316
address@hidden {Scheme Procedure} open-fdes path flags [mode]
address@hidden {C Function} scm_open_fdes (path, flags, mode)
-Similar to @code{open} but return a file descriptor instead of
-a port.
address@hidden deffn
-
- open
address@hidden snarfed from filesys.c:357
address@hidden {Scheme Procedure} open path flags [mode]
address@hidden {C Function} scm_open (path, flags, mode)
-Open the file named by @var{path} for reading and/or writing.
address@hidden is an integer specifying how the file should be opened.
address@hidden is an integer specifying the permission bits of the file, if
-it needs to be created, before the umask is applied. The default is 666
-(Unix itself has no default).
-
address@hidden can be constructed by combining variables using @code{logior}.
-Basic flags are:
-
address@hidden O_RDONLY
-Open the file read-only.
address@hidden defvar
address@hidden O_WRONLY
-Open the file write-only.
address@hidden defvar
address@hidden O_RDWR
-Open the file read/write.
address@hidden defvar
address@hidden O_APPEND
-Append to the file instead of truncating.
address@hidden defvar
address@hidden O_CREAT
-Create the file if it does not already exist.
address@hidden defvar
-
-See the Unix documentation of the @code{open} system call
-for additional flags.
address@hidden deffn
-
- close
address@hidden snarfed from filesys.c:395
address@hidden {Scheme Procedure} close fd_or_port
address@hidden {C Function} scm_close (fd_or_port)
-Similar to close-port (@pxref{Closing, close-port}),
-but also works on file descriptors. A side
-effect of closing a file descriptor is that any ports using that file
-descriptor are moved to a different file descriptor and have
-their revealed counts set to zero.
address@hidden deffn
-
- close-fdes
address@hidden snarfed from filesys.c:422
address@hidden {Scheme Procedure} close-fdes fd
address@hidden {C Function} scm_close_fdes (fd)
-A simple wrapper for the @code{close} system call.
-Close file descriptor @var{fd}, which must be an integer.
-Unlike close (@pxref{Ports and File Descriptors, close}),
-the file descriptor will be closed even if a port is using it.
-The return value is unspecified.
address@hidden deffn
-
- stat
address@hidden snarfed from filesys.c:624
address@hidden {Scheme Procedure} stat object
address@hidden {C Function} scm_stat (object)
-Return an object containing various information about the file
-determined by @var{obj}. @var{obj} can be a string containing
-a file name or a port or integer file descriptor which is open
-on a file (in which case @code{fstat} is used as the underlying
-system call).
-
-The object returned by @code{stat} can be passed as a single
-parameter to the following procedures, all of which return
-integers:
-
address@hidden @code
address@hidden stat:dev
-The device containing the file.
address@hidden stat:ino
-The file serial number, which distinguishes this file from all
-other files on the same device.
address@hidden stat:mode
-The mode of the file. This includes file type information and
-the file permission bits. See @code{stat:type} and
address@hidden:perms} below.
address@hidden stat:nlink
-The number of hard links to the file.
address@hidden stat:uid
-The user ID of the file's owner.
address@hidden stat:gid
-The group ID of the file.
address@hidden stat:rdev
-Device ID; this entry is defined only for character or block
-special files.
address@hidden stat:size
-The size of a regular file in bytes.
address@hidden stat:atime
-The last access time for the file.
address@hidden stat:mtime
-The last modification time for the file.
address@hidden stat:ctime
-The last modification time for the attributes of the file.
address@hidden stat:blksize
-The optimal block size for reading or writing the file, in
-bytes.
address@hidden stat:blocks
-The amount of disk space that the file occupies measured in
-units of 512 byte blocks.
address@hidden table
-
-In addition, the following procedures return the information
-from stat:mode in a more convenient form:
-
address@hidden @code
address@hidden stat:type
-A symbol representing the type of file. Possible values are
-regular, directory, symlink, block-special, char-special, fifo,
-socket and unknown
address@hidden stat:perms
-An integer representing the access permission bits.
address@hidden table
address@hidden deffn
-
- link
address@hidden snarfed from filesys.c:686
address@hidden {Scheme Procedure} link oldpath newpath
address@hidden {C Function} scm_link (oldpath, newpath)
-Creates a new name @var{newpath} in the file system for the
-file named by @var{oldpath}. If @var{oldpath} is a symbolic
-link, the link may or may not be followed depending on the
-system.
address@hidden deffn
-
- rename-file
address@hidden snarfed from filesys.c:724
address@hidden {Scheme Procedure} rename-file oldname newname
address@hidden {C Function} scm_rename (oldname, newname)
-Renames the file specified by @var{oldname} to @var{newname}.
-The return value is unspecified.
address@hidden deffn
-
- delete-file
address@hidden snarfed from filesys.c:741
address@hidden {Scheme Procedure} delete-file str
address@hidden {C Function} scm_delete_file (str)
-Deletes (or "unlinks") the file specified by @var{path}.
address@hidden deffn
-
- mkdir
address@hidden snarfed from filesys.c:758
address@hidden {Scheme Procedure} mkdir path [mode]
address@hidden {C Function} scm_mkdir (path, mode)
-Create a new directory named by @var{path}. If @var{mode} is omitted
-then the permissions of the directory file are set using the current
-umask. Otherwise they are set to the decimal value specified with
address@hidden The return value is unspecified.
address@hidden deffn
-
- rmdir
address@hidden snarfed from filesys.c:785
address@hidden {Scheme Procedure} rmdir path
address@hidden {C Function} scm_rmdir (path)
-Remove the existing directory named by @var{path}. The directory must
-be empty for this to succeed. The return value is unspecified.
address@hidden deffn
-
- directory-stream?
address@hidden snarfed from filesys.c:809
address@hidden {Scheme Procedure} directory-stream? obj
address@hidden {C Function} scm_directory_stream_p (obj)
-Return a boolean indicating whether @var{object} is a directory
-stream as returned by @code{opendir}.
address@hidden deffn
-
- opendir
address@hidden snarfed from filesys.c:820
address@hidden {Scheme Procedure} opendir dirname
address@hidden {C Function} scm_opendir (dirname)
-Open the directory specified by @var{path} and return a directory
-stream.
address@hidden deffn
-
- readdir
address@hidden snarfed from filesys.c:841
address@hidden {Scheme Procedure} readdir port
address@hidden {C Function} scm_readdir (port)
-Return (as a string) the next directory entry from the directory stream
address@hidden If there is no remaining entry to be read then the
-end of file object is returned.
address@hidden deffn
-
- rewinddir
address@hidden snarfed from filesys.c:880
address@hidden {Scheme Procedure} rewinddir port
address@hidden {C Function} scm_rewinddir (port)
-Reset the directory port @var{stream} so that the next call to
address@hidden will return the first directory entry.
address@hidden deffn
-
- closedir
address@hidden snarfed from filesys.c:897
address@hidden {Scheme Procedure} closedir port
address@hidden {C Function} scm_closedir (port)
-Close the directory stream @var{stream}.
-The return value is unspecified.
address@hidden deffn
-
- chdir
address@hidden snarfed from filesys.c:947
address@hidden {Scheme Procedure} chdir str
address@hidden {C Function} scm_chdir (str)
-Change the current working directory to @var{path}.
-The return value is unspecified.
address@hidden deffn
-
- getcwd
address@hidden snarfed from filesys.c:962
address@hidden {Scheme Procedure} getcwd
address@hidden {C Function} scm_getcwd ()
-Return the name of the current working directory.
address@hidden deffn
-
- select
address@hidden snarfed from filesys.c:1164
address@hidden {Scheme Procedure} select reads writes excepts [secs [usecs]]
address@hidden {C Function} scm_select (reads, writes, excepts, secs, usecs)
-This procedure has a variety of uses: waiting for the ability
-to provide input, accept output, or the existence of
-exceptional conditions on a collection of ports or file
-descriptors, or waiting for a timeout to occur.
-It also returns if interrupted by a signal.
-
address@hidden, @var{writes} and @var{excepts} can be lists or
-vectors, with each member a port or a file descriptor.
-The value returned is a list of three corresponding
-lists or vectors containing only the members which meet the
-specified requirement. The ability of port buffers to
-provide input or accept output is taken into account.
-Ordering of the input lists or vectors is not preserved.
-
-The optional arguments @var{secs} and @var{usecs} specify the
-timeout. Either @var{secs} can be specified alone, as
-either an integer or a real number, or both @var{secs} and
address@hidden can be specified as integers, in which case
address@hidden is an additional timeout expressed in
-microseconds. If @var{secs} is omitted or is @code{#f} then
-select will wait for as long as it takes for one of the other
-conditions to be satisfied.
-
-The scsh version of @code{select} differs as follows:
-Only vectors are accepted for the first three arguments.
-The @var{usecs} argument is not supported.
-Multiple values are returned instead of a list.
-Duplicates in the input vectors appear only once in output.
-An additional @code{select!} interface is provided.
address@hidden deffn
-
- fcntl
address@hidden snarfed from filesys.c:1302
address@hidden {Scheme Procedure} fcntl object cmd [value]
address@hidden {C Function} scm_fcntl (object, cmd, value)
-Apply @var{command} to the specified file descriptor or the underlying
-file descriptor of the specified port. @var{value} is an optional
-integer argument.
-
-Values for @var{command} are:
-
address@hidden @code
address@hidden F_DUPFD
-Duplicate a file descriptor
address@hidden F_GETFD
-Get flags associated with the file descriptor.
address@hidden F_SETFD
-Set flags associated with the file descriptor to @var{value}.
address@hidden F_GETFL
-Get flags associated with the open file.
address@hidden F_SETFL
-Set flags associated with the open file to @var{value}
address@hidden F_GETOWN
-Get the process ID of a socket's owner, for @code{SIGIO} signals.
address@hidden F_SETOWN
-Set the process that owns a socket to @var{value}, for @code{SIGIO} signals.
address@hidden FD_CLOEXEC
-The value used to indicate the "close on exec" flag with @code{F_GETFL} or
address@hidden
address@hidden table
address@hidden deffn
-
- fsync
address@hidden snarfed from filesys.c:1334
address@hidden {Scheme Procedure} fsync object
address@hidden {C Function} scm_fsync (object)
-Copies any unwritten data for the specified output file descriptor to disk.
-If @var{port/fd} is a port, its buffer is flushed before the underlying
-file descriptor is fsync'd.
-The return value is unspecified.
address@hidden deffn
-
- symlink
address@hidden snarfed from filesys.c:1359
address@hidden {Scheme Procedure} symlink oldpath newpath
address@hidden {C Function} scm_symlink (oldpath, newpath)
-Create a symbolic link named @var{path-to} with the value (i.e., pointing to)
address@hidden The return value is unspecified.
address@hidden deffn
-
- readlink
address@hidden snarfed from filesys.c:1378
address@hidden {Scheme Procedure} readlink path
address@hidden {C Function} scm_readlink (path)
-Return the value of the symbolic link named by @var{path} (a
-string), i.e., the file that the link points to.
address@hidden deffn
-
- lstat
address@hidden snarfed from filesys.c:1420
address@hidden {Scheme Procedure} lstat str
address@hidden {C Function} scm_lstat (str)
-Similar to @code{stat}, but does not follow symbolic links, i.e.,
-it will return information about a symbolic link itself, not the
-file it points to. @var{path} must be a string.
address@hidden deffn
-
- copy-file
address@hidden snarfed from filesys.c:1443
address@hidden {Scheme Procedure} copy-file oldfile newfile
address@hidden {C Function} scm_copy_file (oldfile, newfile)
-Copy the file specified by @var{path-from} to @var{path-to}.
-The return value is unspecified.
address@hidden deffn
-
- dirname
address@hidden snarfed from filesys.c:1506
address@hidden {Scheme Procedure} dirname filename
address@hidden {C Function} scm_dirname (filename)
-Return the directory name component of the file name
address@hidden If @var{filename} does not contain a directory
-component, @code{.} is returned.
address@hidden deffn
-
- basename
address@hidden snarfed from filesys.c:1549
address@hidden {Scheme Procedure} basename filename [suffix]
address@hidden {C Function} scm_basename (filename, suffix)
-Return the base name of the file name @var{filename}. The
-base name is the file name without any directory components.
-If @var{suffix} is provided, and is equal to the end of
address@hidden, it is removed also.
address@hidden deffn
-
- pipe
address@hidden snarfed from posix.c:233
address@hidden {Scheme Procedure} pipe
address@hidden {C Function} scm_pipe ()
-Return a newly created pipe: a pair of ports which are linked
-together on the local machine. The @emph{car} is the input
-port and the @emph{cdr} is the output port. Data written (and
-flushed) to the output port can be read from the input port.
-Pipes are commonly used for communication with a newly forked
-child process. The need to flush the output port can be
-avoided by making it unbuffered using @code{setvbuf}.
-
-Writes occur atomically provided the size of the data in bytes
-is not greater than the value of @code{PIPE_BUF}. Note that
-the output port is likely to block if too much data (typically
-equal to @code{PIPE_BUF}) has been written but not yet read
-from the input port.
address@hidden deffn
-
- getgroups
address@hidden snarfed from posix.c:254
address@hidden {Scheme Procedure} getgroups
address@hidden {C Function} scm_getgroups ()
-Return a vector of integers representing the current
-supplementary group IDs.
address@hidden deffn
-
- setgroups
address@hidden snarfed from posix.c:287
address@hidden {Scheme Procedure} setgroups group_vec
address@hidden {C Function} scm_setgroups (group_vec)
-Set the current set of supplementary group IDs to the integers
-in the given vector @var{vec}. The return value is
-unspecified.
-
-Generally only the superuser can set the process group IDs.
address@hidden deffn
-
- getpw
address@hidden snarfed from posix.c:336
address@hidden {Scheme Procedure} getpw [user]
address@hidden {C Function} scm_getpwuid (user)
-Look up an entry in the user database. @var{obj} can be an integer,
-a string, or omitted, giving the behaviour of getpwuid, getpwnam
-or getpwent respectively.
address@hidden deffn
-
- setpw
address@hidden snarfed from posix.c:386
address@hidden {Scheme Procedure} setpw [arg]
address@hidden {C Function} scm_setpwent (arg)
-If called with a true argument, initialize or reset the password data
-stream. Otherwise, close the stream. The @code{setpwent} and
address@hidden procedures are implemented on top of this.
address@hidden deffn
-
- getgr
address@hidden snarfed from posix.c:405
address@hidden {Scheme Procedure} getgr [name]
address@hidden {C Function} scm_getgrgid (name)
-Look up an entry in the group database. @var{obj} can be an integer,
-a string, or omitted, giving the behaviour of getgrgid, getgrnam
-or getgrent respectively.
address@hidden deffn
-
- setgr
address@hidden snarfed from posix.c:441
address@hidden {Scheme Procedure} setgr [arg]
address@hidden {C Function} scm_setgrent (arg)
-If called with a true argument, initialize or reset the group data
-stream. Otherwise, close the stream. The @code{setgrent} and
address@hidden procedures are implemented on top of this.
address@hidden deffn
-
- kill
address@hidden snarfed from posix.c:477
address@hidden {Scheme Procedure} kill pid sig
address@hidden {C Function} scm_kill (pid, sig)
-Sends a signal to the specified process or group of processes.
-
address@hidden specifies the processes to which the signal is sent:
-
address@hidden @r
address@hidden @var{pid} greater than 0
-The process whose identifier is @var{pid}.
address@hidden @var{pid} equal to 0
-All processes in the current process group.
address@hidden @var{pid} less than -1
-The process group whose identifier is address@hidden
address@hidden @var{pid} equal to -1
-If the process is privileged, all processes except for some special
-system processes. Otherwise, all processes with the current effective
-user ID.
address@hidden table
-
address@hidden should be specified using a variable corresponding to
-the Unix symbolic name, e.g.,
-
address@hidden SIGHUP
-Hang-up signal.
address@hidden defvar
-
address@hidden SIGINT
-Interrupt signal.
address@hidden defvar
address@hidden deffn
-
- waitpid
address@hidden snarfed from posix.c:528
address@hidden {Scheme Procedure} waitpid pid [options]
address@hidden {C Function} scm_waitpid (pid, options)
-This procedure collects status information from a child process which
-has terminated or (optionally) stopped. Normally it will
-suspend the calling process until this can be done. If more than one
-child process is eligible then one will be chosen by the operating system.
-
-The value of @var{pid} determines the behaviour:
-
address@hidden @r
address@hidden @var{pid} greater than 0
-Request status information from the specified child process.
address@hidden @var{pid} equal to -1 or WAIT_ANY
-Request status information for any child process.
address@hidden @var{pid} equal to 0 or WAIT_MYPGRP
-Request status information for any child process in the current process
-group.
address@hidden @var{pid} less than -1
-Request status information for any child process whose process group ID
-is address@hidden
address@hidden table
-
-The @var{options} argument, if supplied, should be the bitwise OR of the
-values of zero or more of the following variables:
-
address@hidden WNOHANG
-Return immediately even if there are no child processes to be collected.
address@hidden defvar
-
address@hidden WUNTRACED
-Report status information for stopped processes as well as terminated
-processes.
address@hidden defvar
-
-The return value is a pair containing:
-
address@hidden
address@hidden
-The process ID of the child process, or 0 if @code{WNOHANG} was
-specified and no process was collected.
address@hidden
-The integer status value.
address@hidden enumerate
address@hidden deffn
-
- status:exit-val
address@hidden snarfed from posix.c:554
address@hidden {Scheme Procedure} status:exit-val status
address@hidden {C Function} scm_status_exit_val (status)
-Return the exit status value, as would be set if a process
-ended normally through a call to @code{exit} or @code{_exit},
-if any, otherwise @code{#f}.
address@hidden deffn
-
- status:term-sig
address@hidden snarfed from posix.c:572
address@hidden {Scheme Procedure} status:term-sig status
address@hidden {C Function} scm_status_term_sig (status)
-Return the signal number which terminated the process, if any,
-otherwise @code{#f}.
address@hidden deffn
-
- status:stop-sig
address@hidden snarfed from posix.c:588
address@hidden {Scheme Procedure} status:stop-sig status
address@hidden {C Function} scm_status_stop_sig (status)
-Return the signal number which stopped the process, if any,
-otherwise @code{#f}.
address@hidden deffn
-
- getppid
address@hidden snarfed from posix.c:606
address@hidden {Scheme Procedure} getppid
address@hidden {C Function} scm_getppid ()
-Return an integer representing the process ID of the parent
-process.
address@hidden deffn
-
- getuid
address@hidden snarfed from posix.c:618
address@hidden {Scheme Procedure} getuid
address@hidden {C Function} scm_getuid ()
-Return an integer representing the current real user ID.
address@hidden deffn
-
- getgid
address@hidden snarfed from posix.c:629
address@hidden {Scheme Procedure} getgid
address@hidden {C Function} scm_getgid ()
-Return an integer representing the current real group ID.
address@hidden deffn
-
- geteuid
address@hidden snarfed from posix.c:643
address@hidden {Scheme Procedure} geteuid
address@hidden {C Function} scm_geteuid ()
-Return an integer representing the current effective user ID.
-If the system does not support effective IDs, then the real ID
-is returned. @code{(provided? 'EIDs)} reports whether the
-system supports effective IDs.
address@hidden deffn
-
- getegid
address@hidden snarfed from posix.c:660
address@hidden {Scheme Procedure} getegid
address@hidden {C Function} scm_getegid ()
-Return an integer representing the current effective group ID.
-If the system does not support effective IDs, then the real ID
-is returned. @code{(provided? 'EIDs)} reports whether the
-system supports effective IDs.
address@hidden deffn
-
- setuid
address@hidden snarfed from posix.c:676
address@hidden {Scheme Procedure} setuid id
address@hidden {C Function} scm_setuid (id)
-Sets both the real and effective user IDs to the integer @var{id}, provided
-the process has appropriate privileges.
-The return value is unspecified.
address@hidden deffn
-
- setgid
address@hidden snarfed from posix.c:689
address@hidden {Scheme Procedure} setgid id
address@hidden {C Function} scm_setgid (id)
-Sets both the real and effective group IDs to the integer @var{id}, provided
-the process has appropriate privileges.
-The return value is unspecified.
address@hidden deffn
-
- seteuid
address@hidden snarfed from posix.c:704
address@hidden {Scheme Procedure} seteuid id
address@hidden {C Function} scm_seteuid (id)
-Sets the effective user ID to the integer @var{id}, provided the process
-has appropriate privileges. If effective IDs are not supported, the
-real ID is set instead -- @code{(provided? 'EIDs)} reports whether the
-system supports effective IDs.
-The return value is unspecified.
address@hidden deffn
-
- setegid
address@hidden snarfed from posix.c:729
address@hidden {Scheme Procedure} setegid id
address@hidden {C Function} scm_setegid (id)
-Sets the effective group ID to the integer @var{id}, provided the process
-has appropriate privileges. If effective IDs are not supported, the
-real ID is set instead -- @code{(provided? 'EIDs)} reports whether the
-system supports effective IDs.
-The return value is unspecified.
address@hidden deffn
-
- getpgrp
address@hidden snarfed from posix.c:752
address@hidden {Scheme Procedure} getpgrp
address@hidden {C Function} scm_getpgrp ()
-Return an integer representing the current process group ID.
-This is the POSIX definition, not BSD.
address@hidden deffn
-
- setpgid
address@hidden snarfed from posix.c:770
address@hidden {Scheme Procedure} setpgid pid pgid
address@hidden {C Function} scm_setpgid (pid, pgid)
-Move the process @var{pid} into the process group @var{pgid}. @var{pid} or
address@hidden must be integers: they can be zero to indicate the ID of the
-current process.
-Fails on systems that do not support job control.
-The return value is unspecified.
address@hidden deffn
-
- setsid
address@hidden snarfed from posix.c:787
address@hidden {Scheme Procedure} setsid
address@hidden {C Function} scm_setsid ()
-Creates a new session. The current process becomes the session leader
-and is put in a new process group. The process will be detached
-from its controlling terminal if it has one.
-The return value is an integer representing the new process group ID.
address@hidden deffn
-
- ttyname
address@hidden snarfed from posix.c:811
address@hidden {Scheme Procedure} ttyname port
address@hidden {C Function} scm_ttyname (port)
-Return a string with the name of the serial terminal device
-underlying @var{port}.
address@hidden deffn
-
- ctermid
address@hidden snarfed from posix.c:850
address@hidden {Scheme Procedure} ctermid
address@hidden {C Function} scm_ctermid ()
-Return a string containing the file name of the controlling
-terminal for the current process.
address@hidden deffn
-
- tcgetpgrp
address@hidden snarfed from posix.c:874
address@hidden {Scheme Procedure} tcgetpgrp port
address@hidden {C Function} scm_tcgetpgrp (port)
-Return the process group ID of the foreground process group
-associated with the terminal open on the file descriptor
-underlying @var{port}.
-
-If there is no foreground process group, the return value is a
-number greater than 1 that does not match the process group ID
-of any existing process group. This can happen if all of the
-processes in the job that was formerly the foreground job have
-terminated, and no other job has yet been moved into the
-foreground.
address@hidden deffn
-
- tcsetpgrp
address@hidden snarfed from posix.c:898
address@hidden {Scheme Procedure} tcsetpgrp port pgid
address@hidden {C Function} scm_tcsetpgrp (port, pgid)
-Set the foreground process group ID for the terminal used by the file
-descriptor underlying @var{port} to the integer @var{pgid}.
-The calling process
-must be a member of the same session as @var{pgid} and must have the same
-controlling terminal. The return value is unspecified.
address@hidden deffn
-
- execl
address@hidden snarfed from posix.c:930
address@hidden {Scheme Procedure} execl filename . args
address@hidden {C Function} scm_execl (filename, args)
-Executes the file named by @var{path} as a new process image.
-The remaining arguments are supplied to the process; from a C program
-they are accessible as the @code{argv} argument to @code{main}.
-Conventionally the first @var{arg} is the same as @var{path}.
-All arguments must be strings.
-
-If @var{arg} is missing, @var{path} is executed with a null
-argument list, which may have system-dependent side-effects.
-
-This procedure is currently implemented using the @code{execv} system
-call, but we call it @code{execl} because of its Scheme calling interface.
address@hidden deffn
-
- execlp
address@hidden snarfed from posix.c:961
address@hidden {Scheme Procedure} execlp filename . args
address@hidden {C Function} scm_execlp (filename, args)
-Similar to @code{execl}, however if
address@hidden does not contain a slash
-then the file to execute will be located by searching the
-directories listed in the @code{PATH} environment variable.
-
-This procedure is currently implemented using the @code{execvp} system
-call, but we call it @code{execlp} because of its Scheme calling interface.
address@hidden deffn
-
- execle
address@hidden snarfed from posix.c:995
address@hidden {Scheme Procedure} execle filename env . args
address@hidden {C Function} scm_execle (filename, env, args)
-Similar to @code{execl}, but the environment of the new process is
-specified by @var{env}, which must be a list of strings as returned by the
address@hidden procedure.
-
-This procedure is currently implemented using the @code{execve} system
-call, but we call it @code{execle} because of its Scheme calling interface.
address@hidden deffn
-
- primitive-fork
address@hidden snarfed from posix.c:1031
address@hidden {Scheme Procedure} primitive-fork
address@hidden {C Function} scm_fork ()
-Creates a new "child" process by duplicating the current "parent" process.
-In the child the return value is 0. In the parent the return value is
-the integer process ID of the child.
-
-This procedure has been renamed from @code{fork} to avoid a naming conflict
-with the scsh fork.
address@hidden deffn
-
- uname
address@hidden snarfed from posix.c:1051
address@hidden {Scheme Procedure} uname
address@hidden {C Function} scm_uname ()
-Return an object with some information about the computer
-system the program is running on.
address@hidden deffn
-
- environ
address@hidden snarfed from posix.c:1080
address@hidden {Scheme Procedure} environ [env]
address@hidden {C Function} scm_environ (env)
-If @var{env} is omitted, return the current environment (in the
-Unix sense) as a list of strings. Otherwise set the current
-environment, which is also the default environment for child
-processes, to the supplied list of strings. Each member of
address@hidden should be of the form @code{NAME=VALUE} and values of
address@hidden should not be duplicated. If @var{env} is supplied
-then the return value is unspecified.
address@hidden deffn
-
- tmpnam
address@hidden snarfed from posix.c:1113
address@hidden {Scheme Procedure} tmpnam
address@hidden {C Function} scm_tmpnam ()
-Return a name in the file system that does not match any
-existing file. However there is no guarantee that another
-process will not create the file after @code{tmpnam} is called.
-Care should be taken if opening the file, e.g., use the
address@hidden open flag or use @code{mkstemp!} instead.
address@hidden deffn
-
- mkstemp!
address@hidden snarfed from posix.c:1144
address@hidden {Scheme Procedure} mkstemp! tmpl
address@hidden {C Function} scm_mkstemp (tmpl)
-Create a new unique file in the file system and returns a new
-buffered port open for reading and writing to the file.
-
address@hidden is a string specifying where the file should be
-created: it must end with @samp{XXXXXX} and will be changed in
-place to return the name of the temporary file.
-
-The file is created with mode @code{0600}, which means read and
-write for the owner only. @code{chmod} can be used to change
-this.
address@hidden deffn
-
- utime
address@hidden snarfed from posix.c:1179
address@hidden {Scheme Procedure} utime pathname [actime [modtime]]
address@hidden {C Function} scm_utime (pathname, actime, modtime)
address@hidden sets the access and modification times for the
-file named by @var{path}. If @var{actime} or @var{modtime} is
-not supplied, then the current time is used. @var{actime} and
address@hidden must be integer time values as returned by the
address@hidden procedure.
address@hidden
-(utime "foo" (- (current-time) 3600))
address@hidden lisp
-will set the access time to one hour in the past and the
-modification time to the current time.
address@hidden deffn
-
- access?
address@hidden snarfed from posix.c:1244
address@hidden {Scheme Procedure} access? path how
address@hidden {C Function} scm_access (path, how)
-Test accessibility of a file under the real UID and GID of the
-calling process. The return is @code{#t} if @var{path} exists
-and the permissions requested by @var{how} are all allowed, or
address@hidden if not.
-
address@hidden is an integer which is one of the following values,
-or a bitwise-OR (@code{logior}) of multiple values.
-
address@hidden R_OK
-Test for read permission.
address@hidden defvar
address@hidden W_OK
-Test for write permission.
address@hidden defvar
address@hidden X_OK
-Test for execute permission.
address@hidden defvar
address@hidden F_OK
-Test for existence of the file. This is implied by each of the
-other tests, so there's no need to combine it with them.
address@hidden defvar
-
-It's important to note that @code{access?} does not simply
-indicate what will happen on attempting to read or write a
-file. In normal circumstances it does, but in a set-UID or
-set-GID program it doesn't because @code{access?} tests the
-real ID, whereas an open or execute attempt uses the effective
-ID.
-
-A program which will never run set-UID/GID can ignore the
-difference between real and effective IDs, but for maximum
-generality, especially in library functions, it's best not to
-use @code{access?} to predict the result of an open or execute,
-instead simply attempt that and catch any exception.
-
-The main use for @code{access?} is to let a set-UID/GID program
-determine what the invoking user would have been allowed to do,
-without the greater (or perhaps lesser) privileges afforded by
-the effective ID. For more on this, see ``Testing File
-Access'' in The GNU C Library Reference Manual.
address@hidden deffn
-
- getpid
address@hidden snarfed from posix.c:1257
address@hidden {Scheme Procedure} getpid
address@hidden {C Function} scm_getpid ()
-Return an integer representing the current process ID.
address@hidden deffn
-
- putenv
address@hidden snarfed from posix.c:1274
address@hidden {Scheme Procedure} putenv str
address@hidden {C Function} scm_putenv (str)
-Modifies the environment of the current process, which is
-also the default environment inherited by child processes.
-
-If @var{string} is of the form @code{NAME=VALUE} then it will be written
-directly into the environment, replacing any existing environment string
-with
-name matching @code{NAME}. If @var{string} does not contain an equal
-sign, then any existing string with name matching @var{string} will
-be removed.
-
-The return value is unspecified.
address@hidden deffn
-
- setlocale
address@hidden snarfed from posix.c:1358
address@hidden {Scheme Procedure} setlocale category [locale]
address@hidden {C Function} scm_setlocale (category, locale)
-If @var{locale} is omitted, return the current value of the
-specified locale category as a system-dependent string.
address@hidden should be specified using the values
address@hidden, @code{LC_ALL} etc.
-
-Otherwise the specified locale category is set to the string
address@hidden and the new value is returned as a
-system-dependent string. If @var{locale} is an empty string,
-the locale will be set using environment variables.
address@hidden deffn
-
- mknod
address@hidden snarfed from posix.c:1407
address@hidden {Scheme Procedure} mknod path type perms dev
address@hidden {C Function} scm_mknod (path, type, perms, dev)
-Creates a new special file, such as a file corresponding to a device.
address@hidden specifies the name of the file. @var{type} should
-be one of the following symbols:
-regular, directory, symlink, block-special, char-special,
-fifo, or socket. @var{perms} (an integer) specifies the file permissions.
address@hidden (an integer) specifies which device the special file refers
-to. Its exact interpretation depends on the kind of special file
-being created.
-
-E.g.,
address@hidden
-(mknod "/dev/fd0" 'block-special #o660 (+ (* 2 256) 2))
address@hidden lisp
-
-The return value is unspecified.
address@hidden deffn
-
- nice
address@hidden snarfed from posix.c:1453
address@hidden {Scheme Procedure} nice incr
address@hidden {C Function} scm_nice (incr)
-Increment the priority of the current process by @var{incr}. A higher
-priority value means that the process runs less often.
-The return value is unspecified.
address@hidden deffn
-
- sync
address@hidden snarfed from posix.c:1471
address@hidden {Scheme Procedure} sync
address@hidden {C Function} scm_sync ()
-Flush the operating system disk buffers.
-The return value is unspecified.
address@hidden deffn
-
- crypt
address@hidden snarfed from posix.c:1502
address@hidden {Scheme Procedure} crypt key salt
address@hidden {C Function} scm_crypt (key, salt)
-Encrypt @var{key} using @var{salt} as the salt value to the
-crypt(3) library call.
address@hidden deffn
-
- chroot
address@hidden snarfed from posix.c:1531
address@hidden {Scheme Procedure} chroot path
address@hidden {C Function} scm_chroot (path)
-Change the root directory to that specified in @var{path}.
-This directory will be used for path names beginning with
address@hidden/}. The root directory is inherited by all children
-of the current process. Only the superuser may change the
-root directory.
address@hidden deffn
-
- getlogin
address@hidden snarfed from posix.c:1565
address@hidden {Scheme Procedure} getlogin
address@hidden {C Function} scm_getlogin ()
-Return a string containing the name of the user logged in on
-the controlling terminal of the process, or @code{#f} if this
-information cannot be obtained.
address@hidden deffn
-
- cuserid
address@hidden snarfed from posix.c:1583
address@hidden {Scheme Procedure} cuserid
address@hidden {C Function} scm_cuserid ()
-Return a string containing a user name associated with the
-effective user id of the process. Return @code{#f} if this
-information cannot be obtained.
address@hidden deffn
-
- getpriority
address@hidden snarfed from posix.c:1609
address@hidden {Scheme Procedure} getpriority which who
address@hidden {C Function} scm_getpriority (which, who)
-Return the scheduling priority of the process, process group
-or user, as indicated by @var{which} and @var{who}. @var{which}
-is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}
-or @code{PRIO_USER}, and @var{who} is interpreted relative to
address@hidden (a process identifier for @code{PRIO_PROCESS},
-process group identifier for @code{PRIO_PGRP}, and a user
-identifier for @code{PRIO_USER}. A zero value of @var{who}
-denotes the current process, process group, or user. Return
-the highest priority (lowest numerical value) of any of the
-specified processes.
address@hidden deffn
-
- setpriority
address@hidden snarfed from posix.c:1643
address@hidden {Scheme Procedure} setpriority which who prio
address@hidden {C Function} scm_setpriority (which, who, prio)
-Set the scheduling priority of the process, process group
-or user, as indicated by @var{which} and @var{who}. @var{which}
-is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}
-or @code{PRIO_USER}, and @var{who} is interpreted relative to
address@hidden (a process identifier for @code{PRIO_PROCESS},
-process group identifier for @code{PRIO_PGRP}, and a user
-identifier for @code{PRIO_USER}. A zero value of @var{who}
-denotes the current process, process group, or user.
address@hidden is a value in the range -20 and 20, the default
-priority is 0; lower priorities cause more favorable
-scheduling. Sets the priority of all of the specified
-processes. Only the super-user may lower priorities.
-The return value is not specified.
address@hidden deffn
-
- getpass
address@hidden snarfed from posix.c:1668
address@hidden {Scheme Procedure} getpass prompt
address@hidden {C Function} scm_getpass (prompt)
-Display @var{prompt} to the standard error output and read
-a password from @file{/dev/tty}. If this file is not
-accessible, it reads from standard input. The password may be
-up to 127 characters in length. Additional characters and the
-terminating newline character are discarded. While reading
-the password, echoing and the generation of signals by special
-characters is disabled.
address@hidden deffn
-
- flock
address@hidden snarfed from posix.c:1780
address@hidden {Scheme Procedure} flock file operation
address@hidden {C Function} scm_flock (file, operation)
-Apply or remove an advisory lock on an open file.
address@hidden specifies the action to be done:
-
address@hidden LOCK_SH
-Shared lock. More than one process may hold a shared lock
-for a given file at a given time.
address@hidden defvar
address@hidden LOCK_EX
-Exclusive lock. Only one process may hold an exclusive lock
-for a given file at a given time.
address@hidden defvar
address@hidden LOCK_UN
-Unlock the file.
address@hidden defvar
address@hidden LOCK_NB
-Don't block when locking. This is combined with one of the
-other operations using @code{logior}. If @code{flock} would
-block an @code{EWOULDBLOCK} error is thrown.
address@hidden defvar
-
-The return value is not specified. @var{file} may be an open
-file descriptor or an open file descriptor port.
-
-Note that @code{flock} does not lock files across NFS.
address@hidden deffn
-
- sethostname
address@hidden snarfed from posix.c:1805
address@hidden {Scheme Procedure} sethostname name
address@hidden {C Function} scm_sethostname (name)
-Set the host name of the current processor to @var{name}. May
-only be used by the superuser. The return value is not
-specified.
address@hidden deffn
-
- gethostname
address@hidden snarfed from posix.c:1823
address@hidden {Scheme Procedure} gethostname
address@hidden {C Function} scm_gethostname ()
-Return the host name of the current processor.
address@hidden deffn
-
- gethost
address@hidden snarfed from net_db.c:134
address@hidden {Scheme Procedure} gethost [host]
address@hidden {Scheme Procedure} gethostbyname hostname
address@hidden {Scheme Procedure} gethostbyaddr address
address@hidden {C Function} scm_gethost (host)
-Look up a host by name or address, returning a host object. The
address@hidden procedure will accept either a string name or an integer
-address; if given no arguments, it behaves like @code{gethostent} (see
-below). If a name or address is supplied but the address can not be
-found, an error will be thrown to one of the keys:
address@hidden, @code{try-again}, @code{no-recovery} or
address@hidden, corresponding to the equivalent @code{h_error} values.
-Unusual conditions may result in errors thrown to the
address@hidden or @code{misc_error} keys.
address@hidden deffn
-
- getnet
address@hidden snarfed from net_db.c:216
address@hidden {Scheme Procedure} getnet [net]
address@hidden {Scheme Procedure} getnetbyname net-name
address@hidden {Scheme Procedure} getnetbyaddr net-number
address@hidden {C Function} scm_getnet (net)
-Look up a network by name or net number in the network database. The
address@hidden argument must be a string, and the @var{net-number}
-argument must be an integer. @code{getnet} will accept either type of
-argument, behaving like @code{getnetent} (see below) if no arguments are
-given.
address@hidden deffn
-
- getproto
address@hidden snarfed from net_db.c:268
address@hidden {Scheme Procedure} getproto [protocol]
address@hidden {Scheme Procedure} getprotobyname name
address@hidden {Scheme Procedure} getprotobynumber number
address@hidden {C Function} scm_getproto (protocol)
-Look up a network protocol by name or by number. @code{getprotobyname}
-takes a string argument, and @code{getprotobynumber} takes an integer
-argument. @code{getproto} will accept either type, behaving like
address@hidden (see below) if no arguments are supplied.
address@hidden deffn
-
- getserv
address@hidden snarfed from net_db.c:334
address@hidden {Scheme Procedure} getserv [name [protocol]]
address@hidden {Scheme Procedure} getservbyname name protocol
address@hidden {Scheme Procedure} getservbyport port protocol
address@hidden {C Function} scm_getserv (name, protocol)
-Look up a network service by name or by service number, and return a
-network service object. The @var{protocol} argument specifies the name
-of the desired protocol; if the protocol found in the network service
-database does not match this name, a system error is signalled.
-
-The @code{getserv} procedure will take either a service name or number
-as its first argument; if given no arguments, it behaves like
address@hidden (see below).
address@hidden deffn
-
- sethost
address@hidden snarfed from net_db.c:385
address@hidden {Scheme Procedure} sethost [stayopen]
address@hidden {C Function} scm_sethost (stayopen)
-If @var{stayopen} is omitted, this is equivalent to @code{endhostent}.
-Otherwise it is equivalent to @code{sethostent stayopen}.
address@hidden deffn
-
- setnet
address@hidden snarfed from net_db.c:401
address@hidden {Scheme Procedure} setnet [stayopen]
address@hidden {C Function} scm_setnet (stayopen)
-If @var{stayopen} is omitted, this is equivalent to @code{endnetent}.
-Otherwise it is equivalent to @code{setnetent stayopen}.
address@hidden deffn
-
- setproto
address@hidden snarfed from net_db.c:417
address@hidden {Scheme Procedure} setproto [stayopen]
address@hidden {C Function} scm_setproto (stayopen)
-If @var{stayopen} is omitted, this is equivalent to @code{endprotoent}.
-Otherwise it is equivalent to @code{setprotoent stayopen}.
address@hidden deffn
-
- setserv
address@hidden snarfed from net_db.c:433
address@hidden {Scheme Procedure} setserv [stayopen]
address@hidden {C Function} scm_setserv (stayopen)
-If @var{stayopen} is omitted, this is equivalent to @code{endservent}.
-Otherwise it is equivalent to @code{setservent stayopen}.
address@hidden deffn
-
- htons
address@hidden snarfed from socket.c:80
address@hidden {Scheme Procedure} htons value
address@hidden {C Function} scm_htons (value)
-Convert a 16 bit quantity from host to network byte ordering.
address@hidden is packed into 2 bytes, which are then converted
-and returned as a new integer.
address@hidden deffn
-
- ntohs
address@hidden snarfed from socket.c:91
address@hidden {Scheme Procedure} ntohs value
address@hidden {C Function} scm_ntohs (value)
-Convert a 16 bit quantity from network to host byte ordering.
address@hidden is packed into 2 bytes, which are then converted
-and returned as a new integer.
address@hidden deffn
-
- htonl
address@hidden snarfed from socket.c:102
address@hidden {Scheme Procedure} htonl value
address@hidden {C Function} scm_htonl (value)
-Convert a 32 bit quantity from host to network byte ordering.
address@hidden is packed into 4 bytes, which are then converted
-and returned as a new integer.
address@hidden deffn
-
- ntohl
address@hidden snarfed from socket.c:115
address@hidden {Scheme Procedure} ntohl value
address@hidden {C Function} scm_ntohl (value)
-Convert a 32 bit quantity from network to host byte ordering.
address@hidden is packed into 4 bytes, which are then converted
-and returned as a new integer.
address@hidden deffn
-
- inet-aton
address@hidden snarfed from socket.c:135
address@hidden {Scheme Procedure} inet-aton address
address@hidden {C Function} scm_inet_aton (address)
-Convert an IPv4 Internet address from printable string
-(dotted decimal notation) to an integer. E.g.,
-
address@hidden
-(inet-aton "127.0.0.1") @result{} 2130706433
address@hidden lisp
address@hidden deffn
-
- inet-ntoa
address@hidden snarfed from socket.c:158
address@hidden {Scheme Procedure} inet-ntoa inetid
address@hidden {C Function} scm_inet_ntoa (inetid)
-Convert an IPv4 Internet address to a printable
-(dotted decimal notation) string. E.g.,
-
address@hidden
-(inet-ntoa 2130706433) @result{} "127.0.0.1"
address@hidden lisp
address@hidden deffn
-
- inet-netof
address@hidden snarfed from socket.c:178
address@hidden {Scheme Procedure} inet-netof address
address@hidden {C Function} scm_inet_netof (address)
-Return the network number part of the given IPv4
-Internet address. E.g.,
-
address@hidden
-(inet-netof 2130706433) @result{} 127
address@hidden lisp
address@hidden deffn
-
- inet-lnaof
address@hidden snarfed from socket.c:196
address@hidden {Scheme Procedure} inet-lnaof address
address@hidden {C Function} scm_lnaof (address)
-Return the local-address-with-network part of the given
-IPv4 Internet address, using the obsolete class A/B/C system.
-E.g.,
-
address@hidden
-(inet-lnaof 2130706433) @result{} 1
address@hidden lisp
address@hidden deffn
-
- inet-makeaddr
address@hidden snarfed from socket.c:214
address@hidden {Scheme Procedure} inet-makeaddr net lna
address@hidden {C Function} scm_inet_makeaddr (net, lna)
-Make an IPv4 Internet address by combining the network number
address@hidden with the local-address-within-network number
address@hidden E.g.,
-
address@hidden
-(inet-makeaddr 127 1) @result{} 2130706433
address@hidden lisp
address@hidden deffn
-
- inet-pton
address@hidden snarfed from socket.c:350
address@hidden {Scheme Procedure} inet-pton family address
address@hidden {C Function} scm_inet_pton (family, address)
-Convert a string containing a printable network address to
-an integer address. Note that unlike the C version of this
-function,
-the result is an integer with normal host byte ordering.
address@hidden can be @code{AF_INET} or @code{AF_INET6}. E.g.,
-
address@hidden
-(inet-pton AF_INET "127.0.0.1") @result{} 2130706433
-(inet-pton AF_INET6 "::1") @result{} 1
address@hidden lisp
address@hidden deffn
-
- inet-ntop
address@hidden snarfed from socket.c:388
address@hidden {Scheme Procedure} inet-ntop family address
address@hidden {C Function} scm_inet_ntop (family, address)
-Convert a network address into a printable string.
-Note that unlike the C version of this function,
-the input is an integer with normal host byte ordering.
address@hidden can be @code{AF_INET} or @code{AF_INET6}. E.g.,
-
address@hidden
-(inet-ntop AF_INET 2130706433) @result{} "127.0.0.1"
-(inet-ntop AF_INET6 (- (expt 2 128) 1))
- @result{} "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"
address@hidden lisp
address@hidden deffn
-
- socket
address@hidden snarfed from socket.c:430
address@hidden {Scheme Procedure} socket family style proto
address@hidden {C Function} scm_socket (family, style, proto)
-Return a new socket port of the type specified by @var{family},
address@hidden and @var{proto}. All three parameters are
-integers. Supported values for @var{family} are
address@hidden, @code{AF_INET} and @code{AF_INET6}.
-Typical values for @var{style} are @code{SOCK_STREAM},
address@hidden and @code{SOCK_RAW}.
-
address@hidden can be obtained from a protocol name using
address@hidden A value of zero specifies the default
-protocol, which is usually right.
-
-A single socket port cannot by used for communication until it
-has been connected to another socket.
address@hidden deffn
-
- socketpair
address@hidden snarfed from socket.c:451
address@hidden {Scheme Procedure} socketpair family style proto
address@hidden {C Function} scm_socketpair (family, style, proto)
-Return a pair of connected (but unnamed) socket ports of the
-type specified by @var{family}, @var{style} and @var{proto}.
-Many systems support only socket pairs of the @code{AF_UNIX}
-family. Zero is likely to be the only meaningful value for
address@hidden
address@hidden deffn
-
- getsockopt
address@hidden snarfed from socket.c:476
address@hidden {Scheme Procedure} getsockopt sock level optname
address@hidden {C Function} scm_getsockopt (sock, level, optname)
-Return the value of a particular socket option for the socket
-port @var{sock}. @var{level} is an integer code for type of
-option being requested, e.g., @code{SOL_SOCKET} for
-socket-level options. @var{optname} is an integer code for the
-option required and should be specified using one of the
-symbols @code{SO_DEBUG}, @code{SO_REUSEADDR} etc.
-
-The returned value is typically an integer but @code{SO_LINGER}
-returns a pair of integers.
address@hidden deffn
-
- setsockopt
address@hidden snarfed from socket.c:544
address@hidden {Scheme Procedure} setsockopt sock level optname value
address@hidden {C Function} scm_setsockopt (sock, level, optname, value)
-Set the value of a particular socket option for the socket
-port @var{sock}. @var{level} is an integer code for type of option
-being set, e.g., @code{SOL_SOCKET} for socket-level options.
address@hidden is an
-integer code for the option to set and should be specified using one of
-the symbols @code{SO_DEBUG}, @code{SO_REUSEADDR} etc.
address@hidden is the value to which the option should be set. For
-most options this must be an integer, but for @code{SO_LINGER} it must
-be a pair.
-
-The return value is unspecified.
address@hidden deffn
-
- shutdown
address@hidden snarfed from socket.c:646
address@hidden {Scheme Procedure} shutdown sock how
address@hidden {C Function} scm_shutdown (sock, how)
-Sockets can be closed simply by using @code{close-port}. The
address@hidden procedure allows reception or transmission on a
-connection to be shut down individually, according to the parameter
address@hidden:
-
address@hidden @asis
address@hidden 0
-Stop receiving data for this socket. If further data arrives, reject it.
address@hidden 1
-Stop trying to transmit data from this socket. Discard any
-data waiting to be sent. Stop looking for acknowledgement of
-data already sent; don't retransmit it if it is lost.
address@hidden 2
-Stop both reception and transmission.
address@hidden table
-
-The return value is unspecified.
address@hidden deffn
-
- connect
address@hidden snarfed from socket.c:789
address@hidden {Scheme Procedure} connect sock fam address . args
address@hidden {C Function} scm_connect (sock, fam, address, args)
-Initiate a connection from a socket using a specified address
-family to the address
-specified by @var{address} and possibly @var{args}.
-The format required for @var{address}
-and @var{args} depends on the family of the socket.
-
-For a socket of family @code{AF_UNIX},
-only @var{address} is specified and must be a string with the
-filename where the socket is to be created.
-
-For a socket of family @code{AF_INET},
address@hidden must be an integer IPv4 host address and
address@hidden must be a single integer port number.
-
-For a socket of family @code{AF_INET6},
address@hidden must be an integer IPv6 host address and
address@hidden may be up to three integers:
-port [flowinfo] [scope_id],
-where flowinfo and scope_id default to zero.
-
-The return value is unspecified.
address@hidden deffn
-
- bind
address@hidden snarfed from socket.c:848
address@hidden {Scheme Procedure} bind sock fam address . args
address@hidden {C Function} scm_bind (sock, fam, address, args)
-Assign an address to the socket port @var{sock}.
-Generally this only needs to be done for server sockets,
-so they know where to look for incoming connections. A socket
-without an address will be assigned one automatically when it
-starts communicating.
-
-The format of @var{address} and @var{args} depends
-on the family of the socket.
-
-For a socket of family @code{AF_UNIX}, only @var{address}
-is specified and must be a string with the filename where
-the socket is to be created.
-
-For a socket of family @code{AF_INET}, @var{address}
-must be an integer IPv4 address and @var{args}
-must be a single integer port number.
-
-The values of the following variables can also be used for
address@hidden:
-
address@hidden INADDR_ANY
-Allow connections from any address.
address@hidden defvar
-
address@hidden INADDR_LOOPBACK
-The address of the local host using the loopback device.
address@hidden defvar
-
address@hidden INADDR_BROADCAST
-The broadcast address on the local network.
address@hidden defvar
-
address@hidden INADDR_NONE
-No address.
address@hidden defvar
-
-For a socket of family @code{AF_INET6}, @var{address}
-must be an integer IPv6 address and @var{args}
-may be up to three integers:
-port [flowinfo] [scope_id],
-where flowinfo and scope_id default to zero.
-
-The return value is unspecified.
address@hidden deffn
-
- listen
address@hidden snarfed from socket.c:881
address@hidden {Scheme Procedure} listen sock backlog
address@hidden {C Function} scm_listen (sock, backlog)
-Enable @var{sock} to accept connection
-requests. @var{backlog} is an integer specifying
-the maximum length of the queue for pending connections.
-If the queue fills, new clients will fail to connect until
-the server calls @code{accept} to accept a connection from
-the queue.
-
-The return value is unspecified.
address@hidden deffn
-
- accept
address@hidden snarfed from socket.c:993
address@hidden {Scheme Procedure} accept sock
address@hidden {C Function} scm_accept (sock)
-Accept a connection on a bound, listening socket.
-If there
-are no pending connections in the queue, wait until
-one is available unless the non-blocking option has been
-set on the socket.
-
-The return value is a
-pair in which the @emph{car} is a new socket port for the
-connection and
-the @emph{cdr} is an object with address information about the
-client which initiated the connection.
-
address@hidden does not become part of the
-connection and will continue to accept new requests.
address@hidden deffn
-
- getsockname
address@hidden snarfed from socket.c:1020
address@hidden {Scheme Procedure} getsockname sock
address@hidden {C Function} scm_getsockname (sock)
-Return the address of @var{sock}, in the same form as the
-object returned by @code{accept}. On many systems the address
-of a socket in the @code{AF_FILE} namespace cannot be read.
address@hidden deffn
-
- getpeername
address@hidden snarfed from socket.c:1042
address@hidden {Scheme Procedure} getpeername sock
address@hidden {C Function} scm_getpeername (sock)
-Return the address that @var{sock}
-is connected to, in the same form as the object returned by
address@hidden On many systems the address of a socket in the
address@hidden namespace cannot be read.
address@hidden deffn
-
- recv!
address@hidden snarfed from socket.c:1077
address@hidden {Scheme Procedure} recv! sock buf [flags]
address@hidden {C Function} scm_recv (sock, buf, flags)
-Receive data from a socket port.
address@hidden must already
-be bound to the address from which data is to be received.
address@hidden is a string into which
-the data will be written. The size of @var{buf} limits
-the amount of
-data which can be received: in the case of packet
-protocols, if a packet larger than this limit is encountered
-then some data
-will be irrevocably lost.
-
-The optional @var{flags} argument is a value or
-bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.
-
-The value returned is the number of bytes read from the
-socket.
-
-Note that the data is read directly from the socket file
-descriptor:
-any unread buffered port data is ignored.
address@hidden deffn
-
- send
address@hidden snarfed from socket.c:1120
address@hidden {Scheme Procedure} send sock message [flags]
address@hidden {C Function} scm_send (sock, message, flags)
-Transmit the string @var{message} on a socket port @var{sock}.
address@hidden must already be bound to a destination address. The
-value returned is the number of bytes transmitted --
-it's possible for
-this to be less than the length of @var{message}
-if the socket is
-set to be non-blocking. The optional @var{flags} argument
-is a value or
-bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.
-
-Note that the data is written directly to the socket
-file descriptor:
-any unflushed buffered port data is ignored.
address@hidden deffn
-
- recvfrom!
address@hidden snarfed from socket.c:1171
address@hidden {Scheme Procedure} recvfrom! sock str [flags [start [end]]]
address@hidden {C Function} scm_recvfrom (sock, str, flags, start, end)
-Return data from the socket port @var{sock} and also
-information about where the data was received from.
address@hidden must already be bound to the address from which
-data is to be received. @code{str}, is a string into which the
-data will be written. The size of @var{str} limits the amount
-of data which can be received: in the case of packet protocols,
-if a packet larger than this limit is encountered then some
-data will be irrevocably lost.
-
-The optional @var{flags} argument is a value or bitwise OR of
address@hidden, @code{MSG_PEEK}, @code{MSG_DONTROUTE} etc.
-
-The value returned is a pair: the @emph{car} is the number of
-bytes read from the socket and the @emph{cdr} an address object
-in the same form as returned by @code{accept}. The address
-will given as @code{#f} if not available, as is usually the
-case for stream sockets.
-
-The @var{start} and @var{end} arguments specify a substring of
address@hidden to which the data should be written.
-
-Note that the data is read directly from the socket file
-descriptor: any unread buffered port data is ignored.
address@hidden deffn
-
- sendto
address@hidden snarfed from socket.c:1236
address@hidden {Scheme Procedure} sendto sock message fam address .
args_and_flags
address@hidden {C Function} scm_sendto (sock, message, fam, address,
args_and_flags)
-Transmit the string @var{message} on the socket port
address@hidden The
-destination address is specified using the @var{fam},
address@hidden and
address@hidden arguments, in a similar way to the
address@hidden procedure. @var{args_and_flags} contains
-the usual connection arguments optionally followed by
-a flags argument, which is a value or
-bitwise OR of MSG_OOB, MSG_PEEK, MSG_DONTROUTE etc.
-
-The value returned is the number of bytes transmitted --
-it's possible for
-this to be less than the length of @var{message} if the
-socket is
-set to be non-blocking.
-Note that the data is written directly to the socket
-file descriptor:
-any unflushed buffered port data is ignored.
address@hidden deffn
-
- regexp?
address@hidden snarfed from regex-posix.c:106
address@hidden {Scheme Procedure} regexp? obj
address@hidden {C Function} scm_regexp_p (obj)
-Return @code{#t} if @var{obj} is a compiled regular expression,
-or @code{#f} otherwise.
address@hidden deffn
-
- make-regexp
address@hidden snarfed from regex-posix.c:151
address@hidden {Scheme Procedure} make-regexp pat . flags
address@hidden {C Function} scm_make_regexp (pat, flags)
-Compile the regular expression described by @var{pat}, and
-return the compiled regexp structure. If @var{pat} does not
-describe a legal regular expression, @code{make-regexp} throws
-a @code{regular-expression-syntax} error.
-
-The @var{flags} arguments change the behavior of the compiled
-regular expression. The following flags may be supplied:
-
address@hidden @code
address@hidden regexp/icase
-Consider uppercase and lowercase letters to be the same when
-matching.
address@hidden regexp/newline
-If a newline appears in the target string, then permit the
address@hidden and @samp{$} operators to match immediately after or
-immediately before the newline, respectively. Also, the
address@hidden and @samp{[^...]} operators will never match a newline
-character. The intent of this flag is to treat the target
-string as a buffer containing many lines of text, and the
-regular expression as a pattern that may match a single one of
-those lines.
address@hidden regexp/basic
-Compile a basic (``obsolete'') regexp instead of the extended
-(``modern'') regexps that are the default. Basic regexps do
-not consider @samp{|}, @samp{+} or @samp{?} to be special
-characters, and require the @address@hidden@}} and @samp{(...)}
-metacharacters to be backslash-escaped (@pxref{Backslash
-Escapes}). There are several other differences between basic
-and extended regular expressions, but these are the most
-significant.
address@hidden regexp/extended
-Compile an extended regular expression rather than a basic
-regexp. This is the default behavior; this flag will not
-usually be needed. If a call to @code{make-regexp} includes
-both @code{regexp/basic} and @code{regexp/extended} flags, the
-one which comes last will override the earlier one.
address@hidden table
address@hidden deffn
-
- regexp-exec
address@hidden snarfed from regex-posix.c:217
address@hidden {Scheme Procedure} regexp-exec rx str [start [flags]]
address@hidden {C Function} scm_regexp_exec (rx, str, start, flags)
-Match the compiled regular expression @var{rx} against
address@hidden If the optional integer @var{start} argument is
-provided, begin matching from that position in the string.
-Return a match structure describing the results of the match,
-or @code{#f} if no match could be found.
-
-The @var{flags} arguments change the matching behavior.
-The following flags may be supplied:
-
address@hidden @code
address@hidden regexp/notbol
-Operator @samp{^} always fails (unless @code{regexp/newline}
-is used). Use this when the beginning of the string should
-not be considered the beginning of a line.
address@hidden regexp/noteol
-Operator @samp{$} always fails (unless @code{regexp/newline}
-is used). Use this when the end of the string should not be
-considered the end of a line.
address@hidden table
address@hidden deffn