test/test.sod: New file containing miscellaneous tests.

[sod] / doc / SYMBOLS

-----------------------------------------------------------------------------
Package `sod'

builtin.lisp
  *builtin-module*                              variable
  make-builtin-module                           function

c-types-class-impl.lisp
  c-class-type                                  class
  c-type-class                                  generic setf
  cl:class                                      class c-type
  find-class-type                               function
  find-sod-class                                function
  make-class-type                               function
  record-sod-class                              function

c-types-impl.lisp
  cl:*                                          variable function c-type
  cl:array                                      class c-type
  bool                                          c-type
  c-array-dimensions                            generic
  c-array-type                                  class
  c-enum-type                                   class
  c-function-arguments                          generic
  c-function-type                               class
  c-pointer-type                                class
  c-struct-type                                 class
  c-tagged-type-kind                            generic
  c-type-bool                                   variable
  c-type-char                                   variable
  c-type-double                                 variable
  c-type-double-complex                         variable
  c-type-double-imaginary                       variable
  c-type-float                                  variable
  c-type-float-complex                          variable
  c-type-float-imaginary                        variable
  c-type-int                                    variable
  c-type-long                                   variable
  c-type-long-double                            variable
  c-type-long-double-complex                    variable
  c-type-long-double-imaginary                  variable
  c-type-long-long                              variable
  c-type-name                                   generic
  c-type-ptrdiff-t                              variable
  c-type-short                                  variable
  c-type-signed-char                            variable
  c-type-size-t                                 variable
  c-type-tag                                    generic
  c-type-unsigned                               variable
  c-type-unsigned-char                          variable
  c-type-unsigned-long                          variable
  c-type-unsigned-long-long                     variable
  c-type-unsigned-short                         variable
  c-type-va-list                                variable
  c-type-void                                   variable
  c-type-wchar-t                                variable
  c-union-type                                  class
  cl:char                                       function setf c-type parser
  commentify-argument-names                     function
  commentify-function-type                      function
  const-string                                  c-type
  define-simple-c-type                          macro
  double                                        c-type
  double-complex                                c-type
  double-imaginary                              c-type
  enum                                          c-type
  cl:float                                      function class c-type
  float-complex                                 c-type
  float-imaginary                               c-type
  fn                                            c-type
  fun                                           c-type
  func                                          c-type
  cl:function                                   function class c-type
  int                                           c-type
  kind-c-tagged-type                            generic
  llong                                         c-type
  long                                          c-type
  long-double                                   c-type
  long-double-complex                           c-type
  long-double-imaginary                         c-type
  long-int                                      c-type
  long-long                                     c-type
  long-long-int                                 c-type
  make-array-type                               function
  make-c-tagged-type                            function
  make-enum-type                                function
  make-function-type                            function
  make-pointer-type                             function
  make-simple-type                              function
  make-struct-type                              function
  make-union-type                               function
  cl:nil                                        constant c-type parser
  pointer                                       c-type
  ptr                                           c-type
  ptrdiff-t                                     c-type
  cl:schar                                      function setf c-type
  short                                         c-type
  short-int                                     c-type
  signed                                        c-type
  signed-char                                   c-type
  signed-int                                    c-type
  signed-long                                   c-type
  signed-long-int                               c-type
  signed-long-long                              c-type
  signed-long-long-int                          c-type
  signed-short                                  c-type
  signed-short-int                              c-type
  simple-c-type                                 class
  sint                                          c-type
  size-t                                        c-type
  sllong                                        c-type
  slong                                         c-type
  sshort                                        c-type
  cl:string                                     function class c-type opthandler
  struct                                        c-type
  tagged-c-type                                 class
  uchar                                         c-type
  uint                                          c-type
  ullong                                        c-type
  ulong                                         c-type
  cl:union                                      function c-type
  unsigned                                      c-type
  unsigned-char                                 c-type
  unsigned-int                                  c-type
  unsigned-long                                 c-type
  unsigned-long-int                             c-type
  unsigned-long-long                            c-type
  unsigned-long-long-int                        c-type
  unsigned-short                                c-type
  unsigned-short-int                            c-type
  ushort                                        c-type
  va-list                                       c-type
  vec                                           c-type
  void                                          c-type
  wchar-t                                       c-type
  []                                            c-type

c-types-parse.lisp
  parse-c-type                                  function
  parse-declarator                              function

c-types-proto.lisp
  argument                                      class
  argument-name                                 function
  argument-type                                 function
  argumentp                                     function
  c-name-case                                   function
  c-type                                        macro class
  c-type-alias                                  macro
  c-type-equal-p                                generic
  c-type-qualifiers                             generic
  c-type-space                                  function
  c-type-subtype                                generic
  canonify-qualifiers                           function
  commentify-argument-name                      generic
  defctype                                      macro
  define-c-type-syntax                          macro
  expand-c-type-form                            generic
  expand-c-type-spec                            generic
  format-qualifiers                             function
  make-argument                                 function
  maybe-in-parens                               macro
  pprint-c-type                                 generic
  print-c-type                                  generic
  qualifiable-c-type                            class
  qualify-c-type                                generic

class-finalize-impl.lisp
  c3-cpl                                        function
  clos-cpl                                      function
  dylan-cpl                                     function
  flavors-cpl                                   function
  l*loops-cpl                                   function
  python-cpl                                    function

class-finalize-proto.lisp
  check-sod-class                               generic
  compute-chains                                generic
  compute-cpl                                   generic
  finalize-sod-class                            generic

class-layout-impl.lisp
  sod-class-effective-slot                      class
  sod-class-slot                                class
  sod-slot-initializer-function                 generic
  sod-slot-prepare-function                     generic

class-layout-proto.lisp
  base-offset                                   class
  base-offset-chain-head                        generic
  base-offset-class                             generic
  chain-offset                                  class
  chain-offset-chain-head                       generic
  chain-offset-class                            generic
  chain-offset-target-head                      generic
  class-pointer                                 class
  class-pointer-chain-head                      generic
  class-pointer-class                           generic
  class-pointer-meta-chain-head                 generic
  class-pointer-metaclass                       generic
  compute-effective-slot                        generic
  compute-ichain                                generic
  compute-ilayout                               generic
  compute-islots                                generic
  compute-vtable                                generic
  compute-vtable-items                          generic
  compute-vtables                               generic
  compute-vtmsgs                                generic
  effective-slot                                class
  effective-slot-class                          generic
  effective-slot-direct-slot                    generic
  effective-slot-initializer                    generic
  find-slot-initializer                         generic
  ichain                                        class
  ichain-body                                   generic
  ichain-class                                  generic
  ichain-head                                   generic
  ichain-tail                                   generic
  ilayout                                       class
  ilayout-class                                 generic
  ilayout-ichains                               generic
  islots                                        class
  islots-class                                  generic
  islots-slots                                  generic
  islots-subclass                               generic
  make-base-offset                              generic
  make-class-pointer                            generic
  vtable                                        class
  vtable-body                                   generic
  vtable-chain-head                             generic
  vtable-chain-tail                             generic
  vtable-class                                  generic
  vtable-pointer                                class
  vtable-pointer-chain-head                     generic
  vtable-pointer-chain-tail                     generic
  vtable-pointer-class                          generic
  vtmsgs                                        class
  vtmsgs-chain-head                             generic
  vtmsgs-chain-tail                             generic
  vtmsgs-class                                  generic
  vtmsgs-entries                                generic
  vtmsgs-subclass                               generic

class-make-proto.lisp
  check-message-type                            generic
  check-method-type                             generic
  guess-metaclass                               generic
  make-sod-class                                function
  make-sod-class-initializer                    generic
  make-sod-initializer-using-slot               generic
  make-sod-instance-initializer                 generic
  make-sod-message                              generic
  make-sod-method                               generic
  make-sod-method-using-message                 generic
  make-sod-slot                                 generic
  sod-message-method-class                      generic

class-output.lisp
  *instance-class*                              variable

class-utilities.lisp
  argument-lists-compatible-p                   function
  find-class-slot-by-name                       function
  find-instance-slot-by-name                    function
  find-message-by-name                          function
  find-root-metaclass                           function
  find-root-superclass                          function
  find-superclass-by-nick                       function
  ichain-struct-tag                             function
  ichain-union-tag                              function
  ilayout-struct-tag                            function
  islots-struct-tag                             function
  message-macro-name                            function
  sod-subclass-p                                function
  valid-name-p                                  function
  vtable-name                                   function
  vtable-struct-tag                             function
  vtable-union-tag                              function
  vtmsgs-struct-tag                             function

classes.lisp
  sod-class                                     class
  sod-class-chain                               generic
  sod-class-chain-head                          generic
  sod-class-chain-link                          generic
  sod-class-chains                              generic
  sod-class-class-initializers                  generic setf
  sod-class-direct-superclasses                 generic
  sod-class-ilayout                             generic
  sod-class-initializer                         class
  sod-class-instance-initializers               generic setf
  sod-class-messages                            generic setf
  sod-class-metaclass                           generic
  sod-class-methods                             generic setf
  sod-class-name                                generic
  sod-class-nickname                            generic
  sod-class-precedence-list                     generic
  sod-class-slots                               generic setf
  sod-class-state                               generic
  sod-class-type                                generic
  sod-class-vtables                             generic
  sod-initializer                               class
  sod-initializer-class                         generic
  sod-initializer-slot                          generic
  sod-initializer-value-form                    generic
  sod-initializer-value-kind                    generic
  sod-instance-initializer                      class
  sod-message                                   class
  sod-message-class                             generic
  sod-message-name                              generic
  sod-message-type                              generic
  sod-method                                    class
  sod-method-body                               generic
  sod-method-class                              generic
  sod-method-message                            generic
  sod-method-type                               generic
  sod-slot                                      class
  sod-slot-class                                generic
  sod-slot-name                                 generic
  sod-slot-type                                 generic

codegen-impl.lisp
  call-inst                                     class
  codegen                                       class
  do-while-inst                                 class
  if-inst                                       class
  inst-alt                                      generic
  inst-ap                                       generic
  inst-arg                                      generic
  inst-args                                     generic
  inst-body                                     generic
  inst-cond                                     generic
  inst-conseq                                   generic
  inst-from                                     generic
  inst-func                                     generic
  inst-to                                       generic
  make-call-inst                                function
  make-do-while-inst                            function
  make-if-inst                                  function
  make-va-copy-inst                             function
  make-va-end-inst                              function
  make-va-start-inst                            function
  make-while-inst                               function
  temporary-argument                            class
  temporary-function                            function class
  temporary-variable                            class
  va-copy-inst                                  class
  va-end-inst                                   class
  va-start-inst                                 class
  while-inst                                    class

codegen-proto.lisp
  *sod-ap*                                      variable
  *sod-master-ap*                               variable
  block-inst                                    class
  break-inst                                    class
  codegen-add-function                          generic
  codegen-build-function                        function
  codegen-functions                             generic setf
  codegen-pop                                   generic
  codegen-pop-block                             generic
  codegen-pop-function                          generic
  codegen-push                                  generic
  continue-inst                                 class
  convert-stmts                                 function
  definst                                       macro
  deliver-expr                                  function
  emit-decl                                     generic
  emit-decls                                    generic
  emit-inst                                     generic
  emit-insts                                    generic
  ensure-var                                    generic
  expr-inst                                     class
  format-compound-statement                     macro
  format-temporary-name                         generic
  function-inst                                 class
  inst                                          class
  inst-body                                     generic
  inst-decls                                    generic
  inst-expr                                     generic
  inst-init                                     generic
  inst-metric                                   generic
  inst-name                                     generic
  inst-op                                       generic
  inst-type                                     generic
  inst-var                                      generic
  make-block-inst                               function
  make-break-inst                               function
  make-continue-inst                            function
  make-expr-inst                                function
  make-function-inst                            function
  make-return-inst                              function
  make-set-inst                                 function
  make-update-inst                              function
  make-var-inst                                 function
  return-inst                                   class
  set-inst                                      class
  temp-tag                                      generic
  temporary-name                                class
  temporary-var                                 generic
  update-inst                                   class
  var-in-use-p                                  generic setf
  var-inst                                      class
  with-temporary-var                            macro

final.lisp
  *debugout-pathname*                           variable
  *sod-version*                                 variable
  exercise                                      function
  test-module                                   function

fragment-parse.lisp
  parse-delimited-fragment                      function
  scan-c-fragment                               function

lexer-proto.lisp
  define-indicator                              function
  cl:error                                      function class parser
  lexer-error                                   function
  scan-comment                                  function
  skip-until                                    function parser
  sod-token-scanner                             class
  syntax-error                                  function

method-aggregate.lisp
  aggregating-effective-method                  class
  aggregating-message                           class
  aggregating-message-properties                generic
  check-aggregating-message-type                generic
  compute-aggregating-message-kernel            generic
  define-aggregating-method-combination         macro
  sod-message-combination                       generic
  sod-message-kernel-function                   generic

method-impl.lisp
  basic-direct-method                           class
  basic-effective-method                        class
  basic-effective-method-body                   function
  basic-message                                 class
  daemon-direct-method                          class
  delegating-direct-method                      class
  effective-method-after-methods                generic
  effective-method-around-methods               generic
  effective-method-before-methods               generic
  simple-effective-method                       class
  simple-message                                class
  sod-method-role                               generic
  standard-effective-method                     class
  standard-message                              class

method-proto.lisp
  codegen-class                                 generic
  codegen-message                               generic
  codegen-method                                generic
  codegen-target                                generic
  compute-effective-method-body                 generic
  compute-effective-methods                     generic
  compute-method-entry-functions                generic
  compute-sod-effective-method                  generic
  convert-to-ilayout-inst                       class
  effective-method                              class
  effective-method-basic-argument-names         generic
  effective-method-class                        generic
  effective-method-function-name                generic
  effective-method-message                      generic
  ensure-ilayout-var                            function
  inst-chain-head                               generic
  inst-class                                    generic
  inst-expr                                     generic
  invoke-delegation-chain                       function
  invoke-method                                 function
  make-convert-to-ilayout-inst                  function
  make-method-entries                           generic
  make-trampoline                               function
  method-codegen                                class
  method-entry                                  class
  method-entry-chain-head                       generic
  method-entry-chain-tail                       generic
  method-entry-effective-method                 generic
  method-entry-function-name                    generic
  method-entry-function-type                    generic
  method-entry-slot-name                        generic
  primary-method-class                          generic
  simple-method-body                            generic
  sod-message-argument-tail                     generic
  sod-message-effective-method-class            generic
  sod-message-no-varargs-tail                   generic
  sod-method-function-name                      generic
  sod-method-function-type                      generic
  sod-method-next-method-type                   generic
  varargs-message-p                             function

module-impl.lisp
  *module-dirs*                                 variable
  c-fragment                                    class
  c-fragment-text                               generic
  code-fragment                                 generic
  code-fragment-constraints                     generic
  code-fragment-item                            class
  code-fragment-name                            generic
  code-fragment-reason                          generic
  find-file                                     function
  type-item                                     class

module-output.lisp
  banner                                        function
  declare-output-type                           function
  guard-name                                    function
  output-module                                 function
  output-type-pathname                          function

module-parse.lisp
  class-item
  read-module                                   function

module-proto.lisp
  *module*                                      variable
  add-clear-the-decks-function                  function
  add-module-binding                            function
  add-to-module                                 generic
  clear-the-decks                               function
  define-clear-the-decks                        macro
  define-module                                 macro
  define-module-var                             macro
  finalize-module                               generic
  module                                        class
  module-dependencies                           generic setf
  module-import                                 generic
  module-items                                  generic setf
  module-name                                   generic
  module-pset                                   generic
  with-module-environment                       macro
  with-temporary-module                         macro

output-proto.lisp
  add-sequencer-constraint                      generic
  add-sequencer-item-function                   generic
  ensure-sequencer-item                         generic
  hook-output                                   generic
  invoke-sequencer-items                        generic
  make-sequencer-item                           function
  sequence-output                               macro
  sequencer                                     class
  sequencer-constraints                         generic setf
  sequencer-item                                class
  sequencer-item-functions                      function setf
  sequencer-item-name                           function
  sequencer-item-p                              function
  sequencer-table                               generic

pset-parse.lisp
  parse-property-set                            function

pset-proto.lisp
  add-property                                  function
  check-unused-properties                       function
  coerce-property-value                         generic
  decode-property                               generic
  get-property                                  function
  make-property                                 function
  make-property-set                             function
  make-pset                                     function
  p-key                                         function
  p-name                                        function
  p-seenp                                       function setf
  p-type                                        function
  p-value                                       function
  property                                      class
  property-key                                  function
  property-set                                  generic
  propertyp                                     function
  pset                                          class
  pset-get                                      function
  pset-map                                      function
  pset-store                                    function
  psetp                                         function
  store-property                                function
  with-pset-iterator                            macro

Classes:
cl:t
  sb-pcl::slot-object
    cl:standard-object
      base-offset
      sod::basic-codegen
        codegen
          method-codegen
      c-fragment
      c-type
        c-array-type
        c-function-type
        qualifiable-c-type
          c-pointer-type
          simple-c-type
            c-class-type
          tagged-c-type
            c-enum-type
            c-struct-type
            c-union-type
      chain-offset
      class-pointer
      code-fragment-item
      sb-pcl::definition-source-mixin
        cl:class [sb-pcl::dependent-update-mixin sb-pcl::standard-specializer]
      effective-method
        basic-effective-method
          simple-effective-method
            aggregating-effective-method
            standard-effective-method
      effective-slot
        sod-class-effective-slot
      ichain
      ilayout
      inst
        block-inst
        break-inst
        call-inst
        continue-inst
        convert-to-ilayout-inst
        do-while-inst
        expr-inst
        function-inst
        if-inst
        return-inst
        set-inst
        update-inst
        va-copy-inst
        va-end-inst
        va-start-inst
        var-inst
        while-inst
      islots
      sb-mop:metaobject
        sb-mop:specializer
          sb-pcl::standard-specializer
            cl:class [sb-pcl::dependent-update-mixin sb-pcl::definition-source-mixin]
      method-entry
      module
      sb-pcl::plist-mixin
        sb-pcl::dependent-update-mixin
          cl:class [sb-pcl::definition-source-mixin sb-pcl::standard-specializer]
      sequencer
      sod-class
      sod-initializer
        sod-class-initializer
        sod-instance-initializer
      sod-message
        basic-message
          simple-message
            aggregating-message
            standard-message
      sod-method
        basic-direct-method
          daemon-direct-method
          delegating-direct-method
      sod-slot
        sod-class-slot
      temporary-name
        temporary-argument
        temporary-function
        temporary-variable
      sod-parser:token-scanner
        sod-token-scanner
      type-item
      vtable
      vtable-pointer
      vtmsgs
    cl:structure-object
      argument
      property
      pset
      sequencer-item

Methods:
add-sequencer-constraint
  sequencer cl:list
add-sequencer-item-function
  sequencer t t
add-to-module
  module t
aggregating-message-properties
  t t
  aggregating-message (eql :custom)
base-offset-chain-head
  base-offset
base-offset-class
  base-offset
c-array-dimensions
  c-array-type
c-fragment-text
  c-fragment
c-function-arguments
  c-function-type
c-tagged-type-kind
  c-enum-type
  c-struct-type
  c-union-type
c-type-class
  c-class-type
(setf c-type-class)
  t c-class-type
c-type-equal-p
  t t
  c-array-type c-array-type
  c-class-type c-class-type
  c-function-type c-function-type
  c-pointer-type c-pointer-type
  qualifiable-c-type qualifiable-c-type
  simple-c-type simple-c-type
  tagged-c-type tagged-c-type
c-type-name
  simple-c-type
c-type-qualifiers
  qualifiable-c-type
c-type-subtype
  c-array-type
  c-function-type
  c-pointer-type
c-type-tag
  tagged-c-type
chain-offset-chain-head
  chain-offset
chain-offset-class
  chain-offset
chain-offset-target-head
  chain-offset
check-aggregating-message-type
  t t t
  aggregating-message (eql :progn) c-function-type
check-message-type
  aggregating-message t
  sod-message c-function-type
  sod-message c-type
check-method-type
  daemon-direct-method sod-message c-function-type
  sod-method aggregating-message c-function-type
  sod-method sod-message c-function-type
  sod-method sod-message c-type
check-sod-class
  sod-class
class-pointer-chain-head
  class-pointer
class-pointer-class
  class-pointer
class-pointer-meta-chain-head
  class-pointer
class-pointer-metaclass
  class-pointer
code-fragment
  code-fragment-item
code-fragment-constraints
  code-fragment-item
code-fragment-name
  code-fragment-item
code-fragment-reason
  code-fragment-item
codegen-add-function
  codegen t
codegen-class
  method-codegen
codegen-functions
  codegen
(setf codegen-functions)
  t codegen
codegen-message
  method-codegen
codegen-method
  method-codegen
codegen-pop
  codegen
codegen-pop-block
  t
codegen-pop-function
  t t t
codegen-push
  codegen
codegen-target
  method-codegen
coerce-property-value
  cl:string (eql :id) (eql :keyword)
  cl:string (eql :id) (eql :symbol)
  cl:string (eql :id) (eql :type)
  cl:string (eql :string) (eql :id)
  cl:string (eql :string) (eql :keyword)
  cl:string (eql :string) (eql :symbol)
  cl:symbol (eql :symbol) (eql :id)
  cl:symbol (eql :symbol) (eql :keyword)
  t t (eql cl:t)
  t t t
commentify-argument-name
  cl:null
  t
  temporary-name
compute-aggregating-message-kernel
  aggregating-message (eql :and) t t t t
  aggregating-message (eql :custom) t t t t
  aggregating-message (eql :max) t t t t
  aggregating-message (eql :min) t t t t
  aggregating-message (eql :or) t t t t
  aggregating-message (eql :product) t t t t
  aggregating-message (eql :progn) t t t t
  aggregating-message (eql :sum) t t t t
compute-chains
  sod-class
compute-cpl
  sod-class
compute-effective-method-body
  simple-effective-method t t
compute-effective-methods
  sod-class
compute-effective-slot
  sod-class sod-class-slot
  sod-class sod-slot
compute-ichain
  sod-class t
compute-ilayout
  sod-class
compute-islots
  sod-class sod-class
compute-method-entry-functions
  basic-effective-method
  simple-effective-method
compute-sod-effective-method
  sod-message sod-class
compute-vtable
  sod-class cl:list
compute-vtable-items
  sod-class sod-class sod-class sod-class cl:function
compute-vtables
  sod-class
compute-vtmsgs
  sod-class sod-class sod-class sod-class
decode-property
  cl:character
  cl:cons
  cl:function
  cl:integer
  cl:string
  cl:symbol
  c-type
  property
effective-method-after-methods
  basic-effective-method
effective-method-around-methods
  basic-effective-method
effective-method-basic-argument-names
  basic-effective-method
effective-method-before-methods
  basic-effective-method
effective-method-class
  effective-method
effective-method-function-name
  effective-method
effective-method-message
  effective-method
effective-slot-class
  effective-slot
effective-slot-direct-slot
  effective-slot
effective-slot-initializer
  effective-slot
emit-decl
  sod::basic-codegen t
emit-decls
  sod::basic-codegen t
emit-inst
  sod::basic-codegen t
emit-insts
  t t
  sod::basic-codegen t
ensure-sequencer-item
  sequencer t
ensure-var
  sod::basic-codegen t t
expand-c-type-form
  (eql cl:*) t
  (eql cl:array) t
  (eql cl:char) t
  (eql cl:class) t
  (eql cl:float) t
  (eql cl:function) t
  (eql cl:nil) t
  (eql cl:union) t
  (eql bool) t
  (eql double) t
  (eql double-complex) t
  (eql double-imaginary) t
  (eql enum) t
  (eql float-complex) t
  (eql float-imaginary) t
  (eql fn) t
  (eql fun) t
  (eql func) t
  (eql int) t
  (eql long) t
  (eql long-double) t
  (eql long-double-complex) t
  (eql long-double-imaginary) t
  (eql long-long) t
  (eql pointer) t
  (eql ptr) t
  (eql ptrdiff-t) t
  (eql short) t
  (eql signed-char) t
  (eql size-t) t
  (eql struct) t
  (eql unsigned) t
  (eql unsigned-char) t
  (eql unsigned-long) t
  (eql unsigned-long-long) t
  (eql unsigned-short) t
  (eql va-list) t
  (eql vec) t
  (eql void) t
  (eql wchar-t) t
  (eql []) t
  (eql sod-parser:lisp) t
  cl:string t
expand-c-type-spec
  (eql cl:char)
  (eql cl:float)
  (eql cl:schar)
  (eql cl:string)
  (eql bool)
  (eql const-string)
  (eql double)
  (eql double-complex)
  (eql double-imaginary)
  (eql float-complex)
  (eql float-imaginary)
  (eql int)
  (eql llong)
  (eql long)
  (eql long-double)
  (eql long-double-complex)
  (eql long-double-imaginary)
  (eql long-int)
  (eql long-long)
  (eql long-long-int)
  (eql ptrdiff-t)
  (eql short)
  (eql short-int)
  (eql signed)
  (eql signed-char)
  (eql signed-int)
  (eql signed-long)
  (eql signed-long-int)
  (eql signed-long-long)
  (eql signed-long-long-int)
  (eql signed-short)
  (eql signed-short-int)
  (eql sint)
  (eql size-t)
  (eql sllong)
  (eql slong)
  (eql sshort)
  (eql uchar)
  (eql uint)
  (eql ullong)
  (eql ulong)
  (eql unsigned)
  (eql unsigned-char)
  (eql unsigned-int)
  (eql unsigned-long)
  (eql unsigned-long-int)
  (eql unsigned-long-long)
  (eql unsigned-long-long-int)
  (eql unsigned-short)
  (eql unsigned-short-int)
  (eql ushort)
  (eql va-list)
  (eql void)
  (eql wchar-t)
  cl:list
  cl:string
sod-parser:file-location
  c-fragment
  property
  sod-class
  sod-initializer
  sod-message
  sod-method
  sod-slot
finalize-module
  module
finalize-sod-class
  sod-class
find-slot-initializer
  sod-class sod-slot
format-temporary-name
  temporary-argument t
  temporary-function t
  temporary-name t
  temporary-variable t
guess-metaclass
  sod-class
hook-output
  t t t
  base-offset (eql :c) t
  base-offset (eql :h) t
  basic-effective-method (eql :c) t
  chain-offset (eql :c) t
  chain-offset (eql :h) t
  class-pointer (eql :c) t
  class-pointer (eql :h) t
  code-fragment-item t t
  delegating-direct-method (eql :c) t
  effective-slot (eql cl:class) t
  ichain (eql :h) t
  ichain (eql cl:class) t
  ichain (eql ilayout) t
  ichain t t
  ilayout (eql :h) t
  ilayout t t
  islots (eql :h) t
  islots (eql cl:class) t
  islots t t
  method-entry (eql :c) t
  method-entry (eql vtmsgs) t
  module (eql :c) t
  module (eql :h) t
  module t t
  sod-class (eql :c) t
  sod-class (eql :h) t
  sod-class t t
  sod-class-effective-slot (eql cl:class) t
  sod-method (eql :c) t
  sod-method (eql :h) t
  sod-slot (eql islots) t
  vtable (eql :c) t
  vtable (eql :h) t
  vtable t t
  vtable-pointer (eql :h) t
  vtable-pointer (eql cl:class) t
  vtmsgs (eql :c) t
  vtmsgs (eql :h) t
  vtmsgs (eql vtmsgs) t
  vtmsgs t t
ichain-body
  ichain
ichain-class
  ichain
ichain-head
  ichain
ichain-tail
  ichain
ilayout-class
  ilayout
ilayout-ichains
  ilayout
inst-alt
  if-inst
inst-ap
  va-end-inst
  va-start-inst
inst-arg
  va-start-inst
inst-args
  call-inst
inst-body
  block-inst
  do-while-inst
  function-inst
  while-inst
inst-chain-head
  convert-to-ilayout-inst
inst-class
  convert-to-ilayout-inst
inst-cond
  do-while-inst
  if-inst
  while-inst
inst-conseq
  if-inst
inst-decls
  block-inst
inst-expr
  convert-to-ilayout-inst
  expr-inst
  return-inst
  set-inst
  update-inst
inst-from
  va-copy-inst
inst-func
  call-inst
inst-init
  var-inst
inst-metric
  cl:list
  cl:null
  t
  block-inst
  break-inst
  call-inst
  continue-inst
  convert-to-ilayout-inst
  do-while-inst
  expr-inst
  function-inst
  if-inst
  return-inst
  set-inst
  update-inst
  va-copy-inst
  va-end-inst
  va-start-inst
  var-inst
  while-inst
inst-name
  function-inst
  var-inst
inst-op
  update-inst
inst-to
  va-copy-inst
inst-type
  function-inst
  var-inst
inst-var
  set-inst
  update-inst
invoke-sequencer-items
  sequencer
islots-class
  islots
islots-slots
  islots
islots-subclass
  islots
kind-c-tagged-type
  (eql :enum)
  (eql :struct)
  (eql :union)
make-base-offset
  sod-class sod-class
make-class-pointer
  sod-class sod-class sod-class sod-class
cl:make-load-form
  c-fragment
make-method-entries
  basic-effective-method sod-class sod-class
sod-parser:make-scanner-stream
  sod-token-scanner
make-sod-class-initializer
  sod-class t t t t t
make-sod-initializer-using-slot
  sod-class sod-slot t t t t t
make-sod-instance-initializer
  sod-class t t t t t
make-sod-message
  sod-class t t t
make-sod-method
  sod-class t t t t t
make-sod-method-using-message
  sod-message sod-class t t t t
make-sod-slot
  sod-class t t t
method-entry-chain-head
  method-entry
method-entry-chain-tail
  method-entry
method-entry-effective-method
  method-entry
method-entry-function-name
  effective-method sod-class t
method-entry-function-type
  method-entry
method-entry-slot-name
  method-entry
module-dependencies
  module
(setf module-dependencies)
  t module
module-import
  t
  module
  sod-class
  type-item
module-items
  module
(setf module-items)
  t module
module-name
  module
module-pset
  module
pprint-c-type
  t t t
  c-array-type t t
  c-function-type t t
  c-pointer-type t t
  simple-c-type t t
  tagged-c-type t t
primary-method-class
  simple-message
  standard-message
print-c-type
  t c-array-type
  t c-class-type
  t c-function-type
  t c-pointer-type
  t simple-c-type
  t tagged-c-type
cl:print-object
  base-offset t
  block-inst t
  break-inst t
  c-fragment t
  c-type t
  call-inst t
  chain-offset t
  class-pointer t
  continue-inst t
  convert-to-ilayout-inst t
  do-while-inst t
  effective-method t
  effective-slot t
  expr-inst t
  function-inst t
  ichain t
  if-inst t
  ilayout t
  islots t
  method-entry t
  pset t
  return-inst t
  sequencer-item t
  set-inst t
  sod-class t
  sod-initializer t
  sod-message t
  sod-method t
  sod-slot t
  temporary-name t
  update-inst t
  va-copy-inst t
  va-end-inst t
  va-start-inst t
  var-inst t
  vtable t
  vtable-pointer t
  vtmsgs t
  while-inst t
property-set
  cl:list
  pset
qualify-c-type
  qualifiable-c-type t
sod-parser:scanner-token
  sod-token-scanner
sequencer-constraints
  sequencer
(setf sequencer-constraints)
  t sequencer
sequencer-table
  sequencer
cl:shared-initialize
  aggregating-message t
  basic-direct-method t
  c-function-type t
  method-codegen t
  module t
  sequencer t
  simple-effective-method t
  sod-class t
  sod-class-slot t
  sod-initializer t
  sod-message t
  sod-method t
  sod-slot t
  sod-token-scanner t
simple-method-body
  aggregating-effective-method t t
  standard-effective-method t t
cl:slot-unbound
  t basic-direct-method (eql sod::function-type)
  t basic-effective-method (eql sod::basic-argument-names)
  t basic-effective-method (eql sod::functions)
  t basic-message (eql sod::argument-tail)
  t basic-message (eql sod::no-varargs-tail)
  t delegating-direct-method (eql sod::function-type)
  t delegating-direct-method (eql sod::next-method-type)
  t sod-class (eql sod::%ilayout)
  t sod-class (eql sod::effective-methods)
  t sod-class (eql sod::vtables)
sod-class-chain
  sod-class
sod-class-chain-head
  sod-class
sod-class-chain-link
  sod-class
sod-class-chains
  sod-class
sod-class-class-initializers
  sod-class
(setf sod-class-class-initializers)
  t sod-class
sod-class-direct-superclasses
  sod-class
sod-class-ilayout
  sod-class
sod-class-instance-initializers
  sod-class
(setf sod-class-instance-initializers)
  t sod-class
sod-class-messages
  sod-class
(setf sod-class-messages)
  t sod-class
sod-class-metaclass
  sod-class
sod-class-methods
  sod-class
(setf sod-class-methods)
  t sod-class
sod-class-name
  sod-class
sod-class-nickname
  sod-class
sod-class-precedence-list
  sod-class
sod-class-slots
  sod-class
(setf sod-class-slots)
  t sod-class
sod-class-state
  sod-class
sod-class-type
  sod-class
sod-class-vtables
  sod-class
sod-initializer-class
  sod-initializer
sod-initializer-slot
  sod-initializer
sod-initializer-value-form
  sod-initializer
sod-initializer-value-kind
  sod-initializer
sod-message-argument-tail
  basic-message
sod-message-class
  sod-message
sod-message-combination
  aggregating-message
sod-message-effective-method-class
  aggregating-message
  standard-message
sod-message-kernel-function
  aggregating-message
sod-message-method-class
  basic-message sod-class t
  simple-message sod-class t
  sod-message sod-class t
sod-message-name
  sod-message
sod-message-no-varargs-tail
  basic-message
sod-message-type
  sod-message
sod-method-body
  sod-method
sod-method-class
  sod-method
sod-method-function-name
  basic-direct-method
sod-method-function-type
  basic-direct-method
sod-method-message
  sod-method
sod-method-next-method-type
  delegating-direct-method
sod-method-role
  basic-direct-method
sod-method-type
  sod-method
sod-slot-class
  sod-slot
sod-slot-initializer-function
  sod-class-slot
sod-slot-name
  sod-slot
sod-slot-prepare-function
  sod-class-slot
sod-slot-type
  sod-slot
temp-tag
  temporary-name
temporary-var
  sod::basic-codegen t
var-in-use-p
  t
  temporary-variable
(setf var-in-use-p)
  t temporary-variable
vtable-body
  vtable
vtable-chain-head
  vtable
vtable-chain-tail
  vtable
vtable-class
  vtable
vtable-pointer-chain-head
  vtable-pointer
vtable-pointer-chain-tail
  vtable-pointer
vtable-pointer-class
  vtable-pointer
vtmsgs-chain-head
  vtmsgs
vtmsgs-chain-tail
  vtmsgs
vtmsgs-class
  vtmsgs
vtmsgs-entries
  vtmsgs
vtmsgs-subclass
  vtmsgs

-----------------------------------------------------------------------------
Package `sod-frontend'

