The binge Reference Manual

Table of Contents

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

The binge Reference Manual

This is the binge Reference Manual, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 02:58:18 2018 GMT+0.


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

1 Introduction

* INSTALLATION.

To compile and load BINGE an ASDF file is provided.  Just install it
in your system directory and do

  (asdf:oos 'asdf:load-op :binge)

BINGE depends on NPG (the Naive Parser Generator) and SCLF.  NPG can
be found in the same place you found BINGE.


* USAGE.

The compilation of a FFI goes through three steps: the parsing (or
extraction), the creation of the C namespace, and the generation of
the FFI itself.

For example, to generate a FFI for all the functions, types, and
global variables of the a header file foo.h (and its included
headers), you can do:

  (binge:make-ffi #P"foo-ffi.lisp"
  		  (binge:make-namespace
		    (binge:extract-from-headers '("foo.h"))))

This won't extract any symbolic constant unless you explicitly specify
them with the :constants argument of extract-from-headers.

BINGE should be able to parse C source files as well, but this is
currently untested.

Both make-ffi and extract-from-headers have keyword arguments you may
want to look at, they let you specify what to extract and what type of
backend to use (in case you want to cross-generate).  In particular
the :defines and :preamble keywords of extract-from-headers come handy
to cope with weird extensions of certain compilers; for instance on
gcc-based systems you may want to use something like:

  :defines '(("__attribute__(x)" "")
  	     ("__extension__(x)" "0")
	     ("__inline" "")
	     ("__asm(x)" ""))

There is a global variable binge:*gcc-null-defines* just for this
purpose, so on FreeBSD and Linux you just need to write

  (binge:extract-from-headers '("ncurses.h")
    :defines binge:*gcc-null-defines*)

Actually gcc has many more nasty extensions and some cannot be tamed
with just few defines; the __builtin_va_list, for example.  This
needs to be manually added to the namespace as a separate declaration.

The special variable *compress-types* is an experimental feature made
to reduce the number of type declarations in the generated FFI.  It
can be set to three values:

    - NIL, don't compress, keep all the necessary declarations
    - :TYPEDEFS, remove the superfluous typedefs
    - :ALL, remove all the non strictly necessary types, converting
      the pointers to them into void pointers

A real life version of the example above would be something like:

  (setf constants-list '(...))

  (setf namespace
    (binge:make-namespace
      (binge:extract-from-headers '("ncurses.h")
        :defines binge:*gcc-null-defines*
	:constants constants-list)))

  (binge-compiler:add-declaration
     (make-instance 'binge-decl:c-typedef-declaration
		    :name "__builtin_va_list"
		    :type :vararg) namespace)

  (binge:make-ffi #P"ncurses-ffi.lisp" namespace
		  :functions t	; all functions
		  :constants t	; all constants
		  :backend (make-instance 'binge-backend:sbcl-backend
		  	   		  :package "NCURSES"
		  	   		  :prefix "%"))

Where you specify a list of symbolic constants to extract (:constants
some-var), tell BINGE to get all the functions, and prepend all the
exported symbols with an percentage sign (:prefix "%").

So if everything works as expected, you should be able to simply

  (sb-alien:load-1-foreign "/usr/lib/libncurses.so") ; if running SBCL
  (load "ncurses-ffi.lisp")

and use the new curses library.

In reality, this won't be enough; things must be adjusted and many
macros need to be written from scratch (the C macros).  For instance,
in this particular case, ncurses.h declares several functions which
aren't actually in the library (libncurses.so), so either you specify
a limited set of functions you want to extract, with the :functions
keyword argument of make-ffi, or you manually remove from the output
file those missing in the library.  As the former solution may be a
daunting task, given the size of the ncurses library, you'll probably
settle for the latter.

More examples can be found in the example directory.  They are
normally compiled and loaded together with the rest of BINGE and
they'll be available in the binge-examples package (see
example/package.lisp).  For instance, to generate the FFI for the
Berkeley DB library simply type

  (binge-examples:create-db-ffi)

If you want to try a different backend than your default one, try for
instance

  (let ((binge:*backend* (make-instance 'binge-backend:uffi-backend)))
    (binge-examples:create-db-ffi))

The UFFI backend is unconditionally loaded first, so, if your platform
has its own specific backend, UFFI's won't be the default one.  If,
for whatever reason, you need to cross-generate a FFI for another Lisp
system you have to load the appropriate backend manually:

  (load "binge:backends;your-backend.lisp")


* HACKING.

You might want to temper with binge:*c-preprocessor* if, to invoke the
C preprocessor, you don't use "cc -E".

If the general mechanism provided by extract-from-headers doesn't suit
your needs, you could try using binge:extract, which is a generic
function specialised on pathnames and streams.  You have to provide
your own preprocessed file or stream as the sole argument.

If you want to spare a couple of hours to write your own backend, have
a look in src/backend/sbcl.lisp for an example.  That's at the moment
the backend which is likely to be most up to date.

Although BINGE is known to compile on LispWorks 4.2 you may want to
check out this page if you run into stack limit problems:

http://www1.xanalys.com/support/lisp/kbase.nsf/51fe6e1cdfe748a180256639005a2ba9/f35acd8100dfd9ba8525670b0074a8d6!OpenDocument

The parsing of constant expression is still somehow limited and may
result in parser errors in some particularly complex cases; please let
me know.

Some regression tests are provided in the directory test.  You can run
them with

  (asdf:oos 'asdf:load-op :binge-tests)
  (rtest:do-tests)

or simply

  (asdf:oos 'asdf:test-op :binge)


* LEGAL

BINGE is copyright Walter C. Pelissero (walter@pelissero.de) and under
GPL, though the files it produces are not.  See the file COPYING for
further details.


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

2 Systems

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


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

2.1 binge

Maintainer

Walter C. Pelissero <walter@pelissero.de>

Author

Walter C. Pelissero <walter@pelissero.de>

License

GPL

Description

Bovine INterface GEnerator

Long Description

Bovine INterface GEnerator is a Common Lisp program that extracts types, variable/function declarations and symbolic constants from C header files and dumps a foreign function interface for them.

Dependencies
Source

binge.asd (file)

Components

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

3 Modules

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


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

3.1 binge/src

Parent

binge (system)

Location

src/

Components

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

3.2 binge/src/backends

Dependencies
Parent

src (module)

Location

src/backends/

Components

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

3.3 binge/example

Dependency

src (module)

Parent

binge (system)

Location

example/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 binge.asd

Location

binge.asd

Systems

binge (system)

Packages

binge-system

Internal Definitions

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

4.1.2 binge/src/backends/uffi.lisp

Parent

backends (module)

Location

src/backends/uffi.lisp

Exported Definitions
Internal Definitions

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

4.1.3 binge/src/backends/sbcl.lisp

Dependency

uffi.lisp (file)

Parent

backends (module)

Location

src/backends/sbcl.lisp

Exported Definitions
Internal Definitions

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

4.1.4 binge/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

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

4.1.5 binge/src/ss.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/ss.lisp

Exported Definitions
Internal Definitions

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

4.1.6 binge/src/lexer.lisp

Dependencies
Parent

src (module)

Location

src/lexer.lisp

Exported Definitions
Internal Definitions

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

4.1.7 binge/src/grammar.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/grammar.lisp

Exported Definitions

define-grammar (special variable)

Internal Definitions

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

4.1.8 binge/src/decl.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/decl.lisp

Exported Definitions

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

4.1.9 binge/src/binge.lisp

Dependencies
Parent

src (module)

Location

src/binge.lisp

Exported Definitions
Internal Definitions

gather-all-requested-declarations (function)


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

4.1.10 binge/src/parser.lisp

Dependencies
Parent

src (module)

Location

src/parser.lisp

Exported Definitions
Internal Definitions

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

4.1.11 binge/src/backend.lisp

Dependencies
Parent

src (module)

Location

src/backend.lisp

Exported Definitions
Internal Definitions

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

4.1.12 binge/src/namespace.lisp

Dependencies
Parent

src (module)

Location

src/namespace.lisp

Exported Definitions
Internal Definitions

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

4.1.13 binge/src/compiler.lisp

Dependencies
Parent

src (module)

Location

src/compiler.lisp

Exported Definitions
Internal Definitions

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

4.1.14 binge/example/package.lisp

Parent

example (module)

Location

example/package.lisp

Packages

binge-examples


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

4.1.15 binge/example/zlib.lisp

Dependency

package.lisp (file)

Parent

example (module)

Location

example/zlib.lisp

Exported Definitions

create-zlib-ffi (function)

Internal Definitions

*zlib-ffi-c-constants* (special variable)


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

4.1.16 binge/example/ncurses.lisp

Dependency

package.lisp (file)

Parent

example (module)

Location

example/ncurses.lisp

Exported Definitions

create-ncurses-ffi (function)

Internal Definitions

*ncurses-ffi-c-constants* (special variable)


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

4.1.17 binge/example/db.lisp

Dependency

package.lisp (file)

Parent

example (module)

Location

example/db.lisp

Exported Definitions

create-db-ffi (function)

Internal Definitions

*db-ffi-c-constants* (special variable)


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

4.1.18 binge/example/gtk.lisp

Dependency

package.lisp (file)

Parent

example (module)

Location

example/gtk.lisp

Exported Definitions

create-gtk-ffi (function)

Internal Definitions

*gtk-ffi-c-constants* (special variable)


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

4.1.19 binge/example/xlib.lisp

Dependency

package.lisp (file)

Parent

example (module)

Location

example/xlib.lisp

Exported Definitions

create-xlib-ffi (function)

Internal Definitions

*xlib-ffi-c-constants* (special variable)


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

4.2 Doc


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

4.2.1 binge/COPYING

Parent

binge (system)

Location

COPYING


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

4.2.2 binge/README

Parent

binge (system)

Location

README


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

4.2.3 binge/ANNOUNCE

Parent

binge (system)

Location

ANNOUNCE


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

4.3 Other


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

4.3.1 binge/.project

Parent

binge (system)

Location

.project


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

4.3.2 binge/src/backends/cmucl

Dependency

sbcl.lisp (file)

Parent

backends (module)

Location

src/backends/cmucl.lisp


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

4.3.3 binge/src/backends/lispworks

Dependency

cmucl (file)

Parent

backends (module)

Location

src/backends/lispworks.lisp


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

4.3.4 binge/src/backends/clisp

Dependency

lispworks (file)

Parent

backends (module)

Location

src/backends/clisp.lisp


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

5 Packages

Packages are listed by definition order.


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

5.1 binge-system

Source

binge.asd

Use List
Internal Definitions

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

5.2 binge

Source

package.lisp (file)

Use List
Used By List

binge-examples

Exported Definitions
Internal Definitions

gather-all-requested-declarations (function)


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

5.3 binge-compiler

Source

package.lisp (file)

Use List
Used By List

binge

Exported Definitions
Internal Definitions

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

5.4 binge-backend

Source

package.lisp (file)

Use List
Used By List

binge-compiler

Exported Definitions
Internal Definitions

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

5.5 binge-parser

Source

package.lisp (file)

Use List
Used By List
Exported Definitions
Internal Definitions

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

5.6 binge-lexer

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

5.7 binge-grammar

Source

package.lisp (file)

Use List
Used By List

binge-lexer

Exported Definitions

define-grammar (special variable)

Internal Definitions

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

5.8 binge-decl

Source

package.lisp (file)

Use List

common-lisp

Used By List
Exported Definitions

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

5.9 binge-ss

Source

package.lisp (file)

Use List
Used By List

binge-lexer

Exported Definitions
Internal Definitions

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

5.10 binge-examples

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Special variables

Special Variable: *backend*

Should hold the current backend to be used by the compiler.

Package

binge-compiler

Source

compiler.lisp (file)

Special Variable: *c-compiler*

Pathname or just the name of the C compiler program.

Package

binge-parser

Source

parser.lisp (file)

Special Variable: *c-preprocessor*

Pathname or just the name of the C preprocessor program.

Package

binge-parser

Source

parser.lisp (file)

Special Variable: *compress-types*

Whether or not the compiler should try to compress the type hierarchy to avoid writing unnecessary type declarations in the generated FFI. This variable can have one of the following values:

- NIL, don’t compress
- :TYPEDEFS, remove all the typedefs not required by user - :ALL, remove all the types that are not strictly required or requested by user.

Package

binge-compiler

Source

compiler.lisp (file)

Special Variable: *gcc-builtin-va_list*

If you parse gcc header files you might need this declaration added to your namespace.

Package

binge

Source

binge.lisp (file)

Special Variable: *gcc-null-defines*

List of preprocessor defines necessary to remove some special GCC features that would interfere with the parser.

Package

binge-parser

Source

parser.lisp (file)

Special Variable: define-grammar
Package

binge-grammar

Source

grammar.lisp (file)


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

6.1.2 Macros

Macro: with-open-stateful-stream (STREAM PATHNAME &rest OPEN-OPTIONS) &body BODY
Package

binge-ss

Source

ss.lisp (file)

Macro: with-parsable-file (VAR PATHNAME GRAMMAR) &body BODY
Package

binge-lexer

Source

lexer.lisp (file)


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

6.1.3 Functions

Function: anonymous-declaration-p DECL
Package

binge-decl

Source

decl.lisp (file)

Function: complete-declarations DECLARATION-LIST NAMESPACE
Package

binge-compiler

Source

compiler.lisp (file)

Function: create-db-ffi ()
Package

binge-examples

Source

db.lisp (file)

Function: create-gtk-ffi ()
Package

binge-examples

Source

gtk.lisp (file)

Function: create-ncurses-ffi ()
Package

binge-examples

Source

ncurses.lisp (file)

Function: create-xlib-ffi ()
Package

binge-examples

Source

xlib.lisp (file)

Function: create-zlib-ffi ()
Package

binge-examples

Source

zlib.lisp (file)

Function: explain STRING
Package

binge-parser

Source

parser.lisp (file)

Function: extract-from-headers INCLUDES &key PREAMBLE DEFINES CONSTANTS INCLUDE-PATHS

Extract all the definitions from INCLUDES files.

Package

binge-parser

Source

parser.lisp (file)

Function: fpos-column INSTANCE
Function: (setf fpos-column) VALUE INSTANCE
Package

binge-ss

Source

ss.lisp (file)

Function: fpos-line INSTANCE
Function: (setf fpos-line) VALUE INSTANCE
Package

binge-ss

Source

ss.lisp (file)

Function: get-all-c-constants NAMESPACE
Package

binge-compiler

Source

namespace.lisp (file)

Function: get-all-c-functions NAMESPACE
Package

binge-compiler

Source

namespace.lisp (file)

Function: get-all-c-structs NAMESPACE
Package

binge-compiler

Source

namespace.lisp (file)

Function: get-all-c-typedefs NAMESPACE
Package

binge-compiler

Source

namespace.lisp (file)

Function: get-all-c-variables NAMESPACE
Package

binge-compiler

Source

namespace.lisp (file)

Function: make-parsable-stream STREAM GRAMMAR
Package

binge-lexer

Source

lexer.lisp (file)

Function: open-stateful-stream PATHNAME &rest OPEN-OPTIONS
Package

binge-ss

Source

ss.lisp (file)

Function: populate-namespace NAMESPACE DECLARATIONS-LIST

Populate NAMESPACE it with declarations from DECLARATIONS-LIST.

Package

binge-compiler

Source

namespace.lisp (file)

Function: primitive-type-p OBJECT
Package

binge-decl

Source

decl.lisp (file)

Function: scan-file PATHNAME
Package

binge-lexer

Source

lexer.lisp (file)

Function: skip-block STREAM

This function is called upon seeing an open curly bracket, to skip everything up to the matching close bracket.

Package

binge-lexer

Source

lexer.lisp (file)

Function: write-declarations OUTPUT-STREAM DECLARATIONS-LIST

Write a list of declarations to OUTPUT-STREAM.

Package

binge-compiler

Source

compiler.lisp (file)

Function: write-package OUTPUT-STREAM DECLARATIONS

Write the package declaration to OUTPUT-STREAM. The package declaration is taken from DECLARATIONS. The package name is taken from BACKEND. If that slot is not set the whole declaration is skipped.

Package

binge-compiler

Source

compiler.lisp (file)


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

6.1.4 Generic functions

Generic Function: add-declaration DECLARATION NAMESPACE

Add DECLARATION in NAMESPACE, replacing original declaration if already present.

Package

binge-compiler

Source

namespace.lisp (file)

Methods
Method: add-declaration DECL (NAMESPACE c-namespace) after
Method: add-declaration (DECL c-variable-declaration) (NAMESPACE c-namespace)
Method: add-declaration (DECL c-declaration) (NAMESPACE c-namespace)
Generic Function: backend-define-package OBJECT
Generic Function: (setf backend-define-package) NEW-VALUE OBJECT
Package

binge-backend

Methods
Method: backend-define-package (BACKEND backend)
Method: (setf backend-define-package) NEW-VALUE (BACKEND backend)

If true define it’s own package.

Source

backend.lisp (file)

Generic Function: backend-package OBJECT
Generic Function: (setf backend-package) NEW-VALUE OBJECT
Package

binge-backend

Methods
Method: backend-package (BACKEND backend)
Method: (setf backend-package) NEW-VALUE (BACKEND backend)

Name of the package to write the FFI in.

Source

backend.lisp (file)

Generic Function: c-alternate-name OBJECT
Generic Function: (setf c-alternate-name) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-alternate-name (C-DECLARATION c-declaration)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-alternate-name) NEW-VALUE (C-DECLARATION c-declaration)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-arguments OBJECT
Generic Function: (setf c-arguments) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-arguments (C-FUNCTION c-function)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-arguments) NEW-VALUE (C-FUNCTION c-function)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-bits OBJECT
Generic Function: (setf c-bits) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-bits (C-BITFIELD c-bitfield)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-bits) NEW-VALUE (C-BITFIELD c-bitfield)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-constants OBJECT
Generic Function: (setf c-constants) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-constants (C-NAMESPACE c-namespace)

automatically generated reader method

Source

namespace.lisp (file)

Method: c-constants (C-ENUM-DECLARATION c-enum-declaration)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-constants) NEW-VALUE (C-ENUM-DECLARATION c-enum-declaration)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-dimensions OBJECT
Generic Function: (setf c-dimensions) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-dimensions (C-ARRAY c-array)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-dimensions) NEW-VALUE (C-ARRAY c-array)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-documentation OBJECT
Generic Function: (setf c-documentation) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-documentation (C-DECLARATION c-declaration)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-documentation) NEW-VALUE (C-DECLARATION c-declaration)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-library OBJECT
Generic Function: (setf c-library) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-library (C-DECLARATION c-declaration)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-library) NEW-VALUE (C-DECLARATION c-declaration)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-name OBJECT
Generic Function: (setf c-name) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-name (C-NAMED-OBJECT c-named-object)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-name) NEW-VALUE (C-NAMED-OBJECT c-named-object)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-object->ffi-notation OBJECT BACKEND

