<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel about="http://blog.gmane.org/gmane.comp.lang.dylan.gwydion.devel">
    <title>gmane.comp.lang.dylan.gwydion.devel</title>
    <link>http://blog.gmane.org/gmane.comp.lang.dylan.gwydion.devel</link>
    <description/>
    <syn:updatePeriod>hourly</syn:updatePeriod>
    <syn:updateFrequency>1</syn:updateFrequency>
    <syn:updateBase>1901-01-01T00:00+00:00</syn:updateBase>
    <items>
      <rdf:Seq>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2188"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2187"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2186"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2185"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2184"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2183"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2182"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2181"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2180"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2179"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2178"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2177"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2176"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2175"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2174"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2173"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2172"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2171"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2170"/>
        <rdf:li rdf:resource="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2169"/>
      </rdf:Seq>
    </items>
    <image rdf:resource="http://gmane.org/img/gmane-25t.png"/>
    <textinput rdf:resource=""/>
  </channel>
  <image rdf:about="http://gmane.org/img/gmane-25t.png">
    <title>Gmane</title>
    <url>http://gmane.org/img/gmane-25t.png</url>
    <link>http://gmane.org</link>
  </image>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2188">
    <title>Re: [chatter] r11972 - trunk/gwydion/common/io/streams</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2188</link>
    <description>
That was an oversight on my part.


For pipes, stream-size returns #f. In this case the method of
pre-allocating the space needed for the remainder of the stream will not
work, and so we have to fall back on reading one element at a time until
end-of-file.  I'll add a comment the next time I touch this file.
</description>
    <dc:creator>Peter S. Housel</dc:creator>
    <dc:date>2008-11-15T20:58:36</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2187">
    <title>Re: [chatter] r11972 - trunk/gwydion/common/io/streams</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2187</link>
    <description>
Why does this need to call stream.stream-size again?  Why not
use the-size instead?


The reason for calling next-method here escapes me.  Is
it worth a comment, or should it be pretty obvious to anyone
who knows anything about streams (unlike me)?

-Carl
_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Carl Gay</dc:creator>
    <dc:date>2008-11-15T20:33:20</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2186">
    <title>International Lisp Conference</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2186</link>
    <description>

-------- Original Message --------
Subject: International Lisp Conference
Date: Sun, 02 Nov 2008 06:19:38 -0500
From: Dan Weinreb &lt;dlw&lt; at &gt;itasoftware.com&gt;


              CALL FOR SUBMISSIONS

           INTERNATIONAL LISP CONFERENCE 2009

                Lisp: The Next 50 Years

          http://www.international-lisp-conference.org

         Massachusetts Institute of Technology
             Cambridge, Massachusetts, USA
               March 22-25, 2009


           Sponsored by the Association of Lisp Users

General Information:

The Association of Lisp Users is pleased to announce the 2009
International Lisp Conference will be held in Cambridge,
Massachusetts, at the Massachusetts Institute of Technology, Sunday
through Wednesday, March 22-25, 2009.  The emphasis will be on present
and future applications of technologies that have been or might soon
be associated with the Lisp programming language and/or related
languages and software.

We encourage submissions in diverse areas, including but not limited
to: language design and implementation, memory management, software
engineering, mathematical and scientific computing, artificial
intelligence, database processing and data mining, business
intelligence, performance analysis, parallel processing, quantum
computing, bioinformatics, telecommunications and networking, the
semantic web, music, domain-specific languages, and entertainment
technologies.  ILC09 is not limited to topics discussed in previous
symposia.  Authors concerned about the appropriateness of a topic may
communicate by electronic mail with the program chair prior to
submission.

Explaining a known idea in a new way may make as strong a contribution
as inventing a new one. We encourage the submission of "pearls":
elegant essays that illustrate an idea, for example by developing a
short program. (A pearl should be concise, instructive,
self-contained, and entertaining. Your pearl is likely to be rejected
if your readers get bored, if the material gets too complicated, if
too much specialized knowledge is needed, or if the writing is
inelegant. The key to writing a good pearl is polishing.)

There is no formal separation of categories and no need to explicitly
label pearls as such: all papers, whether pearl or otherwise, will be
judged on a combination of correctness, significance, novelty,
clarity, and elegance.  Each paper should explain its contributions in
both general and technical terms, identifying what has been
accomplished, explaining why it is significant, and comparing it with
previous work. Authors should strive to make their papers
understandable to a broad audience.

Alongside our usual four-day program of tutorials, prominent invited
speakers, and excellent technical sessions, this year we will also
consider demonstration sessions.

The official language of the conference is English.  Further details
are available at the conference web site:
http://www.international-lisp-conference.org

Technical Program:

Original submissions in all areas related to the conference themes are
invited for the following categories.

Papers: Technical papers of up to 15 pages that describe original
results ("research papers") or explain known ideas in new ways
("pearls").

Demonstrations: Abstracts of up to 4 pages for demonstrations of
tools, libraries, and applications.

Tutorials: Abstracts of up to 4 pages for in-depth presentations about
topics of special interest for at least 90 minutes and up to 180
minutes.

Panel discussions: Abstracts of up to 4 pages for discussions about
current themes. Panel discussion proposals must mention panel members
who are willing to partake in a discussion.

Lightning talks: Abstracts of up to one page for talks to last
for no more than 5 minutes.

Important Dates:

Please send contributions before the submission deadline to the
program committee (ilc09-program-committee at alu.org).

  Deadline for submissions:  December 9, 2008
  Notification of acceptance or rejection:  January 9, 2009
  Deadline for final paper submissions:  February 9, 2009

Organizing Committee:

Conference Chair: Daniel Weinreb (ITA Software)
   General correspondence: ilc09-organizing-committee at alu.org
Program Chair: Guy L. Steele Jr. (Sun Microsystems Laboratories)
   Contact: ilc09-program-committee at alu.org
Local chair: Howard Shrobe (MIT)

Technical Program Committee:
   Guy Steele (chair), Sun Microsystems Laboratories
   Jerry Boetje, College of Charleston
   William Clinger, Northeastern University
   Pascal Costanza, Vrije Universiteit Brussel
   Jeff Dalton, University of Edinburgh
   Tim McNerney, ITA Software
   Henry Lieberman, MIT
   Julian Padget, University of Bath
   Christian Queinnec, Laboratoire d'Informatique de Paris
   Jon L White, The Ginger Ice Cream Factory / ALU
   David Wilkins, SRI
   Taiichi Yuasa, Kyoto University


_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Carl Gay</dc:creator>
    <dc:date>2008-11-03T20:36:38</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2185">
    <title>Re: [chatter] r11967 - intrunk/libraries:registry/genericutilities/dynamic-bindingutilities/dynamic-binding/test</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2185</link>
    <description>
BTW, though the threads library/module on GD mostly does nothing,
dynamic-bind does work fine in GD.

-Peter-


_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Peter Housel</dc:creator>
    <dc:date>2008-11-03T18:33:35</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2184">
    <title>Re: [chatter] r11967 - in trunk/libraries: registry/generic utilities/dynamic-binding utilities/dynamic-binding/test</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2184</link>
    <description>I have no idea what the trade-offs are, performance-wise. I assume  
that OD and GD keep their handlers in a thread-local stack, but I  
don't know.

Functionally, this library is slightly better than global + dynamic- 
bind because it allows for varying types for the binding in each  
dynamic scope, slightly worse because of keeping track of dynamically  
bound names, and simply different in that you can ask for a  
dynamically scoped value and not have one available (in which case you  
can specify a default).

But yeah, a major advantage is that it works for both GD and OD.


On Nov 3, 2008, at 9:03 AM, Carl Gay wrote:

_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Dustin Voss</dc:creator>
    <dc:date>2008-11-03T17:28:14</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2183">
    <title>Re: [chatter] r11967 - in trunk/libraries: registry/genericutilities/dynamic-binding utilities/dynamic-binding/test</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2183</link>
    <description>
This is pretty cool.  I think it would be good, though, if you
added something to this README explaining the trade-offs between
this and Open Dylan's thread variables + dynamic-bind macro.  I
assume this is more expensive because it has to walk the stack
to find matching condition handlers?  Or maybe it's not, judging
by a comment from Riastradh in #dylan on Oct 15 18:46:23 EDT.
I assume the major benefit is that it works in both OD and GD?
I guess I could write a benchmark. :-)

-Carl
_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Carl Gay</dc:creator>
    <dc:date>2008-11-03T17:03:24</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2182">
    <title>Buildbot, and a minor Gwydion change</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2182</link>
    <description>For those who hadn't noticed, we've now got a Buildbot running. Right
