
7debug.lisp,782
(defmethod (:bug-report-description 686,27426
(defmethod (:bug-report-recipient-system 667,26719
(defvar *closure-names* 25,1044
(define-presentation-to-command-translator edit-frame-function516,20984
(defun error-reporter-frame-p 64,2447
(defun find-frame-internal 376,15430
(defun frame-interesting-p 93,3735
(defun frame-invisible-p 123,5042
(defun fun 185,7564
(defun function-name-for-debugger 30,1180
(defun get-frame-function-and-args 162,6585
(defprop invisible-frame 114,4754
(defun present-stack-frame 197,7909
(defun print-backtrace 492,20081
(defun print-function-and-args 222,8798
(defun short-backtrace 415,16871
(defun show 268,10533
(defun show-all-compiled 362,15016
(defun show-all-compiled-7-1 319,12901
(defun show-all-compiled-7-2 339,13913

CMU-LOW.lisp,32
(defun object-cache-no 50,1700

boot.lisp,1953
(defvar *early-functions*83,3414
(defvar *early-generic-functions* 646,22566
(defvar *generic-function-fixups*123,4627
(defvar *method-function-plist* 557,19418
(defmacro DEFMETHOD 149,5340
(defun add-lexical-functions-to-method-lambda 446,15641
(defun add-method 862,30095
(defun early-add-named-method 835,29261
(defun early-ensure-gf-internal 718,24905
(defmacro early-gf-discriminator-code 732,25371
(defmacro early-gf-methods 729,25276
(defun early-gf-p 725,25164
(defun early-lookup-method 935,32852
(defun early-make-a-method 758,26163
(defun early-method-specializers 825,28877
(defun early-update-discriminator-code 910,31826
(defun ensure-generic-function 685,23641
(defun expand-defmethod 211,7649
(defun expand-defmethod-internal265,9457
(defun expand-with-slots 1265,44763
(defun expand-with-slots-internal 1279,45175
(defun fix-early-generic-functions 997,35289
(defun get-method 896,31271
(defun load-defmethod581,20159
(defun load-defmethod-internal603,21051
(defun make-method-spec 638,22393
(defun make-parameter-references 533,18661
(defun make-progn 1090,38624
(defun make-top-level-form 1079,38399
(defun method-function-get 565,19705
(defun method-function-isl 572,19937
(defun method-function-needs-next-methods-p 575,20029
(defun method-function-plist 559,19481
(defun method-prototype-for-gf 193,6985
(defun parse-defmethod 1108,39158
(defun parse-method-or-spec 1148,40444
(defun parse-specialized-lambda-list 1199,42266
(defun parse-specializers 1119,39582
(defun real-ensure-gf-internal 736,25479
(defun real-make-a-method797,27601
(defun remove-method 882,30764
(defun specialized-lambda-list-lambda-list 1187,41779
(defun specialized-lambda-list-parameters 1181,41540
(defun specialized-lambda-list-specializers 1193,42021
(defun unparse-specializers 1134,40003
(defmacro with-accessors1255,44503
(defmacro with-slots1243,44187
(defun |SETF 562,19582
(defun |SETF 568,19809

braid1.lisp,679
(defvar *std-class-slots* 61,2355
(defvar *std-slotd-slots* 63,2427
(defun bootstrap-accessor-definitions 216,8115
(defun bootstrap-get-slot 121,4534
(defun bootstrap-initialize248,9154
(defun bootstrap-meta-braid 148,5378
(defun bootstrap-parse-slot 271,10322
(defun bootstrap-parse-slots 267,10174
(defun bootstrap-set-slot 125,4669
(defun bootstrap-slot-index 130,4845
(defun class-of 313,11816
(defun early-collect-inheritance 33,1205
(defun early-collect-inheritance-1 44,1588
(defmethod print-object 325,11986
(defmethod print-object 333,12232
(defmethod print-object 336,12335
(defun slotd-name 97,3709
(defun wrapper-of 315,11855
(defun |SETF 104,3915

combin-test.lisp,1020
(defvar *combination-test-classes*30,1138
(defvar *combination-test-generic-functions* 168,3143
(defvar *combination-tests*45,1369
(defclass bar 243,5472
(defmethod bar 258,5846
(defmethod bar 260,5892
(defmethod bar 261,5942
(defmethod bar 262,5992
(defmethod bar 265,6044
(defmethod bar 266,6094
(defmethod bar 267,6144
(defmethod bar 269,6195
(defmethod bar 270,6245
(defmethod bar 271,6295
(defclass baz 244,5496
(defmethod baz 276,6367
(defmethod baz 277,6427
(defmethod baz 278,6485
(defmethod baz 280,6531
(defmethod baz 281,6581
(defmethod baz 282,6629
(defmethod baz 284,6665
(defmethod baz 285,6715
(defmethod baz 286,6763
(defclass foo 242,5451
(defmethod foo 248,5541
(defmethod foo 249,5601
(defmethod foo 250,5659
(defmethod foo 251,5704
(defclass i 230,5271
(defclass j 231,5290
(defclass k 232,5310
(defclass l 238,5391
(defclass m 239,5410
(defclass n 240,5430
(defun test-combination-points 170,3193
(defclass x 234,5331
(defclass y 235,5350
(defclass z 236,5370

combin.lisp,1268
(defvar *combined-method-method-function-gensyms* 375,12647
(defvar *combined-method-next-methods-gensyms* 374,12596
(defvar *effective-method-templates* 190,6354
(defun add-effective-method-template-entry 234,8111
(defun compile-effective-method-template-entry 250,8664
(defun compile-effective-method-template-entry-internal 276,9610
(defmacro compile-effective-method-templates 269,9365
(defun complex-effective-method-match-p 344,11651
(defun compute-combination-points 58,1983
(defun compute-combined-methods 455,15177
(defun compute-effective-method-body 468,15528
(defun convert-effective-method 442,14826
(defun cross-combination-points 86,2806
(defun cross-product 96,3094
(defun forces-complex-walker-p 302,10377
(defun get-effective-method-code-constructor 221,7607
(defun greatest-join-points 107,3374
(defun make-code-constructor 385,12980
(defun make-complex-effective-method-code-constructor 371,12491
(defun make-effective-method-function 192,6396
(defun make-method-call 465,15431
(defun make-simple-effective-method-code-constructor 368,12378
(defun merge-method-into-list 131,4028
(defmacro precompile-effective-method-template-1255,8908
(defun simple-code-walker 333,11325
(defun simple-effective-method-match-p 308,10572

compat.lisp,427
(defvar *inhibit-with-slots-warning* 52,1803
(defun CBOUNDP 129,4193
(defun GET-SETF-GENERIC-FUNCTION 31,1150
(defun SYMBOL-CLASS 121,3939
(defsetf SYMBOL-CLASS 125,4051
(defun class-named 133,4313
(defsetf class-named 136,4399
(defmacro defmethod-setf 43,1517
(defsetf get-setf-generic-function 34,1222
(defun get-setf-generic-function-name 37,1319
(defmacro obsolete-with-slots54,1846
(defmacro run-super 47,1676

coral-low.lisp,118
(defmacro object-cache-no 36,1344
(defun printing-random-thing-internal 42,1529
(defun set-function-name-1 45,1626

dcode-pre1.lisp,0

dcode.lisp,828
(defvar *dcode-arg-symbols* 88,2671
(defvar *dcode-wrapper-symbols* 100,3029
(define-function-template all-std-class-readers-dcode160,5174
(defun all-std-class-readers-miss193,6050
(defmethod all-std-class-readers-miss-1216,6939
(define-function-template all-std-class-writers-dcode220,7073
(defun all-std-class-writers-miss249,7918
(defmacro cached-method 276,8877
(defun caching-dcode-miss338,10886
(define-function-template caching-discriminating-function287,9250
(defun dcode-arg-symbol 90,2704
(defun dcode-wrapper-symbol 102,3066
(defmacro generic-function-cache-entry 114,3413
(defun make-all-std-class-readers-dcode 143,4483
(defun make-all-std-class-writers-dcode 150,4751
(defmacro pre-make-caching-discriminating-functions 373,12043
(defmacro r/w-cache-key 157,5019
(defmacro r/w-cache-val 158,5096

defclass.lisp,1232
(defvar *slotd-unsupplied* 315,11777
(defmethod ADD-NAMED-CLASS188,7164
(defmethod ADD-READER-METHOD 455,16638
(defmethod ADD-WRITER-METHOD 466,17012
(defmacro DEFCLASS 33,1152
(defmethod EXPAND-DEFCLASS 64,2594
(defmethod LEGAL-CLASS-OPTION-P 397,14356
(defmethod LEGAL-SLOT-OPTION-P 402,14529
(defmethod MAKE-CONSTRUCTOR 419,15333
(defmethod MAKE-SLOTD 362,13130
(defmethod PARSE-CLASS-SLOT 317,11833
(defmethod REMOVE-READER-METHOD 478,17412
(defmethod REMOVE-WRITER-METHOD 483,17648
(defmethod UPDATE-CLASS 228,8675
(defun canonicalize-defclass-option 124,4426
(defun canonicalize-slot-specification 102,3704
(defun class-constant-form 437,16081
(defun class-constant-form 442,16183
(defmethod class-default-initargs 308,11647
(defmethod inform-type-system-about-class 554,20587
(defun load-defclass 138,4863
(defun make-initfunction 82,3162
(defmethod make-reader-method-function 508,18801
(defmethod make-type-predicate 560,20840
(defmethod make-writer-method-function 514,19028
(defun merge-accessor/reader-prefixes 366,13281
(define-function-template reader-function--std 521,19256
(define-function-template type-predicate--std 563,20974
(define-function-template writer-function--std 528,19558

defs.lisp,939
(defvar *early-defclass-forms*30,1149
(defvar *fsc-defclass-forms*128,3470
(defvar *methods-defclass-forms*132,3570
(defvar *next-methods* 441,13532
(defvar *setf-function-names* 207,5568
(defvar *the-class-object*)427,13111
(defvar *the-class-t*)426,13088
(defun define-early-setfs-and-type-predicates 384,11847
(defun do-defsetf 241,6810
(defun do-satisfies-deftype 351,10609
(defmacro do-standard-defsetf 229,6312
(defun do-standard-defsetf-1 234,6553
(defmacro do-standard-defsetfs 253,7258
(defun gboundp 320,9819
(defun gdefinition 330,10075
(defun get-setf-function 343,10453
(defun get-setf-function-name 209,5639
(defun gmakunbound 325,9941
(defun make-setf-method-lambda-list 277,8032
(defun make-type-predicate-name 374,11472
(defmacro parse-gspec 301,9121
(defsetf slot-value 420,12921
(defsetf slot-value-always 422,12958
(defun variable-class 432,13236
(defun |SETF 336,10256
(defun |SETF 346,10517

defsys.lisp,969
(defstruct (module 282,10539
(defvar *pathname-extensions*235,8587
(defvar *pcl-directory*530,19411
(defvar *pcl-system-date* 74,3055
(defvar *port*191,6824
(defvar *system-directory*)183,6543
(defvar *the-pcl-package* 72,3006
(defun compile-filter 355,13352
(defun compile-pcl 606,23603
(defmacro defsystem 271,10302
(defun edit-pcl 637,24694
(defun get-system 265,10157
(defun hardcopy-pcl 643,24867
(defun load-pcl 615,24101
(defun mail-pcl 667,25618
(defun make-binary-pathname 495,18117
(defun make-compile-transformation 326,12219
(defun make-load-transformation 337,12655
(defun make-load-without-dependencies-transformation 347,13064
(defun make-modules 292,10825
(defun make-pathname-internal 497,18192
(defun make-source-pathname 494,18043
(defun make-transformations 319,11978
(defsystem my-very-own-system140,4795
(defun operate-on-system 366,13868
(defsystem pcl550,20233
(defun rename-pcl 627,24390
(defun set-system 268,10216

excl-low.lisp,414
(defmacro %iwmc-class-class-wrapper 71,2255
(defmacro %iwmc-class-static-slots 76,2375
(defun (:property 147,4753
(defun (:property 169,5499
(defun function-arglist 122,3770
(defun iwmc-class-p 58,1926
(defmacro load-time-eval 81,2494
(defmacro memq 44,1636
(defun object-cache-no 97,3042
(defun printing-random-thing-internal 111,3483
(defun set-function-name-1 115,3599
(defun symbol-append 125,3820

fin.lisp,5214
(defstruct (%funcallable-instance985,38298
(defvar *fin-env-type*342,14940
(defvar *funcallable-instance-marker* 249,11238
(defvar *funcallable-instance-marker* 805,32180
(defvar *funcallable-instance-marker* 1036,39771
(defvar *funcallable-instance-trampolines* 138,5929
(defun add-instance-vars 658,27460
(defun allocate-funcallable-instance 1239,46350
(defun allocate-funcallable-instance-1 144,6210
(defun allocate-funcallable-instance-1 253,11367
(defun allocate-funcallable-instance-1 353,15291
(defun allocate-funcallable-instance-1 472,19647
(defun allocate-funcallable-instance-1 555,22653
(defun allocate-funcallable-instance-1 621,25436
(defun allocate-funcallable-instance-1 708,29102
(defun allocate-funcallable-instance-1 752,30520
(defun allocate-funcallable-instance-1 809,32309
(defun allocate-funcallable-instance-1(926,36322
(defun allocate-funcallable-instance-1 1050,40374
(defun allocate-funcallable-instance-1 1145,43360
(defun allocate-funcallable-instance-1 1192,44772
(defun allocate-funcallable-instance-2 818,32637
(defmacro allocate-funcallable-instance-2 1040,39961
(defconstant ccl::$v_istruct 1187,44573
(defconstant ccl::fin-data 1190,44719
(defconstant ccl::fin-function 1189,44685
(defvar ccl::initial-fin-slots 1188,44606
(defmacro fin-closure-size 918,36066
(defun fin-env-fin 345,15030
(defsetf fin-env-fin 351,15250
(defmacro fin-set-mem-hword 920,36132
(defmacro funcallable-instance-class 1230,46044
(defconstant funcallable-instance-closure-size 251,11315
(defconstant funcallable-instance-closure-size 340,14888
(defconstant funcallable-instance-closure-size 807,32257
(defconstant funcallable-instance-closure-size 1038,39848
(defconstant funcallable-instance-data109,4768
(defmacro funcallable-instance-data-1 229,10484
(defmacro funcallable-instance-data-1 306,13708
(defsetf funcallable-instance-data-1 311,13857
(defmacro funcallable-instance-data-1 404,17311
(defsetf funcallable-instance-data-1 412,17616
(defun funcallable-instance-data-1 521,21590
(defsetf funcallable-instance-data-1 525,21755
(defmacro funcallable-instance-data-1 610,25201
(defun funcallable-instance-data-1 678,28272
(defsetf funcallable-instance-data-1 683,28488
(defmacro funcallable-instance-data-1 739,30203
(defmacro funcallable-instance-data-1 783,31501
(defun funcallable-instance-data-1 888,35304
(defsetf funcallable-instance-data-1 904,35814
(defmacro funcallable-instance-data-1 952,37271
(defsetf funcallable-instance-data-1 956,37426
(defmacro funcallable-instance-data-1 1007,39082
(defmacro funcallable-instance-data-1 1104,42217
(defsetf funcallable-instance-data-1 1112,42434
(defun funcallable-instance-data-1 1167,44150
(defsetf funcallable-instance-data-1 1176,44433
(defmacro funcallable-instance-data-1 1213,45580
(defsetf funcallable-instance-data-1 1218,45746
(defmacro funcallable-instance-data-position 115,5009
(defconstant funcallable-instance-flag-bit 433,18077
(defun funcallable-instance-mattress-pad 502,21064
(defun funcallable-instance-name 961,37618
(defsetf funcallable-instance-name 964,37711
(defun funcallable-instance-p 435,18126
(defun funcallable-instance-p 717,29427
(defun funcallable-instance-p 761,30813
(defun funcallable-instance-p 826,32940
(defmacro funcallable-instance-p 941,36875
(defun funcallable-instance-p 1060,40738
(defun funcallable-instance-p 1150,43533
(defun funcallable-instance-p 1202,45153
(defconstant funcallable-instance-procedure-size 136,5812
(defmacro funcallable-instance-static-slots 1236,46246
(defmacro funcallable-instance-wrapper 1233,46152
(defun init-fin-fn 449,18593
(defmacro lexical-closure-environment 1023,39399
(defmacro lexical-closure-environment 1028,39555
(defmacro lexical-closure-function 1032,39686
(defun make-trampoline 223,10347
(defun make-trampoline 302,13618
(defun make-trampoline 399,17212
(defun make-trampoline 441,18332
(defun make-trampoline 733,30066
(defun make-trampoline 777,31364
(defun make-trampoline 884,35214
(defun make-trampoline 1097,42062
(defun make-trampoline 1134,43048
(defconstant procedure-is-funcallable-instance-bit-position 137,5865
(defun set-funcallable-instance-data-1 527,21826
(defun set-funcallable-instance-data-1 685,28559
(defun set-funcallable-instance-data-1 896,35560
(defun set-funcallable-instance-data-1 1171,44282
(defun set-funcallable-instance-function 175,7817
(defun set-funcallable-instance-function 275,12303
(defun set-funcallable-instance-function 369,15978
(defun set-funcallable-instance-function 532,22032
(defun set-funcallable-instance-function 566,23123
(defun set-funcallable-instance-function 630,25859
(defun set-funcallable-instance-function 722,29559
(defun set-funcallable-instance-function 766,30943
(defun set-funcallable-instance-function 834,33174
(defun set-funcallable-instance-function 944,36985
(defun set-funcallable-instance-function 1004,38967
(defun set-funcallable-instance-function 1067,41007
(defun set-funcallable-instance-function 1156,43733
(defun set-funcallable-instance-function 1206,45302
(defun set-funcallable-instance-name 966,37778
(defun un-initialized-fin 1137,43134
(defun |set 348,15129

fixup.lisp,33
(defun print-iwmc-class 37,1306

fsc.lisp,654
(defmethod (setf 58,2007
(defmethod allocate-instance84,2741
(defmethod check-super-metaclass-compatibility78,2561
(defmethod make-reader-method-function 91,2998
(defmethod make-type-predicate 125,4276
(defmethod make-writer-method-function 98,3242
(defmethod optimize-standard-instance-access-internal45,1699
(define-function-template reader-function--fsc 105,3486
(defmethod slot-boundp-using-class63,2193
(defmethod slot-makunbound-using-class68,2366
(defmethod slot-value-using-class53,1836
(define-function-template type-predicate--fsc 128,4422
(defmethod wrapper-fetcher41,1597
(define-function-template writer-function--fsc 112,3802

gcl-patches.lisp,162
(defun %write-structure 18,346
(defun PORTABLE-PROGV-BIND 123,4129
(defun PORTABLE-PROGV-UNBIND 132,4448
(deftransform PROGV 140,4729
(DEFmacro TIME 81,2564

gold-low.lisp,82
(defmacro object-cache-no 39,1290
(defun printing-random-thing-internal 47,1492

high.lisp,1569
(define-built-in-classes)160,5241
(defvar *built-in-class-symbols* 108,3292
(defvar *built-in-classes*90,2758
(defvar *built-in-wrapper-symbols* 109,3329
(defmethod *make-instance 407,12728
(defvar *traced-methods* 339,10781
(defmethod allocate-instance 62,1861
(defclass built-in-class 55,1654
(defun built-in-class-of 216,6794
(defun built-in-wrapper-of 213,6725
(defmethod change-class 410,12853
(defmethod check-super-metaclass-compatibility 34,1238
(defmethod check-super-metaclass-compatibility 69,2140
(defmethod check-super-metaclass-compatibility 78,2483
(defmethod check-super-metaclass-compatibility82,2595
(defmethod class-for-redefinition 38,1348
(defun compile-method 383,12063
(defun define-built-in-classes 129,3978
(defmethod describe302,9684
(defmethod describe309,9864
(defmethod describe-class 225,6875
(defun describe-instance 248,7749
(defclass forward-referenced-class 32,1181
(defun get-built-in-class-symbol 111,3369
(defun get-built-in-wrapper-symbol 120,3668
(defmethod inform-type-system-about-class 59,1761
(defun make-built-in-class-of-body 186,5919
(defun make-built-in-class-subs 166,5298
(defun make-built-in-class-tree 175,5570
(defun make-built-in-wrapper-of-body 181,5767
(defun make-built-in-wrapper-of-body-1 192,6068
(defun make-built-in-wrapper-of-body-2 198,6323
(defmethod mki 404,12625
(defmethod slots-to-inspect 245,7656
(defun trace-method 341,10811
(defun trace-method-internal 371,11762
(defmacro undefmethod 390,12298
(defun undefmethod-1 395,12451
(defun untrace-method 348,11029

hp-low.lisp,116
(defmacro load-time-eval 57,2139
(defmacro object-cache-no 81,2771
(defun printing-random-thing-internal 87,2902

init.lisp,415
(defmethod *default-initargs 49,1778
(defvar *default-initargs-flag* 47,1733
(defmethod *initialize-instance 71,2529
(defmethod *make-instance 33,1222
(defconstructor make-foo 223,7604
(defun make-instance 193,6481
(defmethod reinitialize-instance 74,2648
(defmethod shared-initialize 114,3979
(defmethod update-instance-for-different-class 82,2852
(defmethod update-instance-for-redefined-class 102,3647

iterate.lisp,1312
(defvar *active-gatherers* 902,42632
(defparameter *iterate-temp-vars-list*101,4199
(defvar *iterate-warnings* 39,1494
(defmacro collecting 1159,56452
(defmacro eachtime 855,41295
(defun expand-into-let 432,23011
(defun extract-special-bindings 581,30007
(defun function-lambda-p 593,30430
(defmacro gathering 874,41615
(defmacro interval 748,37519
(defmacro iterate 47,1756
(defmacro iterate* 51,1868
(defmacro joining 1169,56847
(defmacro list-elements 799,39579
(defmacro list-tails 807,39774
(defmacro maximizing 1176,57061
(defun maybe-warn 733,37109
(defmacro minimizing 1193,57825
(defun mv-setq 686,34932
(defun optimize-gathering-form 906,42739
(defun optimize-iterate-form 107,4426
(defun parse-declarations 535,28086
(define-walker-template prog1 1220,58892
(defun rename-and-capture-variables 1029,49481
(defun rename-let-bindings 614,31073
(defun rename-variables 669,34111
(defmacro sequence-elements 829,40443
(defun simple-expand-gathering-form 879,41783
(defun simple-expand-iterate-form 55,1982
(defmacro string-characters 842,40864
(defmacro summing 1210,58589
(defmacro until 866,41501
(defun variable-same-p 728,36992
(defun variables-from-let 525,27804
(defmacro vector-elements 816,40027
(defun walk-gathering-body 1057,50880
(defmacro while 861,41406

kcl-low.lisp,806
(define-cstruct-accessor cclosure-data 117,4742
(define-cstruct-accessor cclosure-env 123,5053
(define-cstruct-accessor cclosure-name 113,4505
(define-cstruct-accessor cclosure-self 115,4628
(define-cstruct-accessor cclosure-size 121,4967
(define-cstruct-accessor cclosure-start 119,4856
(defentry cclosurep 137,5454
(define-cstruct-accessor cfun-data 85,3408
(define-cstruct-accessor cfun-name 82,3222
(define-cstruct-accessor cfun-self 83,3302
(define-cstruct-accessor cfun-size 87,3565
(define-cstruct-accessor cfun-start 86,3488
(defentry cfunp 99,3926
(defmacro define-cstruct-accessor 38,1446
(defmacro load-time-eval 163,6399
(defmacro memory-block-ref 166,6480
(defmacro object-cache-no 183,7036
(defun printing-random-thing-internal 189,7181
(defun set-function-name-1 193,7279

kcl-patches.lisp,57
(defvar *defmacro*)30,1149
(defun new-defmacro 48,1821

low.lisp,2310
(defmacro %+ 99,4165
(defmacro %1+ 103,4302
(defmacro %allocate-instance--class 358,13402
(defmacro %allocate-instance--class-1 363,13582
(defmacro %allocate-static-slot-storage--class 378,14198
(defmacro %logand 91,3871
(defmacro %logxor 95,4018
(defmacro %svref 107,4416
(defsetf %svref 112,4588
(defstruct (iwmc-class 343,12778
(defvar *class-of*261,9658
(defvar *slot-unbound* 376,14155
(defvar *templated-function-types* 583,22456
(defvar *warned-about-object-cache-no* 452,16646
(defvar *wrapper-of*270,9933
(defmacro class-of--class 382,14323
(defmacro class-of-1 280,10200
(defconstant class-wrapper-size 392,14486
(defmacro clear-memory-block 237,8774
(defmacro compile-templated-function-constructors 627,24218
(defmacro define-function-template 584,22495
(defun function-pretty-arglist 487,18155
(defsetf function-pretty-arglist 491,18234
(defun get-templated-function-constructor 603,23268
(defun intern-function-name 523,19472
(defmacro invalidate-wrapper 435,15886
(defmacro iwmc-class-class-wrapper 350,13006
(defmacro iwmc-class-static-slots 351,13078
(defun make-%+ 119,4794
(defun make-cache-mask 208,7714
(defmacro make-class-wrapper 398,14573
(defmacro make-memory-block 187,7106
(defmacro make-memory-block-mask 221,8060
(defun make-templated-function-constructor-constructor 679,25772
(defmacro memory-block-ref 194,7297
(defsetf memory-block-ref 200,7484
(defmacro object-cache-no 465,17194
(defmacro pre-make-templated-function-constructor 620,23942
(defmacro pre-make-templated-function-constructor-internal644,24736
(defmacro precompile-random-code-segments 638,24582
(defun print-iwmc-class 353,13149
(defun record-definition 696,26289
(defun reduce-variadic-to-binary129,5073
(defun reset-templated-function-types 599,23128
(defun set-function-name 513,19146
(defun set-function-name-1 519,19350
(defun set-function-pretty-arglist 493,18297
(defun show-templated-function-types 688,26042
(defmacro validate-wrapper 423,15345
(defmacro with-interrupts 162,6071
(defmacro without-interrupts 159,6009
(defmacro wrapper-cache-no 409,15027
(defmacro wrapper-class 418,15259
(defmacro wrapper-class-slots 415,15184
(defmacro wrapper-instance-slots-layout 412,15099
(defmacro wrapper-of-1 288,10423
(defmacro wrapper-of-2 296,10636

lucid-low.lisp,396
(defmacro %logand 98,3458
(defmacro cache-no 163,5012
(defmacro cache-no 172,5166
(defun function-arglist 217,6793
(defstruct-simple-predicate  iwmc-class 151,4757
(defun logand&-variable 109,3645
(defun logand&-variable 168,5103
(defmacro make-memory-block 140,4329
(defmacro object-cache-no 159,4897
(defun printing-random-thing-internal 235,7330
(defun set-function-name-1 190,5681

macros.lisp,1298
(defvar *find-class* 451,15707
(defvar *keyword-package* 157,5462
(defmacro *list-elements 491,16913
(defmacro *list-tails 499,17123
(defun FIND-CLASS 457,15837
(defsetf FIND-CLASS 466,16142
(defmacro alist-entry 182,6284
(defmacro assq 62,2320
(defun capitalize-words 426,15065
(defmacro check-member 176,6037
(defmacro collecting-once 290,9800
(defmacro delq 64,2442
(defun destructure 210,7191
(defun destructure-internal 222,7635
(defmacro destructuring-bind 198,6871
(defmacro doplist 301,10208
(defun extract-declarations 124,4456
(defun false 81,2957
(defun find-wrapper 475,16487
(defmacro keyword-bind 316,10770
(defmacro keyword-parse 337,11541
(defun keyword-parse-assq 396,14278
(defun legal-class-name-p 453,15759
(defun make-caxr 69,2607
(defun make-cdxr 74,2741
(defun make-keyword 159,5514
(defun make-plist 84,3073
(defmacro memq 61,2259
(defmacro neq 66,2566
(defmacro once-only 98,3567
(defmacro posq 65,2503
(defmacro printing-random-thing 410,14721
(defun printing-random-thing-internal 418,14948
(defmacro rassq 63,2380
(defun reduce-constant 478,16556
(defun remtail 91,3216
(defun string-append 164,5627
(defun symbol-append 173,5927
(defun true 80,2901
(defmacro with-collection 283,9617
(defun zero 82,3016
(defun |SETF 470,16300

methods.lisp,2389
(defmethod (setf 70,2007
(defvar *individual-specializer-methods* 128,4019
(defvar *invalid-generic-functions-on-stack* 651,23034
(defvar *lookup-method1* 441,15094
(defvar *lookup-method2* 442,15165
(defmethod ADD-METHOD-ON-SPECIALIZER 130,4092
(defmethod REMOVE-METHOD-ON-SPECIALIZER 141,4510
(defmethod compute-discriminating-function-arglist-info535,18175
(defun compute-discriminating-function-arglist-info-internal550,18868
(defmethod compute-discriminator-code 348,11907
(defun compute-discriminator-code-1 352,12052
(defmethod flush-generic-function-caches305,10353
(defconstant generic-function-cache-size 296,10068
(defmethod generic-function-default-method278,9410
(defun generic-function-p 63,1746
(defmethod generic-function-pretty-arglist200,6740
(defmacro get-class 444,15237
(defun get-class-1 454,15449
(defmacro get-cpl 449,15344
(defun get-cpl-1 457,15526
(defmethod initialize-generic-function-cache310,10553
(defmethod install-discriminating-function340,11554
(defmethod invalidate-generic-function 648,22931
(defun lookup-method-1 424,14664
(defun lookup-method-2 431,14884
(defun lookup-method-internal 464,15733
(defmethod make-caching-discriminating-function 318,10862
(defmethod make-default-method-only-dcode 402,13851
(defun make-discriminating-function-arglist 581,20356
(defun make-generic-function-cache 298,10114
(defun make-generic-function-cache-mask 301,10204
(defmethod make-individual-method-dcode 405,13985
(defmethod make-multi-method-dcode 416,14328
(defmethod make-no-methods-dcode 395,13602
(defun make-specializable 156,5042
(defmethod method-equal 273,9218
(defun method-p 65,1815
(defmethod method-pretty-arglist 223,7601
(defmethod method-pretty-arglist-1 249,8389
(defmethod no-applicable-method 589,20742
(defun notice-methods-change 653,23084
(defun notice-methods-change-1 695,25067
(defun notice-methods-change-2 688,24814
(defmethod print-object 87,2619
(defmethod print-object 97,3052
(defmethod reader/writer-method-slot-name 82,2475
(defun real-add-method 635,22353
(defun real-add-named-method 610,21436
(defun real-get-method 262,8797
(defun real-remove-method 597,20937
(defun remove-method-internal 602,21104
(defmethod remove-named-method 104,3261
(defun standard-reader-method-p 67,1864
(defun standard-writer-method-p 68,1935
(defmethod update-discriminator-code335,11361

mki.lisp,392
(defvar *initarg-argument-symbols* 134,4684
(defmethod default-initargs 44,1640
(defun default-initargs-internal 50,1904
(defun initarg-argument-symbol 136,4760
(defmethod initialize-instance 62,2280
(defun install-constructor-1 141,4946
(defun install-constructor-2 153,5266
(defun install-constructor-internal 166,5640
(defmethod mki 37,1368
(defun optimize-make-instance 86,3028

patch.lisp,214
(defvar *method-fdefs* 59,1930
(defvar *method-setf-fdefs* 60,1996
(defun load-defmethod7,123
(defun load-defmethod-internal21,570
(defun parse-pcl-defmethod-for-zwei 77,2487
(defun record-definition 63,2069

pkg.lisp,61
(defvar *exports* 62,1943
(defvar *other-exports* 114,2976

pyr-low.lisp,35
(defmacro object-cache-no 45,1680

pyr-patches.lisp,0

slots.lisp,1803
(defmethod (setf 53,1961
(defmethod (setf 346,12882
(defvar *slot-value-cache* 84,3315
(defmethod allocate-instance 403,14764
(defmacro bind-wrapper-and-static-slots--fsc 280,10473
(defmacro bind-wrapper-and-static-slots--std 274,10258
(defmethod class-slot-value 48,1760
(defmethod copy-slotd 244,9200
(defmacro find-slotd 236,8983
(defun get-class-slot-value-1 30,1138
(defmacro get-slot-value-1 143,5582
(defmacro get-slot-value-2 180,6873
(defun get-slot-value-cache-miss194,7353
(defmethod initialize 417,15267
(defmethod initialize-from-defaults 421,15405
(defmethod initialize-from-init-plist 432,15811
(defun make-instance 411,15071
(defun reduce-slot-value--mumble-arg 86,3386
(defun set-class-slot-value-1 38,1469
(defun set-slot-value 261,9804
(defmacro set-slot-value-1 161,6223
(defmacro set-slot-value-2 186,7106
(defun set-slot-value-cache-miss206,7859
(defmacro setf-slot-value-using-class-1 310,11593
(defun slot-boundp 264,9936
(defmethod slot-boundp-using-class351,13056
(defmacro slot-boundp-using-class-1 316,11833
(defun slot-exists-p 270,10150
(defmethod slot-exists-p-using-class 361,13386
(defun slot-makunbound 267,10039
(defmethod slot-makunbound-using-class356,13217
(defmacro slot-makunbound-using-class-1 325,12184
(defmethod slot-missing368,13573
(defmethod slot-unbound 381,14059
(defun slot-value 258,9703
(defmacro slot-value--fsc 113,4376
(defmacro slot-value--std 104,4019
(defconstant slot-value-cache-mask 83,3237
(defconstant slot-value-cache-size 82,3196
(defmethod slot-value-using-class341,12723
(defmacro slot-value-using-class-1 304,11364
(defmacro slotd-position 227,8687
(defun sub-class-p 399,14613
(defun subclassp 394,14411
(defmacro typep--class 387,14192
(defmacro |SETF 130,5112
(defmacro |SETF 133,5219

std-class.lisp,1467
(defmethod (setf 49,1819
(defmethod COMPUTE-EFFECTIVE-SLOTD 473,17168
(defmethod PROPAGATE-CLASS-UPDATE 113,3765
(defmethod change-class 855,31410
(defmethod change-class 866,31772
(defmacro change-class-internal 811,29728
(defmethod check-super-metaclass-compatibility 684,25257
(defmethod class-direct-generic-functions 56,2047
(defmethod class-direct-methods 45,1679
(defmethod class-for-redefinition 341,12546
(defun class-ordering-error 640,23614
(defmethod class-prototype 30,1149
(defun classp 690,25585
(defun collect-all-default-initargs 319,11611
(defmethod collect-slotds 391,14038
(defmethod compatible-meta-class-change-p 681,25138
(defmethod compute-class-precedence-list 525,18686
(defmethod compute-method-inheritance-list 676,24972
(defmethod make-instances-obsolete 701,25878
(defun named-object-print-function 886,32310
(defun obsolete-instance-trap 724,26928
(defmacro obsolete-instance-trap-1 746,27719
(defmethod obsolete-instance-trap-internal 794,29305
(defmethod obsolete-instance-trap-internal 800,29496
(defmethod order-slotds 432,15594
(defun shared-tail 376,13659
(defun update-constructors--class 291,10333
(defmethod update-method-inheritance 352,12794
(defun update-method-inheritance-1 365,13263
(defun update-slot-accessors--class 246,8771
(defun update-slot-accessors--class-1 251,8902
(defun update-slot-accessors--class-2 267,9618
(defun update-slots--class 193,6989
(defun walk-supers 599,21739

test.lisp,537
(defvar *built-in-class-tests*107,3417
(defvar *call-next-method-test-object* 402,12516
(defclass class-for-testing-change-class-1 824,25532
(defclass class-for-testing-change-class-2 828,25661
(defun cleanup-do-test 64,2284
(defmacro do-test 48,1828
(defmacro do-test-error 58,2113
(defclass initalization-test-4 587,17739
(defclass initialization-test-1 571,17013
(defclass initialization-test-2 576,17219
(defclass initialization-test-3 581,17461
(defclass initialization-test-5 591,17840
(defclass test-class-1 303,9571

ti-low.lisp,300
(defun function-arglist 64,2068
(defun method-function-spec-handler73,2388
(defmacro object-cache-no 46,1529
(defun printing-random-thing-internal 56,1745
(defun record-definition 67,2119
(defun set-function-name 84,2771
(defmacro with-interrupts 35,1310
(defmacro without-interrupts 32,1232

trace.lisp,0

vaxl-low.lisp,185
(defun function-arglist 58,1842
(defmacro load-time-eval 34,1223
(defmacro object-cache-no 48,1565
(defun printing-random-thing-internal 54,1727
(defun set-function-name-1 61,1927

vector.lisp,2048
(defvar *intern-pv*387,13712
(defvar *intern-slot-lists*214,7730
(defvar *intern-slot-lists-1* 201,7265
(defvar *last-wrapper-cache-no* 83,3006
(defvar *min-cache-size-for-wrapper-cache-no-trap* 85,3042
(defvar *primary-pv-cache-multiple* 475,16684
(defvar *pv-cache-1* 249,8985
(defvar *pv-cache-1-mask* 248,8920
(defvar *pv-cache-1-size* 247,8888
(defvar *pv-cache-2* 270,9717
(defvar *pv-cache-2-mask* 269,9652
(defvar *pv-cache-2-size* 268,9620
(defvar *pv-cache-3* 294,10581
(defvar *pv-cache-3-mask* 293,10516
(defvar *pv-cache-3-size* 292,10484
(defvar *pv-cache-n* 326,11744
(defvar *pv-cache-n-mask* 327,11784
(defmethod OPTIMIZE-SET-SLOT-VALUE 420,14660
(defmethod OPTIMIZE-SLOT-VALUE 414,14451
(defun add-pv-binding 483,16894
(defmacro cache-key-from-wrappers 95,3338
(defun cache-key-from-wrappers-1 122,4470
(defun cache-key-from-wrappers-2 144,5266
(defun can-optimize-access 402,14053
(defun compute-primary-pv-cache-size 477,16725
(defmacro fsc-instance-access-pv558,19400
(define-walker-template fsc-instance-access-pv)548,19140
(defun get-next-wrapper-cache-no 87,3098
(defmacro instance-slot-position 152,5571
(defun intern-in-list-table 177,6473
(defun intern-pv 393,13863
(defun intern-slot-lists 219,7859
(defun intern-slot-lists-1 203,7339
(defun intern-slot-lists-2 210,7592
(defun lookup-pv 231,8303
(defun lookup-pv-1 250,9038
(defun lookup-pv-2 271,9770
(defun lookup-pv-3 295,10634
(defun lookup-pv-miss 365,13041
(defmethod lookup-pv-miss-1 377,13432
(defun lookup-pv-n 329,11837
(defun make-intern-list-table 174,6328
(defun make-permutation-vector 396,13939
(defun optimize-standard-instance-access 428,14905
(defmethod optimize-standard-instance-access-internal 451,15975
(defun primary-pv-cache-miss 537,18699
(defun pv-access-trap 582,20209
(defun sort-slots-into-isl 454,16082
(defmacro std-instance-access-pv550,19189
(define-walker-template std-instance-access-pv)547,19092
(defun std-instance-access-pv-internal566,19621
(defmethod wrapper-fetcher 534,18617

walk.lisp,6308
(define-walker-template #+LCL3.0 1077,36955
(defun %alphalex-p 247,8800
(defstruct (variable 269,9345
(defvar *VARIABLE-DECLARATIONS* 890,29043
(defvar *globally-special-variables* 923,30348
(defvar *key-to-walker-environment* 789,25941
(define-walker-template BLOCK 1034,34761
(define-walker-template CATCH 1035,34831
(define-walker-template COMPILER-LET 1036,34902
(define-walker-template COND 1072,36808
(define-walker-template DECLARE 1037,34966
(define-walker-template DO 1068,36638
(define-walker-template DO* 1069,36679
(define-walker-template EVAL-WHEN 1038,35036
(DEFMACRO FIND-LOCAL-DEFINITION 632,20846
(define-walker-template FLET 1039,35108
(define-walker-template FUNCTION 1040,35164
(define-walker-template GO 1041,35221
(define-walker-template IF 1042,35279
(define-walker-template LABELS 1043,35333
(define-walker-template LAMBDA 1044,35391
(define-walker-template LET 1045,35449
(define-walker-template LET* 1046,35504
(DEFMACRO MACRO-DEF? 624,20501
(define-walker-template MACROLET 1047,35560
(define-walker-template MULTIPLE-VALUE-BIND 1051,35836
(define-walker-template MULTIPLE-VALUE-CALL 1048,35620
(define-walker-template MULTIPLE-VALUE-PROG1 1049,35691
(define-walker-template MULTIPLE-VALUE-SETQ 1050,35764
(defun NESTED-WALK-FORM 1114,38572
(define-walker-template PROG 1070,36721
(define-walker-template PROG* 1071,36764
(define-walker-template PROGN 1052,35907
(define-walker-template PROGV 1053,35973
(define-walker-template QUOTE 1054,36049
(define-walker-template RETURN-FROM 1055,36107
(define-walker-template SETQ 1056,36181
(define-walker-template TAGBODY 1057,36251
(define-walker-template THE 1058,36310
(define-walker-template THROW 1059,36373
(define-walker-template UNWIND-PROTECT 1060,36435
(defun VARIABLE-DECLARATION 892,29088
(defun VARIABLE-LEXICAL-P 887,28962
(defun VARIABLE-SPECIAL-P 901,29471
(defun WALK-FORM 1086,37231
(defun add-contour-to-env-shape 264,9196
(defun add-function-contour 293,9960
(defun add-macrolet-contour 296,10085
(defun add-sfc-contour 290,9845
(defmacro bar 1753,60274
(defun convert-macro-to-lambda 759,24922
(defun convert-macro-to-lambda 765,25119
(defmacro define-walker-template1010,34189
(defmacro do-sfc-contours 310,10569
(defun env-declarations 869,28576
(defun env-lexical-variables 872,28633
(defun env-lock 791,25988
(defun env-walk-form 866,28523
(defun env-walk-function 863,28467
(defun environment-function 157,6438
(defun environment-function 214,8079
(defun environment-function 360,12083
(defun environment-function 457,15072
(defun environment-function 523,17183
(defun environment-function 570,18669
(defun environment-function 654,21681
(defun environment-macro 163,6585
(defun environment-macro 221,8281
(defun environment-macro 379,12635
(defun environment-macro 467,15396
(defun environment-macro 531,17450
(defun environment-macro 577,18835
(defun environment-macro 644,21281
(defun environment-macro 727,24007
(defun expand-rpush 1711,58586
(defun find-alist-element-in-contour 304,10367
(defun find-macrolet-in-contour 307,10473
(defun find-variable-in-contour 299,10194
(defmacro flet-1 1886,65101
(defmacro foo 1751,60230
(defconstant function-contour 257,9083
(defconstant function-sfc-contour 274,9457
(defconstant function-variable-type 276,9531
(defun get-implementation-dependent-walker-template 1025,34628
(defun get-walker-template 1016,34366
(defmacro get-walker-template-internal 1005,33974
(defmacro labels-1 1887,65133
(define-walker-template lambda-block 1080,37083
(defun lookup-macro-function 720,23761
(defun lucid::augment-lexenv-fvars-dummy 254,8958
(defstruct lucid::contour260,9150
(defconstant macrolet-contour 258,9116
(defconstant macrolet-sfc-contour 275,9494
(defun make-function-variable 278,9571
(defun make-sfc-contour 281,9656
(defun note-declaration 876,28697
(defun note-lexical-binding 881,28832
(defun recons 1301,45104
(defun relist 1307,45229
(defun relist* 1310,45291
(defun relist-internal 1313,45353
(defun sfc-contour-elements 287,9781
(defun sfc-contour-type 284,9721
(defmacro take-it-out-for-a-test-walk 1723,58935
(defun unbound-lexical-function 113,4820
(defun variable-globally-special-p 925,30390
(defun walk-arglist 1378,47548
(defun walk-bindings-1 1504,51549
(defun walk-bindings-2 1529,52372
(defun walk-compiler-let 1585,54104
(defun walk-declarations 1325,45579
(defun walk-do 1422,49200
(defun walk-do* 1425,49273
(defun walk-do/do* 1464,50338
(defun walk-flet 1625,55421
(defun walk-form-internal 1178,40856
(defun walk-if 1657,56403
(defun walk-labels 1641,55903
(defun walk-lambda 1548,52894
(defun walk-let 1410,48892
(defun walk-let* 1413,48968
(defun walk-let/let* 1428,49345
(defun walk-macrolet 1599,54516
(defun walk-multiple-value-bind 1483,50947
(defun walk-named-lambda 1560,53303
(defun walk-prog 1416,49043
(defun walk-prog* 1419,49122
(defun walk-prog/prog* 1444,49797
(defun walk-repeat-eval 1295,44941
(defun walk-tagbody 1574,53758
(defun walk-tagbody-1 1577,53866
(defun walk-template 1217,42410
(defun walk-template-handle-repeat 1264,43883
(defun walk-template-handle-repeat-1 1274,44173
(defun walk-unexpected-declare 1372,47371
(defmacro walker-environment-bind 783,25744
(defun walker-environment-bind-1 795,26067
(defun walker-environment-bind-1 811,26769
(defmacro with-augmented-environment142,5988
(defmacro with-augmented-environment199,7610
(defmacro with-augmented-environment315,10715
(defmacro with-augmented-environment429,14258
(defmacro with-augmented-environment488,15957
(defmacro with-augmented-environment554,18121
(defmacro with-augmented-environment690,22889
(defmacro with-augmented-environment703,23139
(defun with-augmented-environment-internal 149,6197
(defun with-augmented-environment-internal 206,7819
(defun with-augmented-environment-internal 326,11047
(defun with-augmented-environment-internal 502,16550
(defun with-augmented-environment-internal 561,18334
(defun with-augmented-environment-internal 671,22214
(defun with-augmented-environment-internal 710,23348
(defmacro with-lexical-macros 1707,58393
(defmacro with-new-definition-in-environment737,24234
(defmacro with-rpush 1714,58656
(define-walker-template zl::named-lambda 1075,36887

xerox-low.lisp,391
(defstruct (iwmc-class 78,2863
(defun compiled-closure-fnheader 227,7320
(defsetf compiled-closure-fnheader 233,7580
(defun function-arglist 165,5556
(defmacro load-time-eval 32,1219
(defmacro object-cache-no 197,6677
(defun printing-random-thing-internal 204,6810
(defun record-definition 210,6991
(defun set-compiled-closure-fnheader 230,7444
(defun set-function-name-1 247,8144