frontend.lisp
  main                                          function

Classes:
cl:t

Methods:

-----------------------------------------------------------------------------
Package `sod-parser'

floc-proto.lisp
  cerror*                                       function
  cerror*-with-location                         function
  cerror-with-location                          function
  condition-with-location                       class
  count-and-report-errors                       macro
  enclosed-condition                            generic
  enclosing-condition                           class
  enclosing-condition-with-location             class
  enclosing-error-with-location                 class
  enclosing-warning-with-location               class
  error-with-location                           function class
  file-location                                 generic class
  file-location-column                          function
  file-location-filename                        function
  file-location-line                            function
  file-location-p                               function
  make-condition-with-location                  function
  make-file-location                            function
  simple-condition-with-location                class
  simple-error-with-location                    class
  simple-warning-with-location                  class
  warn-with-location                            function
  warning-with-location                         class
  with-default-error-location                   macro

parser-expr-proto.lisp
  apply-operator                                generic
  binop                                         macro
  close-parenthesis                             class
  expr                                          parser
  lparen                                        function
  open-parenthesis                              class
  operator-left-precedence                      generic
  operator-push-action                          generic
  operator-right-precedence                     generic
  postop                                        macro
  prefix-operator                               class
  preop                                         macro
  push-operator                                 generic
  push-value                                    generic
  rparen                                        function
  simple-binary-operator                        class
  simple-operator                               class
  simple-postfix-operator                       class
  simple-prefix-operator                        class
  simple-unary-operator                         class

parser-impl.lisp
  list-parser                                   class
  string-parser                                 class

parser-proto.lisp
  ?                                             parser
  cl:and                                        macro parser
  call-pluggable-parser                         function
  cl:char                                       function setf c-type parser
  character-parser-context                      class
  combine-parser-failures                       function
  cond-parse                                    macro
  define-pluggable-parser                       macro
  defparse                                      macro
  expand-parser-form                            generic
  expand-parser-spec                            generic
  filter                                        parser
  if-char                                       parser
  if-parse                                      macro
  sod-utilities:it
  label                                         parser
  lisp                                          c-type parser
  cl:list                                       function class parser opthandler
  many                                          parser
  cl:not                                        function parser
  cl:or                                         macro parser
  parse
  parser                                        macro
  parser-at-eof-p                               generic
  parser-capture-place                          generic
  parser-current-char                           generic
  parser-places-must-be-released-p              generic
  parser-release-place                          generic
  parser-restore-place                          generic
  parser-step                                   generic
  parser-token-type                             generic
  parser-token-value                            generic
  peek                                          parser
  plug                                          parser
  pluggable-parser-add                          function
  cl:satisfies                                  parser
  seq                                           parser
  skip-many                                     parser
  token                                         parser
  token-parser-context                          class
  when-parse                                    macro
  with-parser-context                           macro
  with-parser-place                             macro
  wrap-parser                                   generic

scanner-charbuf-impl.lisp
  charbuf-scanner                               class
  charbuf-scanner-map                           generic
  charbuf-scanner-place-p                       function
  charbuf-scanner-stream                        class

scanner-impl.lisp
  list-scanner                                  class
  list-scanner-p                                function
  make-list-scanner                             function
  make-string-scanner                           function
  string-scanner                                class
  string-scanner-p                              function

scanner-proto.lisp
  character-scanner                             class
  character-scanner-context                     class
  character-scanner-stream                      class
  make-scanner-stream                           generic
  parser-scanner                                generic
  scanner-at-eof-p                              generic
  scanner-capture-place                         generic
  scanner-column                                generic setf
  scanner-context                               class
  scanner-current-char                          generic
  scanner-filename                              generic
  scanner-interval                              generic
  scanner-line                                  generic setf
  scanner-release-place                         generic
  scanner-restore-place                         generic
  scanner-step                                  generic
  scanner-token                                 generic
  scanner-unread                                generic
  token-scanner                                 class
  token-scanner-context                         class
  token-scanner-place                           class
  token-scanner-place-p                         function
  token-type                                    generic
  token-value                                   generic
  with-scanner-place                            macro

streams-impl.lisp
  position-aware-input-stream                   class
  position-aware-output-stream                  class
  position-aware-stream                         class
  position-aware-stream-column                  generic setf
  position-aware-stream-line                    generic setf

streams-proto.lisp
  stream-pathname                               generic

Classes:
cl:t
  sb-pcl::slot-object
    cl:standard-object
      character-parser-context
        character-scanner-context [scanner-context]
        string-parser
      character-scanner
        charbuf-scanner
      sb-gray:fundamental-stream [cl:stream]
        sb-gray:fundamental-character-stream
          sb-gray:fundamental-character-input-stream [sb-gray:fundamental-input-stream]
            character-scanner-stream
              charbuf-scanner-stream
            sod-parser::proxy-character-input-stream [sod-parser::proxy-input-stream]
              position-aware-input-stream [position-aware-stream]
          sb-gray:fundamental-character-output-stream [sb-gray:fundamental-output-stream]
            sod-parser::proxy-character-output-stream [sod-parser::proxy-stream]
              position-aware-output-stream [position-aware-stream]
        sb-gray:fundamental-input-stream
          sb-gray:fundamental-character-input-stream [sb-gray:fundamental-character-stream]
            character-scanner-stream
              charbuf-scanner-stream
            sod-parser::proxy-character-input-stream [sod-parser::proxy-input-stream]
              position-aware-input-stream [position-aware-stream]
          sod-parser::proxy-input-stream [sod-parser::proxy-stream]
            sod-parser::proxy-character-input-stream [sb-gray:fundamental-character-input-stream]
              position-aware-input-stream [position-aware-stream]
        sb-gray:fundamental-output-stream
          sb-gray:fundamental-character-output-stream [sb-gray:fundamental-character-stream]
            sod-parser::proxy-character-output-stream [sod-parser::proxy-stream]
              position-aware-output-stream [position-aware-stream]
        sod-parser::proxy-stream
          position-aware-stream
            position-aware-input-stream [sod-parser::proxy-character-input-stream]
            position-aware-output-stream [sod-parser::proxy-character-output-stream]
          sod-parser::proxy-character-output-stream [sb-gray:fundamental-character-output-stream]
            position-aware-output-stream [position-aware-stream]
          sod-parser::proxy-input-stream [sb-gray:fundamental-input-stream]
            sod-parser::proxy-character-input-stream [sb-gray:fundamental-character-input-stream]
              position-aware-input-stream [position-aware-stream]
      list-parser
      sod-parser::parenthesis
        close-parenthesis
        open-parenthesis [prefix-operator]
      prefix-operator
        open-parenthesis [sod-parser::parenthesis]
        simple-prefix-operator [simple-unary-operator]
      scanner-context
        character-scanner-context [character-parser-context]
        token-scanner-context [token-parser-context]
      simple-operator
        simple-binary-operator
        simple-unary-operator
          simple-postfix-operator
          simple-prefix-operator [prefix-operator]
      token-parser-context
        token-scanner-context [scanner-context]
      token-scanner
    cl:structure-object
      file-location
      list-scanner
      string-scanner
      token-scanner-place
  cl:stream
    sb-gray:fundamental-stream [cl:standard-object]
      sb-gray:fundamental-character-stream
        sb-gray:fundamental-character-input-stream [sb-gray:fundamental-input-stream]
          character-scanner-stream
            charbuf-scanner-stream
          sod-parser::proxy-character-input-stream [sod-parser::proxy-input-stream]
            position-aware-input-stream [position-aware-stream]
        sb-gray:fundamental-character-output-stream [sb-gray:fundamental-output-stream]
          sod-parser::proxy-character-output-stream [sod-parser::proxy-stream]
            position-aware-output-stream [position-aware-stream]
      sb-gray:fundamental-input-stream
        sb-gray:fundamental-character-input-stream [sb-gray:fundamental-character-stream]
          character-scanner-stream
            charbuf-scanner-stream
          sod-parser::proxy-character-input-stream [sod-parser::proxy-input-stream]
            position-aware-input-stream [position-aware-stream]
        sod-parser::proxy-input-stream [sod-parser::proxy-stream]
          sod-parser::proxy-character-input-stream [sb-gray:fundamental-character-input-stream]
            position-aware-input-stream [position-aware-stream]
      sb-gray:fundamental-output-stream
        sb-gray:fundamental-character-output-stream [sb-gray:fundamental-character-stream]
          sod-parser::proxy-character-output-stream [sod-parser::proxy-stream]
            position-aware-output-stream [position-aware-stream]
      sod-parser::proxy-stream
        position-aware-stream
          position-aware-input-stream [sod-parser::proxy-character-input-stream]
          position-aware-output-stream [sod-parser::proxy-character-output-stream]
        sod-parser::proxy-character-output-stream [sb-gray:fundamental-character-output-stream]
          position-aware-output-stream [position-aware-stream]
        sod-parser::proxy-input-stream [sb-gray:fundamental-input-stream]
          sod-parser::proxy-character-input-stream [sb-gray:fundamental-character-input-stream]
            position-aware-input-stream [position-aware-stream]

Methods:
apply-operator
  open-parenthesis sod-parser::expression-parse-state
  simple-binary-operator sod-parser::expression-parse-state
  simple-unary-operator sod-parser::expression-parse-state
charbuf-scanner-map
  charbuf-scanner t
enclosed-condition
  enclosing-condition
expand-parser-form
  t (eql cl:and) t
  t (eql cl:list) t
  t (eql cl:nil) t
  t (eql cl:or) t
  t (eql cl:t) t
  t (eql cl:when) t
  t (eql ?) t
  t (eql expr) t
  t (eql label) t
  t (eql lisp) t
  t (eql many) t
  t (eql peek) t
  t (eql plug) t
  t (eql seq) t
  t (eql skip-many) t
  t t t
  character-parser-context (eql cl:char) t
  character-parser-context (eql cl:not) t
  character-parser-context (eql cl:satisfies) t
  character-parser-context (eql filter) t
  character-parser-context (eql if-char) t
  list-parser (eql cl:quote) t
  list-parser (eql cl:type) t
  token-parser-context (eql token) t
  token-scanner-context (eql cl:error) t
  token-scanner-context (eql sod:skip-until) t
expand-parser-spec
  t (eql :eof)
  t (eql cl:nil)
  t (eql cl:t)
  t cl:list
  character-parser-context (eql :any)
  character-parser-context (eql :whitespace)
  character-parser-context cl:character
  character-parser-context cl:string
  list-parser t
  token-parser-context cl:string
  token-parser-context t
file-location
  cl:stream
  t
  sod:c-fragment
  sod:property
  sod:sod-class
  sod:sod-initializer
  sod:sod-message
  sod:sod-method
  sod:sod-slot
  character-scanner
  sod-parser::charbuf-scanner-place
  condition-with-location
  file-location
  position-aware-stream
  token-scanner
  token-scanner-place
cl:make-load-form
  file-location
make-scanner-stream
  sod:sod-token-scanner
  character-scanner
  charbuf-scanner
  string-scanner
operator-left-precedence
  simple-binary-operator
  simple-postfix-operator
operator-push-action
  t t
  t open-parenthesis
  open-parenthesis t
operator-right-precedence
  simple-binary-operator
  simple-postfix-operator
  simple-prefix-operator
parser-at-eof-p
  list-parser
  scanner-context
  string-parser
  token-parser-context
parser-capture-place
  t
  list-parser
  scanner-context
  string-parser
parser-current-char
  character-scanner-context
  string-parser
parser-places-must-be-released-p
  t
  list-parser
  sod-parser::list-scanner-context
  string-parser
  sod-parser::string-scanner-context
parser-release-place
  t t
  scanner-context t
parser-restore-place
  list-parser t
  scanner-context t
  string-parser t
parser-scanner
  scanner-context
parser-step
  scanner-context
  string-parser
parser-token-type
  token-scanner-context
parser-token-value
  token-scanner-context
position-aware-stream-column
  position-aware-stream
(setf position-aware-stream-column)
  t position-aware-stream
position-aware-stream-line
  position-aware-stream
(setf position-aware-stream-line)
  t position-aware-stream
cl:print-object
  file-location t
  simple-operator t
push-operator
  t sod-parser::expression-parse-state
  close-parenthesis sod-parser::expression-parse-state
  open-parenthesis sod-parser::expression-parse-state
  prefix-operator sod-parser::expression-parse-state
push-value
  t sod-parser::expression-parse-state
scanner-at-eof-p
  charbuf-scanner
  list-scanner
  string-scanner
  token-scanner
scanner-capture-place
  t
  charbuf-scanner
  list-scanner
  string-scanner
  token-scanner
scanner-column
  t
  charbuf-scanner
  token-scanner
(setf scanner-column)
  t token-scanner
scanner-current-char
  charbuf-scanner
  string-scanner
scanner-filename
  t
  charbuf-scanner
  token-scanner
scanner-interval
  charbuf-scanner t
  string-scanner t
scanner-line
  t
  charbuf-scanner
  token-scanner
(setf scanner-line)
  t token-scanner
scanner-release-place
  t t
  charbuf-scanner t
  token-scanner t
scanner-restore-place
  charbuf-scanner t
  list-scanner t
  string-scanner t
  token-scanner t
scanner-step
  charbuf-scanner
  list-scanner
  string-scanner
  token-scanner
scanner-token
  sod:sod-token-scanner
scanner-unread
  charbuf-scanner t
cl:shared-initialize
  charbuf-scanner t
  simple-binary-operator t
  token-scanner t
sb-gray:stream-line-column
  position-aware-output-stream
stream-pathname
  cl:file-stream
  cl:stream
  position-aware-stream
  sod-parser::proxy-stream
sb-gray:stream-peek-char
  character-scanner-stream
sb-gray:stream-read-char
  character-scanner-stream
  position-aware-input-stream
sb-gray:stream-read-line
  charbuf-scanner-stream
  position-aware-input-stream
sb-gray:stream-read-sequence
  charbuf-scanner-stream cl:string
  position-aware-input-stream t
sb-gray:stream-start-line-p
  position-aware-output-stream
sb-gray:stream-terpri
  position-aware-output-stream
sb-gray:stream-unread-char
  character-scanner-stream t
  position-aware-input-stream t
sb-gray:stream-write-char
  position-aware-output-stream t
sb-gray:stream-write-sequence
  position-aware-output-stream t
sb-gray:stream-write-string
  position-aware-output-stream t
token-type
  list-scanner
  token-scanner
token-value
  list-scanner
  token-scanner
wrap-parser
  t t
  string-parser t

-----------------------------------------------------------------------------
Package `optparse'