Convert a C object into a string according to the syntax of the specific FFI.

Package

binge-backend

Source

backend.lisp (file)

Methods
Method: c-object->ffi-notation (DECL c-variable-declaration) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (DECL c-function-declaration) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (DECL c-enum-declaration) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (DECL c-union-declaration) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (DECL c-struct-declaration) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (DECL c-typedef-declaration) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT symbol) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-array) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-function) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-enum-ref) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-union-ref) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-struct-ref) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-user-type-ref) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-pointer) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-slot) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (OBJECT c-argument) (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: c-object->ffi-notation (DECL c-variable-declaration) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (DECL c-function-declaration) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (DECL c-enum-declaration) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (DECL c-union-declaration) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (DECL c-struct-declaration) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (DECL c-typedef-declaration) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT symbol) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT c-array) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT c-function) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT c-type-ref) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT c-pointer) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT c-slot) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (OBJECT c-argument) (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: c-object->ffi-notation (DECLARATION c-declaration) BACKEND around
Source

compiler.lisp (file)

Method: c-object->ffi-notation (OBJECT c-object) (BACKEND backend)
Method: c-object->ffi-notation (DECL c-constant-declaration) (BACKEND backend)
Generic Function: c-object-lisp-name DECLARATION BACKEND

Return the string of the Lisp name used for the DECLARATION. This may be different from the C name and is affected by BACKEND.

Package

binge-backend

Source

backend.lisp (file)

Methods
Method: c-object-lisp-name (DECLARATION c-type-ref) (BACKEND backend)
Method: c-object-lisp-name (DECLARATION c-named-object) (BACKEND backend)
Method: c-object-lisp-name (DECLARATION c-declaration) (BACKEND backend)
Generic Function: c-ref-name OBJECT
Generic Function: (setf c-ref-name) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-ref-name (C-TYPE-REF c-type-ref)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-ref-name) NEW-VALUE (C-TYPE-REF c-type-ref)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-required OBJECT
Generic Function: (setf c-required) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-required (C-DECLARATION c-declaration)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-required) NEW-VALUE (C-DECLARATION c-declaration)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-slots OBJECT
Generic Function: (setf c-slots) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-slots (C-CONTAINER c-container)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-slots) NEW-VALUE (C-CONTAINER c-container)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-type OBJECT
Generic Function: (setf c-type) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-type (C-TYPED-OBJECT c-typed-object)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-type) NEW-VALUE (C-TYPED-OBJECT c-typed-object)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: c-value OBJECT
Generic Function: (setf c-value) NEW-VALUE OBJECT
Package

binge-decl

Methods
Method: c-value (C-CONSTANT-DECLARATION c-constant-declaration)

automatically generated reader method

Source

decl.lisp (file)

Method: (setf c-value) NEW-VALUE (C-CONSTANT-DECLARATION c-constant-declaration)

automatically generated writer method

Source

decl.lisp (file)

Generic Function: extract INPUT

Extract a list of all the definitions from INPUT. Return a tagged list.

Package

binge-parser

Source

parser.lisp (file)

Methods
Method: extract (INPUT string)
Method: extract (INPUT pathname)
Method: extract (INPUT stream)
Generic Function: find-c-constant NAMESPACE NAME

Find constant declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-constant) (generic function)

Methods
Method: find-c-constant (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-constant) DECLARATION NAMESPACE NAME

Insert constant DECLARATION named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-constant (generic function)

Methods
Method: (setf find-c-constant) VALUE (NAMESPACE c-namespace) NAME
Generic Function: find-c-enum NAMESPACE NAME

Find enum declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-enum) (generic function)

