From: Mark Wooding Date: Sun, 30 Aug 2015 09:58:38 +0000 (+0100) Subject: doc/SYMBOLS: Actually check this in, so we can see how it changes. X-Git-Url: https://git.distorted.org.uk/~mdw/sod/commitdiff_plain/e417fab55d827640e10b832b85978847a1bfe5d5 doc/SYMBOLS: Actually check this in, so we can see how it changes. So stop ignoring it. --- diff --git a/.gitignore b/.gitignore index 8ae86b1..b841037 100644 --- a/.gitignore +++ b/.gitignore @@ -13,4 +13,3 @@ Makefile.in /autom4te.cache/ /config/ /configure -/doc/SYMBOLS diff --git a/doc/SYMBOLS b/doc/SYMBOLS new file mode 100644 index 0000000..c49d475 --- /dev/null +++ b/doc/SYMBOLS @@ -0,0 +1,1938 @@ +----------------------------------------------------------------------------- +Package `sod' + +pset-proto.lisp + add-property function + check--unused-properties + coerce-property-value generic + decode-property generic + get-property function + make-property function + make-property-set function + make-pset function + p-key function setf + p-name function setf + p-seenp function setf + p-type function setf + p-value function setf + 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 + +pset-parse.lisp + parse-property-set function + +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 + +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 + +module-parse.lisp + read-module function + +module-output.lisp + banner function + declare-output-type function + guard-name function + output-module function + output-type-pathname function + +module-impl.lisp + *module-dirs* variable + c-fragment class + code-fragment-item class + find-file function + type-item 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 + message-effective-method-class generic + 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-no-varargs-tail generic + sod-method-function-name generic + sod-method-function-type generic + sod-method-next-method-type generic + varargs-message-p function + +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 + simple-effective-method class + simple-message class + standard-effective-method class + standard-message class + +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 + +lexer-proto.lisp + define-indicator function + lexer-error function + sod-token-scanner class + syntax-error function + +fragment-parse.lisp + parse-delimited-fragment function + scan-c-fragment function + +final.lisp + *debugout-pathname* variable + *sod-version* variable + exercise function + test-module function + +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 + +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 + +classes.lisp + sod-class class + sod-class-chain generic setf + sod-class-chain-head generic setf + sod-class-chain-link generic + sod-class-chains generic setf + sod-class-class-initializers generic setf + sod-class-direct-superclasses generic + sod-class-ilayout generic setf + 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 setf + sod-class-slots generic setf + sod-class-state generic setf + sod-class-type generic setf + sod-class-vtables generic setf + 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 + +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 + +class-make-proto.lisp + check-message-type generic + check-method-type generic + define-sod-class macro + 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-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 + +class-layout-impl.lisp + sod-class-effective-slot class + sod-class-slot class + +c-types-proto.lisp + argument class + argument-name function setf + argument-type function setf + 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 + +c-types-parse.lisp + parse-c-type function + parse-declarator function + +c-types-impl.lisp + cl:* variable function c-type + cl:array class 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-name generic + c-type-tag generic + 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 + enum c-type + cl:float function class 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-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 + [] c-type + +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 + +builtin.lisp + *builtin-module* variable + make-builtin-module function + +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 + 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 + aggregating-message (eql :custom) + t t +base-offset-chain-head + base-offset +base-offset-class + base-offset +c-array-dimensions + c-array-type +c-function-arguments + c-function-type +c-tagged-type-kind + c-union-type + c-struct-type + c-enum-type +c-type-class + c-class-type +(setf c-type-class) + t c-class-type +c-type-equal-p + c-class-type c-class-type + c-function-type c-function-type + c-array-type c-array-type + c-pointer-type c-pointer-type + tagged-c-type tagged-c-type + simple-c-type simple-c-type + qualifiable-c-type qualifiable-c-type + t t +c-type-name + simple-c-type +c-type-qualifiers + qualifiable-c-type +c-type-subtype + c-function-type + c-array-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 + aggregating-message (eql :or) c-function-type + aggregating-message (eql :and) c-function-type + aggregating-message (eql :progn) c-function-type + t t t +check-message-type + aggregating-message t + sod-message c-type + sod-message c-function-type +check-method-type + daemon-direct-method sod-message c-function-type + sod-method sod-message c-function-type + sod-method sod-message c-type +class-pointer-chain-head + class-pointer +class-pointer-class + class-pointer +class-pointer-meta-chain-head + class-pointer +class-pointer-metaclass + class-pointer +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:symbol (eql :symbol) (eql :id) + cl:string (eql :string) (eql :id) + cl:string (eql :string) (eql :symbol) + cl:string (eql :id) (eql :symbol) + cl:string (eql :string) (eql :keyword) + cl:string (eql :id) (eql :keyword) + cl:symbol (eql :symbol) (eql :keyword) + t t t + t t (eql cl:t) +commentify-argument-name + temporary-name + cl:null + t +compute-aggregating-message-kernel + aggregating-message (eql :custom) t t t t + aggregating-message (eql :or) t t t t + aggregating-message (eql :and) t t t t + aggregating-message (eql :max) t t t t + aggregating-message (eql :min) t t t t + aggregating-message (eql :product) t t t t + aggregating-message (eql :sum) t t t t + aggregating-message (eql :progn) t t t t +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 + simple-effective-method + basic-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:symbol + cl:integer + cl:string + cl:character + property + cl:cons + cl:function +effective-method-basic-argument-names + 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 + sod::basic-codegen t + t t +ensure-sequencer-item + sequencer t +ensure-var + sod::basic-codegen t t +expand-c-type-form + (eql cl:class) t + (eql fn) t + (eql func) t + (eql cl:nil) t + (eql cl:function) t + (eql fun) t + (eql vec) t + (eql cl:array) t + (eql []) t + (eql ptr) t + (eql pointer) t + (eql cl:*) t + (eql cl:union) t + (eql struct) t + (eql enum) t + (eql ptrdiff-t) t + (eql size-t) t + (eql va-list) t + (eql long-double) t + (eql double) t + (eql cl:float) t + (eql unsigned-long-long) t + (eql long-long) t + (eql unsigned-long) t + (eql long) t + (eql unsigned-short) t + (eql short) t + (eql unsigned) t + (eql int) t + (eql signed-char) t + (eql unsigned-char) t + (eql cl:char) t + (eql void) t + cl:string t + (eql sod-parser:lisp) t +expand-c-type-spec + (eql const-string) + (eql cl:string) + (eql ptrdiff-t) + (eql size-t) + (eql va-list) + (eql long-double) + (eql double) + (eql cl:float) + (eql ullong) + (eql unsigned-long-long-int) + (eql unsigned-long-long) + (eql sllong) + (eql llong) + (eql signed-long-long-int) + (eql long-long-int) + (eql signed-long-long) + (eql long-long) + (eql ulong) + (eql unsigned-long-int) + (eql unsigned-long) + (eql slong) + (eql signed-long-int) + (eql long-int) + (eql signed-long) + (eql long) + (eql ushort) + (eql unsigned-short-int) + (eql unsigned-short) + (eql sshort) + (eql signed-short-int) + (eql short-int) + (eql signed-short) + (eql short) + (eql uint) + (eql unsigned-int) + (eql unsigned) + (eql sint) + (eql signed-int) + (eql signed) + (eql int) + (eql cl:schar) + (eql signed-char) + (eql uchar) + (eql unsigned-char) + (eql cl:char) + (eql void) + cl:string + cl:list +sod-parser:file-location + property + sod-method + sod-message + sod-initializer + sod-slot + sod-class +finalize-module + module +find-slot-initializer + sod-class sod-slot +format-temporary-name + temporary-function t + temporary-variable t + temporary-argument t + temporary-name t +guess-metaclass + sod-class +hook-output + effective-slot (eql cl:class) t + sod-class-effective-slot (eql cl:class) t + vtable-pointer (eql cl:class) t + islots (eql cl:class) t + ichain (eql cl:class) t + method-entry (eql :c) t + sod::vtmsgs (eql :c) t + chain-offset (eql :c) t + base-offset (eql :c) t + class-pointer (eql :c) t + vtable (eql :c) t + basic-effective-method (eql :c) t + sod-method (eql :c) t + delegating-direct-method (eql :c) t + sod-class (eql :c) t + chain-offset (eql :h) t + base-offset (eql :h) t + class-pointer (eql :h) t + method-entry (eql sod::vtmsgs) t + sod::vtmsgs t t + sod::vtmsgs (eql sod::vtmsgs) t + sod::vtmsgs (eql :h) t + vtable (eql :h) t + sod-method (eql :h) t + vtable t t + islots (eql :h) t + islots t t + vtable-pointer (eql :h) t + ichain (eql ilayout) t + ichain (eql :h) t + ilayout (eql :h) t + ichain t t + ilayout t t + sod-slot (eql islots) t + sod-class t t + sod-class (eql :h) t + module (eql :c) t + module (eql :h) t + code-fragment-item t t + module t t + t 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 + do-while-inst + while-inst + function-inst + block-inst +inst-chain-head + convert-to-ilayout-inst +inst-class + convert-to-ilayout-inst +inst-cond + do-while-inst + while-inst + if-inst +inst-conseq + if-inst +inst-decls + block-inst +inst-expr + convert-to-ilayout-inst + expr-inst + return-inst + update-inst + set-inst +inst-from + va-copy-inst +inst-func + call-inst +inst-init + var-inst +inst-metric + convert-to-ilayout-inst + call-inst + va-end-inst + va-copy-inst + va-start-inst + do-while-inst + while-inst + if-inst + function-inst + block-inst + expr-inst + continue-inst + break-inst + return-inst + update-inst + set-inst + var-inst + t + cl:null + cl:list +inst-name + function-inst + var-inst +inst-op + update-inst +inst-to + va-copy-inst +inst-type + function-inst + var-inst +inst-var + update-inst + set-inst +invoke-sequencer-items + sequencer +islots-class + islots +islots-slots + islots +islots-subclass + islots +kind-c-tagged-type + (eql :union) + (eql :struct) + (eql :enum) +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 +message-effective-method-class + aggregating-message + standard-message +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 + sod-class + type-item + module + t +module-items + module +(setf module-items) + t module +module-name + module +module-pset + module +pprint-c-type + c-function-type t t + c-array-type t t + c-pointer-type t t + tagged-c-type t t + simple-c-type t t + t t t +primary-method-class + standard-message + simple-message +print-c-type + t c-class-type + t c-function-type + t c-array-type + t c-pointer-type + t tagged-c-type + t simple-c-type +cl:print-object + vtable t + chain-offset t + base-offset t + class-pointer t + ilayout t + ichain t + vtable-pointer t + islots t + method-entry t + effective-method t + effective-slot t + convert-to-ilayout-inst t + sequencer-item t + c-fragment t + call-inst t + va-end-inst t + va-copy-inst t + va-start-inst t + do-while-inst t + while-inst t + if-inst t + temporary-name t + function-inst t + block-inst t + expr-inst t + continue-inst t + break-inst t + return-inst t + update-inst t + set-inst t + var-inst t + pset t + sod-method t + sod-message t + sod-initializer t + sod-slot t + sod-class t + c-type t +property-set + pset + cl:list +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 + method-codegen t + simple-effective-method t + basic-direct-method t + sod-class-slot t + sod-method t + sod-message t + sod-initializer t + sod-slot t + sod-class t + module t + c-function-type t + sod-token-scanner t +simple-method-body + aggregating-effective-method t t + standard-effective-method t t +cl:slot-unbound + t basic-effective-method (eql sod::functions) + t basic-effective-method (eql sod::basic-argument-names) + t delegating-direct-method (eql sod::function-type) + t delegating-direct-method (eql sod::next-method-type) + t basic-direct-method (eql sod::function-type) + t basic-message (eql sod::no-varargs-tail) + t basic-message (eql sod::argument-tail) + t sod-class (eql sod::vtables) + t sod-class (eql sod::effective-methods) + t sod-class (eql sod::%ilayout) +sod-class-chain + sod-class +(setf sod-class-chain) + t sod-class +sod-class-chain-head + sod-class +(setf sod-class-chain-head) + t sod-class +sod-class-chain-link + sod-class +sod-class-chains + sod-class +(setf sod-class-chains) + t 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 +(setf sod-class-ilayout) + t 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 +(setf sod-class-precedence-list) + t sod-class +sod-class-slots + sod-class +(setf sod-class-slots) + t sod-class +sod-class-state + sod-class +(setf sod-class-state) + t sod-class +sod-class-type + sod-class +(setf sod-class-type) + t sod-class +sod-class-vtables + sod-class +(setf sod-class-vtables) + t 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-method-class + simple-message sod-class t + basic-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-type + sod-method +sod-slot-class + sod-slot +sod-slot-name + sod-slot +sod-slot-type + sod-slot +temp-tag + temporary-name +temporary-var + sod::basic-codegen t +var-in-use-p + temporary-variable + t +(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 + +----------------------------------------------------------------------------- +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 + token-scanner-context (eql cl:error) t + token-scanner-context (eql sod::skip-until) t + t (eql expr) t + list-parser (eql cl:type) t + list-parser (eql cl:quote) t + token-parser-context (eql token) t + character-parser-context (eql filter) t + character-parser-context (eql cl:not) t + character-parser-context (eql cl:satisfies) t + character-parser-context (eql cl:char) t + character-parser-context (eql if-char) t + t (eql peek) t + t (eql plug) t + t (eql ?) t + t (eql cl:or) t + t (eql skip-many) t + t (eql cl:list) t + t (eql many) t + t (eql lisp) t + t (eql cl:and) t + t (eql seq) t + t (eql cl:when) t + t (eql cl:nil) t + t (eql cl:t) t + t (eql label) t + t t t +expand-parser-spec + list-parser t + token-parser-context cl:string + token-parser-context t + character-parser-context cl:string + character-parser-context (eql :whitespace) + character-parser-context cl:character + character-parser-context (eql :any) + t (eql cl:nil) + t (eql cl:t) + t (eql :eof) + t cl:list +file-location + sod:property + sod:sod-method + sod:sod-message + sod:sod-initializer + sod:sod-slot + sod:sod-class + token-scanner-place + sod-parser::charbuf-scanner-place + token-scanner + character-scanner + position-aware-stream + cl:stream + t + condition-with-location + file-location +cl:make-load-form + file-location +make-scanner-stream + sod:sod-token-scanner + charbuf-scanner + string-scanner + character-scanner +operator-left-precedence + simple-postfix-operator + simple-binary-operator +operator-push-action + open-parenthesis t + t open-parenthesis + t t +operator-right-precedence + simple-prefix-operator + simple-postfix-operator + simple-binary-operator +parser-at-eof-p + scanner-context + string-parser + list-parser + token-parser-context +parser-capture-place + scanner-context + string-parser + list-parser + t +parser-current-char + character-scanner-context + string-parser +parser-places-must-be-released-p + sod-parser::list-scanner-context + sod-parser::string-scanner-context + string-parser + list-parser + t +parser-release-place + scanner-context t + t t +parser-restore-place + scanner-context t + string-parser t + list-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 + simple-operator t + file-location t +push-operator + close-parenthesis sod-parser::expression-parse-state + open-parenthesis sod-parser::expression-parse-state + prefix-operator sod-parser::expression-parse-state + t sod-parser::expression-parse-state +push-value + t sod-parser::expression-parse-state +scanner-at-eof-p + token-scanner + charbuf-scanner + list-scanner + string-scanner +scanner-capture-place + token-scanner + charbuf-scanner + list-scanner + string-scanner + t +scanner-column + charbuf-scanner + token-scanner + t +(setf scanner-column) + t token-scanner +scanner-current-char + charbuf-scanner + string-scanner +scanner-filename + charbuf-scanner + token-scanner + t +scanner-interval + charbuf-scanner t + string-scanner t +scanner-line + charbuf-scanner + token-scanner + t +(setf scanner-line) + t token-scanner +scanner-release-place + token-scanner t + charbuf-scanner t + t t +scanner-restore-place + token-scanner t + charbuf-scanner t + list-scanner t + string-scanner t +scanner-step + token-scanner + charbuf-scanner + list-scanner + string-scanner +scanner-token + sod:sod-token-scanner +scanner-unread + charbuf-scanner t +cl:shared-initialize + simple-binary-operator t + token-scanner t + charbuf-scanner t +sb-gray:stream-line-column + position-aware-output-stream +stream-pathname + position-aware-stream + sod-parser::proxy-stream + cl:stream + cl:file-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 + string-parser t + t 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 + 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 +