optparse.lisp
  *command-line*                                variable
  *help*                                        variable
  *options*                                     variable
  *program-name*                                variable
  *usage*                                       variable
  *version*                                     variable
  clear                                         opthandler
  dec                                           opthandler
  define-program                                function
  defopthandler                                 macro
  defoptmacro                                   macro
  die                                           function
  die-usage                                     function
  do-options                                    macro
  do-usage                                      function
  exit                                          function
  help-options                                  optmacro
  inc                                           opthandler
  int                                           opthandler
  invoke-option-handler                         function
  cl:keyword                                    opthandler
  cl:list                                       function class parser opthandler
  make-option                                   function
  make-option-parser                            function
  moan                                          function
  op-long-only-p                                function setf
  op-negated-numeric-p                          function setf
  op-negated-p                                  function setf
  op-non-option                                 function setf
  op-numeric-p                                  function setf
  op-options                                    function setf
  opt-arg-name                                  function setf
  opt-arg-optional-p                            function setf
  opt-documentation                             function setf
  opt-long-name                                 function setf
  opt-negated-tag                               function setf
  opt-short-name                                function setf
  opt-tag                                       function setf
  option                                        class
  option-parse-error                            function class
  option-parse-next                             function
  option-parse-remainder                        function
  option-parse-return                           function
  option-parse-try                              macro
  option-parser                                 class
  option-parser-p                               function
  optionp                                       function
  options                                       macro
  parse-option-form                             function
  cl:read                                       function opthandler
  sanity-check-option-list                      function
  cl:set                                        function opthandler
  set-command-line-arguments                    function
  show-help                                     function
  show-usage                                    function
  simple-usage                                  function
  cl:string                                     function class c-type opthandler
  with-unix-error-reporting                     macro