Methods
Method: find-c-enum (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-enum) DECLARATION NAMESPACE NAME

Insert enum DECLARATION named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-enum (generic function)

Methods
Method: (setf find-c-enum) VALUE (NAMESPACE c-namespace) NAME
Generic Function: find-c-function NAMESPACE NAME

Find function declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-function) (generic function)

Methods
Method: find-c-function (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-function) DECLARATION NAMESPACE NAME

Insert function DECLARATION named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-function (generic function)

Methods
Method: (setf find-c-function) VALUE (NAMESPACE c-namespace) NAME
Generic Function: find-c-struct NAMESPACE NAME

Find struct declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-struct) (generic function)

Methods
Method: find-c-struct (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-struct) DECLARATION NAMESPACE NAME

Insert struct DECLARATION named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-struct (generic function)

Methods
Method: (setf find-c-struct) VALUE (NAMESPACE c-namespace) NAME
Generic Function: find-c-typedef NAMESPACE NAME

Find typedef declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-typedef) (generic function)

Methods
Method: find-c-typedef (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-typedef) DECLARATION NAMESPACE NAME

Insert typedef DECLARATION with NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-typedef (generic function)

Methods
Method: (setf find-c-typedef) VALUE (NAMESPACE c-namespace) NAME
Generic Function: find-c-union NAMESPACE NAME

Find union declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-union) (generic function)

Methods
Method: find-c-union (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-union) DECLARATION NAMESPACE NAME

Insert union DECLARATION named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-union (generic function)

Methods
Method: (setf find-c-union) VALUE (NAMESPACE c-namespace) NAME
Generic Function: find-c-variable NAMESPACE NAME

Find variable declaration named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-c-variable) (generic function)

Methods
Method: find-c-variable (NAMESPACE c-namespace) NAME
Generic Function: (setf find-c-variable) DECLARATION NAMESPACE NAME

Insert variable DECLARATION named NAME in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-c-variable (generic function)

Methods
Method: (setf find-c-variable) VALUE (NAMESPACE c-namespace) NAME
Generic Function: get-position STREAM

Return position of stream. The position may be an object of the class FILE-OFFSET.

Package

binge-ss

Source

ss.lisp (file)

Methods
Method: get-position (STREAM parsable-stream)
Source

lexer.lisp (file)

Method: get-position (STREAM stateful-stream)
Generic Function: make-c-reference TYPE

Make a reference to TYPE if TYPE is among those referenciables (struct, union, enum), otherwise return NIL.

Package

binge-decl

Source

decl.lisp (file)

Methods
Method: make-c-reference (TYPE c-enum-declaration)
Method: make-c-reference (TYPE c-union-declaration)
Method: make-c-reference (TYPE c-struct-declaration)
Method: make-c-reference TYPE
Generic Function: make-ffi OUTPUT NAMESPACE &key CONSTANTS TYPES FUNCTIONS VARIABLES BACKEND

Write a FFI to OUTPUT from C declarations found in NAMESPACE. Select those you need sepcifying CONSTANTS, TYPES (struct, union, enum or typedef), FUNCTIONS and VARIABLES. If any of them is given the value T, all the declarations in that category are written.

Package

binge

Source

binge.lisp (file)

Methods
Method: make-ffi (OUTPUT (eql nil)) NAMESPACE &key CONSTANTS TYPES FUNCTIONS VARIABLES BACKEND
Method: make-ffi (OUTPUT (eql t)) NAMESPACE &key CONSTANTS TYPES FUNCTIONS VARIABLES BACKEND
Method: make-ffi (OUTPUT pathname) NAMESPACE &key CONSTANTS TYPES FUNCTIONS VARIABLES BACKEND
Method: make-ffi (OUTPUT stream) NAMESPACE &key CONSTANTS TYPES FUNCTIONS VARIABLES BACKEND
Generic Function: ss-bol OBJECT
Package

binge-ss

Methods
Method: ss-bol (STATEFUL-STREAM stateful-stream)

automatically generated reader method

Source

ss.lisp (file)

Generic Function: ss-column OBJECT
Package

binge-ss

Methods
Method: ss-column (STATEFUL-STREAM stateful-stream)

automatically generated reader method

Source

ss.lisp (file)

Generic Function: ss-line OBJECT
Package

binge-ss

Methods
Method: ss-line (STATEFUL-STREAM stateful-stream)

automatically generated reader method

Source

ss.lisp (file)

Generic Function: use-packages BACKEND

Return the list of packages to use in making the package declaration for the FFI. Specialised by every backend.

Package

binge-backend

Source

backend.lisp (file)

