gmane.comp.lang.dylan.gwydion.devel

Buildbot, and a minor Gwydion change

Peter S. Housel — 2008-08-29T05:41:11

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) < at >< at > -139,7 +139,7 < at >< at > # 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"; < at >< at > -353,7 +353,7 < at >< at > 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"; < at >< at > -374,6 +374,7 < at >< at > "$gen_makefile -p$platforms_dot_descr ."); &emit_rule('compile'); + &emit_rule('check'); $destdir && do emit_rule ('install'); $destdir && do emit_rule ('uninstall'); &emit_rule('clean'); < at >< at > -460,6 +461,9 < at >< at > push(< at >compile_commands, sprintf($host_platform{'recursive_make_command'}, $subdir, "")); + push(< at >check_commands, + sprintf($host_platform{'recursive_make_command'}, + $subdir, "check")); push(< at >install_commands, sprintf($host_platform{'recursive_make_command'}, $subdir, "install")); Index: qa/Makegen =================================================================== --- qa/Makegen(revision 11926) +++ qa/Makegen(working copy) < at >< at > -6,15 +6,17 < at >< at > "../common/io/tests", "../common/system/tests"); -foreach $testdir (< at >testdirs) { +foreach $testdir (< at >testdirs, "test-suites") { if ($features{'compiled_for_win32'}) { $testdir =~ s|/|\\|; } - push(< at >compile_commands, + push(< at >check_commands, sprintf($host_platform{'recursive_make_command'}, $testdir, "")); push(< at >clean_commands, sprintf($host_platform{'recursive_make_command'}, $testdir, "clean")); } -&compile_subdirs("test-suites", "test-apps"); - +push(< at >check_commands, + sprintf($host_platform{'recursive_make_command'}, "test-apps", "check")); +push(< at >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) < at >< at > -11,15 +11,11 < at >< at > sub emit_run_tests_rule { local (< at >tests) = < at >_; local ($test); - print "run_tests : "; - foreach $test (< at >tests) { -print "$test$dot_exe "; - } - print "\n"; foreach $test (< at >tests) { -local ($test) = &convert_path_separator("./$test"); -print "\t$test $testflags\n"; +push < at >check_dependencies, "$test$dot_exe"; + +local ($runtest) = &convert_path_separator("./$test"); +push < at >check_commands, "$runtest $testflags"; } - push(< at >compile_dependencies, "run_tests"); } Index: doc/Makefile.in =================================================================== --- doc/Makefile.in(revision 11926) +++ doc/Makefile.in(working copy) < at >< at > -6,11 +6,14 < at >< at > 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< at >lists.opendylan.org https://www.opendylan.org/mailman/listinfo/hackers

Diff for Gwydion Dylan --dump-od switch

Dustin Voss — 2008-08-21T13:18:23

Index: compiler/main/main-unit-state.dylan =================================================================== --- compiler/main/main-unit-state.dylan(revision 11909) +++ compiler/main/main-unit-state.dylan(working copy) < at >< at > -37,6 +37,8 < at >< at > required-init-keyword: command-line-features:; constant slot unit-log-dependencies :: , required-init-keyword: log-dependencies:; + constant slot unit-log-text-du :: , + required-init-keyword: log-text-du:; constant slot unit-target :: , required-init-keyword: target:; constant slot unit-no-binaries :: , Index: compiler/main/main.dylan =================================================================== --- compiler/main/main.dylan(revision 11909) +++ compiler/main/main.dylan(working copy) < at >< at > -92,6 +92,7 < at >< at > " -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" < at >< at > -293,6 +294,9 < at >< at > long-options: #("log-deps"), short-options: #("M")); add-option-parser-by-type(argp, + , + long-options: #("dump-du")); + add-option-parser-by-type(argp, , long-options: #("target"), short-options: #("T")); < at >< at > -378,6 +382,7 < at >< at > 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; < at >< at > -504,6 +509,7 < at >< at > source-locator: locator, command-line-features: as(, features), log-dependencies: log-dependencies, + log-text-du: log-text-du, target: *current-target*, no-binaries: no-binaries, no-makefile: no-makefile, < at >< at > -516,6 +522,7 < at >< at > lid-locator: locator, command-line-features: as(, 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) < at >< at > -11,4 +11,5 < at >< at > 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) < at >< at > -32,6 +32,8 < at >< at > use Dylan; use Common-Dylan; use IO; + use Stream-extensions, + import: {indenting-streams}; use System; use String-extensions; use Random; < at >< at > -76,6 +78,7 < at >< at > 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) < at >< at > -0,0 +1,339 < at >< at > +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 gwydiondylan.org>; questions, +// comments and suggestions are welcome at gwydiondylan.org>. +// 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 #"" +// 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 object, even across libraries. + + +define function dump-text-du + (unit-name :: , file :: ) + => (); + format(*debug-output*, "Dumping library summary as text.\n", file); + let stream = make(, locator: file, direction: #"output"); + let ind-stream = make(, + inner-stream: stream, + output-tab-width: #f); + *extern-count* := 0; + let du = find-data-unit(as(, 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 :: ) + => dispatcher :: ; + let dispatcher = make(, 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 :: , flags :: , + label :: false-or(), + default-loader :: false-or()) + => (obj :: ) + 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 s and put them in +// a vector for extern-index. Instead, we build s and put them +// in a vector. +// +define variable *extern-count* :: = 0; +define class () + constant slot index :: , 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 :: , flags :: , label :: false- or(), + default-loader :: false-or(), entry-type :: , + stream :: ) + => obj :: ; + // Print entry label and type. + format(stream, "%s", as(, 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 & 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(, size: data-size); + if (data-size > 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(); + 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, ) => + if (sub.forward-ref-id) + format(stream, "[[%x]]\n", sub.forward-ref-id) + else + write(stream, "[[unknown forward reference]]"); + end if; + instance?(sub, ) & entry-type ~= #"extern- index" => + 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" => as(, subobjects); + #"extern-handle" => make(, index: *extern-count* - 1); + otherwise => 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 :: , flags :: ) + => (data-size :: , padding-size :: ); + let raw-data-format = logand(flags, $odf-raw-format-mask); + let size-unit + = select (raw-data-format) + $odf-no-raw-data-format => 0; + $odf-byte-raw-data-format => 1; + $odf-16bit-raw-data-format => 2; + $odf-32bit-raw-data-format => 4; + $odf-64bit-raw-data-format => 8; + $odf-word-raw-data-format => $word-bytes; + otherwise => + 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 => 0; + otherwise => + 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 :: , flags :: , data :: , + entry-type :: ) + => (); + let raw-data-format = logand(flags, $odf-raw-format-mask); + let group-every + = select (raw-data-format) + $odf-byte-raw-data-format => 1; + $odf-16bit-raw-data-format => 2; + $odf-32bit-raw-data-format => 4; + $odf-64bit-raw-data-format => 8; + $odf-word-raw-data-format => $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(, data[i])); + if (modulo(i + 1, group-every) == 0) + write-element(stream, ' '); + end if; + end for; + if (data-size > capped-data-size) + format(stream, "... (%d bytes)", data-size); + end if; +end method; + +define method format-raw-data + (stream :: , flags :: , data :: , + entry-type :: one-of(#"local-index", #"local-object-map")) + => (); + let raw-data-format = logand(flags, $odf-raw-format-mask); + let elem-size + = select (raw-data-format) + $odf-byte-raw-data-format => 1; + $odf-16bit-raw-data-format => 2; + $odf-32bit-raw-data-format => 4; + $odf-64bit-raw-data-format => 8; + $odf-word-raw-data-format => $word-bytes; + end select; + let (field, cap) + = select (elem-size) + 1 => values("%02x", 16); + 2 => values("%04x", 8); + 4 => values("%08x", 4); + 8 => 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 > capped-data-size) + format(stream, "... (%d bytes)", data-size * elem-size); + end if; +end method; + +define method format-raw-data + (stream :: , flags :: , data :: , + entry-type :: one-of(#"fixed-integer", #"extended-integer", #"ratio", + #"single-float")) + => () + format(stream, "%s", data); +end method; + +define method format-raw-data + (stream :: , flags :: , data :: , + entry-type :: one-of(#"file-locator", #"byte-string")) + => (); + format(stream, "\"%s\"", as(, data)); +end method; + +define method format-raw-data + (stream :: , flags :: , data :: , + entry-type == #"byte-symbol") + => (); + format(stream, "#\"%s\"", as(, data)); +end method; + +define method format-raw-data + (stream :: , flags :: , data :: , + entry-type == #"byte-character") + => (); + 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) < at >< at > -353,6 +353,11 < at >< at > 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) < at >< at > -833,10 +833,15 < at >< at > 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) < at >< at > -179,16 +179,22 < at >< at > load-sole-subobject, assert-end-object, , + forward-ref-id, actual-obj, obj-resolved?, request-backpatch, resolve-forward-ref, + , + extern-ref-du-name, + extern-ref-du-loc, + extern-ref-local-id, , 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) < at >< at > -0,0 +1,1549 < at >< at > + + + + + +od-format-description + + + +

