Overview of the Guile API

Guile's application programming interface (API) makes functionality available that an application developer can use in either C or Scheme programming. The interface consists of elements that may be macros, functions or variables in C, and procedures, variables, syntax or other types of object in Scheme. Broadly speaking, the interface as a whole can be divided into three groups.

1. Elements that are available equivalently as C functions or Scheme procedures.
2. Elements that are only available as macros, functions or variables for C programming.
3. Elements that are only available as procedures or other objects in Scheme.

Functions/procedures in the first group are often known as primitives, subrs or builtins. An example is the assq Scheme procedure, which is also available as scm_assq in C.

Elements in the second and third groups exist because they provide additional language-specific benefits in either Scheme or C. Examples are the C macro SCM_CONSP, which is faster and more convenient in C programming than the primitive scm_pair_p, and the procedure-with-setter make-object-property, which provides a more convenient property handling interface in Scheme than the primitives on which it is based.

Identical Function in both Scheme and C

They form the majority of the API, and allow both C and Scheme programmers to perform identical operations.

Scheme procedures marked "primitive functions" have a regular interface when calling from C, reflected in two areas: the name of a C function, and the convention for passing non-required arguments to this function.

Transforming Scheme name to C name

Normally, the name of a C function can be derived given its Scheme name, using some simple textual transformations:

• Replace - (hyphen) with _ (underscore).
• Replace ? (question mark) with "_p".
• Replace ! (exclamation point) with "_x".
• Replace internal -> with "_to_".
• Replace <= (less than or equal) with "_leq".
• Replace >= (greater than or equal) with "_geq".
• Replace < (less than) with "_less".
• Replace > (greater than) with "_gr".
• Replace @ with "at". [Omit?]
• Prefix with "gh_" (or "scm_" if you are ignoring the gh interface).
• [Anything else? --ttn, 2000/01/16 15:17:28]

Here is an Emacs Lisp command that prompts for a Scheme function name and inserts the corresponding C function name into the buffer.

(defun insert-scheme-to-C (name &optional use-gh)
  "Transforms Scheme NAME, a string, to its C counterpart, and inserts it.
Prefix arg non-nil means use \"gh_\" prefix, otherwise use \"scm_\" prefix."
  (interactive "sScheme name: \nP")
  (let ((transforms '(("-"  . "_")
                      ("?"  . "_p")
                      ("!"  . "_x")
                      ("->" . "_to_")
                      ("<=" . "_leq")
                      (">=" . "_geq")
                      ("<"  . "_less")
                      (">"  . "_gr")
                      ("@"  . "at"))))
    (while transforms
      (let ((trigger (concat "\\(.*\\)"
                             (regexp-quote (caar transforms))
                             "\\(.*\\)"))
            (sub (cdar transforms))
            (m nil))
        (while (setq m (string-match trigger name))
          (setq name (concat (match-string 1 name)
                             sub
                             (match-string 2 name)))))
      (setq transforms (cdr transforms))))
  (insert (if use-gh "gh_" "scm_") name))

Structuring argument lists for C functions

The C function's arguments will be all of the Scheme procedure's arguments, both required and optional; if the Scheme procedure takes a "rest" argument, that will be a final argument to the C function. The C function's arguments, as well as its return type, will be SCM.

Elements Available Only in C

For C this is usually a matter of better performance (e.g. the SCM_CONSP macro) or of accepting C language types rather than the generic SCM.

Elements Available Only in Scheme

Go to the first, previous, next, last section, table of contents.