Methods
Method: use-packages (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: use-packages (BACKEND uffi-backend)
Source

uffi.lisp (file)

Method: use-packages (BACKEND backend)
Generic Function: write-epilogue OUTPUT-STREAM BACKEND

Write an epilogue to OUTPUT-STREAM. Specialised by every backend.

Package

binge-backend

Source

backend.lisp (file)

Methods
Method: write-epilogue OUTPUT-STREAM (BACKEND backend)
Generic Function: write-prologue OUTPUT-STREAM BACKEND

Write a prologue to OUTPUT-STREAM. Specialised by every backend.

Package

binge-backend

Source

backend.lisp (file)

Methods
Method: write-prologue OUTPUT-STREAM (BACKEND backend)

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

6.1.5 Conditions

Condition: compilation-unsupported-error ()
Package

binge-compiler

Source

compiler.lisp (file)

Direct superclasses

compilation-error (condition)

Direct methods

comp-error-item (method)

Direct slots
Slot: item
Initargs

:item

Readers

comp-error-item (generic function)


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

6.1.6 Structures

Structure: file-offset ()
Package

binge-ss

Source

ss.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

lexer-position (structure)

Direct methods
  • later-position (method)
  • print-object (method)
Direct slots
Slot: line
Readers

fpos-line (function)

Writers

(setf fpos-line) (function)

Slot: column
Readers

fpos-column (function)

Writers

(setf fpos-column) (function)


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

6.1.7 Classes

Class: backend ()

Base class for backend objects. Backend modules must derive another class from it: the C-OBJECT->FFI-NOTATION dispatching mechanism relies on it.

Package

binge-backend

Source

backend.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: package

Name of the package to write the FFI in.

Initargs

:package

Readers

backend-package (generic function)

Writers

(setf backend-package) (generic function)

Slot: define-package

If true define it’s own package.

Type

boolean

Initargs

:define-package

Readers

backend-define-package (generic function)

Writers

(setf backend-define-package) (generic function)

Slot: prefix

Prefix to add to declared functions/variables/types of the FFI.

Initargs

:prefix

Readers

backend-prefix (generic function)

Writers

(setf backend-prefix) (generic function)

Slot: library

Default library name where to find the C object of the FFI.

Initargs

:library

Readers

backend-library (generic function)

Writers

(setf backend-library) (generic function)

Class: c-argument ()

Class modelling C function arguments.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-typed-name (class)

Direct methods
Class: c-array ()

Class modelling C arrays.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: dimensions
Type

list

Initargs

:dimensions

Readers

c-dimensions (generic function)

Writers

(setf c-dimensions) (generic function)

Class: c-bitfield ()

Class modelling C bitfields.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: bits
Type

integer

Initargs

:bits

Readers

c-bits (generic function)

Writers

(setf c-bits) (generic function)

Class: c-constant-declaration ()

Class modelling C constant declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-declaration (class)

Direct methods
Direct slots
Slot: value
Initargs

:value

Readers

c-value (generic function)

Writers

(setf c-value) (generic function)

Class: c-container ()

Base class modelling C structured types; those containing a list of other objects.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-type (class)

Direct subclasses
Direct methods
Direct slots
Slot: slots
Type

list

Initargs

:slots

Readers

c-slots (generic function)

Writers

(setf c-slots) (generic function)

Class: c-declaration ()

Base class modelling the C declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-named-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: documentation
Type

(or string null)

Initargs

:documentation

Readers

c-documentation (generic function)

Writers

(setf c-documentation) (generic function)

Slot: alternate-name
Type

(or string symbol null)

Initargs

:alternate-name

Readers

c-alternate-name (generic function)

Writers

(setf c-alternate-name) (generic function)

Slot: required
Type

(or symbol null)

Initargs

:required

Readers

c-required (generic function)

Writers

(setf c-required) (generic function)

Slot: library
Type

(or string null)

Initargs

:library

Readers

c-library (generic function)

Writers

(setf c-library) (generic function)

Class: c-enum-declaration ()

Class modelling C enumerated declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: constants
Type

list

Initargs

:constants

Readers

c-constants (generic function)

Writers

(setf c-constants) (generic function)

Class: c-enum-ref ()

Class modelling references to C enums

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-type-ref (class)

Direct methods
Class: c-function ()

Class modelling the C function types.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct subclasses

c-function-declaration (class)

Direct methods
Direct slots
Slot: arguments
Type

list

Initargs

:arguments

Readers

c-arguments (generic function)

Writers

(setf c-arguments) (generic function)

Class: c-function-declaration ()

Class modelling the C function declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Class: c-named-object ()

Mixin class for C objects (declarations/types/variable/slots/ whatever) bearing a name.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name
Type

(or string symbol)

Initargs

:name

Initform

(gensym)

Readers

c-name (generic function)

Writers

(setf c-name) (generic function)

Class: c-namespace ()

Objects of this class represent all the declarations taken from parsing a C source/header file. Structs, unions and enums share the same hashtable as in C they share the same namespace.

Package

binge-compiler

Source

namespace.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: constants
Type

hash-table

Initform

(make-hash-table :test (quote equalp))

Readers

c-constants (generic function)

Slot: typedefs
Type

hash-table

Initform

(make-hash-table :test (quote equalp))

Readers

c-typedefs (generic function)

Slot: structs
Type

hash-table

Initform

(make-hash-table :test (quote equalp))

Readers

c-structs (generic function)

Slot: functions
Type

hash-table

Initform

(make-hash-table :test (quote equalp))

Readers

c-functions (generic function)

Slot: variables
Type

hash-table

Initform

(make-hash-table :test (quote equalp))

Readers

c-variables (generic function)

Class: c-object ()

Root class for all C language related objects: declarations, types and so on.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods

c-object->ffi-notation (method)

Class: c-pointer ()

Class modelling C pointers.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Class: c-slot ()

Class modelling C struct/union slots.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-typed-name (class)

Direct methods
Class: c-struct-declaration ()

Class modelling C struct declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Class: c-struct-ref ()

Class modeliing references to C struct.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-type-ref (class)

Direct methods
Class: c-type ()

Base class modelling the C types. Those which are not declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-object (class)

Direct subclasses
Class: c-type-ref ()

Base class modelling references to C types. Whether they are typedef, struct, union or enum.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-type (class)

Direct subclasses
Direct methods
Direct slots
Slot: ref-name
Type

(or string symbol)

Initargs

:ref-name

Readers

c-ref-name (generic function)

Writers

(setf c-ref-name) (generic function)

Class: c-typed-name ()

Base class for objects having a name and a type.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct subclasses
Direct methods

convert-to-c-syntax (method)

Class: c-typed-object ()

Mixin class for C objects having a type.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: type
Type

(or binge-decl:c-type keyword)

Initargs

:type

Readers

c-type (generic function)

Writers

(setf c-type) (generic function)

Class: c-typedef-declaration ()

Class modelling C user type definition (aka typedef) .

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Class: c-union-declaration ()

Class modelling C union declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Class: c-union-ref ()

Class modeliing references to C unions.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-type-ref (class)

Direct methods
Class: c-user-type-ref ()

Class modelling references to user defined C types (those created with typedefs) .

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses

c-type-ref (class)

Direct methods
Class: c-variable-declaration ()

Class modelling C variable declarations.

Package

binge-decl

Source

decl.lisp (file)

Direct superclasses
Direct methods
Class: sbcl-backend ()
Package

binge-backend

Source

sbcl.lisp (file)

Direct superclasses

backend (class)

Direct methods
Class: stateful-stream ()
Package

binge-ss

Source

ss.lisp (file)

Direct superclasses

fundamental-character-input-stream (class)

Direct subclasses

parsable-stream (class)

Direct methods
  • get-position (method)
  • stream-peek-char (method)
  • stream-unread-char (method)
  • close (method)
  • stream-read-char (method)
  • print-object (method)
  • ss-bol (method)
  • ss-line (method)
  • ss-column (method)
Direct slots
Slot: column
Type

integer

Initform

0

Readers

ss-column (generic function)

Slot: line
Type

integer

Initform

0

Readers

ss-line (generic function)

Slot: real-stream
Initargs

:stream

Slot: bol
Type

boolean

Initform

t

Readers

ss-bol (generic function)

Class: uffi-backend ()
Package

binge-backend

Source

uffi.lisp (file)

Direct superclasses

backend (class)

Direct methods

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

6.2 Internal definitions


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

6.2.1 Special variables

Special Variable: *binge-base-directory*
Package

binge-system

Source

binge.asd

Special Variable: *db-ffi-c-constants*
Package

binge-examples

Source

db.lisp (file)

Special Variable: *extract-constants-with-cc*

Whether or not use the C compiler to extract symbolic constants. If this is NIL then the internal parser is used instead.

Package

binge-parser

Source

parser.lisp (file)

Special Variable: *gtk-ffi-c-constants*
Package

binge-examples

Source

gtk.lisp (file)

Special Variable: *ncurses-ffi-c-constants*
Package

binge-examples

Source

ncurses.lisp (file)

Special Variable: *xlib-ffi-c-constants*
Package

binge-examples

Source

xlib.lisp (file)

Special Variable: *zlib-ffi-c-constants*
Package

binge-examples

Source

zlib.lisp (file)

Special Variable: +word-component-table+
Package

binge-lexer

Source

lexer.lisp (file)

Special Variable: +word-start-table+
Package

binge-lexer

Source

lexer.lisp (file)


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

6.2.2 Functions

Function: add-new-declaration DECL NAMESPACE

Add DECL declaration in NAMESPACE namespace only if it’s not already in.

Package

binge-compiler

Source

namespace.lisp (file)

Function: add-presence-into-fslist OBJ HASH

This will add only a placeholder in the hashtable of a FAST-SEARCHABLE-LIST, but not in its list. This is handy to pretend the object is already in the list when actualy it isn’t.

Package

binge-compiler

Source

compiler.lisp (file)

Function: convert-array-dimensions DIMENSIONS BACKEND
Package

binge-backend

Source

backend.lisp (file)

Function: convert-compound-to-c-syntax TYPE DECLARATION
Package

binge-compiler

Source

compiler.lisp (file)

Function: convert-constant-expression EXPRESSION BACKEND
Package

binge-backend

Source

backend.lisp (file)

Function: copy-file-offset INSTANCE
Package

binge-ss

Source

ss.lisp (file)

Function: copy-lexer-position INSTANCE
Package

binge-lexer

Source

lexer.lisp (file)

Function: digit-value CHAR &optional BASE

Return the integer value of CHAR if it’s a digit otherwise NIL. CHAR can be a letter to accomodate exadecimal numbers. Actually the base can be up to 36.

Package

binge-lexer

Source

lexer.lisp (file)

Function: extract-constants CONSTANTS INCLUDES INCLUDE-PATHS

Extract C symbolic constants writing and compiling a special C source files that produces an alist of constants and values. Read its output and return the alist.

Package

binge-parser

Source

parser.lisp (file)

Function: file-offset-p OBJECT
Package

binge-ss

Source

ss.lisp (file)

Function: fpos-file-name INSTANCE
Function: (setf fpos-file-name) VALUE INSTANCE
Package

binge-lexer

Source

lexer.lisp (file)

Function: fpos-token INSTANCE
Function: (setf fpos-token) VALUE INSTANCE
Package

binge-lexer

Source

lexer.lisp (file)

Function: gather-all-requested-declarations NAMESPACE CONSTANTS TYPES FUNCTIONS VARIABLES
Package

binge

Source

binge.lisp (file)

Function: get-rid-of-optional-ul STREAM
Package

binge-lexer

Source

lexer.lisp (file)

Function: hash-table-values-list HASH-TABLE
Package

binge-compiler

Source

namespace.lisp (file)

Function: lexer-position-p OBJECT
Package

binge-lexer

Source

lexer.lisp (file)

Function: make-file-offset &key (LINE LINE) (COLUMN COLUMN)
Package

binge-ss

Source

ss.lisp (file)

Function: make-lexer-position &key (LINE LINE) (COLUMN COLUMN) (FILE-NAME FILE-NAME) (TOKEN TOKEN)
Package

binge-lexer

Source

lexer.lisp (file)

Function: make-parsable-file PATHNAME GRAMMAR
Package

binge-lexer

Source

lexer.lisp (file)

Function: make-presence-table CHARS
Package

binge-lexer

Source

lexer.lisp (file)

Function: member-of-fslist OBJ HASH
Package

binge-compiler

Source

compiler.lisp (file)

Function: populate-grammar ()
Package

binge-grammar

Source

grammar.lisp (file)

Function: push-into-fslist OBJ HASH
Package

binge-compiler

Source

compiler.lisp (file)

Function: read-character-sequence STREAM
Package

binge-lexer

Source

lexer.lisp (file)

Function: read-dots STREAM
Package

binge-lexer

Source

lexer.lisp (file)

Function: read-escape-sequence STREAM
Package

binge-lexer

Source

lexer.lisp (file)

Function: read-integer-from-string STR &key START END BASE

Try to interprete STR as an integer. Return its value.

Package

binge-lexer

Source

lexer.lisp (file)

Function: read-integer-number STREAM &optional BASE

Try to read an integer number from STREAM according to BASE. Return its integer value.

Package

binge-lexer

Source

lexer.lisp (file)

Function: read-number STREAM FIRST-DIGIT

Read any kind of syntactically correct C number. Return a token according to type and value.

Package

binge-lexer

Source

lexer.lisp (file)

Function: read-pound-line STREAM

Read a preprocessor line (those starting with # on column 0) and adjust the stream file name and line number accordingly.

Package

binge-lexer

Source

lexer.lisp (file)

Function: read-string STREAM DELIMITER
Package

binge-lexer

Source

lexer.lisp (file)

Function: read-word STREAM &rest FIRST-CHARS
Package

binge-lexer

Source

lexer.lisp (file)

Function: sbcl-format-compound TYPE DECLARATION BACKEND
Package

binge-backend

Source

sbcl.lisp (file)

Function: skip-to-eol STREAM
Package

binge-lexer

Source

lexer.lisp (file)

Function: skip-whitespace STREAM
Package

binge-lexer

Source

lexer.lisp (file)

Function: typify-names BASE-TYPE NAME-COMPLETION-FUNCTIONS CONTAINER-CLASS

Create objects of type CONTAINER-CLASS typifying names of variables/slots. The typification is done calling function in NAME-COMPLETION-FUNCTIONS passing the BASE-TYPE, which is the missing bit to fully qualify a C name.

Package

binge-grammar

Source

grammar.lisp (file)

Function: uffi-format-compound TYPE DECLARATION BACKEND
Package

binge-backend

Source

uffi.lisp (file)

Function: word-component-p C
Package

binge-lexer

Source

lexer.lisp (file)

Function: word-start-p C
Package

binge-lexer

Source

lexer.lisp (file)

Function: write-c-source-for-compilation OUT PREAMBLE DEFINES INCLUDES CONSTANTS

Write a C source file on OUT stream suitable for compilation and execution. This means inserting the necessary inclusion statements and the DEFINES to clear out all the fancy cc extensions that can be found. A main function is written including printf()s of all the CONSTANTS values.

Package

binge-parser

Source

parser.lisp (file)

Function: write-c-source-for-parser OUT PREAMBLE DEFINES INCLUDES CONSTANTS

Write a C source file on OUT stream suitable for preprocessing and, later on, parsing by BINGE. This means inserting the necessary inclusion statements and the DEFINES to clear out all the fancy cc extensions that can be found. CONSTANTS are written in a special syntax only BINGE can parse.

Package

binge-parser

Source

parser.lisp (file)


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

6.2.3 Generic functions

Generic Function: backend-library OBJECT
Generic Function: (setf backend-library) NEW-VALUE OBJECT
Package

binge-backend

Methods
Method: backend-library (BACKEND backend)
Method: (setf backend-library) NEW-VALUE (BACKEND backend)

Default library name where to find the C object of the FFI.

Source

backend.lisp (file)

Generic Function: backend-prefix OBJECT
Generic Function: (setf backend-prefix) NEW-VALUE OBJECT
Package

binge-backend

Methods
Method: backend-prefix (BACKEND backend)
Method: (setf backend-prefix) NEW-VALUE (BACKEND backend)

Prefix to add to declared functions/variables/types of the FFI.

Source

backend.lisp (file)

Generic Function: c-expression C-OBJECT NAME

Convert C-OBJECT type to C syntax and attach name.

Package

binge-compiler

Source

compiler.lisp (file)

Methods
Method: c-expression (OBJECT c-function) NAME
Method: c-expression (OBJECT c-array) NAME
Method: c-expression (OBJECT c-pointer) NAME
Method: c-expression (OBJECT c-bitfield) NAME
Method: c-expression (OBJECT c-enum-ref) NAME
Method: c-expression (OBJECT c-union-ref) NAME
Method: c-expression (OBJECT c-struct-ref) NAME
Method: c-expression (OBJECT c-user-type-ref) NAME
Method: c-expression (OBJECT symbol) NAME
Generic Function: c-functions OBJECT
Package

binge-compiler

Methods
Method: c-functions (C-NAMESPACE c-namespace)

automatically generated reader method

Source

namespace.lisp (file)

Generic Function: c-structs OBJECT
Package

binge-compiler

Methods
Method: c-structs (C-NAMESPACE c-namespace)

automatically generated reader method

Source

namespace.lisp (file)

Generic Function: c-typedefs OBJECT
Package

binge-compiler

Methods
Method: c-typedefs (C-NAMESPACE c-namespace)

automatically generated reader method

Source

namespace.lisp (file)

Generic Function: c-variables OBJECT
Package

binge-compiler

Methods
Method: c-variables (C-NAMESPACE c-namespace)

automatically generated reader method

Source

namespace.lisp (file)

Generic Function: check-reference DECL NAMESPACE

Make sure that the type referred by DECL exists. This is a nop if DECL is not a reference to a type. If the referenced type doesn’t exist it’s created and added to namespace.

Package

binge-compiler

Source

namespace.lisp (file)

Methods
Method: check-reference (DECL c-user-type-ref) (NAMESPACE c-namespace)
Method: check-reference (DECL c-enum-ref) (NAMESPACE c-namespace)
Method: check-reference (DECL c-union-ref) (NAMESPACE c-namespace)
Method: check-reference (DECL c-struct-ref) (NAMESPACE c-namespace)
Method: check-reference DECL (NAMESPACE c-namespace)
Generic Function: collect-declarations DECLARATION DECLARATIONS-LIST NAMESPACE

Add to DECLARATIONS-LIST any missing declarations to fully define DECLARATION itself. All the additional declarations are taken from NAMESPACE. DECLARATIONS-LIST is sorted with most basic declarations last and independed delcarations first in the list.

Package

binge-compiler

Source

compiler.lisp (file)

Methods
Method: collect-declarations (DECLARATION c-type-ref) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (DECLARATION c-container) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (DECLARATION c-function) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (OBJ c-typed-object) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (OBJ c-pointer) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (DECLARATION c-struct-declaration) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (DECLARATION c-declaration) DECLARATIONS-LIST NAMESPACE
Method: collect-declarations (DECLARATION symbol) DECLARATIONS-LIST NAMESPACE
Generic Function: comp-error-declaration CONDITION
Generic Function: (setf comp-error-declaration) NEW-VALUE CONDITION
Package

binge-compiler

Methods
Method: comp-error-declaration (CONDITION compilation-error)
Method: (setf comp-error-declaration) NEW-VALUE (CONDITION compilation-error)
Source

compiler.lisp (file)

Generic Function: comp-error-item CONDITION
Package

binge-compiler

Methods
Method: comp-error-item (CONDITION compilation-unsupported-error)
Source

compiler.lisp (file)

Generic Function: convert-to-c-syntax C-OBJECT

Convert C-OBJECT to C syntax. More or less the opposite of what the BINGE parser does.

Package

binge-compiler

Source

compiler.lisp (file)

Methods
Method: convert-to-c-syntax (DECLARATION c-declaration)
Method: convert-to-c-syntax (DECLARATION c-union-declaration)
Method: convert-to-c-syntax (DECLARATION c-struct-declaration)
Method: convert-to-c-syntax (DECLARATION c-variable-declaration)
Method: convert-to-c-syntax (DECLARATION c-function-declaration)
Method: convert-to-c-syntax (OBJECT c-typed-name)
Generic Function: explain-c-object OBJ

Explain in plain English what the C object OBJ stands for.

Package

binge-parser

Source

parser.lisp (file)

Methods
Method: explain-c-object (OBJ symbol)
Method: explain-c-object (OBJ c-variable-declaration)
Method: explain-c-object (OBJ c-pointer)
Method: explain-c-object (OBJ c-array)
Method: explain-c-object (OBJ c-user-type-ref)
Method: explain-c-object (OBJ c-enum-declaration)
Method: explain-c-object (OBJ c-union-declaration)
Method: explain-c-object (OBJ c-struct-declaration)
Method: explain-c-object (OBJ c-function)
Method: explain-c-object (OBJ c-named-object)
Generic Function: ffi-sizeof THING BACKEND

Generic function that returns the string for the syntax required to get the size of a C type.

Package

binge-backend

Source

backend.lisp (file)

Methods
Method: ffi-sizeof THING (BACKEND sbcl-backend)
Source

sbcl.lisp (file)

Method: ffi-sizeof THING (BACKEND uffi-backend)
Source

uffi.lisp (file)

Generic Function: find-declaration DECL NAMESPACE

Find DECL declaration in NAMESPACE and return it, otherwise return nil.

Package

binge-compiler

Source

namespace.lisp (file)

Writer

(setf find-declaration) (generic function)

Methods
Method: find-declaration (OBJ c-enum-ref) (NAMESPACE c-namespace)
Method: find-declaration (OBJ c-union-ref) (NAMESPACE c-namespace)
Method: find-declaration (OBJ c-struct-ref) (NAMESPACE c-namespace)
Method: find-declaration (OBJ c-user-type-ref) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-constant-declaration) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-typedef-declaration) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-variable-declaration) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-enum-declaration) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-union-declaration) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-struct-declaration) (NAMESPACE c-namespace)
Method: find-declaration (DECL c-function-declaration) (NAMESPACE c-namespace)
Generic Function: (setf find-declaration) VALUE DECL NAMESPACE