Gwydion Dylan DU File Format
+Aug 17, 2008
+

+ +

+The conceptual root of the DU file format is the dumped <unit- info> instance, but it is not the first object physically found in the file.
+
+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.
+
+

#t base/dylan-dump:45
+
- #”true”
  +
+
#f base/dylan-dump:58
+
- #”false”
  +
+
<integer> base/dylan-dump:72
+
- #”fixed-integer”
  +
  - raw word data (1)
    +
  - raw word data (value of integer)
    +
  +
+
<extended-integer> base/dylan-dump:114
+
- #”extended-integer”
  +
  - raw word data (number of subsequent words)
    +
  - series of raw word data
    +
  +
+
<ratio> base/dylan-dump:157
+
- #”ratio”
  +
  - numerator
    +
  - denominator
    +
  +
+
<file-locator> base/dylan-dump:177
+
- #”file-locator”
  +
  - raw byte data (path to file)
    +
  +
+
<single-float> base/dylan-dump:229
+
- #”single-float”
  +
  - fractional part
    +
  - exponent part
    +
  +
+
<byte-string> base/dylan-dump:249
+
- #”byte-string”
  +
  - raw byte data
    +
  +
+
<symbol> base/dylan-dump:272
+
- #”byte-symbol”
  +
  - raw byte data (string form of symbol)
    +
  +
+
<byte-character> base/dylan-dump:294
+
- #”byte-character”
  +
  - raw byte data (1 byte)
    +
  +
+
<list> base/dylan-dump:315
+
- #”list*” (if improper)
  +
  - series of elements
    +
  +
- #”list” (if proper)
  +
  - series of elements
    +
  +
+
<simple-object-vector> base/dylan-dump:399
+
- #”simple-object-vector”
  +
  - series of elements
    +
  +
+
<unknown-source-location> base/source.dylan: 92
+
- #”unknown-source-location”
  +
+
<source-file> base/source.dylan:195
+
- #”source-file”
  +
  - <file-locator>
    +
  +
+
<source-buffer>
+
- #”source-buffer”
  +
  - <byte-string> (buffer name)
    +
  +
+
<known-source-location> base/source.dylan: 434
+
- #”known-source-location”
  +
  - raw word data (6)
    +
  - raw word data (start position)
    +
  - raw word data (start line)
    +
  - raw word data (start column)
    +
  - raw word data (end position)
    +
  - raw word data (end line)
    +
  - raw word data (end column)
    +
  - <source-file> or <source-buffer>
    +
  +
+
<ct-raw-function> base/ctfunc.dylan:107
+
- #”ct-function”
  +
  - info
    +
  - <name>
    +
  - <signature>
    +
  - <function-definition> or #f (if it didn’t come from a definition)
    +
  - <list> of <ctype>? (types of closure vars for local functions)
    +
  - <boolean> (has-general-entry?)
    +
  +
+
<ct-callback-function> base/ctfunc.dylan: 122
+
- #”ct-callback-function”
  +
  - info
    +
  - <name>
    +
  - <signature>
    +
  - <function-definition> or #f (if it didn’t come from a definition)
    +
  - <list> of <ctype>? (types of closure vars for local functions)
    +
  - <boolean> (has-general-entry?)
    +
  - <boolean> (has-callback-entry?)
    +
  +
+
<ct-sealed-generic> base/ctfunc.dylan:155
+
- #”ct-sealed-generic”
  +
  - info
    +
  - <name>
    +
  - <signature>
    +
  - <function-definition> or #f (if it didn’t come from a definition)
    +
  - <list> of <ctype>? (types of closure vars for local functions)
    +
  - <boolean> (has-general-entry?)
    +
  - <boolean> (sealed)
    +
  +
+
<ct-open-generic> base/ctfunc.dylan:161
+
- #”ct-open-generic”
  +
  - info
    +
  - <name>
    +
  - <signature>
    +
  - <function-definition> or #f (if it didn’t come from a definition)
    +
  - <list> of <ctype>? (types of closure vars for local functions)
    +
  - <boolean> (has-general-entry?)
    +
  - <boolean> (sealed)
    +
  +
+
<ct-method> base/ctfunc.dylan:186
+
- #”ct-method”
  +
  - info
    +
  - <name>
    +
  - <signature>
    +
  - <function-definition> or #f (if it didn’t come from a definition)
    +
  - <list> of <ctype>? (types of closure vars for local functions)
    +
  - <boolean> (has-general-entry?)
    +
  - <boolean> (method is hidden inside generic function)
    +
  - <boolean> (has-generic-entry?)
    +
  +
+
<ct-accessor-method> base/ctfunc.dylan:205
+
- #”ct-accessor-method”
  +
  - info
    +
  - <name>
    +
  - <signature>
    +
  - <function-definition> or #f (if it didn’t come from a definition)
    +
  - <list> of <ctype>? (types of closure vars for local functions)
    +
  - <boolean> (has-general-entry?)
    +
  - <boolean> (method is hidden inside generic function)
    +
  - <boolean> (has-generic-entry?)
    +
  - <slot-info>
    +
  - <ct-function> (shared accessor stand-in) or #f (need custom stand-in)
    +
  +
+
<ct-entry-point> base/ctfunc.dylan:251
+
<ct-not-supplied-marker> base/ctv.dylan:782
+
<eql-literal> base/ctv.dylan:790
+
<literal-integer> base/ctv.dylan:816
+
<literal-single-float> base/ctv.dylan:822
+
<literal-double-float> base/ctv.dylan:828
+
<literal-extended-float> base/ctv.dylan:834
+
<literal-pair> base/ctv.dylan:864
+
<literal-simple-object-vector> base/ctv.dylan: 871
+
<literal-byte-string> base/ctv.dylan:879
+
<basic-name> base/names.dylan:79
+
- #”basic-name”
  +
  - <symbol>
    +
  - <module>
    +
  +