now it does an automatic build whenever anything affecting Gwydion
Dylan 2.5.x is committed; automatic builds for Open Dylan will come
soon.  You can monitor what the Buildbot is currently up to at
http://www.opendylan.org/buildbot/ (trailing slash required).

Right now we have builders and build hosts for

- FreeBSD 8.0-CURRENT
- Debian GNU/Linux 4.0 (Etch)
- Mac OS X

If you have a persistent network connection and another one of the
platforms supported by Gwydion Dylan, and would like to volunteer a
build host, let me know in e-mail or IRC.

In order to improve the Buildbot "experience", I'd like to change the
Gwydion build system slightly to split the running of the test suites
out of the "make compile" target (the default target) and into a new
"make check" target.  This will make it easier to write some
customization code for Buildbot to scan the test report and include it
on the status page.

Diff follows.

Index: tools/shared-misc/gen-makefile.in
===================================================================
--- tools/shared-misc/gen-makefile.in(revision 11926)
+++ tools/shared-misc/gen-makefile.in(working copy)
&lt; at &gt;&lt; at &gt; -139,7 +139,7 &lt; at &gt;&lt; at &gt;
 #         where "makefileTarget" is the name of a Makefile target
 #
 # gen-makefile supports the following top-level makefile targets:
-# compile (default), install, clean, and cc_files (compiles C code
+# compile (default), check, install, clean, and cc_files (compiles C code
 # generated by d2c).
 
 $usage_message = "Usage: $0 [-pPlatforms.descr] [directory]\n";
&lt; at &gt;&lt; at &gt; -353,7 +353,7 &lt; at &gt;&lt; at &gt;
     print "BUILDDIR=$builddir\n";
     print "DESTDIR=\n"; # GNU DESTDIR, not the $destdir variable.
     if ($host_platform{'make_supports_phony_targets?'}) {
-        print "\n.PHONY: default compile install uninstall clean\n\n";
+        print "\n.PHONY: default compile check install uninstall clean\n\n";
     }
     print "default: compile\n\n";
 
&lt; at &gt;&lt; at &gt; -374,6 +374,7 &lt; at &gt;&lt; at &gt;
         "$gen_makefile -p$platforms_dot_descr .");
 
     &amp;emit_rule('compile');
+    &amp;emit_rule('check');
     $destdir &amp;&amp; do emit_rule ('install');
     $destdir &amp;&amp; do emit_rule ('uninstall');
     &amp;emit_rule('clean');
&lt; at &gt;&lt; at &gt; -460,6 +461,9 &lt; at &gt;&lt; at &gt;
     push(&lt; at &gt;compile_commands, 
          sprintf($host_platform{'recursive_make_command'}, 
                  $subdir, ""));
+    push(&lt; at &gt;check_commands,
+         sprintf($host_platform{'recursive_make_command'}, 
+                 $subdir, "check"));
     push(&lt; at &gt;install_commands, 
          sprintf($host_platform{'recursive_make_command'}, 
                  $subdir, "install"));
Index: qa/Makegen
===================================================================
--- qa/Makegen(revision 11926)
+++ qa/Makegen(working copy)
&lt; at &gt;&lt; at &gt; -6,15 +6,17 &lt; at &gt;&lt; at &gt;
      "../common/io/tests",
      "../common/system/tests");
 