Insert DECL declaration in NAMESPACE.

Package

binge-compiler

Source

namespace.lisp (file)

Reader

find-declaration (generic function)

Methods
Method: (setf find-declaration) VALUE (OBJ c-enum-ref) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (OBJ c-union-ref) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (OBJ c-struct-ref) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (OBJ c-user-type-ref) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-constant-declaration) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-typedef-declaration) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-variable-declaration) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-enum-declaration) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-union-declaration) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-struct-declaration) (NAMESPACE c-namespace)
Method: (setf find-declaration) VALUE (DECL c-function-declaration) (NAMESPACE c-namespace)
Generic Function: get-list OBJECT
Package

binge-compiler

Methods
Method: get-list (FAST-SEARCHABLE-LIST fast-searchable-list)

automatically generated reader method

Source

compiler.lisp (file)

Generic Function: make-sure-referred-types-exist OBJ NAMESPACE

Make sure all the types referenced by C object OBJ exist. If necessary populate namespace with dummies of the missing types.

Package

binge-compiler

Source

namespace.lisp (file)

Methods
Method: make-sure-referred-types-exist (OBJ c-function) (NAMESPACE c-namespace)
Method: make-sure-referred-types-exist (OBJ c-container) (NAMESPACE c-namespace)
Method: make-sure-referred-types-exist (OBJ c-typed-object) (NAMESPACE c-namespace)
Method: make-sure-referred-types-exist (OBJ c-type-ref) (NAMESPACE c-namespace)
Method: make-sure-referred-types-exist OBJ (NAMESPACE c-namespace)
Generic Function: substitute-declarations-with-references OBJECT NAMESPACE

Extract type definitions, if any, from C OBJECT, populating NAMESPACE with new declarations, and susbstitute when necessary with references to types. Return the possibly modified object.

Package

binge-compiler

Source

namespace.lisp (file)

Methods
Method: substitute-declarations-with-references (DECL c-container) (NAMESPACE c-namespace)
Method: substitute-declarations-with-references (OBJ c-typed-object) (NAMESPACE c-namespace)
Method: substitute-declarations-with-references OBJ (NAMESPACE c-namespace)
Generic Function: transform-to-reference OBJECT NAMESPACE

If possible transform C OBJECT into a reference and populate NAMESPACE with its declaration.

Package

binge-compiler

Source

namespace.lisp (file)

Methods
Method: transform-to-reference (OBJ c-declaration) (NAMESPACE c-namespace)
Method: transform-to-reference (OBJ c-typed-object) (NAMESPACE c-namespace)
Method: transform-to-reference OBJ (NAMESPACE c-namespace)
Generic Function: unalias-reference OBJECT NAMESPACE

Return the primitive type or a reference to the first user-required typedef or compound object at the basis of object. Look it up in NAMESPACE.

Package

binge-compiler

Source

compiler.lisp (file)

Methods
Method: unalias-reference (OBJECT c-user-type-ref) NAMESPACE
Method: unalias-reference OBJECT NAMESPACE

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

6.2.4 Conditions

Condition: compilation-error ()
Package

binge-compiler

Source

compiler.lisp (file)

Direct superclasses

error (condition)

Direct subclasses

compilation-unsupported-error (condition)

Direct methods
Direct slots
Slot: declaration
Initargs

:declaration

Readers

comp-error-declaration (generic function)

Writers

(setf comp-error-declaration) (generic function)


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

6.2.5 Structures

Structure: lexer-position ()
Package

binge-lexer

Source

lexer.lisp (file)

Direct superclasses

file-offset (structure)

Direct methods
  • later-position (method)
  • print-object (method)
Direct slots
Slot: file-name
Readers

fpos-file-name (function)

Writers

(setf fpos-file-name) (function)

Slot: token
Readers

fpos-token (function)

Writers

(setf fpos-token) (function)


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

6.2.6 Classes

Class: fast-searchable-list ()
Package

binge-compiler

Source

compiler.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
  • print-object (method)
  • get-list (method)
Direct slots
Slot: table
Initform

(make-hash-table)

Slot: list
Initform

(quote nil)

Readers

get-list (generic function)

Class: inactive-file ()
Package

binge-system

Source

binge.asd

Direct superclasses

static-file (class)

Direct methods

source-file-type (method)

Class: parsable-stream ()
Package

binge-lexer

Source

lexer.lisp (file)

Direct superclasses

stateful-stream (class)

Direct methods
Direct slots
Slot: grammar
Type

naive-parser-generator:grammar

Initargs

:grammar

Slot: file-name
Initargs

:file-name

Slot: token
Type

integer

Initform

0


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   B   D   F   L   M   O  
Index Entry  Section

B
binge.asd: The binge<dot>asd file
binge/.project: The binge/<dot>project file
binge/ANNOUNCE: The binge/announce file
binge/COPYING: The binge/copying file
binge/example: The binge/example module
binge/example/db.lisp: The binge/example/db<dot>lisp file
binge/example/gtk.lisp: The binge/example/gtk<dot>lisp file
binge/example/ncurses.lisp: The binge/example/ncurses<dot>lisp file
binge/example/package.lisp: The binge/example/package<dot>lisp file
binge/example/xlib.lisp: The binge/example/xlib<dot>lisp file
binge/example/zlib.lisp: The binge/example/zlib<dot>lisp file
binge/README: The binge/readme file
binge/src: The binge/src module
binge/src/backend.lisp: The binge/src/backend<dot>lisp file
binge/src/backends: The binge/src/backends module
binge/src/backends/clisp: The binge/src/backends/clisp file
binge/src/backends/cmucl: The binge/src/backends/cmucl file
binge/src/backends/lispworks: The binge/src/backends/lispworks file
binge/src/backends/sbcl.lisp: The binge/src/backends/sbcl<dot>lisp file
binge/src/backends/uffi.lisp: The binge/src/backends/uffi<dot>lisp file
binge/src/binge.lisp: The binge/src/binge<dot>lisp file
binge/src/compiler.lisp: The binge/src/compiler<dot>lisp file
binge/src/decl.lisp: The binge/src/decl<dot>lisp file
binge/src/grammar.lisp: The binge/src/grammar<dot>lisp file
binge/src/lexer.lisp: The binge/src/lexer<dot>lisp file
binge/src/namespace.lisp: The binge/src/namespace<dot>lisp file
binge/src/package.lisp: The binge/src/package<dot>lisp file
binge/src/parser.lisp: The binge/src/parser<dot>lisp file
binge/src/ss.lisp: The binge/src/ss<dot>lisp file

D
Doc File, binge/ANNOUNCE: The binge/announce file
Doc File, binge/COPYING: The binge/copying file
Doc File, binge/README: The binge/readme file

