The bitfield Reference Manual

Table of Contents

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

The bitfield Reference Manual

This is the bitfield Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 14:12:17 2021 GMT+0.


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

1 Introduction

#+TITLE: Bitfield

* How It Works

The =bitfield= library provides a simple, efficient mechanism for storing
multiple discrete states into a single non-negative integer.  Its main API
is the macro =define-bitfield= that defines a certain kind of bitfield
consisting of a constructor, a function for creating modified clones, and
one reader function for each slot.

The following example illustrates these features for the case of defining
cards from a standard 52 card deck:

#+BEGIN_SRC lisp
(define-bitfield card
  (suit (member clubs diamonds hearts spades))
  (rank (member ace 2 3 4 5 6 7 8 9 10 jack queen king)))

(defparameter *card* (make-card :rank 'ace :suit 'spades))

(values
 ,*card*
 (card-suit *card*)
 (card-rank *card*))
;; => 3
;; => spades
;; => ace

(defparameter *card* (clone-card *card* :rank 'queen))

(values
 ,*card*
 (card-suit *card*)
 (card-rank *card*))
;; => 91
;; => spades
;; => queen
#+END_SRC

* Kinds of Bitfield Slots

Each bitfield slot is described by a list whose first element is the slot
name and whose second element is a slot specifier.  The remaining entries
form a plist that may supply additional keyword arguments.  The bitfield
slot specifier is then parsed using an extensible protocol to obtain a
bitfield slot class, the number of distinct states of that slot, and a
(possibly empty) plist of additional keyword arguments.  These properties
are then used to create a bitfield slot instance.  In the end, the
properties of the bitfield slot instances of all slots constitute the
behavior of the resulting bitfield.

The different kinds of bitfield slots are illustrated in this second
example:

#+BEGIN_SRC lisp
(define-bitfield examplebits
  (a boolean)
  (b (signed-byte 2))
  (c (unsigned-byte 3) :initform 1)
  (d (integer -100 100))
  (e (member foo bar baz)))

(defun examplebits-values (examplebits)
  (list
   (examplebits-a examplebits)
   (examplebits-b examplebits)
   (examplebits-c examplebits)
   (examplebits-d examplebits)
   (examplebits-e examplebits)))

(defparameter *default* (make-examplebits))

(examplebits-values *default*)
;; => (nil 0 1 -100 foo)

(defparameter *explicit* (make-examplebits :a t :b -1 :c 7 :d 42 :e 'baz))

(examplebits-values *explicit*)
;; => (t -1 7 42 baz)

(defparameter *clone* (clone-examplebits *explicit* :a nil :b -1 :c 2 :d -12 :e 'bar))

(examplebits-values *clone*)
;; => (nil -1 2 -12 bar)
#+END_SRC

This library comes equipped with parsers for =boolean=, =bit=,
=(unsigned-byte N)=, =(signed-byte N)=, =(integer A B)=, and =(member OBJ1
... OBJN)= slot specifiers.  New kinds of slots and slot specifiers can be
defined by extending the existing protocol functions, as shown in the next
section.

* Custom Bitfield Slots

In the next example, we show how the protocol can be augmented by
introducing both a bitfield slot class and the corresponding atomic
bitfield slot specifier parser for an =ascii= slot.

#+BEGIN_SRC lisp
(defclass bitfield-ascii-slot (bitfield-slot)
  ())

(defmethod bitfield-slot-pack ((slot bitfield-ascii-slot) value-form)
  `(char-code ,value-form))

(defmethod bitfield-slot-unpack ((slot bitfield-ascii-slot) value-form)
  `(code-char ,value-form))

(defmethod parse-atomic-bitfield-slot-specifier
    ((specifier (eql 'ascii)) &key (initform #\?))
  (values 'bitfield-ascii-slot
          128
          `(:initform ,initform)))

(define-bitfield four-letter-word
  (first-letter ascii)
  (second-letter ascii)
  (third-letter ascii)
  (fourth-letter ascii))

(defun four-letter-word-string (four-letter-word)
  (format nil "~C~C~C~C"
          (four-letter-word-first-letter four-letter-word)
          (four-letter-word-second-letter four-letter-word)
          (four-letter-word-third-letter four-letter-word)
          (four-letter-word-fourth-letter four-letter-word)))

(four-letter-word-string
 (make-four-letter-word))
;; => "????"

(four-letter-word-string
 (make-four-letter-word
  :fourth-letter #\n
  :second-letter #\v
  :first-letter #\o
  :third-letter #\e))
;; => "oven"
#+END_SRC

* Performance

Bitfields are defined or redefined exclusively via keyword arguments.
Thanks to inlining, this doesn't affect performance at all.  In this
example, we inspect the assembler code that is generated for manipulations
of a particular bitfield.  The examples are shown for SBCL.

#+BEGIN_SRC lisp
(define-bitfield hero
  (dex (integer 1 24))
  (str (integer 1 24))
  (int (integer 1 24)))
#+END_SRC

Firstly, we look at the code that is generated for a bitfield whose
arguments are constant:

#+BEGIN_SRC lisp
(defun make-archmage ()
  (make-hero :dex 10 :str 8 :int 24))

(disassemble #'make-archmage)
; disassembly for make-archmage
; Size: 21 bytes. Origin: #x52E2147C                          ; make-archmage
; 7C:       498B4510         mov RAX, [R13+16]                ; thread.binding-stack-pointer
; 80:       488945F8         mov [RBP-8], RAX
; 84:       BAD2B90000       mov EDX, 47570
; 89:       488BE5           mov RSP, RBP
; 8C:       F8               clc
; 8D:       5D               pop RBP
; 8E:       C3               ret
; 8F:       CC10             int3 16                          ; Invalid argument count trap

#+END_SRC

We see that the entire constructor has been folded into a single constant,
47570, which is the value of an Archmage shifted left by one bit.  The
shift is due to SBCL's internal representation of fixnums.

A more interesting example is when we consider constructors where not all
arguments are constant.  Here, we define a constructor for a wizard where
we supply the =int= attribute as an argument:

#+BEGIN_SRC lisp
(defun make-wizard (int)
  (make-hero :dex 10 :str 8 :int int))

(disassemble #'make-wizard)
; disassembly for make-wizard
; Size: 53 bytes. Origin: #x52E21510                          ; make-wizard
; 10:       498B5D10         mov RBX, [R13+16]                ; thread.binding-stack-pointer
; 14:       48895DF8         mov [RBP-8], RBX
; 18:       4885C0           test RAX, RAX
; 1B:       7422             jeq L0
; 1D:       A801             test AL, 1
; 1F:       751E             jne L0
; 21:       4883F830         cmp RAX, 48
; 25:       7718             jnbe L0
; 27:       488BD0           mov RDX, RAX
; 2A:       4883C2FE         add RDX, -2
; 2E:       48C1E20A         shl RDX, 10
; 32:       4881CAD2010000   or RDX, 466
; 39:       488BE5           mov RSP, RBP
; 3C:       F8               clc
; 3D:       5D               pop RBP
; 3E:       C3               ret
; 3F: L0:   CC1E             int3 30                          ; OBJECT-NOT-TYPE-ERROR
; 41:       00               byte #X00                        ; RAX
; 42:       23               byte #X23                        ; '(integer 1 24)
; 43:       CC10             int3 16                          ; Invalid argument count trap
#+END_SRC

The generated assembler code is slightly more complicated, but most of this
is about checking that the =int= argument is actually a positive integer
that is at most 24.  If we strip the argument checking code, we end up with

#+BEGIN_SRC lisp
; 27:       488BD0           mov RDX, RAX
; 2A:       4883C2FE         add RDX, -2
; 2E:       48C1E20A         shl RDX, 10
; 32:       4881CAD2010000   or RDX, 466
; 39:       488BE5           mov RSP, RBP
; 3C:       F8               clc
; 3D:       5D               pop RBP
; 3E:       C3               ret
#+END_SRC

We see that adding one variable argument to a bitfield constructor only
costs one =add= instruction and one =shl= (left-shift) instruction.

The next example is about cloning bitfields.  The next function takes a
hero and returns a copy of that hero but with a slightly higher =str=
attribute.

#+BEGIN_SRC lisp
(defun go-to-gym (hero)
  (clone-hero hero :str (1+ (hero-str hero))))
#+END_SRC

If we disable argument checking (e.g., by declaring =(safety 0)=) we end up
with the following sequence of instructions for our =go-to-gym= function:

#+BEGIN_SRC lisp
; 12:       8BD8             mov EBX, EAX
; 14:       C1EB05           shr EBX, 5
; 17:       83E33E           and EBX, 62
; 1A:       4883C302         add RBX, 2
; 1E:       4883C302         add RBX, 2
; 22:       488BD0           mov RDX, RAX
; 25:       8BF2             mov ESI, EDX
; 27:       83E63E           and ESI, 62
; 2A:       4883C602         add RSI, 2
; 2E:       488BCA           mov RCX, RDX
; 31:       48C1F90A         sar RCX, 10
; 35:       4883E1FE         and RCX, -2
; 39:       4883C102         add RCX, 2
; 3D:       488D56FE         lea RDX, [RSI-2]
; 41:       4883C3FE         add RBX, -2
; 45:       48C1E305         shl RBX, 5
; 49:       4809DA           or RDX, RBX
; 4C:       4883C1FE         add RCX, -2
; 50:       48C1E10A         shl RCX, 10
; 54:       4809CA           or RDX, RCX
; 57:       488BE5           mov RSP, RBP
; 5A:       F8               clc
; 5B:       5D               pop RBP
; 5C:       C3               ret
#+END_SRC

We count one =shr= instruction, two =shl= instructions, six =add=
instructions and two =or= instructions.  Not bad for parsing three keyword
arguments with complicated values.  With argument checking, the code grows
further by two conditional branches per argument.  But with the branch
prediction of a modern CPU, those branches will be almost for free.

* Conclusion

I wrote this library because I am tired of manually fiddling with bits just
to save memory.  Now I can finally pack plenty of information into a single
machine word without worrying about correctness.  I hope you find this
useful, too.


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 bitfield

Author

Marco Heisig <marco.heisig@fau.de>

License

MIT

Description

Efficiently represent several finite sets or small integers as a single non-negative integer.

Source

bitfield.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 bitfield.asd

Location

bitfield.asd

Systems

bitfield (system)


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

3.1.2 bitfield/packages.lisp

Parent

bitfield (system)

Location

packages.lisp

Packages

bitfield


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

3.1.3 bitfield/bitfield.lisp

Dependency

packages.lisp (file)

Parent

bitfield (system)

Location

bitfield.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 bitfield

Source

packages.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: define-bitfield NAME &body SLOTS

Defines an encoding of enumerable properties like booleans,
integers or finite sets as a single non-negative integer.

For a supplied bitfield name NAME, and for some slot definitions of the
form (SLOT-NAME TYPE &KEY INITFORM &ALLOW-OTHER-KEYS), this macro defines
the following functions:

1. A constructor named MAKE-{NAME}, that takes one keyword argument per
SLOT-NAME, similar to the default constructor generated by DEFSTRUCT.
It returns a bitfield whose entries have the values indicated by the
keyword arguments, or the supplied initform.

2. A clone operation named CLONE-{NAME}, that takes an existing bitfield
and one keyword argument per SLOT-NAME. It returns a copy of the
existing bitfield, but where each supplied keyword argument supersedes
the value of the corresponding slot.

3. A reader function named {NAME}-{SLOT-NAME} for each slot.

In addition to these functions, NAME is defined as a suitable subtype of UNSIGNED-BYTE.

This macro supports boolean, integer, and member slots. It is also
possible to add new kinds of slots by defining new subclasses of
BITFIELD-SLOT and the corresponding methods on BITFIELD-SLOT-PACK, BITFIELD-SLOT-UNPACK and PARSE-ATOMIC-BITFIELD-SLOT-SPECIFIER or PARSE-COMPOUND-BITFIELD-SLOT-SPECIFIER.

Example:

(define-bitfield examplebits
(a boolean)
(b (signed-byte 2))
(c (unsigned-byte 3) :initform 1)
(d (integer -100 100))
(e (member foo bar baz)))

(defun examplebits-values (examplebits)
(list
(examplebits-a examplebits)
(examplebits-b examplebits)
(examplebits-c examplebits)
(examplebits-d examplebits)
(examplebits-e examplebits)))

(defparameter *default* (make-examplebits))

(examplebits-values *default*)
;; => (nil 0 1 -100 foo)

(defparameter *explicit* (make-examplebits :a t :b -1 :c 7 :d 42 :e ’baz))

(examplebits-values *explicit*)
;; => (t -1 7 42 baz)

(defparameter *clone* (clone-examplebits *explicit* :a nil :b -1 :c 2 :d -12 :e ’bar))

(examplebits-values *clone*)
;; => (nil -1 2 -12 bar)

Package

bitfield

Source

bitfield.lisp (file)


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

5.1.2 Generic functions

Generic Function: bitfield-slot-end BITFIELD-SLOT

Returns the position right after the last bit of this slot in the bitfield.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-end (BITFIELD-SLOT bitfield-slot)

automatically generated reader method

Generic Function: bitfield-slot-initform BITFIELD-SLOT

Returns a form that produces the initial value for that slot.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-initform (BITFIELD-SLOT bitfield-slot)

automatically generated reader method

Generic Function: bitfield-slot-name BITFIELD-SLOT

Returns a symbol that is the name of the bitfield slot.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-name (BITFIELD-SLOT bitfield-slot)

automatically generated reader method

Generic Function: bitfield-slot-pack BITFIELD-SLOT VALUE-FORM

Takes a form that produces a value and turns it into a form that produces a non-negative integer representing that value.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-pack (SLOT bitfield-member-slot) VALUE-FORM
Method: bitfield-slot-pack (SLOT bitfield-integer-slot) VALUE-FORM
Method: bitfield-slot-pack (SLOT bitfield-boolean-slot) VALUE-FORM
Generic Function: bitfield-slot-size BITFIELD-SLOT

Returns an unsigned byte that is the number of distinct states of the slot.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-size (BITFIELD-SLOT bitfield-slot)

automatically generated reader method

Generic Function: bitfield-slot-start BITFIELD-SLOT

Returns the position of the first bit of this slot in the bitfield.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-start (BITFIELD-SLOT bitfield-slot)

automatically generated reader method

Generic Function: bitfield-slot-unpack BITFIELD-SLOT VALUE-FORM

Take a form that produces a value that is encoded as a non-negative integer (as produced by BITFIELD-SLOT-PACK), and turn it into a form that produces the decoded value.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: bitfield-slot-unpack (SLOT bitfield-member-slot) VALUE-FORM
Method: bitfield-slot-unpack (SLOT bitfield-integer-slot) VALUE-FORM
Method: bitfield-slot-unpack (SLOT bitfield-boolean-slot) VALUE-FORM
Generic Function: parse-atomic-bitfield-slot-specifier SPECIFIER &key INITFORM

Parses an atomic bitfield slot specifier, i.e., a bitfield slot specifier that is not a list. Returns three values:

1. A designator for a bitfield slot class.

2. The size of the bitfield slot.

3. A list of additional arguments that will be supplied to MAKE-INSTANCE when creating the bitfield slot instance.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: parse-atomic-bitfield-slot-specifier (SPECIFIER (eql bit)) &key INITFORM
Method: parse-atomic-bitfield-slot-specifier (SPECIFIER (eql boolean)) &key INITFORM
Generic Function: parse-compound-bitfield-slot-specifier SPECIFIER ARGUMENTS &key INITFORM

Parses a compount bitfield slot specifier, i.e., a bitfield slot specifier that is a list. The SPECIFIER is the CAR of that list and the ARGUMENTS are the CDR of that list. Returns three values:

1. A designator for a bitfield slot class.

2. The size of the bitfield slot.

3. A list of additional arguments that will be supplied to MAKE-INSTANCE when creating the bitfield slot instance.

Package

bitfield

Source

bitfield.lisp (file)

Methods
Method: parse-compound-bitfield-slot-specifier (SPECIFIER (eql member)) OBJECTS &key INITFORM
Method: parse-compound-bitfield-slot-specifier (SPECIFIER (eql integer)) BOUNDS &key INITFORM
Method: parse-compound-bitfield-slot-specifier (SPECIFIER (eql signed-byte)) ARGUMENTS &key INITFORM
Method: parse-compound-bitfield-slot-specifier (SPECIFIER (eql unsigned-byte)) ARGUMENTS &key INITFORM

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

5.1.3 Classes

Class: bitfield-boolean-slot ()
Package

bitfield

Source

bitfield.lisp (file)

Direct superclasses

bitfield-slot (class)

Direct methods
Class: bitfield-integer-slot ()
Package

bitfield

Source

bitfield.lisp (file)

Direct superclasses

bitfield-slot (class)

Direct methods
Direct slots
Slot: %offset
Type

integer

Initargs

:offset

Readers

bitfield-integer-slot-offset (generic function)

Class: bitfield-member-slot ()
Package

bitfield

Source

bitfield.lisp (file)

Direct superclasses

bitfield-slot (class)

Direct methods
Direct slots
Slot: %objects
Type

list

Initargs

:objects

Readers

bitfield-member-slot-objects (generic function)

Class: bitfield-slot ()
Package

bitfield

Source

bitfield.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: %name
Initargs

:name

Readers

bitfield-slot-name (generic function)

Slot: %initform
Initargs

:initform

Readers

bitfield-slot-initform (generic function)

Slot: %start
Initargs

:start

Readers

bitfield-slot-start (generic function)

Slot: %end
Initargs

:end

Readers

bitfield-slot-end (generic function)

Slot: %size
Initargs

:size

Readers

bitfield-slot-size (generic function)


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

5.1.4 Types

Type: bitfield ()

A bitfield is a non-negative integer that efficiently encodes information about some booleans, enumerations, or small integers.

Package

bitfield

Source

bitfield.lisp (file)


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *bitfield-position*
Package

bitfield

Source

bitfield.lisp (file)


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

5.2.2 Functions

Function: parse-bitfield-slot SLOT
Package

bitfield

Source

bitfield.lisp (file)


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

5.2.3 Generic functions

Generic Function: bitfield-integer-slot-offset OBJECT
Package

bitfield

Methods
Method: bitfield-integer-slot-offset (BITFIELD-INTEGER-SLOT bitfield-integer-slot)

automatically generated reader method

Source

bitfield.lisp (file)

Generic Function: bitfield-member-slot-objects OBJECT
Package

bitfield

Methods
Method: bitfield-member-slot-objects (BITFIELD-MEMBER-SLOT bitfield-member-slot)

automatically generated reader method

Source

bitfield.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   B   F   L  
Index Entry  Section

B
bitfield.asd: The bitfield․asd file
bitfield/bitfield.lisp: The bitfield/bitfield․lisp file
bitfield/packages.lisp: The bitfield/packages․lisp file

F
File, Lisp, bitfield.asd: The bitfield․asd file
File, Lisp, bitfield/bitfield.lisp: The bitfield/bitfield․lisp file
File, Lisp, bitfield/packages.lisp: The bitfield/packages․lisp file

L
Lisp File, bitfield.asd: The bitfield․asd file
Lisp File, bitfield/bitfield.lisp: The bitfield/bitfield․lisp file
Lisp File, bitfield/packages.lisp: The bitfield/packages․lisp file

Jump to:   B   F   L  

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

A.2 Functions

Jump to:   B   D   F   G   M   P  
Index Entry  Section

B
bitfield-integer-slot-offset: Internal generic functions
bitfield-integer-slot-offset: Internal generic functions
bitfield-member-slot-objects: Internal generic functions
bitfield-member-slot-objects: Internal generic functions
bitfield-slot-end: Exported generic functions
bitfield-slot-end: Exported generic functions
bitfield-slot-initform: Exported generic functions
bitfield-slot-initform: Exported generic functions
bitfield-slot-name: Exported generic functions
bitfield-slot-name: Exported generic functions
bitfield-slot-pack: Exported generic functions
bitfield-slot-pack: Exported generic functions
bitfield-slot-pack: Exported generic functions
bitfield-slot-pack: Exported generic functions
bitfield-slot-size: Exported generic functions
bitfield-slot-size: Exported generic functions
bitfield-slot-start: Exported generic functions
bitfield-slot-start: Exported generic functions
bitfield-slot-unpack: Exported generic functions
bitfield-slot-unpack: Exported generic functions
bitfield-slot-unpack: Exported generic functions
bitfield-slot-unpack: Exported generic functions

D
define-bitfield: Exported macros

F
Function, parse-bitfield-slot: Internal functions

G
Generic Function, bitfield-integer-slot-offset: Internal generic functions
Generic Function, bitfield-member-slot-objects: Internal generic functions
Generic Function, bitfield-slot-end: Exported generic functions
Generic Function, bitfield-slot-initform: Exported generic functions
Generic Function, bitfield-slot-name: Exported generic functions
Generic Function, bitfield-slot-pack: Exported generic functions
Generic Function, bitfield-slot-size: Exported generic functions
Generic Function, bitfield-slot-start: Exported generic functions
Generic Function, bitfield-slot-unpack: Exported generic functions
Generic Function, parse-atomic-bitfield-slot-specifier: Exported generic functions
Generic Function, parse-compound-bitfield-slot-specifier: Exported generic functions

M
Macro, define-bitfield: Exported macros
Method, bitfield-integer-slot-offset: Internal generic functions
Method, bitfield-member-slot-objects: Internal generic functions
Method, bitfield-slot-end: Exported generic functions
Method, bitfield-slot-initform: Exported generic functions
Method, bitfield-slot-name: Exported generic functions
Method, bitfield-slot-pack: Exported generic functions
Method, bitfield-slot-pack: Exported generic functions
Method, bitfield-slot-pack: Exported generic functions
Method, bitfield-slot-size: Exported generic functions
Method, bitfield-slot-start: Exported generic functions
Method, bitfield-slot-unpack: Exported generic functions
Method, bitfield-slot-unpack: Exported generic functions
Method, bitfield-slot-unpack: Exported generic functions
Method, parse-atomic-bitfield-slot-specifier: Exported generic functions
Method, parse-atomic-bitfield-slot-specifier: Exported generic functions
Method, parse-compound-bitfield-slot-specifier: Exported generic functions
Method, parse-compound-bitfield-slot-specifier: Exported generic functions
Method, parse-compound-bitfield-slot-specifier: Exported generic functions
Method, parse-compound-bitfield-slot-specifier: Exported generic functions

P
parse-atomic-bitfield-slot-specifier: Exported generic functions
parse-atomic-bitfield-slot-specifier: Exported generic functions
parse-atomic-bitfield-slot-specifier: Exported generic functions
parse-bitfield-slot: Internal functions
parse-compound-bitfield-slot-specifier: Exported generic functions
parse-compound-bitfield-slot-specifier: Exported generic functions
parse-compound-bitfield-slot-specifier: Exported generic functions
parse-compound-bitfield-slot-specifier: Exported generic functions
parse-compound-bitfield-slot-specifier: Exported generic functions

Jump to:   B   D   F   G   M   P  

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

A.3 Variables

Jump to:   %   *  
S  
Index Entry  Section

%
%end: Exported classes
%initform: Exported classes
%name: Exported classes
%objects: Exported classes
%offset: Exported classes
%size: Exported classes
%start: Exported classes

*
*bitfield-position*: Internal special variables

S
Slot, %end: Exported classes
Slot, %initform: Exported classes
Slot, %name: Exported classes
Slot, %objects: Exported classes
Slot, %offset: Exported classes
Slot, %size: Exported classes
Slot, %start: Exported classes
Special Variable, *bitfield-position*: Internal special variables

Jump to:   %   *  
S  

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

A.4 Data types

Jump to:   B   C   P   S   T  
Index Entry  Section

B
bitfield: The bitfield system
bitfield: The bitfield package
bitfield: Exported types
bitfield-boolean-slot: Exported classes
bitfield-integer-slot: Exported classes
bitfield-member-slot: Exported classes
bitfield-slot: Exported classes

C
Class, bitfield-boolean-slot: Exported classes
Class, bitfield-integer-slot: Exported classes
Class, bitfield-member-slot: Exported classes
Class, bitfield-slot: Exported classes

P
Package, bitfield: The bitfield package

S
System, bitfield: The bitfield system

T
Type, bitfield: Exported types

Jump to:   B   C   P   S   T