Leaked slot names: cl:documentation, options
  option: cl:documentation
  option-parser: options

Classes:
cl:t
  sb-pcl::slot-object
    cl:structure-object
      option
      option-parser

Methods:
cl:print-object
  option t

-----------------------------------------------------------------------------
Package `sod-utilities'

utilities.lisp
  acase                                         macro
  acond                                         macro
  aecase                                        macro
  aetypecase                                    macro
  aif                                           macro
  asetf                                         macro
  atypecase                                     macro
  awhen                                         macro
  backtrack-position                            function
  categorize                                    macro
  compose                                       function
  copy-instance                                 function
  copy-instance-using-class                     generic
  default-slot                                  macro
  define-access-wrapper                         macro
  define-on-demand-slot                         macro
  dosequence                                    macro
  sb-mop:eql-specializer                        class
  sb-mop:eql-specializer-object                 generic
  frob-identifier                               function
  sb-mop:generic-function-methods               generic setf
  inconsistent-merge-error                      class
  instance-initargs                             generic
  it
  lbuild-add                                    function
  lbuild-add-list                               function
  lbuild-list                                   function
  loc                                           class
  locf                                          macro
  locp                                          function
  make-list-builder                             function
  mappend                                       function
  maybe-print-unreadable-object                 macro
  merge-error-candidates                        generic
  merge-lists                                   function
  sb-mop:method-specializers                    generic
  once-only                                     macro
  parse-body                                    function
  print-ugly-stuff                              function
  ref                                           function setf
  symbolicate                                   function
  update-position                               function
  whitespace-char-p                             function
  with-gensyms                                  macro
  with-locatives                                macro

Classes:
cl:t
  sb-pcl::slot-object
    cl:standard-object
      sb-mop:metaobject
        sb-mop:specializer
          sb-pcl::exact-class-specializer
            sb-mop:eql-specializer [sb-pcl::standard-specializer sb-pcl::specializer-with-object]
          sb-pcl::specializer-with-object
            sb-mop:eql-specializer [sb-pcl::standard-specializer sb-pcl::exact-class-specializer]
          sb-pcl::standard-specializer
            sb-mop:eql-specializer [sb-pcl::exact-class-specializer sb-pcl::specializer-with-object]
    cl:structure-object
      loc

Methods:
copy-instance-using-class
  cl:standard-class t
sb-mop:eql-specializer-object
  sb-mop:eql-specializer
sb-mop:generic-function-methods
  cl:standard-generic-function
(setf sb-mop:generic-function-methods)
  t cl:standard-generic-function
instance-initargs
  cl:standard-object
merge-error-candidates
  inconsistent-merge-error
sb-mop:method-specializers
  cl:standard-method