F
File, doc, binge/ANNOUNCE: The binge/announce file
File, doc, binge/COPYING: The binge/copying file
File, doc, binge/README: The binge/readme file
File, Lisp, binge.asd: The binge<dot>asd file
File, Lisp, binge/example/db.lisp: The binge/example/db<dot>lisp file
File, Lisp, binge/example/gtk.lisp: The binge/example/gtk<dot>lisp file
File, Lisp, binge/example/ncurses.lisp: The binge/example/ncurses<dot>lisp file
File, Lisp, binge/example/package.lisp: The binge/example/package<dot>lisp file
File, Lisp, binge/example/xlib.lisp: The binge/example/xlib<dot>lisp file
File, Lisp, binge/example/zlib.lisp: The binge/example/zlib<dot>lisp file
File, Lisp, binge/src/backend.lisp: The binge/src/backend<dot>lisp file
File, Lisp, binge/src/backends/sbcl.lisp: The binge/src/backends/sbcl<dot>lisp file
File, Lisp, binge/src/backends/uffi.lisp: The binge/src/backends/uffi<dot>lisp file
File, Lisp, binge/src/binge.lisp: The binge/src/binge<dot>lisp file
File, Lisp, binge/src/compiler.lisp: The binge/src/compiler<dot>lisp file
File, Lisp, binge/src/decl.lisp: The binge/src/decl<dot>lisp file
File, Lisp, binge/src/grammar.lisp: The binge/src/grammar<dot>lisp file
File, Lisp, binge/src/lexer.lisp: The binge/src/lexer<dot>lisp file
File, Lisp, binge/src/namespace.lisp: The binge/src/namespace<dot>lisp file
File, Lisp, binge/src/package.lisp: The binge/src/package<dot>lisp file
File, Lisp, binge/src/parser.lisp: The binge/src/parser<dot>lisp file
File, Lisp, binge/src/ss.lisp: The binge/src/ss<dot>lisp file
File, other, binge/.project: The binge/<dot>project file
File, other, binge/src/backends/clisp: The binge/src/backends/clisp file
File, other, binge/src/backends/cmucl: The binge/src/backends/cmucl file
File, other, binge/src/backends/lispworks: The binge/src/backends/lispworks file

L
Lisp File, binge.asd: The binge<dot>asd file
Lisp File, binge/example/db.lisp: The binge/example/db<dot>lisp file
Lisp File, binge/example/gtk.lisp: The binge/example/gtk<dot>lisp file
Lisp File, binge/example/ncurses.lisp: The binge/example/ncurses<dot>lisp file
Lisp File, binge/example/package.lisp: The binge/example/package<dot>lisp file
Lisp File, binge/example/xlib.lisp: The binge/example/xlib<dot>lisp file
Lisp File, binge/example/zlib.lisp: The binge/example/zlib<dot>lisp file
Lisp File, binge/src/backend.lisp: The binge/src/backend<dot>lisp file
Lisp File, binge/src/backends/sbcl.lisp: The binge/src/backends/sbcl<dot>lisp file
Lisp File, binge/src/backends/uffi.lisp: The binge/src/backends/uffi<dot>lisp file
Lisp File, binge/src/binge.lisp: The binge/src/binge<dot>lisp file
Lisp File, binge/src/compiler.lisp: The binge/src/compiler<dot>lisp file
Lisp File, binge/src/decl.lisp: The binge/src/decl<dot>lisp file
Lisp File, binge/src/grammar.lisp: The binge/src/grammar<dot>lisp file
Lisp File, binge/src/lexer.lisp: The binge/src/lexer<dot>lisp file
Lisp File, binge/src/namespace.lisp: The binge/src/namespace<dot>lisp file
Lisp File, binge/src/package.lisp: The binge/src/package<dot>lisp file
Lisp File, binge/src/parser.lisp: The binge/src/parser<dot>lisp file
Lisp File, binge/src/ss.lisp: The binge/src/ss<dot>lisp file

M
Module, binge/example: The binge/example module
Module, binge/src: The binge/src module
Module, binge/src/backends: The binge/src/backends module

O
Other File, binge/.project: The binge/<dot>project file
Other File, binge/src/backends/clisp: The binge/src/backends/clisp file
Other File, binge/src/backends/cmucl: The binge/src/backends/cmucl file
Other File, binge/src/backends/lispworks: The binge/src/backends/lispworks file

Jump to:   B   D   F   L   M   O  

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

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   L   M   O   P   R   S   T   U   W  
Index Entry  Section

(
(setf backend-define-package): Exported generic functions
(setf backend-define-package): Exported generic functions
(setf backend-library): Internal generic functions
(setf backend-library): Internal generic functions
(setf backend-package): Exported generic functions
(setf backend-package): Exported generic functions
(setf backend-prefix): Internal generic functions
(setf backend-prefix): Internal generic functions
(setf c-alternate-name): Exported generic functions
(setf c-alternate-name): Exported generic functions
(setf c-arguments): Exported generic functions
(setf c-arguments): Exported generic functions
(setf c-bits): Exported generic functions
(setf c-bits): Exported generic functions
(setf c-constants): Exported generic functions
(setf c-constants): Exported generic functions
(setf c-dimensions): Exported generic functions
(setf c-dimensions): Exported generic functions
(setf c-documentation): Exported generic functions
(setf c-documentation): Exported generic functions
(setf c-library): Exported generic functions
(setf c-library): Exported generic functions
(setf c-name): Exported generic functions
(setf c-name): Exported generic functions
(setf c-ref-name): Exported generic functions
(setf c-ref-name): Exported generic functions
(setf c-required): Exported generic functions
(setf c-required): Exported generic functions
(setf c-slots): Exported generic functions
(setf c-slots): Exported generic functions
(setf c-type): Exported generic functions
(setf c-type): Exported generic functions
(setf c-value): Exported generic functions
(setf c-value): Exported generic functions
(setf comp-error-declaration): Internal generic functions
(setf comp-error-declaration): Internal generic functions
(setf find-c-constant): Exported generic functions
(setf find-c-constant): Exported generic functions
(setf find-c-enum): Exported generic functions
(setf find-c-enum): Exported generic functions
(setf find-c-function): Exported generic functions
(setf find-c-function): Exported generic functions
(setf find-c-struct): Exported generic functions
(setf find-c-struct): Exported generic functions
(setf find-c-typedef): Exported generic functions
(setf find-c-typedef): Exported generic functions
(setf find-c-union): Exported generic functions
(setf find-c-union): Exported generic functions
(setf find-c-variable): Exported generic functions
(setf find-c-variable): Exported generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf find-declaration): Internal generic functions
(setf fpos-column): Exported functions
(setf fpos-file-name): Internal functions
(setf fpos-line): Exported functions
(setf fpos-token): Internal functions

A
add-declaration: Exported generic functions
add-declaration: Exported generic functions
add-declaration: Exported generic functions
add-declaration: Exported generic functions
add-new-declaration: Internal functions
add-presence-into-fslist: Internal functions
anonymous-declaration-p: Exported functions

B
backend-define-package: Exported generic functions
backend-define-package: Exported generic functions
backend-library: Internal generic functions
backend-library: Internal generic functions
backend-package: Exported generic functions
backend-package: Exported generic functions
backend-prefix: Internal generic functions
backend-prefix: Internal generic functions

C
c-alternate-name: Exported generic functions
c-alternate-name: Exported generic functions
c-arguments: Exported generic functions
c-arguments: Exported generic functions
c-bits: Exported generic functions
c-bits: Exported generic functions
c-constants: Exported generic functions
c-constants: Exported generic functions
c-constants: Exported generic functions
c-dimensions: Exported generic functions
c-dimensions: Exported generic functions
c-documentation: Exported generic functions
c-documentation: Exported generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-expression: Internal generic functions
c-functions: Internal generic functions
c-functions: Internal generic functions
c-library: Exported generic functions
c-library: Exported generic functions
c-name: Exported generic functions
c-name: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object->ffi-notation: Exported generic functions
c-object-lisp-name: Exported generic functions
c-object-lisp-name: Exported generic functions
c-object-lisp-name: Exported generic functions
c-object-lisp-name: Exported generic functions
c-ref-name: Exported generic functions
c-ref-name: Exported generic functions
c-required: Exported generic functions
c-required: Exported generic functions
c-slots: Exported generic functions
c-slots: Exported generic functions
c-structs: Internal generic functions
c-structs: Internal generic functions
c-type: Exported generic functions
c-type: Exported generic functions
c-typedefs: Internal generic functions
c-typedefs: Internal generic functions
c-value: Exported generic functions
c-value: Exported generic functions
c-variables: Internal generic functions
c-variables: Internal generic functions
check-reference: Internal generic functions
check-reference: Internal generic functions
check-reference: Internal generic functions
check-reference: Internal generic functions
check-reference: Internal generic functions
check-reference: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
collect-declarations: Internal generic functions
comp-error-declaration: Internal generic functions
comp-error-declaration: Internal generic functions
comp-error-item: Internal generic functions
comp-error-item: Internal generic functions
complete-declarations: Exported functions
convert-array-dimensions: Internal functions
convert-compound-to-c-syntax: Internal functions
convert-constant-expression: Internal functions
convert-to-c-syntax: Internal generic functions
convert-to-c-syntax: Internal generic functions
convert-to-c-syntax: Internal generic functions
convert-to-c-syntax: Internal generic functions
convert-to-c-syntax: Internal generic functions
convert-to-c-syntax: Internal generic functions
convert-to-c-syntax: Internal generic functions
copy-file-offset: Internal functions
copy-lexer-position: Internal functions
create-db-ffi: Exported functions
create-gtk-ffi: Exported functions
create-ncurses-ffi: Exported functions
create-xlib-ffi: Exported functions
create-zlib-ffi: Exported functions

D
digit-value: Internal functions

E
explain: Exported functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
explain-c-object: Internal generic functions
extract: Exported generic functions
extract: Exported generic functions
extract: Exported generic functions
extract: Exported generic functions
extract-constants: Internal functions
extract-from-headers: Exported functions