+
<derived-name> (internal use) base/ names.dylan:132
+
- #”derived-name”
  +
  - <name>
    +
  - <symbol> (describing what kind of derivation to do)
    +
  +
+
<internal-name> (local method etc) base/ names.dylan:159
+
- #”internal-name”
  +
  - <symbol> (name of local method)
    +
  - <name> (container)
    +
  +
+
<anonymous-name> (unnamed tlf) base/ names.dylan:185
+
- #”anonymous-name”
  +
  - <source-location>
    +
  +
+
<method-name> base/names.dylan:218
+
- #”method-name”
  +
  - <basic-name>
    +
  - <sequence> of <ctype> (specializers)
    +
  +
+
<signature> base/signature.dylan:70
+
- #”function-signature”
  +
  - <list> of <ctype> (specializers for req’d arguments)
    +
  - <boolean> (#next present)
    +
  - <ctype> (#rest type) or #f (if no #rest)
    +
  - <list> of <key-info>, or #f (if no #key)
    +
  - <boolean> (#all-keys present)
    +
  - <values-ctype> (result type)
    +
  +
+
<key-info> base/signature.dylan:119
+
- #”function-key-info”
  +
  - <symbol>
    +
  - <ctype>
    +
  - <boolean> (required)
    +
  - <ct-value> (default compile-time value) or #f
    +
  +
+
<token> base/tokens.dylan:610
+
- #”token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  +
+
<identifier-token> base/tokens.dylan:626
+
- #”identifier-token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  - <symbol>
    +
  - <module> or #f
    +
  - <uniquifier> or #f
    +
  +
+
<left-bracket-token> (tokens that have a symbol name) base/tokens.dylan:629
+
- #”left-bracket-token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  - <module>
    +
  +
+
<uniquifier> base/tokens.dylan:632
+
- #”uniquifier”
  +
+
<operator-token> base/tokens.dylan:639
+
- #”operator-token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  - <symbol>
    +
  - <module> or #f
    +
  - <uniquifier> or #f
    +
  +
+
<constrained-name-token> base/tokens.dylan: 642
+
- #”constrained-name-token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  - <symbol> (pattern variable name part)
    +
  - <symbol> (pattern variable constraint part)
    +
  +
+
<literal-token> base/tokens.dylan:647
+
- #”literal-token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  - <literal>
    +
  +
+
<pre-parsed-token> base/tokens.dylan:651
+
- #”pre-parsed-token”
  +
  - <source-location>
    +
  - <integer> (token kind)
    +
  - token-parse-tree
    +
  +
+
<union-ctype> base/type-dump.dylan:47
+
- #”union-type”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <list> of <ctype> (classes, limited types, or singletons in union)
    +
  +
+
<unknown-ctype> base/type-dump.dylan:99
+
- #”unknown-type”
  +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - #f (theoretically, the expression of unknown type)
    +
  +
+
<limited-integer-ctype> base/type-dump.dylan: 107
+
- #”limited-integer-type”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <cclass> (most specific supertype of this limited type)
    +
  - <extended-integer> or #f (low bound)
    +
  - <extended-integer> or #f (high bound)
    +
  +
+
<direct-instance-ctype> base/type-dump.dylan: 115
+
- #”direct-instance-type”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <cclass> (most specific supertype of this type)
    +
  +
+
<singleton-ctype> base/type-dump.dylan:121
+
- #”singleton-type”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <cclass> (direct class of this type)
    +
  - <ct-value>
    +
  +
+
<byte-character-ctype> base/type-dump.dylan: 128
+
- #”byte-character-type”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <cclass> (most specific supertype of this type)
    +
  +
+
<multi-value-ctype> base/type-dump.dylan: 134
+
- #”multi-value-type”
  +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <list> of <ctype> (types of specifically typed values)
    +
  - <integer> (min number of values that will ever be included)
    +
  - <ctype> (type of rest value) or empty-ctype
    +
  +
+
<subclass-ctype> base/type-dump.dylan:141
+
- #”subclass-type”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <cclass> (most specific supertype of this type)
    +
  - <cclass> (class this type covers subclasses of)
    +
  +
+
<limited-collection-ctype> base/type- dump.dylan:148
+
- #”limited-collection”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <cclass> (most specific supertype of this limited type)
    +
  - <ctype> (element type)
    +
  - <integer>, or <sequence> of <integer>, or #f (size or dimensions)
    +
  +
+
<proxy> base/type-dump.dylan:157
+
- #”class-proxy”
  +
  - info
    +
  - <cclass> (proxied class)
    +
  +
+
<instance-slot-info> base/type-dump.dylan: 204
+
- #”instance-slot-info”
  +
  - <cclass> (that introduces this slot)
    +
  - <ctype>
    +
  - <variable> (getter generic function) or #f (if not needed for identity)
    +
  - <boolean> (no setter)
    +
  - <ct-value> (initial value) or #t (if there is an initial value, but it is unknown) or #f (if there is no initial value)
    +
  - <ct-value> (init-function) or #t (if there is an init-function, but it is unknown) or #f (if there is no init- function)
    +
  - <symbol> (init-keyword) or #f
    +
  - <boolean> (init-keyword is required)
    +
  +
+
<vector-slot-info> base/type-dump.dylan:216
+
- #”vector-slot-info”
  +
  - <cclass> (that introduces this slot)
    +
  - <ctype>
    +
  - <variable> (getter generic function) or #f (if not needed for identity)
    +
  - <boolean> (no setter)
    +
  - <ct-value> (initial value) or #t (if there is an initial value, but it is unknown) or #f (if there is no initial value)
    +
  - <ct-value> (init-function) or #t (if there is an init-function, but it is unknown) or #f (if there is no init- function)
    +
  - <symbol> (init-keyword) or #f
    +
  - <boolean> (init-keyword is required)
    +
  - <instance-slot-info> (slot-size slot)
    +
  +
+
<meta-slot-info> base/type-dump.dylan:224
+(actual class slot or each-subclass slot, located in instance’s object-class)
+
- #”meta-slot-info”
  +
  - <cclass> (that introduces this slot)
    +
  - <ctype>
    +
  - <variable> (getter generic function) or #f (if not needed for identity)
    +
  - <boolean> (no setter)
    +
  - <ct-value> (initial value) or #t (if there is an initial value, but it is unknown) or #f (if there is no initial value)
    +
  - <ct-value> (init-function) or #t (if there is an init-function, but it is unknown) or #f (if there is no init- function)
    +
  - <symbol> (init-keyword) or #f
    +
  - <boolean> (init-keyword is required)
    +
  - <class-slot-info> or <each-subclass-slot- info>
    +
  +
+
<class-slot-info> base/type-dump.dylan:233
+
- #”class-slot-info”
  +
  - <cclass> (that introduces this slot)
    +
  - <ctype>
    +
  - <variable> (getter generic function) or #f (if not needed for identity)
    +
  - <boolean> (no setter)
    +
  - <ct-value> (initial value) or #t (if there is an initial value, but it is unknown) or #f (if there is no initial value)
    +
  - <ct-value> (init-function) or #t (if there is an init-function, but it is unknown) or #f (if there is no init- function)
    +
  - <symbol> (init-keyword) or #f
    +
  - <boolean> (init-keyword is required)
    +
  - <meta-slot-info>
    +
  +
+
<each-subclass-slot-info> base/type- dump.dylan:242
+
- #”each-subclass-slot-info”
  +
  - <cclass> (that introduces this slot)
    +
  - <ctype>
    +
  - <variable> (getter generic function) or #f (if not needed for identity)
    +
  - <boolean> (no setter)
    +
  - <ct-value> (initial value) or #t (if there is an initial value, but it is unknown) or #f (if there is no initial value)
    +
  - <ct-value> (init-function) or #t (if there is an init-function, but it is unknown) or #f (if there is no init- function)
    +
  - <symbol> (init-keyword) or #f
    +
  - <boolean> (init-keyword is required)
    +
  - <meta-slot-info>
    +
  +
+
<virtual-slot-info> base/type-dump.dylan: 250
+
- #”virtual-slot-info”
  +
  - <cclass> (that introduces this slot)
    +
  - <ctype>
    +
  - <variable> (getter generic function) or #f (if not needed for identity)
    +
  - <boolean> (no setter)
    +
  - <ct-value> (initial value) or #t (if there is an initial value, but it is unknown) or #f (if there is no initial value)
    +
  - <ct-value> (init-function) or #t (if there is an init-function, but it is unknown) or #f (if there is no init- function)
    +
  - <symbol> (init-keyword) or #f
    +
  - <boolean> (init-keyword is required)
    +
  +
+
<override-info> base/type-dump.dylan:256
+
- #”override-info”
  +
  - <cclass> (that introduces this inherited slot clause)
    +
  - <variable> (getter generic function being inherited)
    +
  - <ct-value> (initial value) or #t (if there is a new initial value, but it is unknown) or #f (if there is no new initial value)
    +
  - <ct-value> (init-function) or #t (if there is a new init-function, but it is unknown) or #f (if there is no new init- function)
    +
  +
+
<keyword-info> base/type-dump.dylan:265
+
- #”keyword-info”
  +
  - <cclass> (that introduces this keyword clause)
    +
  - <symbol> (the keyword symbol)
    +
  - <ct-value> (initial value) or #t (if there is a new initial value, but it is unknown) or #f (if there is no new initial value)
    +
  - <ct-value> (init-function) or #t (if there is a new init-function, but it is unknown) or #f (if there is no new init- function)
    +
  - <boolean> (required keyword)
    +
  - <ctype> (type restriction of keyword)
    +
  +
+
<defined-cclass> base/type-dump.dylan:285
+
- #”defined-class”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <name> (printable name of class)
    +
  - <list> of <cclass> (direct superclasses)
    +
  - <cclass> (closest primary superclass)
    +
  - <boolean> (this class and its subclasses can’t be functional)
    +
  - <boolean> (this class is functional)
    +
  - <boolean> (this class is sealed)
    +
  - <boolean> (this class is abstract)
    +
  - <boolean> (this class is primary)
    +
  - <list> of <cclass> (class precedence list, including this class and indirect superclasses)
    +
  - <integer> (unique id of concrete class) or #f
    +
  - <integer> (subclass id range min of sealed & non-mixed class) or #f
    +
  - <integer> (subclass id range max of sealed & non-mixed class) or #f
    +
  - <representation> (direct speed representation) or #f (if abstract)
    +
  - <representation> (direct space representation) or #f (if abstract)
    +
  - <representation> (general speed representation) or #f (if abstract)
    +
  - <representation> (general space representation) or #f (if abstract)
    +
  - <meta-cclass> or #f
    +
  +
+
<limited-cclass> base/type-dump.dylan:292
+
- #”limited-class”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <name> (printable name of class)
    +
  - <list> of <cclass> (direct superclasses)
    +
  - <cclass> (closest primary superclass)
    +
  - <boolean> (this class and its subclasses can’t be functional)
    +
  - <boolean> (this class is functional)
    +
  - <boolean> (this class is sealed)
    +
  - <boolean> (this class is abstract)
    +
  - <boolean> (this class is primary)
    +
  - <list> of <cclass> (class precedence list, including this class and indirect superclasses)
    +
  - <integer> (unique id of concrete class) or #f
    +
  - <integer> (subclass id range min of sealed & non-mixed class) or #f
    +
  - <integer> (subclass id range max of sealed & non-mixed class) or #f
    +
  - <representation> (direct speed representation) or #f (if abstract)
    +
  - <representation> (direct space representation) or #f (if abstract)
    +
  - <representation> (general speed representation) or #f (if abstract)
    +
  - <representation> (general space representation) or #f (if abstract)
    +
  - <meta-cclass> or #f
    +
  +
+
<meta-cclass> base/type-dump.dylan:299
+
- #”meta-class”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <name> (printable name of class)
    +
  - <list> of <cclass> (direct superclasses)
    +
  - <cclass> (closest primary superclass)
    +
  - <boolean> (this class and its subclasses can’t be functional)
    +
  - <boolean> (this class is functional)
    +
  - <boolean> (this class is sealed)
    +
  - <boolean> (this class is abstract)
    +
  - <boolean> (this class is primary)
    +
  - <list> of <cclass> (class precedence list, including this class and indirect superclasses)
    +
  - <integer> (unique id of concrete class) or #f
    +
  - <integer> (subclass id range min of sealed & non-mixed class) or #f
    +
  - <integer> (subclass id range max of sealed & non-mixed class) or #f
    +
  - <representation> (direct speed representation) or #f (if abstract)
    +
  - <representation> (direct space representation) or #f (if abstract)
    +
  - <representation> (general speed representation) or #f (if abstract)
    +
  - <representation> (general space representation) or #f (if abstract)
    +
  - <meta-cclass> or #f
    +
  - <simple-object-vector> of <slot-info> (slots introduced by this class)
    +
  +
+
<defined-cdclass> base/type-dump.dylan:307
+
- #”defined-designator-class”
  +
  - info
    +
  - <values-ctype> (memo of extensional version of type) or #f
    +
  - <name> (printable name of class)
    +
  - <list> of <cclass> (direct superclasses)
    +
  - <cclass> (closest primary superclass)
    +
  - <boolean> (this class and its subclasses can’t be functional)
    +
  - <boolean> (this class is functional)
    +
  - <boolean> (this class is sealed)
    +
  - <boolean> (this class is abstract)
    +
  - <boolean> (this class is primary)
    +
  - <list> of <cclass> (class precedence list, including this class and indirect superclasses)
    +
  - <integer> (unique id of concrete class) or #f
    +
  - <integer> (subclass id range min of sealed & non-mixed class) or #f
    +
  - <integer> (subclass id range max of sealed & non-mixed class) or #f
    +
  - <representation> (direct speed representation) or #f (if abstract)
    +
  - <representation> (direct space representation) or #f (if abstract)
    +
  - <representation> (general speed representation) or #f (if abstract)
    +
  - <representation> (general space representation) or #f (if abstract)
    +
  - <meta-cclass> or #f
    +
  - <integer> (sizeof designated type)
    +
  - <integer> (alignment in sizeof units)
    +
  - <representation> (representation of FFI type) or #f
    +
  - <defined-cdclass> (referenced type of this pointer designator type) or #f
    +
  - <defined-cdclass> (pointer designator type referring to this type) or #f
    +
  - <cclass> (superclass for generating above) or #f
    +
  - <ctype> (correpsonding Dylan import type) or #f
    +
  - <ctype> (corresponding Dylan export type) or #f
    +
  - <ct-value> (indirect-getter function) or #f
    +
  - <ct-value> (indirect-setter function)
    +
  +
+
<struct-slot-info> base/type-dump.dylan:323
+
<library> base/variables.dylan:1239
+
- #”library”
  +
  - <symbol> (library name)
    +
  +
+
<module> base/variables.dylan:1250
+
- #”module”
  +
  - <library>
    +
  - <symbol> (module name)
    +
  +
+
<variable> base/variables.dylan:1287
+
- #”module-variable”
  +
  - <module> (owner, not definer)
    +
  - <symbol> (variable name)
    +
  +
+
<use> base/variables.dylan:1300
+
- #”use”
  +
  - <symbol-token> (name of used library)
    +
  - <simple-object-vector> of <symbol- token>, or <all-marker> (imported names)
    +
  - <byte-string> or #f (prefix)
    +
  - <simple-object-vector> of <symbol- token> (excluded names)
    +
  - <simple-object-vector> of <renaming> (renamed binding, also included in imported names)
    +
  - <simple-object-vector> of <symbol- token>, or <all-marker> (re-exported names)
    +
  +
+
<all-marker> base/variables.dylan:1308
+
- #”all-marker”
  +
  - <source-location>
    +
  +
+
<renaming> base/variables.dylan:1311
+
- #”renaming”
  +
  - <symbol-token> (original name)
    +
  - <symbol-token> (new name)
    +
  +
+
<define-bindings-tlf> convert/ defconstvar.dylan:533
+
- #”define-binding-tlf” (main binding)
  +
  - <definition>
    +
  - <top-level-form>, or <list> of <top- level-form> (dependencies)
    +
  +
- #”define-binding-tlf” (multiple aux bindings)
  +
  - <definition>
    +
  - <top-level-form>, or <list> of <top- level-form> (dependencies)
    +
  +
- #”define-binding-tlf” (optional if rest defn)
  +
  - <variable-definition> or <constant- definition>
    +
  - <top-level-form>, or <list> of <top- level-form> (dependencies)
    +
  +
+
<constant-definition> convert/ defconstvar.dylan:549
+
- #”constant-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <ctype> (constant value type)
    +
  - <ct-value> (constant value) or #f (if not computable at compile time) or #”not-computed-yet” (if unknown)
    +
  +
+
<constant-method-definition> convert/ defconstvar.dylan:555
+
- #”constant-method-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <function-literal> or #f (inlined function literal)
    +
  - <symbol> (inlining type)
    +
  - <ctype> (constant value)
    +
  - <ct-value> (constant value type) or #f (if not computable at compile time) or #”not-computed-yet” (if unknown)
    +
  +
+
<variable-definition> convert/ defconstvar.dylan:562
+
- #”variable-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <ctype> (initial value)
    +
  - <ct-value> (initial value type) or #f (if not computable at compile time) or #”not-computed-yet” (if unknown)
    +
  - <constant-definition> (if initial value type is not compile-time constant) or #f
    +
  +
+
<define-class-tlf> convert/defclass.dylan: 4117
+
- #”define-binding-tlf”
  +
  - <real-class-definition>
    +
  - #f (no dependencies)
    +
  +
- <getter-method-definition> (per inherited or exported non-virtual getter)
  +
- #”sealed-domain” (immediately following each above if sealed)
  +
  - <generic-definition> (of getter) or #f
    +
  - <library> (of this tlf’s <real-class- definition>)
    +
  - <list> of <ctype> (getter specializers)
    +
  +
- <setter-method-definition> (per inherited or exported non-virtual setter)
  +
- #”sealed-domain” (immediately following each above if sealed)
  +
  - <generic-definition> (of setter) or #f
    +
  - <library> (of this tlf’s <real-class- definition>)
    +
  - <list> of <ctype> (setter specializers)
    +
  +
+
<real-class-definition> convert/ defclass.dylan:4245
+
- #”class-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <cclass> or #f (if unknown) or #”not- computed-yet” or #”computing”
    +
  - <ct-function> (to do deferred evaluations) or #f
    +
  - <ct-function> (to do key defaulting) or #f
    +
  - <ct-function> (to do making) or #f
    +
  - <simple-object-vector> of <slot-info> (slots introduced by this class)
    +
  - <simple-object-vector> of <override- info> (overrides introduced by this class)
    +
  - <simple-object-vector> of <keyword- info> (for overrides introduced by this class)
    +
  +
+
<local-class-definition> convert/ defclass.dylan:4256
+
- same as <real-class-definition>
  +
+
<init-function-definition> convert/ defclass.dylan:4260
+
- #”init-function-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <function-literal> or #f (inlined function literal)
    +
  - <symbol> (inlining type)
    +
  +
+
<maker-function-definition> convert/ defclass.dylan:4265
+
- #”maker-function-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <function-literal> or #f (inlined function literal)
    +
  - <symbol> (inlining type)
    +
  - <class-definition>
    +
  +
+
<real-define-method-tlf> convert/ deffunc.dylan:1344
+
- <generic-definition> (if inherited or exported)
  +
- #”sealed-domain” (if sealed)
  +
  - <generic-definition>
    +
  - <library> (of this tlf)
    +
  - <list> of <ctype> (specializers)
    +
  +
+
<define-sealed-domain-tlf> convert/ deffunc.dylan:1359
+
- #”sealed-domain” (if sealed)
  +
  - <generic-definition>
    +
  - <library>
    +
  - <list> of <ctype> (specializers)
    +
  +
+
<define-library-tlf> convert/deflibmod.dylan: 73
+
- #”define-library-tlf”
  +
  - <symbol-token> (library name)
    +
  - <simple-object-vector> of <use> (used libraries)
    +
  - <simple-object-vector> of <identifier- token> (exported module names)
    +
  +
+
<define-module-tlf> convert/deflibmod.dylan: 152
+
- #”define-module-tlf”
  +
  - <symbol-token> (module name)
    +
  - <simple-object-vector> of <use> (used modules)
    +
  - <simple-object-vector> of <identifier- token> (exported binding names)
    +
  - <simple-object-vector> of <identifier- token> (created binding names)
    +
  +
+
<real-designator-class-definition> convert/ defdclass.dylan:437
+
<local-designator-class-definition> convert/ defdclass.dylan:449
+
<expression-tlf> convert/tlexpr.dylan:110
+
- nothing
  +
+
<magic-internal-primitives-placeholder> convert/tlexpr.dylan:140
+
- nothing
  +
+
<generic-definition> front/func-defns.dylan: 900
+
- #”generic-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <boolean> (sealed)
    +
  - <list> of <seal-info> (seals on this generic)
    +
  - <ct-function> or #f (discriminator function)
    +
  +
+
<implicit-generic-definition> front/func- defns.dylan:905
+
- #”implicit-generic-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <boolean> (sealed)
    +
  - <list> of <seal-info> (seals on this generic)
    +
  - <ct-function> or #f (discriminator function)
    +
  +
+
<seal-info> front/func-defns.dylan:910
+
- #”seal-info”
  +
  - <list> of <ctype> (specializers)
    +
  +
+
<method-definition> front/func-defns.dylan: 932
+
- #”method-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <function-literal> or #f (inlined function literal)
    +
  - <symbol> (inlining type)
    +
  - <generic-definition> or #f
    +
  - <boolean> (congruent to <generic- definition>)
    +
  +
+
<getter-method-definition> front/func- defns.dylan:941
+
- #”getter-method-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <function-literal> or #f (inlined function literal)
    +
  - <symbol> (inlining type)
    +
  - <generic-definition> or #f
    +
  - <boolean> (congruent to <generic- definition>)
    +
  - <slot-info> or #f
    +
  +
+
<setter-method-definition> front/func- defns.dylan:945
+
- #”setter-method-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <signature>
    +
  - <boolean> (hairy: something non-constant in signature)
    +
  - <ct-function> or #f (if hairy) or #”not- computed-yet”
    +
  - <boolean> (flushable: no side effects)
    +
  - <boolean> (movable: result only depends on arguments)
    +
  - <function-literal> or #f (inlined function literal)
    +
  - <symbol> (inlining type)
    +
  - <generic-definition> or #f
    +
  - <boolean> (congruent to <generic- definition>)
    +
  - <slot-info> or #f
    +
  +
+
<function-literal> front/fer-od.dylan:535
+
- #”function-literal”
  +
  - <values-ctype> (subclass of <function>)
    +
  - <symbol> (indicating visibility)
    +
  - <signature>
    +
  - <ct-function> (if global visibility) or #f
    +
  - <fer-function-region>
    +
  - <fer-function-region> or #f
    +
  +
+
<simple-define-tlf> front/tlf.dylan:220
+
- #”define-binding-tlf”
  +
  - <definition>
    +
  - <top-level-form>, or <list> of <top- level-form> (dependencies)
    +
  +
+
<unit-info> main/unit-info.dylan:62
+
- #”unit-info”
  +
  - <byte-string> (unit name)
    +
  - <simple-object-vector> (undumped objects)
    +
  - <simple-object-vector> (extra labels)
    +
  - <byte-string> (linker options) or #f
    +
  +
+
<define-list-macro-definition> parser/ macros.dylan:3184
+
- #”define-bindings-macro-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <simple-object-vector> of <symbol> (intermediate words)
    +
  - <main-rule-set>
    +
  - <simple-object-vector> of <auxiliary-rule- set>
    +
  +
+
<define-body-macro-definition> parser/ macros.dylan:3187
+
- #”define-macro-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <simple-object-vector> of <symbol> (intermediate words)
    +
  - <main-rule-set>
    +
  - <simple-object-vector> of <auxiliary-rule- set>
    +
  +
+
<function-macro-definition> parser/ macros.dylan:3190
+
- #”function-macro-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <simple-object-vector> of <symbol> (intermediate words)
    +
  - <main-rule-set>
    +
  - <simple-object-vector> of <auxiliary-rule- set>
    +
  +
+
<statement-macro-definition> parser/ macros.dylan:3193
+
- #”statement-macro-definition”
  +
  - info
    +
  - <name>
    +
  - <library> (library making the definition)
    +
  - <boolean> (definition can be dynamically redefined)
    +
  - <simple-object-vector> of <symbol> (intermediate words)
    +
  - <main-rule-set>
    +
  - <simple-object-vector> of <auxiliary-rule- set>
    +
  +
+
<main-rule-set> parser/macros.dylan:3201
+
- #”main-rule-set”
  +
  - <simple-object-vector> of <rule>
    +
  +
+
<auxiliary-rule-set> parser/macros.dylan: 3204
+
- #”aux-rule-set”
  +
  - <simple-object-vector> of <rule>
    +
  - <symbol> (name of aux rule set)
    +
  - <boolean> (a rule in this set ends with pattern variable with body/case constraint)
    +
  +
+
<body-style-define-rule> parser/macros.dylan: 3222
+
- #”body-style-define-rule”
  +
  - <pattern>
    +
  - <template>
    +
  - <symbol-token> or #f (name of macro containing this rule)
    +
  - <pattern> or #f (modifiers part of pattern)
    +
  +
+
<list-style-define-rule> parser/macros.dylan: 3226
+
- #”list-style-define-rule”
  +
  - <pattern>
    +
  - <template>
    +
  - <symbol-token> or #f (name of macro containing this rule)
    +
  - <pattern> or #f (modifiers part of pattern)
    +
  +
+
<statement-rule> parser/macros.dylan:3230
+
- #”statement-rule”
  +
  - <pattern>
    +
  - <template>
    +
  - <symbol-token> or #f (name of macro containing this rule)
    +
  +
+
<function-rule> parser/macros.dylan:3234
+
- #”statement-rule”
  +
  - <pattern>
    +
  - <template>
    +
  - <symbol-token> or #f (name of macro containing this rule)
    +
  +
+
<auxiliary-rule> parser/macros.dylan:3238
+
- #”auxiliary-rule”
  +
  - <pattern>
    +
  - <template>
    +
  +
+
<empty-pattern> parser/macros.dylan:3243
+
- #”empty-pattern”
  +
+
<semicolon-pattern> parser/macros.dylan: 3252
+
- #”semicolon-pattern”
  +
  - <pattern> (left-hand side)
    +
  - <pattern> (right-hand side)
    +
  - <boolean> (last semicolon pattern in chain)
    +
  +
+
<comma-pattern> parser/macros.dylan:3256
+
- #”comma-pattern”
  +
  - <pattern> (left-hand side)
    +
  - <pattern> (right-hand side)
    +
  - <boolean> (last comma pattern in chain)
    +
  +
+
<sequential-pattern> parser/macros.dylan: 3260
+
- #”sequential-pattern”
  +
  - <pattern> (left-hand side)
    +
  - <pattern> (right-hand side)
    +
  - <boolean> (last sequential pattern in chain)
    +
  +
+
<bracketed-pattern> parser/macros.dylan: 3264
+
- #”bracketed-pattern”
  +
  - <token> (left bracket)
    +
  - <pattern>
    +
  - <token> (right bracket)
    +
  +
+
<variable-pattern> parser/macros.dylan:3270
+(pattern representing a variable, e.g. “?:name :: ?:expression”)
+
- #”variable-pattern”
  +
  - <pattern-variable> (name part)
    +
  - <pattern-variable> (type part)
    +
  +
+
<bindings-pattern> parser/macros.dylan:3275
+(pattern representing a binding, e.g. “?:variable = ?:expression”)
+
- #”bindings-pattern”
  +
  - <pattern-variable> or <variable- pattern> (left-hand side)
    +
  - <pattern-variable> (right-hand side)
    +
  +
+
<name-pattern> parser/macros.dylan:3280
+
- #”name-pattern”
  +
  - <symbol-token>
    +
  +
+
<arrow-pattern> parser/macros.dylan:3284
+
- #”arrow-pattern”
  +
+
<pattern-variable> parser/macros.dylan:3294
+
- #”pattern-variable”
  +
  - <source-location>
    +
  - <symbol> or #f (pattern variable name)
    +
  - <symbol> or #f (pattern variable constraint)
    +
  - <boolean> (pattern variable is at end of pattern)
    +
  +
+
<property-list-pattern> parser/macros.dylan: 3298
+
- #”property-list-pattern”
  +
  - <pattern-variable> (#rest part of prop list pattern) or #f
    +
  - <simple-object-vector> of <pattern- keyword> (#key parts of prop list pattern) or #f
    +
  - <boolean> (#all-keys present in prop list pattern)
    +
  +
+
<pattern-keyword> parser/macros.dylan:3304
+
- #”pattern-keyword”
  +
  - <source-location>
    +
  - <symbol> or #f (pattern variable name)
    +
  - <symbol> or #f (pattern variable constraint)
    +
  - #t
    +
  - <template> (default template for keyword) or #f
    +
  - <boolean> (?? keyword)
    +
  +
+
<procedural-template> parser/macros.dylan: 3311
+
- #”procedural-template”
  +
  - <identifier-token> (procedure that produces replacement)
    +
  - <simple-object-vector> of <template> (arguments)
    +
  +
+
<literal-template> parser/macros.dylan:3316
+
- #”literal-template”
  +
  - <simple-object-vector> of <token> or <bracketed-element> or <pattern-variable-reference>
    +
  +
+
<bracketed-element> parser/macros.dylan: 3320
+
- #”bracketed-element”
  +
  - <token> (left bracket)
    +
  - <literal-template>
    +
  - <token> (right bracket)
    +
  +
+
<simple-pattern-variable-reference> parser/ macros.dylan:3329
+
- #”simple-pattern-variable-reference”
  +
  - <token> (name, string, or symbol)
    +
  +
+
<ellipsis-pattern-variable-reference> parser/ macros.dylan:3334
+
- #”ellipsis-pattern-variable-reference”
  +
  - <token> (ellipsis)
    +
  +
+
<concatenating-pattern-variable-reference> parser/macros.dylan:3339
+
- #”concatenating-pattern-variable- reference”
  +
  - <token> (name, string, or symbol)
    +
  - <byte-string> (prefix) or #f
    +
  - <byte-string> (suffix) or #f
    +
  +
+
<sequence-pattern-variable-reference> parser/ macros.dylan:3346
+
- #”sequence-pattern-variable-reference”
  +
  - <token> (name, string, or symbol)
    +
  - <token> (separator)
    +
  +
+
<unhygienic-pattern-variable-reference> parser/macros.dylan:3352
+
- #”unhygienic-pattern-variable- reference”
  +
  - <token> (name)
    +
  +
+
+A <boolean> will be dumped as one of
+
- #t
  +
- #f
  +
+
+A <sequence> will be dumped as one of
+
- <list>
  +
- <simple-object-vector>
  +
  +
+A <source-location> will be dumped as one of
+
- <known-source-location>
  +
- <unknown-source-location>
  +
  +
+A <symbol-token> will be dumped as one of
+
- <identifier-token>
  +
- <operator-token>
  +
- <constrained-name-token>
  +
+
+A <literal> will be dumped as one of
+
- <eql-literal>
  +
- <literal-integer>
  +
- <literal-single-float>
  +
- <literal-double-float>
  +
- <literal-extended-float>
  +
- <literal-pair>
  +
- <literal-simple-object-vector>
  +
- <literal-byte-string>
  +
+
+A <top-level-form> will be dumped as one of
+
- <define-sealed-domain-tlf>
  +
- <define-library-tlf>
  +
- <define-module-tlf>
  +
- <expression-tlf>
  +
- <simple-define-tlf>
  +
- <define-class-tlf>
  +
- <define-bindings-tlf>
  +
  +
+A <definition> will be dumped as one of
+
- <generic-definition>
  +
- <implicit-generic-definition>
  +
- <method-definition>
  +
- <init-function-definition>
  +
- <maker-function-definition>
  +
- <constant-method-definition>
  +
- <getter-method-definition>
  +
- <setter-method-definition>
  +
- <real-class-definition>
  +
- <local-class-definition>
  +
- <constant-definition>
  +
- <variable-definition>
  +
- <define-list-macro-definition>
  +
- <define-body-macro-definition>
  +
- <function-macro-definition>
  +
- <statement-macro-definition>
  +
- <real-designator-class-definition>
  +
- <local-designator-class-definition>
  +
+
+A <function-definition> will be dumped as one of
+
- <generic-definition>
  +
- <maker-function-definition>
  +
- <init-function-definition>
  +
- <constant-method-definition>
  +
- <getter-method-definition>
  +
- <setter-method-definition>
  +
- <implicit-generic-definition>
  +
+
+A <class-definition> will be dumped as one of
+
- <real-class-definition>
  +
- <local-class-definition>
  +
- <real-designator-class-definition>
  +
- <local-designator-class-definition>
  +
+
+A <name> will be dumped as one of
+
- <basic-name>
  +
- <derived-name>
  +
- <internal-name>
  +
- <anonymous-name>
  +
- <method-name>
  +
+
+A <ctype> will be dumped as one of
+
- <union-ctype>
  +
- <unknown-ctype>
  +
- <limited-integer-ctype>
  +
- <direct-instance-ctype>
  +
- <singleton-ctype>
  +
- <byte-character-ctype>
  +
- <subclass-ctype>
  +
- <limited-collection-ctype>
  +
- <defined-cclass>
  +
- <limited-cclass>
  +
- <meta-cclass>
  +
- <defined-cdclass>
  +
+
+There doesn’t seem to be any dump format for <values- ctype>. It will probably only be dumped as a more specific <ctype>.
+
+An empty-ctype is dumped as a <union-ctype> with no members.
+
+A <ct-value> will be dumped as one of
+
- <ct-not-supplied-marker>
  +
- <eql-literal>
  +
- <literal-integer>
  +
- <literal-single-float>
  +
- <literal-double-float>
  +
- <literal-extended-float>
  +
- <literal-pair>
  +
- <literal-simple-object-vector>
  +
- <literal-byte-string>
  +
- <ct-entry-point>
  +
- <struct-slot-info>
  +
- <ct-function> (see below)
  +
- <slot-info> (see below)
  +
+
+A <ct-function> will be dumped as one of
+
- <ct-raw-function>
  +
- <ct-callback-function>
  +
- <ct-sealed-generic>
  +
- <ct-open-generic>
  +
- <ct-method>
  +
- <ct-accessor-method>
  +
+
+A <cclass> will be dumped as one of
+
- <defined-cclass>
  +
- <limited-cclass>
  +
- <meta-cclass>
  +
- <defined-cdclass>
  +
+
+A <slot-info> will be dumped as one of
+
- <instance-slot-info>
  +
- <vector-slot-info>
  +
- <meta-slot-info>
  +
- <class-slot-info>
  +
- <each-subclass-slot-info>
  +
- <virtual-slot-info>
  +
+
+A <rule> will be dumped as one of
+
- <body-style-define-rule>
  +
- <list-style-define-rule>
  +
- <statement-rule>
  +
- <function-rule>
  +
- <auxiliary-rule>
  +
+
+A <pattern> will be dumped as one of
+
- <empty-pattern>
  +
- <semicolon-pattern>
  +
- <comma-pattern>
  +
- <sequential-pattern>
  +
- <bracketed-pattern>
  +
- <variable-pattern>
  +
- <bindings-pattern>
  +
- <name-pattern>
  +
- <arrow-pattern>
  +
+
+A <template> will be dumped as one of
+
- <procedural-template>
  +
- <literal-template>
  +
  +
+A <pattern-variable-reference> will be dumped as one of
+
- <simple-pattern-variable-reference>
  +
- <ellipsis-pattern-variable-reference>
  +
- <concatenating-pattern-variable-reference>
  +
- <sequence-pattern-variable-reference>
  +
- <unhygienic-pattern-variable-reference>
  +
+
+A <representation> will be in a dump format defined in base/c- rep.dylan.
+
+An info or a token-parse-tree can be dumped as anything.
+
+I am omitting dump formats from the following, because they don’t seem important for most purposes:
+
- base/c-rep.dylan
  +
- base/policy.dylan
  +
- cback/cback.dylan
  +
- cback/heap.dylan
  +
- front/fer-od.dylan (except <function- literal>)
  +
- front/primitives.dylan
  +
- Macintosh
  +
- parser/srcutil.dylan
  +
+
+ +
+
+
Page # of #
+
+ + + Property changes on: compiler/base/od-format-description.html ___________________________________________________________________ Name: svn:mime-type + text/html Name: svn:eol-style + native Index: compiler/base/od-format.dylan =================================================================== --- compiler/base/od-format.dylan(revision 11909) +++ compiler/base/od-format.dylan(working copy) < at >< at > -377,7 +377,8 < at >< at > // already been loaded from some other data unit. That is, this provides the // mechanism by which one data unit builds on another. -register-object-id(#"extern-handle", #x0004); +define constant $extern-handle-odf-id = #x0004; +register-object-id(#"extern-handle", $extern-handle-odf-id); // Dylan object IDs: < at >< at > -1195,7 +1196,16 < at >< at > // The index in the local-map of the next labeled object to be loaded. slot next-labeled :: , init-value: 0, setter: %next-labeled-setter; + // + // The label at the current location, about to be loaded. Once loaded, or if + // the current location is not a label, this should be reset to #f. + slot just-labeled :: false-or(), init-value: #f; // + // Load and resolve external references. If #f, external data units are not + // used and external references will be returned as objects. + slot load-external-objects? :: , init-value: #t, + init-keyword: load-external:; + // // Vector mapping extern IDs in this data unit to the actual in-core // objects. Will contain s where there are circular // cross-unit dependencies. < at >< at > -1403,7 +1413,7 < at >< at > define method load-data-unit (name :: , type :: , loc :: false-or(), hash :: false-or(), - dispatcher :: ) + dispatcher :: , load-external :: ) => res :: ; let name-guess < at >< at > -1425,7 +1435,7 < at >< at > let state = make(, stream: stream, buffer: buf, next: initial-next, end: buf-end, position-offset: -initial-next, - dispatcher: dispatcher); + dispatcher: dispatcher, load-external: load- external); let (unit, oa-len) = check-unit-header(state, name, type, hash, < at >< at > -1446,7 +1456,7 < at >< at > state.position-offset := state.position-offset; state.extern-index := load-object-dispatch(state); - + let lindex = make(, size: nlocals, fill: $empty-object); unit.local-index := lindex; < at >< at > -1480,7 +1490,8 < at >< at > (name :: , type :: , #key location-hint :: false-or(), check-hash: expected-hash :: false-or(), -dispatcher :: = *default-dispatcher*) + dispatcher :: = *default-dispatcher*, + load-external :: = #t) => res :: ; let types = element(*data-units*, name, default: #()); block (punt) < at >< at > -1495,7 +1506,8 < at >< at > punt(found); end; end for; - load-data-unit(name, type, location-hint, expected-hash, dispatcher); + load-data-unit(name, type, location-hint, expected-hash, dispatcher, + load-external); end block; end method; < at >< at > -1543,6 +1555,7 < at >< at > // recurse to get the value. let nextlab = state.next-labeled; let id = state.raw-local-map[nextlab]; + state.just-labeled := id; state.next-labeled := nextlab + 1; let res = load-object-dispatch(state); let lidx = state.load-unit.local-index; < at >< at > -1564,21 +1577,34 < at >< at > else let (buf, next) = buffer-at-least($word-bytes, state); let (flags, code) = buffer-header-word(buf, next); + let id = state.just-labeled; + state.just-labeled := #f; select (ash(flags, $odf-etype-shift)) $odf-object-definition-shifted => + let loader :: = state.dispatcher.table[code]; + let args :: + = select (loader.function-arguments) + // If loader can handle extra arguments, pass them in. Otherwise, + // just pass state argument as usual. + 3 => vector(state, flags, id); + 4 => let def-loader = *default-dispatcher*.table[code]; + vector(state, flags, id, + def-loader ~= undefined-entry-type & def- loader); + otherwise => vector(state); + end select; if ($load-debug) assert(code < $dispatcher-table-size); let orig-stack = state.load-stack; block () state.load-stack := pair(code, orig-stack); - state.dispatcher.table[code](state); + apply(loader, args); cleanup state.load-stack := orig-stack; end; else - state.dispatcher.table[code](state); + apply(loader, args); end if; $odf-end-entry-shifted => < at >< at > -1589,7 +1615,7 < at >< at > $odf-external-reference-shifted => let wot = state.extern-index[code]; - if (obj-resolved?(wot)) + if (obj-resolved?(wot) & state.load-external-objects?) let res = wot.actual-obj; unless (instance?(res, ) & instance?(res.handle, )) < at >< at > -1775,6 +1801,10 < at >< at > // True when resolved. /* exported */ slot obj-resolved? :: , init-value: #f; // + // Local ID this reference should resolve to. Optional. + /* exported */ slot forward-ref-id :: false-or(), init- value: #f, + init-keyword: id:; + // // List of registered backpatch functions. slot patchers :: , init-value: #(); end class; < at >< at > -1783,6 +1813,8 < at >< at > define sealed domain initialize (); // Anything that isn't a is resolved, and is itself. +// s aren't technically resolved, but they won't get any *more* +// resolved, so whatever. // define method obj-resolved? (obj :: ) => res :: ; #t; < at >< at > -1842,7 +1874,7 < at >< at > let lidx = unit.local-index; let thing = lidx[id]; if (thing == $empty-object) - lidx[id] := make(); + lidx[id] := make(, id: id); elseif (thing.obj-resolved?) thing.actual-obj; else < at >< at > -1853,6 +1885,21 < at >< at > // External references: +// A class representing an external reference. Only used if not loading +// external objects. +// +define /* exported */ class () + /* exported */ slot extern-ref-du-name :: , + required-init-keyword: name:; + /* exported */ slot extern-ref-du-loc :: , + required-init-keyword: loc:; + /* exported */ slot extern-ref-local-id :: , + required-init-keyword: id:; +end class; + +define sealed domain make (singleton()); +define sealed domain initialize (); + // A handle on some object having . This is where // we record the ID used to reference the object in this dump. // < at >< at > -2126,7 +2173,8 < at >< at > // Load an extern-handle. After parsing the contents, we look up the // referenced data unit and try to find the object. If it isn't there yet, we -// make a forward reference. +// make a forward reference. If not loading external objects, returns an +// object. // add-od-loader(*default-dispatcher*, #"extern-handle", method (state :: ) => res :: ; < at >< at > -2138,12 +2186,16 < at >< at > let hint = load-object-dispatch(state); assert-end-object(state); + if (state.load-external-objects?) let ext-unit = find-data-unit(name, du-type, location-hint: hint, check-hash: hash, dispatcher: state.dispatcher); - maybe-forward-ref(ext-unit, localid); + maybe-forward-ref(ext-unit, localid); + else + make(, id: localid, name: name, loc: hint); + end if; end method ); < at >< at > -2419,3 +2471,7 < at >< at > end for; vec; end method invert-registry; + +define function registered-object-ids () => (ids :: ) + map-as(, identity, $object-id-registry.key-sequence); +end function; _______________________________________________ hackers mailing list hackers< at >lists.opendylan.org https://www.opendylan.org/mailman/listinfo/hackers

Library information file

Dustin Voss — 2008-08-04T03:43:29

_______________________________________________ hackers mailing list hackers< at >lists.opendylan.org https://www.opendylan.org/mailman/listinfo/hackers