-foreach $testdir (&lt; at &gt;testdirs) {
+foreach $testdir (&lt; at &gt;testdirs, "test-suites") {
     if ($features{'compiled_for_win32'}) {
 $testdir =~ s|/|\\|;
     }
-    push(&lt; at &gt;compile_commands,
+    push(&lt; at &gt;check_commands,
  sprintf($host_platform{'recursive_make_command'}, $testdir, ""));
     push(&lt; at &gt;clean_commands,
  sprintf($host_platform{'recursive_make_command'}, $testdir, "clean"));
 }
 
-&amp;compile_subdirs("test-suites", "test-apps");
-
+push(&lt; at &gt;check_commands,
+     sprintf($host_platform{'recursive_make_command'}, "test-apps", "check"));
+push(&lt; at &gt;clean_commands,
+     sprintf($host_platform{'recursive_make_command'}, "test-apps", "clean"));
Index: qa/common-Makegen
===================================================================
--- qa/common-Makegen(revision 11926)
+++ qa/common-Makegen(working copy)
&lt; at &gt;&lt; at &gt; -11,15 +11,11 &lt; at &gt;&lt; at &gt;
 sub emit_run_tests_rule {
     local (&lt; at &gt;tests) = &lt; at &gt;_;
     local ($test);
-    print "run_tests : ";
-    foreach $test (&lt; at &gt;tests) {
-print "$test$dot_exe ";
-    }
-    print "\n";
 
     foreach $test (&lt; at &gt;tests) {
-local ($test) = &amp;convert_path_separator("./$test");
-print "\t$test $testflags\n";
+push &lt; at &gt;check_dependencies, "$test$dot_exe";
+
+local ($runtest) = &amp;convert_path_separator("./$test");
+push &lt; at &gt;check_commands, "$runtest $testflags";
     }
-    push(&lt; at &gt;compile_dependencies, "run_tests");
 }
Index: doc/Makefile.in
===================================================================
--- doc/Makefile.in(revision 11926)
+++ doc/Makefile.in(working copy)
&lt; at &gt;&lt; at &gt; -6,11 +6,14 &lt; at &gt;&lt; at &gt;
 
 default: compile
 
-.PHONY: default compile install clean
+.PHONY: default compile check install clean
 
 compile:
 -echo 'Nothing to do.'
 
+check:
+-echo 'Nothing to do.'
+
 install: compile
 ${INSTALL_DATA} dylan.7 ${DESTDIR}${MANDIR}/man7/dylan.7
 ${INSTALL_DATA} gwydion.7 ${DESTDIR}${MANDIR}/man7/gwydion.7
_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Peter S. Housel</dc:creator>
    <dc:date>2008-08-29T05:41:11</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2181">
    <title>Re: Diff for Gwydion Dylan --dump-od switch</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2181</link>
    <description>Um, it looks like the mailing list word-wrapped that message, making  
it useless for patching.

Download "switch.diff" from http://public.me.com/d_j_v instead.


On Aug 21, 2008, at 6:18 AM, Dustin Voss wrote:

_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Dustin Voss</dc:creator>
    <dc:date>2008-08-22T22:44:52</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2180">
    <title>Re: Diff for Gwydion Dylan --dump-od switch</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2180</link>
    <description>For those who missed the comment on IRC, this patch adds a --dump-du  
switch to GD. This switch creates a .lib.du.txt file in addition to  
the .lib.du file. The .txt file is a human-readable version of  
the .lib.du file.

I had to add some features to the od-format library to get this to  
work, but these changes are all conditional and have no impact on pre- 
existing code. Specifically, I added an option to prevent loading  
objects from external data units, a &lt;extern-ref&gt; class to handle  
references to said objects that is only used when that option is  
enabled, and support for additional informational parameters to object  
loader functions.

The actual functionality of the --dump-du switch is in d2c/compiler/ 
main/text-du.dylan.

This patch also includes an HTML file, d2c/compiler/base/od-format- 
description.html, that describes the format of various dumped objects.  
Without this, the .txt file is mostly useless.


On Aug 21, 2008, at 6:18 AM, Dustin Voss wrote:

_______________________________________________
hackers mailing list
hackers&lt; at &gt;lists.opendylan.org
https://www.opendylan.org/mailman/listinfo/hackers

</description>
    <dc:creator>Dustin Voss</dc:creator>
    <dc:date>2008-08-22T22:09:35</dc:date>
  </item>
  <item rdf:about="http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2179">
    <title>Diff for Gwydion Dylan --dump-od switch</title>
    <link>http://permalink.gmane.org/gmane.comp.lang.dylan.gwydion.devel/2179</link>
    <description>Index: compiler/main/main-unit-state.dylan
===================================================================
--- compiler/main/main-unit-state.dylan(revision 11909)
+++ compiler/main/main-unit-state.dylan(working copy)
&lt; at &gt;&lt; at &gt; -37,6 +37,8 &lt; at &gt;&lt; at &gt;
      required-init-keyword: command-line-features:;
    constant slot unit-log-dependencies :: &lt;boolean&gt;,
      required-init-keyword: log-dependencies:;
+  constant slot unit-log-text-du :: &lt;boolean&gt;,
+    required-init-keyword: log-text-du:;
    constant slot unit-target :: &lt;platform&gt;,
      required-init-keyword: target:;
    constant slot unit-no-binaries :: &lt;boolean&gt;,
Index: compiler/main/main.dylan
===================================================================
--- compiler/main/main.dylan(revision 11909)
+++ compiler/main/main.dylan(working copy)
&lt; at &gt;&lt; at &gt; -92,6 +92,7 &lt; at &gt;&lt; at &gt;
  "       -D, --define:      Define conditional compilation features.\n"
  "       -U, --undefine:    Undefine conditional compilation features. 
\n"
  "       -M, --log-deps:    Log dependencies to a file.\n"
+"       --dump-du:         Create human-readable lib.du.txt file.\n"
  "       -T, --target:      Target platform name.\n"
  "       -p, --platforms:   File containing platform descriptions.\n"
  "       --no-binaries:     Do not compile generated C files.\n"
&lt; at &gt;&lt; at &gt; -293,6 +294,9 &lt; at &gt;&lt; at &gt;
      long-options: #("log-deps"),
      short-options: #("M"));
    add-option-parser-by-type(argp,
+    &lt;simple-option-parser&gt;,
+    long-options: #("dump-du"));
+  add-option-parser-by-type(argp,
      &lt;parameter-option-parser&gt;,
      long-options: #("target"),
      short-options: #("T"));
&lt; at &gt;&lt; at &gt; -378,6 +382,7 &lt; at &gt;&lt; at &gt;
    let library-dirs = option-value-by-long-name(argp, "libdir");
    let features = option-value-by-long-name(argp, "define");
    let log-dependencies = option-value-by-long-name(argp, "log-deps");
+  let log-text-du = option-value-by-long-name(argp, "dump-du");
    let no-binaries-pre = option-value-by-long-name(argp, "no- 
binaries");
    let no-makefile = option-value-by-long-name(argp, "no-makefile");
    let no-binaries = no-binaries-pre | no-makefile;
&lt; at &gt;&lt; at &gt; -504,6 +509,7 &lt; at &gt;&lt; at &gt;
                       source-locator: locator,
                       command-line-features: as(&lt;list&gt;, features),
                       log-dependencies: log-dependencies,
+                     log-text-du: log-text-du,
                       target: *current-target*,
                       no-binaries: no-binaries,
                       no-makefile: no-makefile,
&lt; at &gt;&lt; at &gt; -516,6 +522,7 &lt; at &gt;&lt; at &gt;
                       lid-locator: locator,
                       command-line-features: as(&lt;list&gt;, features),
                       log-dependencies: log-dependencies,
+                     log-text-du: log-text-du,
                       target: *current-target*,
                       no-binaries: no-binaries,
                       no-makefile: no-makefile,
Index: compiler/main/Main.lid
===================================================================
--- compiler/main/Main.lid(revision 11909)
+++ compiler/main/Main.lid(working copy)
&lt; at &gt;&lt; at &gt; -11,4 +11,5 &lt; at &gt;&lt; at &gt;
  testworks-spec.dylan
  misc.dylan
  evaluate.dylan
+text-du.dylan
  main.dylan
Index: compiler/main/main-exports.dylan
===================================================================
--- compiler/main/main-exports.dylan(revision 11909)
+++ compiler/main/main-exports.dylan(working copy)
&lt; at &gt;&lt; at &gt; -32,6 +32,8 &lt; at &gt;&lt; at &gt;
    use Dylan;
    use Common-Dylan;
    use IO;
+  use Stream-extensions,
+     import: {indenting-streams};
    use System;
    use String-extensions;
    use Random;
&lt; at &gt;&lt; at &gt; -76,6 +78,7 &lt; at &gt;&lt; at &gt;
    use random;
    use command-line-parser;
    use option-parser-protocol;
+  use indenting-streams;

    use utils;
    use variables;
Index: compiler/main/text-du.dylan
===================================================================
--- compiler/main/text-du.dylan(revision 0)
+++ compiler/main/text-du.dylan(revision 0)
&lt; at &gt;&lt; at &gt; -0,0 +1,339 &lt; at &gt;&lt; at &gt;
+module: main
+copyright: see below
+synopsis: Translate binary DU format to text.
+
+
+// 
======================================================================
+//
+// Copyright (c) 2008  Gwydion Dylan Maintainers
+// All rights reserved.
+//
+// Use and copying of this software and preparation of derivative
+// works based on this software are permitted, including commercial
+// use, provided that the following conditions are observed:
+//
+// 1. This copyright notice must be retained in full on any copies
+//    and on appropriate parts of any derivative works.
+// 2. Documentation (paper or online) accompanying any system that
+//    incorporates this software, or any part of it, must acknowledge
+//    the contribution of the Gwydion Project at Carnegie Mellon
+//    University, and the Gwydion Dylan Maintainers.
+//
+// This software is made available "as is".  Neither the authors nor
+// Carnegie Mellon University make any warranty about the software,
+// its performance, or its conformity to any specification.
+//
+// Bug reports should be sent to &lt;gd-bugs&lt; at &gt;gwydiondylan.org&gt;; questions,
+// comments and suggestions are welcome at &lt;gd- 
hackers&lt; at &gt;gwydiondylan.org&gt;.
+// Also, see http://www.gwydiondylan.org/ for updates and  
documentation.
+//
+// 
======================================================================
+
+
+// This file provides the output for the --dump-du switch. Each line  
of output
+// is an ODF object. An ODF object may have a label (if it is the  
target of a
+// forward or external reference), data content, and sub-objects, all  
optional.
+// The label and content is displayed on the line and sub-objects are  
indented
+// and displayed on subsequent lines. A sub-object can be a forward  
reference
+// within the same library (labeled with double brackets) or an  
external
+// reference to another library (labeled with brackets). Here is some  
sample
+// output:
+//
+// extern-index
+//   extern-handle [0]  8C8C908E 00000000 0000079A
+//     byte-symbol  #"io"
+//     file-locator  "usr/local/lib/dylan/2.5.0pre3/intel-darwin-gcc4/ 
io.lib.du"
+//   extern-handle [1]  8C8C908E 00000000 00000043
+// ...
+// define-binding-tlf
+//   class-definition [[2]]
+//     ...
+//     defined-class [[4]]
+//       constant-info
+//         ...
+//       [[4]]
+//       basic-name
+//         byte-symbol  #"&lt;basic-wrapper-stream&gt;"
+//       list
+//         [0]
+//
+// The second line ("extern-handle [0]") is an ODF #"extern-handle"  
object.
+// This is a reference to a particular ODF object in the IO library.  
The last
+// line ("[0]") is referring to the second line, and should be taken  
to mean
+// the ODF object in the IO library. Similarly, the thirteenth line  
("[[4]]")
+// is a reference to the ODF object on the tenth line ("defined-class  
[[4]]").
+// This means the #"defined-class" on line ten is self-referential:  
its second
+// sub-object (on line thirteen) is the #"defined-class" object itself.
+//
+// Reference labels are in hexadecimal for easier cross-referencing  
with an
+// extern-handle.
+//
+// Note that in actual usage, all references are replaced by their  
referents
+// or a &lt;forward-ref&gt; object, even across libraries.
+
+
+define function dump-text-du
+    (unit-name :: &lt;byte-string&gt;, file :: &lt;byte-string&gt;)
+ =&gt; ();
+  format(*debug-output*, "Dumping library summary as text.\n", file);
+  let stream = make(&lt;file-stream&gt;, locator: file, direction:  
#"output");
+  let ind-stream = make(&lt;indenting-stream&gt;,
+                        inner-stream: stream,
+                        output-tab-width: #f);
+  *extern-count* := 0;
+  let du = find-data-unit(as(&lt;symbol&gt;, unit-name), $library-summary- 
unit-type,
+                          check-hash: #f, load-external: #f,
+                          dispatcher: make-dispatcher(ind-stream));
+  close(stream);
+end function;
+
+
+define function make-dispatcher (stream :: &lt;indenting-stream&gt;)
+ =&gt; dispatcher :: &lt;dispatcher&gt;;
+  let dispatcher = make(&lt;dispatcher&gt;, initialize-from: #f);
+  let entry-types = registered-object-ids();
+  for (unusable-entry in #[ #"32bit-data-unit", #"64bit-data-unit" ])
+    entry-types := remove!(entry-types, unusable-entry);
+  end for;
+
+  for (entry-type in entry-types)
+    add-od-loader(dispatcher, entry-type,
+        method (state :: &lt;load-state&gt;, flags :: &lt;integer&gt;,
+                label :: false-or(&lt;integer&gt;),
+                default-loader :: false-or(&lt;function&gt;))
+         =&gt; (obj :: &lt;object&gt;)
+          load-and-format-odf-entry(state, flags, label, default- 
loader,
+                                    entry-type, stream);
+        end method);
+  end for;
+  dispatcher;
+end function;
+
+
+// We handle extern references ourselves, because we need to display  
them.
+// The od-format library would normally build &lt;extern-ref&gt;s and put  
them in
+// a vector for extern-index. Instead, we build &lt;extern-marker&gt;s and  
put them
+// in a vector.
+//
+define variable *extern-count* :: &lt;integer&gt; = 0;
+define class &lt;extern-marker&gt; (&lt;object&gt;)
+  constant slot index :: &lt;integer&gt;, required-init-keyword: index:;
+end class;
+
+
+// Element types to delegate to default dispatcher. These are  
elemental ODF
+// types without sub-objects.
+//
+define constant $default-loader-entries
+  = #[ #"local-index", #"local-object-map",
+       #"true", #"false", #"fixed-integer", #"extended-integer",
+       #"file-locator", #"byte-string", #"byte-symbol", #"byte- 
character" ];
+
+
+// The load state and buffer can't handle state.od-next being forced  
to some
+// value, so avoid doing that.
+//
+define method load-and-format-odf-entry
+    (state :: &lt;load-state&gt;, flags :: &lt;integer&gt;, label :: false- 
or(&lt;integer&gt;),
+     default-loader :: false-or(&lt;function&gt;), entry-type :: &lt;symbol&gt;,
+     stream :: &lt;indenting-stream&gt;)
+ =&gt; obj :: &lt;object&gt;;
+  // Print entry label and type.
+  format(stream, "%s", as(&lt;string&gt;, entry-type));
+  if (label)
+    format(stream, " [[%x]]", label);
+  end if;
+  if (entry-type = #"extern-handle")
+    format(stream, " [%x]", *extern-count*);
+    *extern-count* := *extern-count* + 1;
+  end if;
+  write(stream, "  ");
+
+  // Delegate to default dispatcher?
+  let default-entry-type?
+    = default-loader &amp; member?(entry-type, $default-loader-entries);
+
+  // Get info.
+  let has-data?
+    = logand(flags, $odf-raw-format-mask) ~= $odf-no-raw-data-format;
+  let has-subobjects?
+    = logand(flags, $odf-subobjects-flag) = $odf-subobjects-flag;
+
+  // Get raw data size if we need it.
+  let (data-size, padding-size)
+    = if (~default-entry-type?)
+        odf-data-size(state, flags);
+      else
+        values(0, 0);
+      end if;
+
+  // Get data or delegate that to default dispatcher.
+  let data
+    = if (default-entry-type?)
+        default-loader(state);
+      else
+        let buf = make(&lt;byte-string&gt;, size: data-size);
+        if (data-size &gt; 0)
+          // Read raw data then advance past padding.
+          load-raw-data(buf, data-size, state);
+          buffer-at-least(padding-size, state);
+        end if;
+        buf;
+      end if;
+
+  // Print data (if any).
+  if (has-data?)
+    format-raw-data(stream, flags, data, entry-type);
+  end if;
+  new-line(stream);
+
+  // Print sub-objects (if any).
+  let subobjects = make(&lt;stretchy-vector&gt;);
+  if (has-subobjects?)
+    indent(stream, +2);
+    for (sub = load-object-dispatch(state) then load-object- 
dispatch(state),
+         until: sub == $end-object)
+      add!(subobjects, sub);
+      case
+        instance?(sub, &lt;forward-ref&gt;) =&gt;
+          if (sub.forward-ref-id)
+            format(stream, "[[%x]]\n", sub.forward-ref-id)
+          else
+            write(stream, "[[unknown forward reference]]");
+          end if;
+        instance?(sub, &lt;extern-marker&gt;) &amp; entry-type ~= #"extern- 
index" =&gt;
+          format(stream, "[%x]\n", sub.index);
+      end case;
+    end for;
+    indent(stream, -2);
+  end if;
+
+  // Special return values for extern handling.
+  select (entry-type)
+    #"extern-index" =&gt; as(&lt;simple-object-vector&gt;, subobjects);
+    #"extern-handle" =&gt; make(&lt;extern-marker&gt;, index: *extern-count* -  
1);
+    otherwise =&gt; data;
+  end select;
+end method;
+
+
+// Only call this if we aren't using a default loader, because we may  
need to
+// buffer a word to get the size and that will confuse the loader.
+//
+define method odf-data-size (state :: &lt;load-state&gt;, flags :: &lt;integer&gt;)
+ =&gt; (data-size :: &lt;integer&gt;, padding-size :: &lt;integer&gt;);
+  let raw-data-format = logand(flags, $odf-raw-format-mask);
+  let size-unit
+    = select (raw-data-format)
+        $odf-no-raw-data-format =&gt; 0;
+        $odf-byte-raw-data-format =&gt; 1;
+        $odf-16bit-raw-data-format =&gt; 2;
+        $odf-32bit-raw-data-format =&gt; 4;
+        $odf-64bit-raw-data-format =&gt; 8;
+        $odf-word-raw-data-format =&gt; $word-bytes;
+        otherwise =&gt;
+          error("Untranslatable or unrecognized raw data format at  
index %d",
+                raw-data-format, state.od-next);
+      end select;
+  let data-size
+    = select (size-unit)
+        0 =&gt; 0;
+        otherwise =&gt;
+          let (buf, next) = buffer-at-least($word-bytes, state);
+          buffer-word(buf, next) * size-unit;
+      end select;
+  let padding-size
+    = if (modulo(data-size, $word-bytes) ~= 0)
+        $word-bytes - modulo(data-size, $word-bytes);
+      else
+        0
+      end if;
+  values(data-size, padding-size);
+end method;
+
+
+define method format-raw-data
+    (stream :: &lt;stream&gt;, flags :: &lt;integer&gt;, data :: &lt;object&gt;,
+     entry-type :: &lt;symbol&gt;)
+ =&gt; ();
+  let raw-data-format = logand(flags, $odf-raw-format-mask);
+  let group-every
+    = select (raw-data-format)
+        $odf-byte-raw-data-format =&gt; 1;
+        $odf-16bit-raw-data-format =&gt; 2;
+        $odf-32bit-raw-data-format =&gt; 4;
+        $odf-64bit-raw-data-format =&gt; 8;
+        $odf-word-raw-data-format =&gt; $word-bytes;
+      end select;
+  let data-size = data.size;
+  let capped-data-size = min(16, data-size);
+  for (i from 0 below capped-data-size)
+    format(stream, "%02x", as(&lt;integer&gt;, data[i]));
+    if (modulo(i + 1, group-every) == 0)
+      write-element(stream, ' ');
+    end if;
+  end for;
+  if (data-size &gt; capped-data-size)
+    format(stream, "... (%d bytes)", data-size);
+  end if;
+end method;
+
+define method format-raw-data
+    (stream :: &lt;stream&gt;, flags :: &lt;integer&gt;, data :: &lt;object&gt;,
+     entry-type :: one-of(#"local-index", #"local-object-map"))
+ =&gt; ();
+  let raw-data-format = logand(flags, $odf-raw-format-mask);
+  let elem-size
+    = select (raw-data-format)
+        $odf-byte-raw-data-format =&gt; 1;
+        $odf-16bit-raw-data-format =&gt; 2;
+        $odf-32bit-raw-data-format =&gt; 4;
+        $odf-64bit-raw-data-format =&gt; 8;
+        $odf-word-raw-data-format =&gt; $word-bytes;
+      end select;
+  let (field, cap)
+    = select (elem-size)
+        1 =&gt; values("%02x", 16);
+        2 =&gt; values("%04x", 8);
+        4 =&gt; values("%08x", 4);
+        8 =&gt; values("%016x", 2);
+      end select;
+  let data-size = data.size;
+  let capped-data-size = min(cap, data-size);
+  for (i from 0 below capped-data-size)
+    format(stream, field, data[i]);
+    write-element(stream, ' ');
+  end for;
+  if (data-size &gt; capped-data-size)
+    format(stream, "... (%d bytes)", data-size * elem-size);
+  end if;
+end method;
+
+define method format-raw-data
+    (stream :: &lt;stream&gt;, flags :: &lt;integer&gt;, data :: &lt;object&gt;,
+     entry-type :: one-of(#"fixed-integer", #"extended-integer",  
#"ratio",
+                          #"single-float"))
+ =&gt; ()
+  format(stream, "%s", data);
+end method;
+
+define method format-raw-data
+    (stream :: &lt;stream&gt;, flags :: &lt;integer&gt;, data :: &lt;object&gt;,
+     entry-type :: one-of(#"file-locator", #"byte-string"))
+ =&gt; ();
+  format(stream, "\"%s\"", as(&lt;string&gt;, data));
+end method;
+
+define method format-raw-data
+    (stream :: &lt;stream&gt;, flags :: &lt;integer&gt;, data :: &lt;object&gt;,
+     entry-type == #"byte-symbol")
+ =&gt; ();
+  format(stream, "#\"%s\"", as(&lt;string&gt;, data));
+end method;
+
+define method format-raw-data
+    (stream :: &lt;stream&gt;, flags :: &lt;integer&gt;, data :: &lt;object&gt;,
+     entry-type == #"byte-character")
+ =&gt; ();
+  format(stream, "'%c'", data);
+end method;

Property changes on: compiler/main/text-du.dylan
___________________________________________________________________
Name: svn:mime-type
    + text/plain
Name: svn:eol-style
    + native

Index: compiler/main/single-file-mode-state.dylan
===================================================================
--- compiler/main/single-file-mode-state.dylan(revision 11909)
+++ compiler/main/single-file-mode-state.dylan(working copy)
&lt; at &gt;&lt; at &gt; -353,6 +353,11 &lt; at &gt;&lt; at &gt;

    format(*debug-output*, "Optimize called %d times.\n", *optimize- 
ncalls*);

+  if (state.unit-log-text-du)
+    dump-text-du(state.unit-name,
+                 concatenate(state.unit-mprefix, ".lib.du.txt"));
+  end if;
+
    let worked? = zero?(*errors*);
    format(*debug-output*,
   "Compilation %s with %d Warning%s and %d Error%s\n",
Index: compiler/main/lid-mode-state.dylan
===================================================================
--- compiler/main/lid-mode-state.dylan(revision 11909)
+++ compiler/main/lid-mode-state.dylan(working copy)
&lt; at &gt;&lt; at &gt; -833,10 +833,15 &lt; at &gt;&lt; at &gt;
      end if;
      dump-library-summary(state);

+    if (state.unit-log-text-du)
+      dump-text-du(state.unit-lib-name,
+                   concatenate(state.unit-mprefix, ".lib.du.txt"));
+    end if;
+
      if (state.unit-log-dependencies)
        spew-dependency-log(concatenate(state.unit-mprefix, ".dep"));
      end if;
-
+
      unless (state.unit-no-makefile)
        do-make(state);
      end;
Index: compiler/base/base-exports.dylan
===================================================================
--- compiler/base/base-exports.dylan(revision 11909)
+++ compiler/base/base-exports.dylan(working copy)
&lt; at &gt;&lt; at &gt; -179,16 +179,22 &lt; at &gt;&lt; at &gt;
      load-sole-subobject,
      assert-end-object,
      &lt;forward-ref&gt;,
+    forward-ref-id,
      actual-obj,
      obj-resolved?,
      request-backpatch,
      resolve-forward-ref,
+    &lt;extern-ref&gt;,
+    extern-ref-du-name,
+    extern-ref-du-loc,
+    extern-ref-local-id,
      &lt;identity-preserving-mixin&gt;,
      defined-externally?,
      maybe-dump-reference,
      load-external-definition,
      add-make-dumper,
      invert-registry,
+    registered-object-ids,
      *Data-Unit-Search-Path*;

  end;
Index: compiler/base/od-format-description.html
===================================================================
--- compiler/base/od-format-description.html(revision 0)
+++ compiler/base/od-format-description.html(revision 0)
&lt; at &gt;&lt; at &gt; -0,0 +1,1549 &lt; at &gt;&lt; at &gt;
+&lt;!--This file created by AppleWorks HTML Filter 6.0--&gt;
+&lt;HTML&gt;
+&lt;HEAD&gt;
+&lt;META NAME=GENERATOR CONTENT="AppleWorks HTML Filter 6.0"&gt;
+&lt;META HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=macintosh"&gt;
+&lt;TITLE&gt;od-format-description&lt;/TITLE&gt;
+&lt;/HEAD&gt;
+&lt;BODY  &gt;
+
+&lt;P ALIGN=CENTER&gt;&lt;FONT SIZE=4&gt;&lt;B&gt;Gwydion Dylan DU File Format&lt;BR&gt;
+&lt;/B&gt;&lt;/FONT&gt;&lt;B&gt;Aug 17, 2008&lt;BR&gt;
+&lt;/B&gt;&lt;/P&gt;
+
+&lt;P&gt;&lt;BR&gt;
+The conceptual root of the DU file format is the dumped &amp;lt;unit- 
info&amp;gt; instance, but it is not the first object physically found in  
the file.&lt;BR&gt;
+&lt;BR&gt;
+Here are most of the dumped compiler classes, where their dump  
formats are defined, and the formats themselves: the dumped tags (in  
order) and the elements of each tag.&lt;BR&gt;
+&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#t base/dylan-dump:45&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;true&amp;#148;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;#f base/dylan-dump:58&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;false&amp;#148;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; base/dylan-dump:72&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;fixed-integer&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw word data (1)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (value of integer)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;extended-integer&amp;gt; base/dylan-dump:114&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;extended-integer&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw word data (number of subsequent words)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;series of raw word data&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ratio&amp;gt; base/dylan-dump:157&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ratio&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;numerator&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;denominator&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;file-locator&amp;gt; base/dylan-dump:177&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;file-locator&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw byte data (path to file)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;single-float&amp;gt; base/dylan-dump:229&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;single-float&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;fractional part&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;exponent part&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; base/dylan-dump:249&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;byte-string&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw byte data&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; base/dylan-dump:272&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;byte-symbol&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw byte data (string form of symbol)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-character&amp;gt; base/dylan-dump:294&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;byte-character&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw byte data (1 byte)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; base/dylan-dump:315&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;list*&amp;#148; (if improper)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;series of elements&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;list&amp;#148; (if proper)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;series of elements&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; base/dylan-dump:399&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;simple-object-vector&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;series of elements&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;unknown-source-location&amp;gt; base/source.dylan: 
92&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;unknown-source-location&amp;#148;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-file&amp;gt; base/source.dylan:195&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;source-file&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;file-locator&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-buffer&amp;gt;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;source-buffer&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; (buffer name)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;known-source-location&amp;gt; base/source.dylan: 
434&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;known-source-location&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;raw word data (6)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (start position)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (start line)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (start column)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (end position)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (end line)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;raw word data (end column)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-file&amp;gt; or &amp;lt;source-buffer&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-raw-function&amp;gt; base/ctfunc.dylan:107&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ct-function&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-definition&amp;gt; or #f (if it  
didn&amp;#146;t come from a definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt;? (types of closure  
vars for local functions)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-general-entry?)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-callback-function&amp;gt; base/ctfunc.dylan: 
122&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ct-callback-function&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-definition&amp;gt; or #f (if it  
didn&amp;#146;t come from a definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt;? (types of closure  
vars for local functions)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-general-entry?)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-callback-entry?)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-sealed-generic&amp;gt; base/ctfunc.dylan:155&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ct-sealed-generic&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-definition&amp;gt; or #f (if it  
didn&amp;#146;t come from a definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt;? (types of closure  
vars for local functions)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-general-entry?)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (sealed)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-open-generic&amp;gt; base/ctfunc.dylan:161&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ct-open-generic&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-definition&amp;gt; or #f (if it  
didn&amp;#146;t come from a definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt;? (types of closure  
vars for local functions)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-general-entry?)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (sealed)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-method&amp;gt; base/ctfunc.dylan:186&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ct-method&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-definition&amp;gt; or #f (if it  
didn&amp;#146;t come from a definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt;? (types of closure  
vars for local functions)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-general-entry?)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (method is hidden inside generic  
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-generic-entry?)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-accessor-method&amp;gt; base/ctfunc.dylan:205&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ct-accessor-method&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-definition&amp;gt; or #f (if it  
didn&amp;#146;t come from a definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt;? (types of closure  
vars for local functions)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-general-entry?)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (method is hidden inside generic  
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (has-generic-entry?)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; (shared accessor stand-in) or  
#f (need custom stand-in)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-entry-point&amp;gt; base/ctfunc.dylan:251&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-not-supplied-marker&amp;gt; base/ctv.dylan:782&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;eql-literal&amp;gt; base/ctv.dylan:790&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-integer&amp;gt; base/ctv.dylan:816&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-single-float&amp;gt; base/ctv.dylan:822&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-double-float&amp;gt; base/ctv.dylan:828&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-extended-float&amp;gt; base/ctv.dylan:834&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-pair&amp;gt; base/ctv.dylan:864&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-simple-object-vector&amp;gt; base/ctv.dylan: 
871&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-byte-string&amp;gt; base/ctv.dylan:879&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;basic-name&amp;gt; base/names.dylan:79&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;basic-name&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;module&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;derived-name&amp;gt; (internal use) base/ 
names.dylan:132&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;derived-name&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (describing what kind of derivation  
to do)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;internal-name&amp;gt; (local method etc) base/ 
names.dylan:159&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;internal-name&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (name of local method)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt; (container)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;anonymous-name&amp;gt; (unnamed tlf) base/ 
names.dylan:185&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;anonymous-name&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;method-name&amp;gt; base/names.dylan:218&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;method-name&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;basic-name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;sequence&amp;gt; of &amp;lt;ctype&amp;gt; (specializers)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt; base/signature.dylan:70&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;function-signature&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (specializers for  
req&amp;#146;d arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (#next present)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt; (#rest type) or #f (if no #rest)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;key-info&amp;gt;, or #f  (if no  
#key)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (#all-keys present)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (result type)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;key-info&amp;gt; base/signature.dylan:119&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;function-key-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (required)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (default compile-time value) or  
#f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; base/tokens.dylan:610&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt;  (token kind)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;identifier-token&amp;gt; base/tokens.dylan:626&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;identifier-token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (token kind)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;module&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;uniquifier&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;left-bracket-token&amp;gt; (tokens that have a  
symbol name) base/tokens.dylan:629&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;left-bracket-token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (token kind)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;module&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;uniquifier&amp;gt; base/tokens.dylan:632&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;uniquifier&amp;#148;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;operator-token&amp;gt; base/tokens.dylan:639&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;operator-token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (token kind)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;module&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;uniquifier&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;constrained-name-token&amp;gt; base/tokens.dylan: 
642&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;constrained-name-token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt;  (token kind)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (pattern variable name part)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (pattern variable constraint part)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-token&amp;gt; base/tokens.dylan:647&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;literal-token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (token kind)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pre-parsed-token&amp;gt; base/tokens.dylan:651&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;pre-parsed-token&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (token kind)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;token-parse-tree&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;union-ctype&amp;gt; base/type-dump.dylan:47&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;union-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (classes, limited  
types, or singletons in union)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;unknown-ctype&amp;gt; base/type-dump.dylan:99&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;unknown-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;#f (theoretically, the expression of unknown  
type)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;limited-integer-ctype&amp;gt; base/type-dump.dylan: 
107&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;limited-integer-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (most specific supertype of this  
limited type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;extended-integer&amp;gt; or #f (low bound)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;extended-integer&amp;gt; or #f (high bound)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;direct-instance-ctype&amp;gt; base/type-dump.dylan: 
115&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;direct-instance-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (most specific supertype of this  
type)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;singleton-ctype&amp;gt; base/type-dump.dylan:121&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;singleton-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (direct class of this type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-character-ctype&amp;gt; base/type-dump.dylan: 
128&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;byte-character-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (most specific supertype of this  
type)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;multi-value-ctype&amp;gt; base/type-dump.dylan: 
134&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;multi-value-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (types of  
specifically typed values)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (min number of values that will  
ever be included)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt; (type of rest value) or empty-ctype&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;subclass-ctype&amp;gt; base/type-dump.dylan:141&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;subclass-type&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (most specific supertype of this  
type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (class this type covers subclasses  
of)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;limited-collection-ctype&amp;gt; base/type- 
dump.dylan:148&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;limited-collection&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (most specific supertype of this  
limited type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt; (element type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt;, or &amp;lt;sequence&amp;gt; of  
&amp;lt;integer&amp;gt;, or #f (size or dimensions)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;proxy&amp;gt; base/type-dump.dylan:157&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;class-proxy&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (proxied class)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;instance-slot-info&amp;gt; base/type-dump.dylan: 
204&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;instance-slot-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this slot)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function) or #f  
(if not needed for identity)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (no setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
an initial value, but it is unknown) or #f (if there is no initial  
value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
an init-function, but it is unknown) or #f (if there is no init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (init-keyword) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (init-keyword is required)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;vector-slot-info&amp;gt; base/type-dump.dylan:216&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;vector-slot-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this slot)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function) or #f  
(if not needed for identity)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (no setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
an initial value, but it is unknown) or #f (if there is no initial  
value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
an init-function, but it is unknown) or #f (if there is no init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (init-keyword) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (init-keyword is required)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;instance-slot-info&amp;gt; (slot-size slot)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-slot-info&amp;gt; base/type-dump.dylan:224&lt;BR&gt;
+(actual class slot or each-subclass slot, located in instance&amp;#146;s  
object-class)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;meta-slot-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this slot)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function) or #f  
(if not needed for identity)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (no setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
an initial value, but it is unknown) or #f (if there is no initial  
value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
an init-function, but it is unknown) or #f (if there is no init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (init-keyword) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (init-keyword is required)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;class-slot-info&amp;gt; or &amp;lt;each-subclass-slot- 
info&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;class-slot-info&amp;gt; base/type-dump.dylan:233&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;class-slot-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this slot)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function) or #f  
(if not needed for identity)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (no setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
an initial value, but it is unknown) or #f (if there is no initial  
value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
an init-function, but it is unknown) or #f (if there is no init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (init-keyword) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (init-keyword is required)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-slot-info&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;each-subclass-slot-info&amp;gt; base/type- 
dump.dylan:242&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;each-subclass-slot-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this slot)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function) or #f  
(if not needed for identity)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (no setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
an initial value, but it is unknown) or #f (if there is no initial  
value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
an init-function, but it is unknown) or #f (if there is no init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (init-keyword) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (init-keyword is required)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-slot-info&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;virtual-slot-info&amp;gt; base/type-dump.dylan: 
250&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;virtual-slot-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this slot)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function) or #f  
(if not needed for identity)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (no setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
an initial value, but it is unknown) or #f (if there is no initial  
value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
an init-function, but it is unknown) or #f (if there is no init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (init-keyword) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (init-keyword is required)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;override-info&amp;gt; base/type-dump.dylan:256&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;override-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this inherited slot  
clause)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; (getter generic function being  
inherited)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
a new initial value, but it is unknown) or #f (if there is no new  
initial value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
a new init-function, but it is unknown) or #f (if there is no new init- 
function)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;keyword-info&amp;gt; base/type-dump.dylan:265&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;keyword-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (that introduces this keyword  
clause)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (the keyword symbol)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value) or #t (if there is  
a new initial value, but it is unknown) or #f (if there is no new  
initial value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (init-function) or #t (if there is  
a new init-function, but it is unknown) or #f (if there is no new init- 
function)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (required keyword)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt; (type restriction of keyword)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;defined-cclass&amp;gt; base/type-dump.dylan:285&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;defined-class&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt; (printable name of class)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (direct  
superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (closest primary superclass)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class and its subclasses  
can&amp;#146;t be functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is sealed)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is primary)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (class precedence  
list, including this class and indirect superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (unique id of concrete class) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range min of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range max of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-cclass&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;limited-cclass&amp;gt; base/type-dump.dylan:292&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;limited-class&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt; (printable name of class)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (direct  
superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (closest primary superclass)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class and its subclasses  
can&amp;#146;t be functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is sealed)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is primary)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (class precedence  
list, including this class and indirect superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (unique id of concrete class) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range min of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range max of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-cclass&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-cclass&amp;gt; base/type-dump.dylan:299&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;meta-class&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt; (printable name of class)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (direct  
superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (closest primary superclass)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class and its subclasses  
can&amp;#146;t be functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is sealed)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is primary)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (class precedence  
list, including this class and indirect superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (unique id of concrete class) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range min of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range max of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-cclass&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;slot-info&amp;gt;  
(slots introduced by this class)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;defined-cdclass&amp;gt; base/type-dump.dylan:307&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;defined-designator-class&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (memo of extensional version  
of type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt; (printable name of class)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (direct  
superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (closest primary superclass)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class and its subclasses  
can&amp;#146;t be functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is functional)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is sealed)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (this class is primary)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;cclass&amp;gt; (class precedence  
list, including this class and indirect superclasses)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (unique id of concrete class) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range min of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (subclass id range max of sealed  
&amp;amp; non-mixed class) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (direct space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general speed  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (general space  
representation) or #f (if abstract)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;meta-cclass&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (sizeof designated type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;integer&amp;gt; (alignment in sizeof units)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;representation&amp;gt; (representation of FFI type)  
or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;defined-cdclass&amp;gt; (referenced type of this  
pointer designator type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;defined-cdclass&amp;gt; (pointer designator type  
referring to this type) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; (superclass for generating above) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt; (correpsonding Dylan import type) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt; (corresponding Dylan export type) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (indirect-getter function) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (indirect-setter function)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;struct-slot-info&amp;gt; base/type-dump.dylan:323&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; base/variables.dylan:1239&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;library&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (library name)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;module&amp;gt; base/variables.dylan:1250&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;module&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (module name)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable&amp;gt; base/variables.dylan:1287&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;module-variable&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;module&amp;gt; (owner, not definer)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (variable name)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;use&amp;gt; base/variables.dylan:1300&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;use&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; (name of used library)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol- 
token&amp;gt;, or &amp;lt;all-marker&amp;gt; (imported names)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; or #f (prefix)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol- 
token&amp;gt; (excluded names)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;renaming&amp;gt;  
(renamed binding, also included in imported names)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol- 
token&amp;gt;, or &amp;lt;all-marker&amp;gt; (re-exported names)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;all-marker&amp;gt; base/variables.dylan:1308&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;all-marker&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;renaming&amp;gt; base/variables.dylan:1311&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;renaming&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; (original name)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; (new name)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-bindings-tlf&amp;gt; convert/ 
defconstvar.dylan:533&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-binding-tlf&amp;#148; (main binding)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;top-level-form&amp;gt;, or &amp;lt;list&amp;gt; of &amp;lt;top- 
level-form&amp;gt; (dependencies)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-binding-tlf&amp;#148; (multiple aux  
bindings)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;top-level-form&amp;gt;, or &amp;lt;list&amp;gt; of &amp;lt;top- 
level-form&amp;gt; (dependencies)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-binding-tlf&amp;#148; (optional if rest  
defn)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable-definition&amp;gt; or &amp;lt;constant- 
definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;top-level-form&amp;gt;, or &amp;lt;list&amp;gt; of &amp;lt;top- 
level-form&amp;gt; (dependencies)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;constant-definition&amp;gt; convert/ 
defconstvar.dylan:549&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;constant-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;  (constant value type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (constant value) or #f (if not  
computable at compile time) or #&amp;#148;not-computed-yet&amp;#148; (if  
unknown)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;constant-method-definition&amp;gt; convert/ 
defconstvar.dylan:555&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;constant-method-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; or #f (inlined function  
literal)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (inlining type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;  (constant value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (constant value type) or #f (if  
not computable at compile time) or #&amp;#148;not-computed-yet&amp;#148; (if  
unknown)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable-definition&amp;gt; convert/ 
defconstvar.dylan:562&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;variable-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ctype&amp;gt;  (initial value)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-value&amp;gt; (initial value type) or #f (if not  
computable at compile time) or #&amp;#148;not-computed-yet&amp;#148; (if  
unknown)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;constant-definition&amp;gt; (if initial value  type  
is not compile-time constant) or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-class-tlf&amp;gt; convert/defclass.dylan: 
4117&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-binding-tlf&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;real-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;#f (no dependencies)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;getter-method-definition&amp;gt; (per inherited or  
exported non-virtual getter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;sealed-domain&amp;#148; (immediately following  
each above if sealed)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; (of getter) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (of this tlf&amp;#146;s &amp;lt;real-class- 
definition&amp;gt;)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (getter  
specializers)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;setter-method-definition&amp;gt; (per inherited or  
exported non-virtual setter)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;sealed-domain&amp;#148; (immediately following  
each above if sealed)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; (of setter) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (of this tlf&amp;#146;s &amp;lt;real-class- 
definition&amp;gt;)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (setter  
specializers)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;real-class-definition&amp;gt; convert/ 
defclass.dylan:4245&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;class-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;cclass&amp;gt; or #f (if unknown) or #&amp;#148;not- 
computed-yet&amp;#148; or #&amp;#148;computing&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; (to do deferred evaluations) or  
#f &lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; (to do key defaulting) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; (to do making) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;slot-info&amp;gt;  
(slots introduced by this class)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;override- 
info&amp;gt; (overrides introduced by this class)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;keyword- 
info&amp;gt; (for overrides introduced by this class)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;local-class-definition&amp;gt; convert/ 
defclass.dylan:4256&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;same as &amp;lt;real-class-definition&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;init-function-definition&amp;gt; convert/ 
defclass.dylan:4260&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;init-function-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; or #f (inlined function  
literal)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (inlining type)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;maker-function-definition&amp;gt; convert/ 
defclass.dylan:4265&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;maker-function-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; or #f (inlined function  
literal)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (inlining type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;class-definition&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;real-define-method-tlf&amp;gt; convert/ 
deffunc.dylan:1344&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; (if inherited or  
exported)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;sealed-domain&amp;#148; (if sealed)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (of this tlf)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (specializers)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-sealed-domain-tlf&amp;gt; convert/ 
deffunc.dylan:1359&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;sealed-domain&amp;#148; (if sealed)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; &lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (specializers)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-library-tlf&amp;gt; convert/deflibmod.dylan: 
73&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-library-tlf&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; (library name)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;use&amp;gt; (used  
libraries)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;identifier- 
token&amp;gt; (exported module names)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-module-tlf&amp;gt; convert/deflibmod.dylan: 
152&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-module-tlf&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; (module name)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;use&amp;gt; (used  
modules)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;identifier- 
token&amp;gt; (exported binding names)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;identifier- 
token&amp;gt; (created binding names)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;real-designator-class-definition&amp;gt; convert/ 
defdclass.dylan:437&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;local-designator-class-definition&amp;gt; convert/ 
defdclass.dylan:449&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;expression-tlf&amp;gt; convert/tlexpr.dylan:110&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;nothing&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;magic-internal-primitives-placeholder&amp;gt;  
convert/tlexpr.dylan:140&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;nothing&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; front/func-defns.dylan: 
900&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;generic-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (sealed)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;seal-info&amp;gt; (seals on this  
generic)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (discriminator  
function)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;implicit-generic-definition&amp;gt; front/func- 
defns.dylan:905&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;implicit-generic-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (sealed)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;seal-info&amp;gt; (seals on this  
generic)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (discriminator  
function)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;seal-info&amp;gt; front/func-defns.dylan:910&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;seal-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list&amp;gt; of &amp;lt;ctype&amp;gt; (specializers)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;method-definition&amp;gt; front/func-defns.dylan: 
932&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;method-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; or #f (inlined function  
literal)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (inlining type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (congruent to &amp;lt;generic- 
definition&amp;gt;)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;getter-method-definition&amp;gt; front/func- 
defns.dylan:941&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;getter-method-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; or #f (inlined function  
literal)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (inlining type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (congruent to &amp;lt;generic- 
definition&amp;gt;)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;slot-info&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;setter-method-definition&amp;gt; front/func- 
defns.dylan:945&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;setter-method-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (hairy: something non-constant in  
signature)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; or #f (if hairy) or #&amp;#148;not- 
computed-yet&amp;#148;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (flushable: no side effects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (movable: result only depends on  
arguments)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; or #f (inlined function  
literal)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (inlining type)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;generic-definition&amp;gt; or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (congruent to &amp;lt;generic- 
definition&amp;gt;)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;slot-info&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-literal&amp;gt; front/fer-od.dylan:535&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;function-literal&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;values-ctype&amp;gt; (subclass of  
&amp;lt;function&amp;gt;)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (indicating visibility)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;signature&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ct-function&amp;gt; (if global visibility) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;fer-function-region&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;fer-function-region&amp;gt; or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-define-tlf&amp;gt; front/tlf.dylan:220&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-binding-tlf&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;top-level-form&amp;gt;, or &amp;lt;list&amp;gt; of &amp;lt;top- 
level-form&amp;gt; (dependencies)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;unit-info&amp;gt; main/unit-info.dylan:62&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;unit-info&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; (unit name)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; (undumped objects)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; (extra labels)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; (linker options) or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-list-macro-definition&amp;gt; parser/ 
macros.dylan:3184&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-bindings-macro-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol&amp;gt;  
(intermediate words)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;main-rule-set&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;auxiliary-rule- 
set&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;define-body-macro-definition&amp;gt; parser/ 
macros.dylan:3187&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;define-macro-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol&amp;gt;  
(intermediate words)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;main-rule-set&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;auxiliary-rule- 
set&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-macro-definition&amp;gt; parser/ 
macros.dylan:3190&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;function-macro-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol&amp;gt;  
(intermediate words)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;main-rule-set&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;auxiliary-rule- 
set&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;statement-macro-definition&amp;gt; parser/ 
macros.dylan:3193&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;statement-macro-definition&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;info&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;library&amp;gt; (library making the definition)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (definition can be dynamically  
redefined)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;symbol&amp;gt;  
(intermediate words)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;main-rule-set&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;auxiliary-rule- 
set&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;main-rule-set&amp;gt; parser/macros.dylan:3201&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;main-rule-set&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;rule&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;auxiliary-rule-set&amp;gt; parser/macros.dylan: 
3204&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;aux-rule-set&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;rule&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; (name of aux rule set)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (a rule in this set ends with  
pattern variable with body/case constraint)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;body-style-define-rule&amp;gt; parser/macros.dylan: 
3222&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;body-style-define-rule&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;template&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; or #f (name of macro  
containing this rule)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; or #f (modifiers part of pattern)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;list-style-define-rule&amp;gt; parser/macros.dylan: 
3226&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;list-style-define-rule&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;template&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; or #f (name of macro  
containing this rule)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; or #f (modifiers part of pattern)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;statement-rule&amp;gt; parser/macros.dylan:3230&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;statement-rule&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;template&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; or #f (name of macro  
containing this rule)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;function-rule&amp;gt; parser/macros.dylan:3234&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;statement-rule&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;template&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt; or #f (name of macro  
containing this rule)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;auxiliary-rule&amp;gt; parser/macros.dylan:3238&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;auxiliary-rule&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;template&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;empty-pattern&amp;gt; parser/macros.dylan:3243&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;empty-pattern&amp;#148;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;semicolon-pattern&amp;gt; parser/macros.dylan: 
3252&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;semicolon-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; (left-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; (right-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (last semicolon pattern in chain)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;comma-pattern&amp;gt; parser/macros.dylan:3256&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;comma-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; (left-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; (right-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (last comma pattern in chain)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;sequential-pattern&amp;gt; parser/macros.dylan: 
3260&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;sequential-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; (left-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt; (right-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (last sequential pattern in  
chain)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;bracketed-pattern&amp;gt; parser/macros.dylan: 
3264&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;bracketed-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (left bracket)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (right bracket)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;variable-pattern&amp;gt; parser/macros.dylan:3270&lt;BR&gt;
+(pattern representing a variable, e.g.  
&amp;#147;?:name :: ?:expression&amp;#148;)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;variable-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-variable&amp;gt; (name part)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-variable&amp;gt; (type part)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;bindings-pattern&amp;gt; parser/macros.dylan:3275&lt;BR&gt;
+(pattern representing a binding, e.g. &amp;#147;?:variable  
= ?:expression&amp;#148;)&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;bindings-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-variable&amp;gt; or &amp;lt;variable- 
pattern&amp;gt; (left-hand side)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-variable&amp;gt; (right-hand side)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;name-pattern&amp;gt; parser/macros.dylan:3280&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;name-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol-token&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;arrow-pattern&amp;gt; parser/macros.dylan:3284&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;arrow-pattern&amp;#148;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-variable&amp;gt; parser/macros.dylan:3294&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;pattern-variable&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; or #f (pattern variable name)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; or #f (pattern variable  
constraint)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (pattern variable is at end of  
pattern)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;property-list-pattern&amp;gt; parser/macros.dylan: 
3298&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;property-list-pattern&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-variable&amp;gt; (#rest part of prop list  
pattern) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;pattern- 
keyword&amp;gt; (#key parts of prop list pattern) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (#all-keys present in prop list  
pattern)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;pattern-keyword&amp;gt; parser/macros.dylan:3304&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;pattern-keyword&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; or #f (pattern variable name)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;symbol&amp;gt; or #f (pattern variable  
constraint)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;#t&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;template&amp;gt; (default template for keyword) or  
#f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;boolean&amp;gt; (?? keyword)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;procedural-template&amp;gt; parser/macros.dylan: 
3311&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;procedural-template&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;identifier-token&amp;gt; (procedure that produces  
replacement)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;template&amp;gt;  
(arguments)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-template&amp;gt; parser/macros.dylan:3316&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;literal-template&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-object-vector&amp;gt; of &amp;lt;token&amp;gt; or  
&amp;lt;bracketed-element&amp;gt; or &amp;lt;pattern-variable-reference&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;bracketed-element&amp;gt; parser/macros.dylan: 
3320&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;bracketed-element&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (left bracket)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;literal-template&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (right bracket)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;simple-pattern-variable-reference&amp;gt; parser/ 
macros.dylan:3329&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;simple-pattern-variable-reference&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (name, string, or symbol)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;ellipsis-pattern-variable-reference&amp;gt; parser/ 
macros.dylan:3334&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;ellipsis-pattern-variable-reference&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (ellipsis)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;concatenating-pattern-variable-reference&amp;gt;  
parser/macros.dylan:3339&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;concatenating-pattern-variable- 
reference&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (name, string, or symbol)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; (prefix) or #f&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;byte-string&amp;gt; (suffix) or #f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;sequence-pattern-variable-reference&amp;gt; parser/ 
macros.dylan:3346&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;sequence-pattern-variable-reference&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (name, string, or symbol)&lt;BR&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (separator)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;unhygienic-pattern-variable-reference&amp;gt;  
parser/macros.dylan:3352&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;#&amp;#148;unhygienic-pattern-variable- 
reference&amp;#148;&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="circle"&gt;&amp;lt;token&amp;gt; (name)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;boolean&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;#t&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;#f&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;sequence&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;list&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;simple-object-vector&amp;gt;&lt;BR&gt;
+&lt;BR&gt;
+&lt;/UL&gt;
+A &amp;lt;source-location&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;known-source-location&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;unknown-source-location&amp;gt;&lt;BR&gt;
+&lt;BR&gt;
+&lt;/UL&gt;
+A &amp;lt;symbol-token&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;identifier-token&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;operator-token&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;constrained-name-token&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;literal&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;eql-literal&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-integer&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-single-float&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-double-float&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-extended-float&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-pair&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-simple-object-vector&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-byte-string&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;top-level-form&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-sealed-domain-tlf&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-library-tlf&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-module-tlf&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;expression-tlf&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;simple-define-tlf&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-class-tlf&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-bindings-tlf&amp;gt;&lt;BR&gt;
+&lt;BR&gt;
+&lt;/UL&gt;
+A &amp;lt;definition&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;generic-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;implicit-generic-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;init-function-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;maker-function-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;constant-method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;getter-method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;setter-method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;real-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;local-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;constant-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;variable-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-list-macro-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;define-body-macro-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;function-macro-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;statement-macro-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;real-designator-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;local-designator-class-definition&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;function-definition&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;generic-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;maker-function-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;init-function-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;constant-method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;getter-method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;setter-method-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;implicit-generic-definition&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;class-definition&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;real-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;local-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;real-designator-class-definition&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;local-designator-class-definition&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;name&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;basic-name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;derived-name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;internal-name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;anonymous-name&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;method-name&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;ctype&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;union-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;unknown-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;limited-integer-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;direct-instance-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;singleton-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;byte-character-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;subclass-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;limited-collection-ctype&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;defined-cclass&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;limited-cclass&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;meta-cclass&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;defined-cdclass&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+There doesn&amp;#146;t seem to be any dump format for &amp;lt;values- 
ctype&amp;gt;. It will probably only be dumped as a more specific  
&amp;lt;ctype&amp;gt;.&lt;BR&gt;
+&lt;BR&gt;
+An empty-ctype is dumped as a &amp;lt;union-ctype&amp;gt; with no members.&lt;BR&gt;
+&lt;BR&gt;
+A &amp;lt;ct-value&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-not-supplied-marker&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;eql-literal&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-integer&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-single-float&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-double-float&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-extended-float&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-pair&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-simple-object-vector&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;literal-byte-string&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-entry-point&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;struct-slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-function&amp;gt; (see below)&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;slot-info&amp;gt; (see below)&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;ct-function&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-raw-function&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-callback-function&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-sealed-generic&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-open-generic&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-method&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;ct-accessor-method&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;cclass&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;defined-cclass&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;limited-cclass&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;meta-cclass&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;defined-cdclass&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;slot-info&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;instance-slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;vector-slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;meta-slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;class-slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;each-subclass-slot-info&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;virtual-slot-info&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;rule&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;body-style-define-rule&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;list-style-define-rule&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;statement-rule&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;function-rule&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;auxiliary-rule&amp;gt;&lt;BR&gt;
+&lt;/UL&gt;
+&lt;BR&gt;
+A &amp;lt;pattern&amp;gt; will be dumped as one of&lt;BR&gt;
+&lt;UL&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;empty-pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;semicolon-pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;comma-pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"&gt;&amp;lt;sequential-pattern&amp;gt;&lt;BR&gt;
+&lt;LI TYPE="disc"