F
ffi-sizeof: Internal generic functions
ffi-sizeof: Internal generic functions
ffi-sizeof: Internal generic functions
file-offset-p: Internal functions
find-c-constant: Exported generic functions
find-c-constant: Exported generic functions
find-c-enum: Exported generic functions
find-c-enum: Exported generic functions
find-c-function: Exported generic functions
find-c-function: Exported generic functions
find-c-struct: Exported generic functions
find-c-struct: Exported generic functions
find-c-typedef: Exported generic functions
find-c-typedef: Exported generic functions
find-c-union: Exported generic functions
find-c-union: Exported generic functions
find-c-variable: Exported generic functions
find-c-variable: Exported generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
find-declaration: Internal generic functions
fpos-column: Exported functions
fpos-file-name: Internal functions
fpos-line: Exported functions
fpos-token: Internal functions
Function, (setf fpos-column): Exported functions
Function, (setf fpos-file-name): Internal functions
Function, (setf fpos-line): Exported functions
Function, (setf fpos-token): Internal functions
Function, add-new-declaration: Internal functions
Function, add-presence-into-fslist: Internal functions
Function, anonymous-declaration-p: Exported functions
Function, complete-declarations: Exported functions
Function, convert-array-dimensions: Internal functions
Function, convert-compound-to-c-syntax: Internal functions
Function, convert-constant-expression: Internal functions
Function, copy-file-offset: Internal functions
Function, copy-lexer-position: Internal functions
Function, create-db-ffi: Exported functions
Function, create-gtk-ffi: Exported functions
Function, create-ncurses-ffi: Exported functions
Function, create-xlib-ffi: Exported functions
Function, create-zlib-ffi: Exported functions
Function, digit-value: Internal functions
Function, explain: Exported functions
Function, extract-constants: Internal functions
Function, extract-from-headers: Exported functions
Function, file-offset-p: Internal functions
Function, fpos-column: Exported functions
Function, fpos-file-name: Internal functions
Function, fpos-line: Exported functions
Function, fpos-token: Internal functions
Function, gather-all-requested-declarations: Internal functions
Function, get-all-c-constants: Exported functions
Function, get-all-c-functions: Exported functions
Function, get-all-c-structs: Exported functions
Function, get-all-c-typedefs: Exported functions
Function, get-all-c-variables: Exported functions
Function, get-rid-of-optional-ul: Internal functions
Function, hash-table-values-list: Internal functions
Function, lexer-position-p: Internal functions
Function, make-file-offset: Internal functions
Function, make-lexer-position: Internal functions
Function, make-parsable-file: Internal functions
Function, make-parsable-stream: Exported functions
Function, make-presence-table: Internal functions
Function, member-of-fslist: Internal functions
Function, open-stateful-stream: Exported functions
Function, populate-grammar: Internal functions
Function, populate-namespace: Exported functions
Function, primitive-type-p: Exported functions
Function, push-into-fslist: Internal functions
Function, read-character-sequence: Internal functions
Function, read-dots: Internal functions
Function, read-escape-sequence: Internal functions
Function, read-integer-from-string: Internal functions
Function, read-integer-number: Internal functions
Function, read-number: Internal functions
Function, read-pound-line: Internal functions
Function, read-string: Internal functions
Function, read-word: Internal functions
Function, sbcl-format-compound: Internal functions
Function, scan-file: Exported functions
Function, skip-block: Exported functions
Function, skip-to-eol: Internal functions
Function, skip-whitespace: Internal functions
Function, typify-names: Internal functions
Function, uffi-format-compound: Internal functions
Function, word-component-p: Internal functions
Function, word-start-p: Internal functions
Function, write-c-source-for-compilation: Internal functions
Function, write-c-source-for-parser: Internal functions
Function, write-declarations: Exported functions
Function, write-package: Exported functions

G
gather-all-requested-declarations: Internal functions
Generic Function, (setf backend-define-package): Exported generic functions
Generic Function, (setf backend-library): Internal generic functions
Generic Function, (setf backend-package): Exported generic functions
Generic Function, (setf backend-prefix): Internal generic functions
Generic Function, (setf c-alternate-name): Exported generic functions
Generic Function, (setf c-arguments): Exported generic functions
Generic Function, (setf c-bits): Exported generic functions
Generic Function, (setf c-constants): Exported generic functions
Generic Function, (setf c-dimensions): Exported generic functions
Generic Function, (setf c-documentation): Exported generic functions
Generic Function, (setf c-library): Exported generic functions
Generic Function, (setf c-name): Exported generic functions
Generic Function, (setf c-ref-name): Exported generic functions
Generic Function, (setf c-required): Exported generic functions
Generic Function, (setf c-slots): Exported generic functions
Generic Function, (setf c-type): Exported generic functions
Generic Function, (setf c-value): Exported generic functions
Generic Function, (setf comp-error-declaration): Internal generic functions
Generic Function, (setf find-c-constant): Exported generic functions
Generic Function, (setf find-c-enum): Exported generic functions
Generic Function, (setf find-c-function): Exported generic functions
Generic Function, (setf find-c-struct): Exported generic functions
Generic Function, (setf find-c-typedef): Exported generic functions
Generic Function, (setf find-c-union): Exported generic functions
Generic Function, (setf find-c-variable): Exported generic functions
Generic Function, (setf find-declaration): Internal generic functions
Generic Function, add-declaration: Exported generic functions
Generic Function, backend-define-package: Exported generic functions
Generic Function, backend-library: Internal generic functions
Generic Function, backend-package: Exported generic functions
Generic Function, backend-prefix: Internal generic functions
Generic Function, c-alternate-name: Exported generic functions
Generic Function, c-arguments: Exported generic functions
Generic Function, c-bits: Exported generic functions
Generic Function, c-constants: Exported generic functions
Generic Function, c-dimensions: Exported generic functions
Generic Function, c-documentation: Exported generic functions
Generic Function, c-expression: Internal generic functions
Generic Function, c-functions: Internal generic functions
Generic Function, c-library: Exported generic functions
Generic Function, c-name: Exported generic functions
Generic Function, c-object->ffi-notation: Exported generic functions
Generic Function, c-object-lisp-name: Exported generic functions
Generic Function, c-ref-name: Exported generic functions
Generic Function, c-required: Exported generic functions
Generic Function, c-slots: Exported generic functions
Generic Function, c-structs: Internal generic functions
Generic Function, c-type: Exported generic functions
Generic Function, c-typedefs: Internal generic functions
Generic Function, c-value: Exported generic functions
Generic Function, c-variables: Internal generic functions
Generic Function, check-reference: Internal generic functions
Generic Function, collect-declarations: Internal generic functions
Generic Function, comp-error-declaration: Internal generic functions
Generic Function, comp-error-item: Internal generic functions
Generic Function, convert-to-c-syntax: Internal generic functions
Generic Function, explain-c-object: Internal generic functions
Generic Function, extract: Exported generic functions
Generic Function, ffi-sizeof: Internal generic functions
Generic Function, find-c-constant: Exported generic functions
Generic Function, find-c-enum: Exported generic functions
Generic Function, find-c-function: Exported generic functions
Generic Function, find-c-struct: Exported generic functions
Generic Function, find-c-typedef: Exported generic functions
Generic Function, find-c-union: Exported generic functions
Generic Function, find-c-variable: Exported generic functions
Generic Function, find-declaration: Internal generic functions
Generic Function, get-list: Internal generic functions
Generic Function, get-position: Exported generic functions
Generic Function, make-c-reference: Exported generic functions
Generic Function, make-ffi: Exported generic functions
Generic Function, make-sure-referred-types-exist: Internal generic functions
Generic Function, ss-bol: Exported generic functions
Generic Function, ss-column: Exported generic functions
Generic Function, ss-line: Exported generic functions
Generic Function, substitute-declarations-with-references: Internal generic functions
Generic Function, transform-to-reference: Internal generic functions
Generic Function, unalias-reference: Internal generic functions
Generic Function, use-packages: Exported generic functions
Generic Function, write-epilogue: Exported generic functions
Generic Function, write-prologue: Exported generic functions
get-all-c-constants: Exported functions
get-all-c-functions: Exported functions
get-all-c-structs: Exported functions
get-all-c-typedefs: Exported functions
get-all-c-variables: Exported functions
get-list: Internal generic functions
get-list: Internal generic functions
get-position: Exported generic functions
get-position: Exported generic functions
get-position: Exported generic functions
get-rid-of-optional-ul: Internal functions

H
hash-table-values-list: Internal functions

L
lexer-position-p: Internal functions

M
Macro, with-open-stateful-stream: Exported macros
Macro, with-parsable-file: Exported macros
make-c-reference: Exported generic functions
make-c-reference: Exported generic functions
make-c-reference: Exported generic functions
make-c-reference: Exported generic functions
make-c-reference: Exported generic functions
make-ffi: Exported generic functions
make-ffi: Exported generic functions
make-ffi: Exported generic functions
make-ffi: Exported generic functions
make-ffi: Exported generic functions
make-file-offset: Internal functions
make-lexer-position: Internal functions
make-parsable-file: Internal functions
make-parsable-stream: Exported functions
make-presence-table: Internal functions
make-sure-referred-types-exist: Internal generic functions
make-sure-referred-types-exist: Internal generic functions
make-sure-referred-types-exist: Internal generic functions
make-sure-referred-types-exist: Internal generic functions
make-sure-referred-types-exist: Internal generic functions
make-sure-referred-types-exist: Internal generic functions
member-of-fslist: Internal functions
Method, (setf backend-define-package): Exported generic functions
Method, (setf backend-library): Internal generic functions
Method, (setf backend-package): Exported generic functions
Method, (setf backend-prefix): Internal generic functions
Method, (setf c-alternate-name): Exported generic functions
Method, (setf c-arguments): Exported generic functions
Method, (setf c-bits): Exported generic functions
Method, (setf c-constants): Exported generic functions
Method, (setf c-dimensions): Exported generic functions
Method, (setf c-documentation): Exported generic functions
Method, (setf c-library): Exported generic functions
Method, (setf c-name): Exported generic functions
Method, (setf c-ref-name): Exported generic functions
Method, (setf c-required): Exported generic functions
Method, (setf c-slots): Exported generic functions
Method, (setf c-type): Exported generic functions
Method, (setf c-value): Exported generic functions
Method, (setf comp-error-declaration): Internal generic functions
Method, (setf find-c-constant): Exported generic functions
Method, (setf find-c-enum): Exported generic functions
Method, (setf find-c-function): Exported generic functions
Method, (setf find-c-struct): Exported generic functions
Method, (setf find-c-typedef): Exported generic functions
Method, (setf find-c-union): Exported generic functions
Method, (setf find-c-variable): Exported generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, (setf find-declaration): Internal generic functions
Method, add-declaration: Exported generic functions
Method, add-declaration: Exported generic functions
Method, add-declaration: Exported generic functions
Method, backend-define-package: Exported generic functions
Method, backend-library: Internal generic functions
Method, backend-package: Exported generic functions
Method, backend-prefix: Internal generic functions
Method, c-alternate-name: Exported generic functions
Method, c-arguments: Exported generic functions
Method, c-bits: Exported generic functions
Method, c-constants: Exported generic functions
Method, c-constants: Exported generic functions
Method, c-dimensions: Exported generic functions
Method, c-documentation: Exported generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-expression: Internal generic functions
Method, c-functions: Internal generic functions
Method, c-library: Exported generic functions
Method, c-name: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object->ffi-notation: Exported generic functions
Method, c-object-lisp-name: Exported generic functions
Method, c-object-lisp-name: Exported generic functions
Method, c-object-lisp-name: Exported generic functions
Method, c-ref-name: Exported generic functions
Method, c-required: Exported generic functions
Method, c-slots: Exported generic functions
Method, c-structs: Internal generic functions
Method, c-type: Exported generic functions
Method, c-typedefs: Internal generic functions
Method, c-value: Exported generic functions
Method, c-variables: Internal generic functions
Method, check-reference: Internal generic functions
Method, check-reference: Internal generic functions
Method, check-reference: Internal generic functions
Method, check-reference: Internal generic functions
Method, check-reference: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, collect-declarations: Internal generic functions
Method, comp-error-declaration: Internal generic functions
Method, comp-error-item: Internal generic functions
Method, convert-to-c-syntax: Internal generic functions
Method, convert-to-c-syntax: Internal generic functions
Method, convert-to-c-syntax: Internal generic functions
Method, convert-to-c-syntax: Internal generic functions
Method, convert-to-c-syntax: Internal generic functions
Method, convert-to-c-syntax: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, explain-c-object: Internal generic functions
Method, extract: Exported generic functions
Method, extract: Exported generic functions
Method, extract: Exported generic functions
Method, ffi-sizeof: Internal generic functions
Method, ffi-sizeof: Internal generic functions
Method, find-c-constant: Exported generic functions
Method, find-c-enum: Exported generic functions
Method, find-c-function: Exported generic functions
Method, find-c-struct: Exported generic functions
Method, find-c-typedef: Exported generic functions
Method, find-c-union: Exported generic functions
Method, find-c-variable: Exported generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, find-declaration: Internal generic functions
Method, get-list: Internal generic functions
Method, get-position: Exported generic functions
Method, get-position: Exported generic functions
Method, make-c-reference: Exported generic functions
Method, make-c-reference: Exported generic functions
Method, make-c-reference: Exported generic functions
Method, make-c-reference: Exported generic functions
Method, make-ffi: Exported generic functions
Method, make-ffi: Exported generic functions
Method, make-ffi: Exported generic functions
Method, make-ffi: Exported generic functions
Method, make-sure-referred-types-exist: Internal generic functions
Method, make-sure-referred-types-exist: Internal generic functions
Method, make-sure-referred-types-exist: Internal generic functions
Method, make-sure-referred-types-exist: Internal generic functions
Method, make-sure-referred-types-exist: Internal generic functions
Method, ss-bol: Exported generic functions
Method, ss-column: Exported generic functions
Method, ss-line: Exported generic functions
Method, substitute-declarations-with-references: Internal generic functions
Method, substitute-declarations-with-references: Internal generic functions
Method, substitute-declarations-with-references: Internal generic functions
Method, transform-to-reference: Internal generic functions
Method, transform-to-reference: Internal generic functions
Method, transform-to-reference: Internal generic functions
Method, unalias-reference: Internal generic functions
Method, unalias-reference: Internal generic functions
Method, use-packages: Exported generic functions
Method, use-packages: Exported generic functions
Method, use-packages: Exported generic functions
Method, write-epilogue: Exported generic functions
Method, write-prologue: Exported generic functions

O
open-stateful-stream: Exported functions

P
populate-grammar: Internal functions
populate-namespace: Exported functions
primitive-type-p: Exported functions
push-into-fslist: Internal functions

R
read-character-sequence: Internal functions
read-dots: Internal functions
read-escape-sequence: Internal functions
read-integer-from-string: Internal functions
read-integer-number: Internal functions
read-number: Internal functions
read-pound-line: Internal functions
read-string: Internal functions
read-word: Internal functions

S
sbcl-format-compound: Internal functions
scan-file: Exported functions
skip-block: Exported functions
skip-to-eol: Internal functions
skip-whitespace: Internal functions
ss-bol: Exported generic functions
ss-bol: Exported generic functions
ss-column: Exported generic functions
ss-column: Exported generic functions
ss-line: Exported generic functions
ss-line: Exported generic functions
substitute-declarations-with-references: Internal generic functions
substitute-declarations-with-references: Internal generic functions
substitute-declarations-with-references: Internal generic functions
substitute-declarations-with-references: Internal generic functions

T
transform-to-reference: Internal generic functions
transform-to-reference: Internal generic functions
transform-to-reference: Internal generic functions
transform-to-reference: Internal generic functions
typify-names: Internal functions

U
uffi-format-compound: Internal functions
unalias-reference: Internal generic functions
unalias-reference: Internal generic functions
unalias-reference: Internal generic functions
use-packages: Exported generic functions
use-packages: Exported generic functions
use-packages: Exported generic functions
use-packages: Exported generic functions

W
with-open-stateful-stream: Exported macros
with-parsable-file: Exported macros
word-component-p: Internal functions
word-start-p: Internal functions
write-c-source-for-compilation: Internal functions
write-c-source-for-parser: Internal functions
write-declarations: Exported functions
write-epilogue: Exported generic functions
write-epilogue: Exported generic functions
write-package: Exported functions
write-prologue: Exported generic functions
write-prologue: Exported generic functions

Jump to:   (  
A   B   C   D   E   F   G   H   L   M   O   P   R   S   T   U   W  

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

A.3 Variables

Jump to:   *   +  
A   B   C   D   F   G   I   L   N   P   R   S   T   V  
Index Entry  Section

*
*backend*: Exported special variables
*binge-base-directory*: Internal special variables
*c-compiler*: Exported special variables
*c-preprocessor*: Exported special variables
*compress-types*: Exported special variables
*db-ffi-c-constants*: Internal special variables
*extract-constants-with-cc*: Internal special variables
*gcc-builtin-va_list*: Exported special variables
*gcc-null-defines*: Exported special variables
*gtk-ffi-c-constants*: Internal special variables
*ncurses-ffi-c-constants*: Internal special variables
*xlib-ffi-c-constants*: Internal special variables
*zlib-ffi-c-constants*: Internal special variables

+
+word-component-table+: Internal special variables
+word-start-table+: Internal special variables

A
alternate-name: Exported classes
arguments: Exported classes

B
bits: Exported classes
bol: Exported classes

C
column: Exported structures
column: Exported classes
constants: Exported classes
constants: Exported classes

D
declaration: Internal conditions
define-grammar: Exported special variables
define-package: Exported classes
dimensions: Exported classes
documentation: Exported classes

F
file-name: Internal structures
file-name: Internal classes
functions: Exported classes

G
grammar: Internal classes

I
item: Exported conditions

L
library: Exported classes
library: Exported classes
line: Exported structures
line: Exported classes
list: Internal classes

N
name: Exported classes

P
package: Exported classes
prefix: Exported classes

R
real-stream: Exported classes
ref-name: Exported classes
required: Exported classes

S
Slot, alternate-name: Exported classes
Slot, arguments: Exported classes
Slot, bits: Exported classes
Slot, bol: Exported classes
Slot, column: Exported structures
Slot, column: Exported classes
Slot, constants: Exported classes
Slot, constants: Exported classes
Slot, declaration: Internal conditions
Slot, define-package: Exported classes
Slot, dimensions: Exported classes
Slot, documentation: Exported classes
Slot, file-name: Internal structures
Slot, file-name: Internal classes
Slot, functions: Exported classes
Slot, grammar: Internal classes
Slot, item: Exported conditions
Slot, library: Exported classes
Slot, library: Exported classes
Slot, line: Exported structures
Slot, line: Exported classes
Slot, list: Internal classes
Slot, name: Exported classes
Slot, package: Exported classes
Slot, prefix: Exported classes
Slot, real-stream: Exported classes
Slot, ref-name: Exported classes
Slot, required: Exported classes
Slot, slots: Exported classes
Slot, structs: Exported classes
Slot, table: Internal classes
Slot, token: Internal structures
Slot, token: Internal classes
Slot, type: Exported classes
Slot, typedefs: Exported classes
Slot, value: Exported classes
Slot, variables: Exported classes
slots: Exported classes
Special Variable, *backend*: Exported special variables
Special Variable, *binge-base-directory*: Internal special variables
Special Variable, *c-compiler*: Exported special variables
Special Variable, *c-preprocessor*: Exported special variables
Special Variable, *compress-types*: Exported special variables
Special Variable, *db-ffi-c-constants*: Internal special variables
Special Variable, *extract-constants-with-cc*: Internal special variables
Special Variable, *gcc-builtin-va_list*: Exported special variables
Special Variable, *gcc-null-defines*: Exported special variables
Special Variable, *gtk-ffi-c-constants*: Internal special variables
Special Variable, *ncurses-ffi-c-constants*: Internal special variables
Special Variable, *xlib-ffi-c-constants*: Internal special variables
Special Variable, *zlib-ffi-c-constants*: Internal special variables
Special Variable, +word-component-table+: Internal special variables
Special Variable, +word-start-table+: Internal special variables
Special Variable, define-grammar: Exported special variables
structs: Exported classes

T
table: Internal classes
token: Internal structures
token: Internal classes
type: Exported classes
typedefs: Exported classes

V
value: Exported classes
variables: Exported classes

Jump to:   *   +  
A   B   C   D   F   G   I   L   N   P   R   S   T   V  

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

A.4 Data types

Jump to:   B   C   F   I   L   P   S   U  
Index Entry  Section

B
backend: Exported classes
binge: The binge system
binge: The binge package
binge-backend: The binge-backend package
binge-compiler: The binge-compiler package
binge-decl: The binge-decl package
binge-examples: The binge-examples package
binge-grammar: The binge-grammar package
binge-lexer: The binge-lexer package
binge-parser: The binge-parser package
binge-ss: The binge-ss package
binge-system: The binge-system package

C
c-argument: Exported classes
c-array: Exported classes
c-bitfield: Exported classes
c-constant-declaration: Exported classes
c-container: Exported classes
c-declaration: Exported classes
c-enum-declaration: Exported classes
c-enum-ref: Exported classes
c-function: Exported classes
c-function-declaration: Exported classes
c-named-object: Exported classes
c-namespace: Exported classes
c-object: Exported classes
c-pointer: Exported classes
c-slot: Exported classes
c-struct-declaration: Exported classes
c-struct-ref: Exported classes
c-type: Exported classes
c-type-ref: Exported classes
c-typed-name: Exported classes
c-typed-object: Exported classes
c-typedef-declaration: Exported classes
c-union-declaration: Exported classes
c-union-ref: Exported classes
c-user-type-ref: Exported classes
c-variable-declaration: Exported classes
Class, backend: Exported classes
Class, c-argument: Exported classes
Class, c-array: Exported classes
Class, c-bitfield: Exported classes
Class, c-constant-declaration: Exported classes
Class, c-container: Exported classes
Class, c-declaration: Exported classes
Class, c-enum-declaration: Exported classes
Class, c-enum-ref: Exported classes
Class, c-function: Exported classes
Class, c-function-declaration: Exported classes
Class, c-named-object: Exported classes
Class, c-namespace: Exported classes
Class, c-object: Exported classes
Class, c-pointer: Exported classes
Class, c-slot: Exported classes
Class, c-struct-declaration: Exported classes
Class, c-struct-ref: Exported classes
Class, c-type: Exported classes
Class, c-type-ref: Exported classes
Class, c-typed-name: Exported classes
Class, c-typed-object: Exported classes
Class, c-typedef-declaration: Exported classes
Class, c-union-declaration: Exported classes
Class, c-union-ref: Exported classes
Class, c-user-type-ref: Exported classes
Class, c-variable-declaration: Exported classes
Class, fast-searchable-list: Internal classes
Class, inactive-file: Internal classes
Class, parsable-stream: Internal classes
Class, sbcl-backend: Exported classes
Class, stateful-stream: Exported classes
Class, uffi-backend: Exported classes
compilation-error: Internal conditions
compilation-unsupported-error: Exported conditions
Condition, compilation-error: Internal conditions
Condition, compilation-unsupported-error: Exported conditions

F
fast-searchable-list: Internal classes
file-offset: Exported structures

I
inactive-file: Internal classes

L
lexer-position: Internal structures

P
Package, binge: The binge package
Package, binge-backend: The binge-backend package
Package, binge-compiler: The binge-compiler package
Package, binge-decl: The binge-decl package
Package, binge-examples: The binge-examples package
Package, binge-grammar: The binge-grammar package
Package, binge-lexer: The binge-lexer package
Package, binge-parser: The binge-parser package
Package, binge-ss: The binge-ss package
Package, binge-system: The binge-system package
parsable-stream: Internal classes

S
sbcl-backend: Exported classes
stateful-stream: Exported classes
Structure, file-offset: Exported structures
Structure, lexer-position: Internal structures
System, binge: The binge system

U
uffi-backend: Exported classes

Jump to:   B   C   F   I   L   P   S   U