*** 1.22	95/12/15 16:16:36
--- ./compiler/front/builder.dylan	96/03/11 02:57:05
***************
*** 1,6 ****
  Module: front
  Description: Interface to building the Front-End representation.
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/builder.dylan,v 1.22 95/12/15 16:16:36 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,6 ----
  Module: front
  Description: Interface to building the Front-End representation.
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/builder.dylan,v 1.22 1995/12/15 16:16:36 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 248,250 ****
--- 248,258 ----
       signature :: <signature>, main-entry :: <fer-function-region>)
   => res :: <leaf>;
  
+ 
+ // Seals for file builder.dylan
+ 
+ // <flow-builder> -- subclass of <object>
+ seal generic make(singleton(<flow-builder>));
+ seal generic initialize(<flow-builder>);
+ // <fer-builder> -- subclass of <flow-builder>
+ seal generic make(singleton(<fer-builder>));
*** 1.124	96/03/13 03:12:15
--- ./compiler/front/cheese.dylan	96/03/16 23:12:37
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/cheese.dylan,v 1.124 96/03/13 03:12:15 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/cheese.dylan,v 1.124 96/03/13 03:12:15 rgs Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 12,18 ****
  define method print-shit () => (); *print-shit* := #t; end;
  define method dont-print-shit () => (); *print-shit* := #f; end;
  
! define variable *optimize-ncalls* = 0;
  
  // Note: the simplify-only: keyword is used only during inline
  // expansions.  It is not useful in any other situation.
--- 12,18 ----
  define method print-shit () => (); *print-shit* := #t; end;
  define method dont-print-shit () => (); *print-shit* := #f; end;
  
! define variable *optimize-ncalls* <integer> = 0;
  
  // Note: the simplify-only: keyword is used only during inline
  // expansions.  It is not useful in any other situation.
*** 1.5	96/01/27 00:21:22
--- ./compiler/front/clone.dylan	96/03/11 02:57:05
***************
*** 1,5 ****
  module: front
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/clone.dylan,v 1.5 96/01/27 00:21:22 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: front
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/clone.dylan,v 1.5 1996/01/27 00:21:22 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 409,411 ****
--- 409,417 ----
    end-body(state.clone-builder);
  end;
  
+ 
+ // Seals for file clone.dylan
+ 
+ // <clone-state> -- subclass of <object>
+ seal generic make(singleton(<clone-state>));
+ seal generic initialize(<clone-state>);
*** 1.59	96/02/21 02:46:09
--- ./compiler/front/defclass.dylan	96/03/11 02:57:06
***************
*** 2518,2520 ****
--- 2518,2540 ----
  		<init-function-definition>,
  		$abstract-method-definition-slots,
  		load-external: #t);
+ 
+ // Seals for file defclass.dylan
+ 
+ // <real-class-definition> -- subclass of <class-definition>
+ seal generic make(singleton(<real-class-definition>));
+ seal generic initialize(<real-class-definition>);
+ // <local-class-definition> -- subclass of <real-class-definition>
+ seal generic make(singleton(<local-class-definition>));
+ // <slot-defn> -- subclass of <object>
+ seal generic make(singleton(<slot-defn>));
+ seal generic initialize(<slot-defn>);
+ // <override-defn> -- subclass of <object>
+ seal generic make(singleton(<override-defn>));
+ seal generic initialize(<override-defn>);
+ // <init-function-definition> -- subclass of <abstract-method-definition>
+ seal generic make(singleton(<init-function-definition>));
+ seal generic initialize(<init-function-definition>);
+ // <define-class-tlf> -- subclass of <simple-define-tlf>
+ seal generic make(singleton(<define-class-tlf>));
+ seal generic initialize(<define-class-tlf>);
*** 1.29	96/02/06 15:47:32
--- ./compiler/front/defconstvar.dylan	96/03/11 02:57:06
***************
*** 428,430 ****
--- 428,453 ----
  			    list(var-defn-type-defn, type-defn:,
  				   var-defn-type-defn-setter)),
  		load-external: #t);
+ 
+ // Seals for file defconstvar.dylan
+ 
+ // <bindings-definition> -- subclass of <definition>
+ seal generic make(singleton(<bindings-definition>));
+ seal generic initialize(<bindings-definition>);
+ // <constant-definition> -- subclass of 
+ seal generic make(singleton(<constant-definition>));
+ seal generic initialize(<constant-definition>);
+ // <constant-method-definition> -- subclass of 
+ seal generic make(singleton(<constant-method-definition>));
+ seal generic initialize(<constant-method-definition>);
+ // <variable-definition> -- subclass of <bindings-definition>
+ seal generic make(singleton(<variable-definition>));
+ // <define-bindings-tlf> -- subclass of <define-tlf>
+ seal generic make(singleton(<define-bindings-tlf>));
+ seal generic initialize(<define-bindings-tlf>);
+ // <define-constant-tlf> -- subclass of <define-bindings-tlf>
+ seal generic make(singleton(<define-constant-tlf>));
+ // <define-constant-method-tlf> -- subclass of <define-constant-tlf>
+ seal generic make(singleton(<define-constant-method-tlf>));
+ // <define-variable-tlf> -- subclass of <define-bindings-tlf>
+ seal generic make(singleton(<define-variable-tlf>));
*** 1.61	96/03/02 19:01:13
--- ./compiler/front/deffunc.dylan	96/03/11 23:47:45
***************
*** 1,5 ****
  module: define-functions
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/deffunc.dylan,v 1.61 96/03/02 19:01:13 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: define-functions
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/deffunc.dylan,v 1.61 96/03/02 19:01:13 rgs Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 11,33 ****
  define class <generic-definition> (<function-definition>)
    //
    // #f iff the open adjective wasn't supplied.
!   slot generic-defn-sealed? :: <boolean>, init-keyword: sealed:,
!     init-function:
!       curry(error, "sealed: unsupplied in make of <generic-definition>");
    //
    // All the <method-definition>s defined on this generic function.
!   slot generic-defn-methods :: <list>,
!     init-value: #(), init-keyword: methods:;
    //
    // List of all the seals on this generic function.  Each seal is a list of
    // <seal-info>s.
!   slot generic-defn-seals :: <list>,
!     init-value: #(), init-keyword: seals:;
    //
    // The discriminator ct-value, if there is one.
    slot %generic-defn-discriminator
      :: type-union(<ct-function>, one-of(#f, #"not-computed-yet")),
      init-value: #"not-computed-yet", init-keyword: discriminator:;
  end;
  
  define method defn-type (defn :: <generic-definition>) => res :: <cclass>;
--- 11,32 ----
  define class <generic-definition> (<function-definition>)
    //
    // #f iff the open adjective wasn't supplied.
!   slot generic-defn-sealed? :: <boolean>
!     = error("sealed: unsupplied in make of <generic-definition>"),
!     init-keyword: sealed:;
    //
    // All the <method-definition>s defined on this generic function.
!   slot generic-defn-methods :: <list> = #(), init-keyword: methods:;
    //
    // List of all the seals on this generic function.  Each seal is a list of
    // <seal-info>s.
!   slot generic-defn-seals :: <list> = #(), init-keyword: seals:;
    //
    // The discriminator ct-value, if there is one.
    slot %generic-defn-discriminator
      :: type-union(<ct-function>, one-of(#f, #"not-computed-yet")),
      init-value: #"not-computed-yet", init-keyword: discriminator:;
+   slot generic-defn-find-seal-cache :: false-or(<general-cache>) = #f;
  end;
  
  define method defn-type (defn :: <generic-definition>) => res :: <cclass>;
***************
*** 1358,1363 ****
--- 1357,1440 ----
    end if;
  end method;
  
+ define class <general-cache-cell> (<object>)
+   slot key :: <object> = #f, init-keyword: #"key";
+   slot value :: <object> = #f, init-keyword: #"value";
+   slot cell-next :: false-or(<general-cache-cell>) = #f;
+   slot cell-prev :: false-or(<general-cache-cell>) = #f;
+ end class <general-cache-cell>;
+  
+ define class <general-cache> (<object>)
+   slot size :: <integer> = 0;
+   slot chain :: false-or(<general-cache-cell>) = #f;
+ end class <general-cache>;
+ 
+ define method update-cache
+     (cache :: <general-cache>, elem :: <general-cache-cell>) => ();
+   // Remove elem from chain
+   let prev = elem.cell-prev;
+   let next = elem.cell-next;
+   prev.cell-next := next;
+   next.cell-prev := prev;
+  
+   // Set up elem to be first in chain
+   let next = cache.chain;
+   let prev = next.cell-prev;
+   elem.cell-next := next;
+   elem.cell-prev := prev;
+   // Adjust first and last in chain to acknowledge elem
+   next.cell-prev := elem;
+   prev.cell-next := elem;
+   cache.chain := elem;
+ end method update-cache;
+  
+ define inline method find-cache-entry
+     (cache :: <general-cache>, correct? :: <function>)
+  => (result :: false-or(<object>), found? :: <boolean>);
+   let chain = cache.chain;
+   case
+     (chain == #f) => values(#f, #f);
+     (chain.key.correct?) => values(chain.value, #t);
+     otherwise =>
+       block (return)
+ 	for (elem :: false-or(<general-cache-cell>)
+ 	       = chain.cell-next then elem.cell-next,
+ 	     until: elem == chain)
+ 	  if (elem.key.correct?)
+ 	    update-cache(cache, elem);
+ 	    return(elem.value, #t);
+ 	  end if;
+ 	finally
+ 	  values(#f, #f);
+ 	end for;
+       end block;
+   end case;
+ end method find-cache-entry;
+ 
+ define method add-cache-entry
+     (cache :: <general-cache>, elem-key :: <object>, elem-value :: <object>,
+      #key max :: false-or(<integer>))
+   if (cache.size == 0)
+     let new = make(<general-cache-cell>, key: key, elem: elem);
+     new.cell-next := new;
+     new.cell-prev := new;
+     cache.chain := new;
+   elseif (max & cache.size >= max)
+     let new = cache.chain.cell-prev;
+     cache.chain := new;
+     new.chain.key := elem-key;
+     new.chain.value := elem-value;
+   else
+     let new = make(<general-cache-cell>, key: key, elem: elem);
+     let next = cache.chain;
+     let prev = next.cell-prev;
+     new.cell-next := next;
+     new.cell-prev := prev;
+     prev.cell-next := new;
+     next.cell-prev := new;
+     cache.chain := new;
+   end if;
+ end method add-cache-entry;
  
  define method find-seal (gf :: <generic-definition>, call-types :: <list>)
      => res :: false-or(<seal-info>);
***************
*** 1752,1754 ****
--- 1829,1869 ----
  add-make-dumper(#"setter-method-definition", *compiler-dispatcher*,
  		<setter-method-definition>, $accessor-method-definition-slots,
  		load-external: #t);
+ 
+ // Seals for file deffunc.dylan
+ 
+ // <generic-definition> -- subclass of <function-definition>
+ seal generic make(singleton(<generic-definition>));
+ seal generic initialize(<generic-definition>);
+ // <implicit-generic-definition> -- subclass of 
+ seal generic make(singleton(<implicit-generic-definition>));
+ seal generic initialize(<implicit-generic-definition>);
+ // <abstract-method-definition> -- subclass of <function-definition>
+ seal generic make(singleton(<abstract-method-definition>));
+ seal generic initialize(<abstract-method-definition>);
+ // <method-definition> -- subclass of <abstract-method-definition>
+ seal generic make(singleton(<method-definition>));
+ // <accessor-method-definition> -- subclass of <method-definition>
+ seal generic make(singleton(<accessor-method-definition>));
+ // <getter-method-definition> -- subclass of <accessor-method-definition>
+ seal generic make(singleton(<getter-method-definition>));
+ // <setter-method-definition> -- subclass of <accessor-method-definition>
+ seal generic make(singleton(<setter-method-definition>));
+ // <define-generic-tlf> -- subclass of <simple-define-tlf>
+ seal generic make(singleton(<define-generic-tlf>));
+ seal generic initialize(<define-generic-tlf>);
+ // <define-implicit-generic-tlf> -- subclass of <simple-define-tlf>
+ seal generic make(singleton(<define-implicit-generic-tlf>));
+ seal generic initialize(<define-implicit-generic-tlf>);
+ // <seal-generic-tlf> -- subclass of <top-level-form>
+ seal generic make(singleton(<seal-generic-tlf>));
+ seal generic initialize(<seal-generic-tlf>);
+ // <define-method-tlf> -- subclass of <simple-define-tlf>
+ seal generic make(singleton(<define-method-tlf>));
+ seal generic initialize(<define-method-tlf>);
+ // <method-set> -- subclass of <object>
+ seal generic make(singleton(<method-set>));
+ seal generic initialize(<method-set>);
+ // <seal-info> -- subclass of <object>
+ seal generic make(singleton(<seal-info>));
+ seal generic initialize(<seal-info>);
*** 1.10	96/01/14 02:06:00
--- ./compiler/front/deflibmod.dylan	96/03/11 02:57:07
***************
*** 269,271 ****
--- 269,280 ----
    end;
  end;
  
+ 
+ // Seals for file deflibmod.dylan
+ 
+ // <define-library-tlf> -- subclass of <top-level-form>
+ seal generic make(singleton(<define-library-tlf>));
+ seal generic initialize(<define-library-tlf>);
+ // <define-module-tlf> -- subclass of <top-level-form>
+ seal generic make(singleton(<define-module-tlf>));
+ seal generic initialize(<define-module-tlf>);
*** 1.9	96/01/27 00:21:22
--- ./compiler/front/dump.dylan	96/03/11 02:57:07
***************
*** 1,5 ****
  module: dump
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/dump.dylan,v 1.9 96/01/27 00:21:22 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: dump
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/dump.dylan,v 1.9 1996/01/27 00:21:22 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 464,466 ****
--- 464,475 ----
    dump(thing, stream);
    write('\n', stream);
  end;
+ 
+ // Seals for file dump.dylan
+ 
+ // <dump-state-stream> -- subclass of <stream>
+ seal generic make(singleton(<dump-state-stream>));
+ seal generic initialize(<dump-state-stream>);
+ // <varinfo> -- subclass of <object>
+ seal generic make(singleton(<varinfo>));
+ seal generic initialize(<varinfo>);
*** 1.43	95/12/15 16:16:36
--- ./compiler/front/fer-builder.dylan	96/03/11 02:57:07
***************
*** 612,614 ****
--- 612,622 ----
    leaf;
  end;
  
+ 
+ // Seals for file fer-builder.dylan
+ 
+ // <internal-builder> -- subclass of <flow-builder>
+ seal generic make(singleton(<internal-builder>));
+ seal generic initialize(<internal-builder>);
+ // <internal-fer-builder> -- subclass of <fer-builder>, <internal-builder>
+ seal generic make(singleton(<internal-fer-builder>));
*** 1.51	96/02/09 20:39:44
--- ./compiler/front/fer-convert.dylan	96/03/11 02:57:07
***************
*** 1147,1149 ****
--- 1147,1152 ----
       as(<list>, args));
  end method;
  
+ 
+ // Seals for file fer-convert.dylan
+ 
*** 1.36	96/01/27 00:21:22
--- ./compiler/front/fer-dump.dylan	96/03/16 22:50:00
***************
*** 1,12 ****
  module: front
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/fer-dump.dylan,v 1.36 96/01/27 00:21:22 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
  
  // Id stuff.
  
! define variable *id-table* = make(<table>);
  define constant $id-vector = make(<stretchy-vector>);
  
  define method reset-ids () => ();
--- 1,12 ----
  module: front
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/fer-dump.dylan,v 1.36 1996/01/27 00:21:22 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
  
  // Id stuff.
  
! define variable *id-table* :: <object-table> = make(<table>);
  define constant $id-vector = make(<stretchy-vector>);
  
  define method reset-ids () => ();
***************
*** 465,467 ****
--- 465,470 ----
      (exit-function :: <exit-function>, stream :: <stream>) => ();
    format(stream, "EXIT-FUN[%d]", exit-function.id);
  end;
+ 
+ // Seals for file fer-dump.dylan
+ 
*** 1.9	96/01/31 23:55:21
--- ./compiler/front/fer-od.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  Module: fer-od
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/fer-od.dylan,v 1.9 96/01/31 23:55:21 ram Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  Module: fer-od
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/fer-od.dylan,v 1.9 1996/01/31 23:55:21 ram Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 615,617 ****
--- 615,620 ----
      res;
    end method
  );
+ 
+ // Seals for file fer-od.dylan
+ 
*** 1.52	96/03/02 19:09:17
--- ./compiler/front/front.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  Module: front
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/front.dylan,v 1.52 96/03/02 19:09:17 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  Module: front
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/front.dylan,v 1.52 96/03/02 19:09:17 rgs Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 552,554 ****
--- 552,665 ----
    slot nlx-throws :: false-or(<throw>), init-value: #f,
      init-keyword: throws:;
  end;
+ 
+ // Seals for file front.dylan
+ 
+ // <fer-assignment> -- subclass of <assignment>
+ seal generic make(singleton(<fer-assignment>));
+ seal generic initialize(<fer-assignment>);
+ // <let-assignment> -- subclass of <fer-assignment>
+ seal generic make(singleton(<let-assignment>));
+ // <set-assignment> -- subclass of <fer-assignment>
+ seal generic make(singleton(<set-assignment>));
+ // <primitive> -- subclass of <operation>
+ seal generic make(singleton(<primitive>));
+ seal generic initialize(<primitive>);
+ // <abstract-call> -- subclass of <operation>
+ seal generic make(singleton(<abstract-call>));
+ seal generic initialize(<abstract-call>);
+ // <known-call> -- subclass of <abstract-call>
+ seal generic make(singleton(<known-call>));
+ // <general-call> -- subclass of <abstract-call>
+ seal generic make(singleton(<general-call>));
+ // <unknown-call> -- subclass of <general-call>
+ seal generic make(singleton(<unknown-call>));
+ // <mv-call> -- subclass of <general-call>
+ seal generic make(singleton(<mv-call>));
+ // <error-call> -- subclass of <abstract-call>
+ seal generic make(singleton(<error-call>));
+ // <prologue> -- subclass of <operation>
+ seal generic make(singleton(<prologue>));
+ seal generic initialize(<prologue>);
+ // <module-var-access> -- subclass of <operation>
+ seal generic make(singleton(<module-var-access>));
+ seal generic initialize(<module-var-access>);
+ // <module-var-ref> -- subclass of <module-var-access>
+ seal generic make(singleton(<module-var-ref>));
+ // <module-var-set> -- subclass of <module-var-access>
+ seal generic make(singleton(<module-var-set>));
+ // <self-tail-call> -- subclass of <operation>
+ seal generic make(singleton(<self-tail-call>));
+ seal generic initialize(<self-tail-call>);
+ // <slot-access> -- subclass of <operation>
+ seal generic make(singleton(<slot-access>));
+ seal generic initialize(<slot-access>);
+ // <slot-ref> -- subclass of <slot-access>
+ seal generic make(singleton(<slot-ref>));
+ // <slot-set> -- subclass of <slot-access>
+ seal generic make(singleton(<slot-set>));
+ // <truly-the> -- subclass of <operation>
+ seal generic make(singleton(<truly-the>));
+ seal generic initialize(<truly-the>);
+ // <instance?> -- subclass of <operation>
+ seal generic make(singleton(<instance?>));
+ seal generic initialize(<instance?>);
+ // <nlx-operation> -- subclass of <operation>
+ seal generic make(singleton(<nlx-operation>));
+ seal generic initialize(<nlx-operation>);
+ // <catch> -- subclass of <nlx-operation>
+ seal generic make(singleton(<catch>));
+ // <throw> -- subclass of <nlx-operation>
+ seal generic make(singleton(<throw>));
+ // <make-catcher> -- subclass of <nlx-operation>
+ seal generic make(singleton(<make-catcher>));
+ // <disable-catcher> -- subclass of <nlx-operation>
+ seal generic make(singleton(<disable-catcher>));
+ // <constant> -- subclass of <leaf>
+ seal generic make(singleton(<constant>));
+ seal generic initialize(<constant>);
+ // <literal-constant> -- subclass of <constant>
+ seal generic make(singleton(<literal-constant>));
+ // <definition-constant-leaf> -- subclass of <constant>
+ seal generic make(singleton(<definition-constant-leaf>));
+ // <uninitialized-value> -- subclass of <constant>
+ seal generic make(singleton(<uninitialized-value>));
+ // <debug-named-info> -- subclass of <variable-info>
+ seal generic make(singleton(<debug-named-info>));
+ seal generic initialize(<debug-named-info>);
+ // <values-cluster-info> -- subclass of <debug-named-info>
+ seal generic make(singleton(<values-cluster-info>));
+ // <local-var-info> -- subclass of <debug-named-info>
+ seal generic make(singleton(<local-var-info>));
+ // <lexical-var-info> -- subclass of <debug-named-info>, <source-location-mixin>
+ seal generic make(singleton(<lexical-var-info>));
+ // <abstract-function-literal> -- subclass of <leaf>
+ seal generic make(singleton(<abstract-function-literal>));
+ seal generic initialize(<abstract-function-literal>);
+ // <function-literal> -- subclass of 
+ seal generic make(singleton(<function-literal>));
+ seal generic initialize(<function-literal>);
+ // <method-literal> -- subclass of <function-literal>
+ seal generic make(singleton(<method-literal>));
+ // <exit-function> -- subclass of <abstract-function-literal>, <dependent-mixin>
+ seal generic make(singleton(<exit-function>));
+ // <fer-function-region> -- subclass of 
+ seal generic make(singleton(<fer-function-region>));
+ seal generic initialize(<fer-function-region>);
+ // <lambda> -- subclass of <fer-function-region>
+ seal generic make(singleton(<lambda>));
+ // <fer-component> -- subclass of <component>, <identity-preserving-mixin>
+ seal generic make(singleton(<fer-component>));
+ seal generic initialize(<fer-component>);
+ // <unwind-protect-region> -- subclass of <body-region>
+ seal generic make(singleton(<unwind-protect-region>));
+ seal generic initialize(<unwind-protect-region>);
+ // <environment> -- subclass of <annotatable>
+ seal generic make(singleton(<environment>));
+ seal generic initialize(<environment>);
+ // <closure-var> -- subclass of <object>
+ seal generic make(singleton(<closure-var>));
+ seal generic initialize(<closure-var>);
+ // <nlx-info> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<nlx-info>));
+ seal generic initialize(<nlx-info>);
*** 1.6	96/02/09 01:37:43
--- ./compiler/front/misc-dump.dylan	96/03/11 02:57:08
***************
*** 80,82 ****
--- 80,85 ----
      find-variable(load-basic-name(state), create: #t);
    end method
  );
+ 
+ // Seals for file misc-dump.dylan
+ 
*** 1.29	96/02/09 00:00:34
--- ./compiler/front/primitives.dylan	96/03/11 02:57:08
***************
*** 457,459 ****
--- 457,465 ----
  define-primitive
    (#"object-address", #(#"<object>"), #"<raw-pointer>",
     pure: #t);
+ 
+ // Seals for file primitives.dylan
+ 
+ // <primitive-info> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<primitive-info>));
+ seal generic initialize(<primitive-info>);
*** 1.19	96/02/09 00:00:50
--- ./compiler/front/primopt.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/primopt.dylan,v 1.19 96/02/09 00:00:50 wlott Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/primopt.dylan,v 1.19 1996/02/09 00:00:50 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 557,559 ****
--- 557,562 ----
       let type = new-dep.dependent-next.source-exp.dylan-type-for-c-type;
       assert-type(component, primitive.dependents.dependent, new-dep, type);
     end);
+ 
+ // Seals for file primopt.dylan
+ 
*** 1.8	95/12/04 16:23:36
--- ./compiler/front/tlexpr.dylan	96/03/11 02:57:08
***************
*** 105,107 ****
--- 105,116 ----
      => ();
    // Do nothing.
  end;
+ 
+ // Seals for file tlexpr.dylan
+ 
+ // <expression-tlf> -- subclass of <top-level-form>
+ seal generic make(singleton(<expression-tlf>));
+ seal generic initialize(<expression-tlf>);
+ // <magic-interal-primitives-placeholder> -- subclass of <top-level-form>
+ seal generic make(singleton(<magic-interal-primitives-placeholder>));
+ seal generic initialize(<magic-interal-primitives-placeholder>);
*** 1.10	96/02/21 15:52:45
--- ./compiler/front/tlf.dylan	96/03/11 02:57:08
***************
*** 111,113 ****
--- 111,122 ----
  		note-variable-definition(defn);
  		defn;
  	      end);
+ 
+ // Seals for file tlf.dylan
+ 
+ // <top-level-form> -- subclass of <source-location-mixin>
+ seal generic make(singleton(<top-level-form>));
+ // <define-tlf> -- subclass of <top-level-form>
+ seal generic make(singleton(<define-tlf>));
+ // <simple-define-tlf> -- subclass of <define-tlf>
+ seal generic make(singleton(<simple-define-tlf>));
*** 1.25	96/03/02 19:01:13
--- ./compiler/front/trans.dylan	96/03/11 19:56:51
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/trans.dylan,v 1.25 96/03/02 19:01:13 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/trans.dylan,v 1.25 96/03/02 19:01:13 rgs Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 458,463 ****
--- 458,464 ----
  
  define method is-it-functional? (class :: <cclass>)
      => res :: one-of(#t, #f, #"maybe");
+   if (~class.sealed?)
      if (class.functional?)
        #t;
      elseif (class.not-functional?)
***************
*** 465,470 ****
--- 466,481 ----
      else
        #"maybe";
      end;
+   else
+     let subs = find-direct-classes(class);
+     if (every?(functional?, subs))
+       #t;
+     elseif (every?(not-functional?, subs))
+       #f;
+     else
+       #"maybe";
+     end if;
+   end if;
  end;
  
  define method is-it-functional? (type :: <limited-ctype>)
***************
*** 1391,1393 ****
--- 1402,1410 ----
  	     iteration-vars.iteration-state-var)));
  end;
  
+ 
+ // Seals for file trans.dylan
+ 
+ // <iteration-vars> -- subclass of <object>
+ seal generic make(singleton(<iteration-vars>));
+ seal generic initialize(<iteration-vars>);
*** 1.11	96/03/02 19:01:13
--- ./compiler/front/front-exports.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  module: dylan-user
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/front-exports.dylan,v 1.11 96/03/02 19:01:13 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: dylan-user
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/front-exports.dylan,v 1.11 96/03/02 19:01:13 rgs Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 426,429 ****
--- 426,432 ----
    export
      optimize-component, *optimize-ncalls*, build-xep, build-xep-component;
  end;
+ 
+ 
+ // Seals for file front-exports.dylan
  
*** 1.6	96/02/22 17:47:23
--- ./compiler/front/callopt.dylan	96/03/11 02:57:05
***************
*** 1091,1093 ****
--- 1091,1096 ----
      end;
    end;
  end;
+ 
+ // Seals for file callopt.dylan
+ 
*** 1.3	96/03/02 19:01:13
--- ./compiler/front/xep.dylan	96/03/11 02:57:09
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/xep.dylan,v 1.3 96/03/02 19:01:13 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/xep.dylan,v 1.3 96/03/02 19:01:13 rgs Exp $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 467,469 ****
--- 467,475 ----
  
    xep;
  end;
+ 
+ // Seals for file xep.dylan
+ 
+ // <keyarg-info> -- subclass of <object>
+ seal generic make(singleton(<keyarg-info>));
+ seal generic initialize(<keyarg-info>);
*** 1.2	96/02/23 15:09:53
--- ./compiler/front/fer-edit.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/fer-edit.dylan,v 1.2 96/02/23 15:09:53 wlott Exp Locker: wlott $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/fer-edit.dylan,v 1.2 96/02/23 15:09:53 wlott Exp $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 985,987 ****
--- 985,990 ----
    end unless;
    make(<empty-region>);
  end method extract-stuff-after;
+ 
+ // Seals for file fer-edit.dylan
+ 
*** 1.1	96/02/02 23:19:47
--- ./compiler/front/funcopt.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/funcopt.dylan,v 1.1 96/02/02 23:19:47 wlott Exp Locker: wlott $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/funcopt.dylan,v 1.1 1996/02/02 23:19:47 wlott Exp $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 304,306 ****
--- 304,309 ----
       region :: <exit>)
      => ();
  end;
+ 
+ // Seals for file funcopt.dylan
+ 
*** 1.1	96/02/02 23:19:47
--- ./compiler/front/tailcall.dylan	96/03/11 02:57:08
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/tailcall.dylan,v 1.1 96/02/02 23:19:47 wlott Exp Locker: wlott $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/tailcall.dylan,v 1.1 1996/02/02 23:19:47 wlott Exp $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 250,252 ****
--- 250,255 ----
    reoptimize(component, op);
    reoptimize(component, assign);
  end;
+ 
+ // Seals for file tailcall.dylan
+ 
*** 1.1	96/02/23 15:44:07
--- ./compiler/front/constraint.dylan	96/03/11 02:57:05
***************
*** 1,5 ****
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/constraint.dylan,v 1.1 96/02/23 15:44:07 wlott Exp Locker: wlott $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cheese
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/front/RCS/constraint.dylan,v 1.1 96/02/23 15:44:07 wlott Exp $
  copyright: Copyright (c) 1996  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 362,364 ****
--- 362,373 ----
    temp;
  end method insert-type-constraint;
  
+ 
+ // Seals for file constraint.dylan
+ 
+ // <renaming> -- subclass of <object>
+ seal generic make(singleton(<renaming>));
+ seal generic initialize(<renaming>);
+ // <renaming-set> -- subclass of <object>
+ seal generic make(singleton(<renaming-set>));
+ seal generic initialize(<renaming-set>);
*** 1.43	96/02/23 17:49:46
--- ./compiler/base/ctype.dylan	96/03/13 03:59:19
***************
*** 43,59 ****
  ///
  /// ### vector could be limited to type-union(<ctype>, one-of(#t, #f));
  ///
  define constant <memo-table> = <simple-object-vector>;
  
  /// log2 of the the number of entries in the table.
  define constant memo2-bits = 9;
  
  // mask which gives a vector index from a large hash value.  Low zeros align to
  // start of an entry.
! define constant memo2-mask = ash(1, memo2-bits);
  
  define constant make-memo2-table = method ()
!   make(<memo-table>, size: ash(4, memo2-bits), fill: #f);
  end method;
  
  // some hit rate info, for tuning.
--- 43,108 ----
  ///
  /// ### vector could be limited to type-union(<ctype>, one-of(#t, #f));
  ///
+ define class <memo-entry> (<object>)
+   slot memo-type1 :: false-or(<ctype>) = #f;
+   slot memo-type2 :: false-or(<ctype>) = #f;
+   slot memo-value :: type-union(<ctype>, <boolean>) = #f;
+   slot memo-precise :: <boolean> = #f;
+ end class <memo-entry>;
+ seal generic make(singleton(<memo-entry>));
+ seal generic initialize(<memo-entry>);
+ 
+ define constant $null-memo-entry :: <memo-entry> = make(<memo-entry>);
+ 
+ #if (mindy)
+ 
  define constant <memo-table> = <simple-object-vector>;
  
+ #else
+ 
+ define sealed class <memo-table> (<vector>)
+   sealed slot %element :: <memo-entry>,
+     init-value: type-union(), init-keyword: fill:,
+     sizer: size, size-init-value: 0, size-init-keyword: size:;
+ end class <memo-table>;
+ 
+ seal generic make (singleton(<memo-table>));
+ seal generic initialize (<memo-table>);
+ 
+ define sealed inline method element
+     (vec :: <memo-table>, index :: <integer>, #key default = $not-supplied)
+  => (element :: <memo-entry>);
+   if (index >= 0 & index < vec.size)
+     %element(vec, index);
+   elseif (default == $not-supplied)
+     error("Undefined element: %s[%s]", vec, index);
+   else
+     default;
+   end;
+ end;
+ 
+ define sealed inline method element-setter
+     (new-value :: <memo-entry>, vec :: <memo-table>, index :: <integer>)
+     => new-value :: <memo-entry>;
+   if (index >= 0 & index < vec.size)
+     %element(vec, index) := new-value;
+   else
+     error("Undefined element: %s[%s]", vec, index);
+   end;
+ end;
+ 
+ #end
+ 
  /// log2 of the the number of entries in the table.
  define constant memo2-bits = 9;
  
  // mask which gives a vector index from a large hash value.  Low zeros align to
  // start of an entry.
! define constant memo2-size = ash(1, memo2-bits);
! define constant memo2-mask = memo2-size - 1;
  
  define constant make-memo2-table = method ()
!   make(<memo-table>, size: memo2-size, fill: $null-memo-entry);
  end method;
  
  // some hit rate info, for tuning.
***************
*** 64,91 ****
  // are returned.  If not, we return #"miss" and #f;
  define constant memo2-lookup = method
     (type1 :: <ctype>, type2 :: <ctype>, table :: <memo-table>)
!     => (value :: type-union(<ctype>, one-of(#f, #t, #"miss")),
          precise :: <boolean>);
  
    *memo2-probes* := *memo2-probes* + 1;
!   let base = modulo(type1.type-hash - type2.type-hash, memo2-mask) * 4;
!   if (table[base] == type1 & table[base + 1] == type2)
      *memo2-hits* := *memo2-hits* + 1;
!     values(table[base + 2], table[base + 3]);
    else
      values(#"miss", #f);
    end;
  end method;
  
  define constant memo2-enter = method
!    (type1 :: <ctype>, type2 :: <ctype>, result :: type-union(<ctype>, <boolean>),
      precise :: <boolean>, table :: <memo-table>)
! 
!   let base = modulo(type1.type-hash - type2.type-hash, memo2-mask) * 4;
!   table[base] := type1;
!   table[base + 1] := type2;
!   table[base + 2] := result;
!   table[base + 3] := precise;
  end method;
   
  
--- 113,154 ----
  // are returned.  If not, we return #"miss" and #f;
  define constant memo2-lookup = method
     (type1 :: <ctype>, type2 :: <ctype>, table :: <memo-table>)
!     => (value :: type-union(<ctype>, <boolean>, singleton(#"miss")),
          precise :: <boolean>);
  
    *memo2-probes* := *memo2-probes* + 1;
! #if (mindy)
!   let base = modulo(type1.type-hash - type2.type-hash, memo2-size);
! #else
!   let base = logand(type1.type-hash - type2.type-hash, memo2-mask);
! #end
!   let entry :: <memo-entry> = table[base];
!   if (entry.memo-type1 == type1 & entry.memo-type2 == type2)
      *memo2-hits* := *memo2-hits* + 1;
!     values(entry.memo-value, entry.memo-precise);
    else
      values(#"miss", #f);
    end;
  end method;
  
  define constant memo2-enter = method
!    (type1 :: <ctype>, type2 :: <ctype>,
!     result :: type-union(<ctype>, <boolean>),
      precise :: <boolean>, table :: <memo-table>)
! #if (mindy)  
!   let base = modulo(type1.type-hash - type2.type-hash, memo2-size);
! #else
!   let base = logand(type1.type-hash - type2.type-hash, memo2-mask);
! #end
!   let entry :: <memo-entry> = table[base];
!   if (entry == $null-memo-entry)
!     entry := make(<memo-entry>);
!     table[base] := entry;
!   end if;
!   entry.memo-type1 := type1;
!   entry.memo-type2 := type2;
!   entry.memo-value := result;
!   entry.memo-precise := precise;
  end method;
   
  
***************
*** 1687,1689 ****
--- 1750,1782 ----
      make-values-ctype(map(specifier-type, args), #f);
    end;
  end;
+ 
+ // Seals for file ctype.dylan
+ 
+ // <values-ctype> -- subclass of <object>
+ seal generic make(singleton(<values-ctype>));
+ seal generic initialize(<values-ctype>);
+ // <ctype> -- subclass of <values-ctype>
+ seal generic make(singleton(<ctype>));
+ // <union-ctype> -- subclass of <ctype>, <ct-value>
+ seal generic make(singleton(<union-ctype>));
+ // <union-table> -- subclass of <table>
+ seal generic make(singleton(<union-table>));
+ seal generic initialize(<union-table>);
+ // <unknown-ctype> -- subclass of <ctype>
+ seal generic make(singleton(<unknown-ctype>));
+ // <limited-ctype> -- subclass of <ctype>
+ seal generic make(singleton(<limited-ctype>));
+ // <limited-integer-table> -- subclass of <table>
+ seal generic make(singleton(<limited-integer-table>));
+ seal generic initialize(<limited-integer-table>);
+ // <limited-integer-ctype> -- subclass of <limited-ctype>, <ct-value>
+ seal generic make(singleton(<limited-integer-ctype>));
+ // <direct-instance-ctype> -- subclass of <limited-ctype>, <ct-value>
+ seal generic make(singleton(<direct-instance-ctype>));
+ // <singleton-ctype> -- subclass of <limited-ctype>, <ct-value>
+ seal generic make(singleton(<singleton-ctype>));
+ // <byte-character-ctype> -- subclass of <limited-ctype>, <ct-value>
+ seal generic make(singleton(<byte-character-ctype>));
+ // <multi-value-ctype> -- subclass of <values-ctype>
+ seal generic make(singleton(<multi-value-ctype>));
*** 1.24	96/02/20 16:00:01
--- ./compiler/base/utils.dylan	96/03/15 23:17:33
***************
*** 1,5 ****
  module: utils
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/utils.dylan,v 1.24 96/02/20 16:00:01 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: utils
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/utils.dylan,v 1.24 1996/02/20 16:00:01 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 291,297 ****
  
  define method stringify (#rest things) => res :: <byte-string>;
    let res = for (thing in things,
! 		 len = 0 then len + string-length(thing))
  	    finally
  	      make(<byte-string>, size: len);
  	    end for;
--- 291,297 ----
  
  define method stringify (#rest things) => res :: <byte-string>;
    let res = for (thing in things,
! 		 len :: <integer> = 0 then len + string-length(thing))
  	    finally
  	      make(<byte-string>, size: len);
  	    end for;
***************
*** 434,436 ****
--- 434,444 ----
    close(stream);
  end method spew-dependency-log;
  
+ 
+ // Seals for file utils.dylan
+ 
+ // <flush-happy-stream> -- subclass of <stream>
+ seal generic make(singleton(<flush-happy-stream>));
+ seal generic initialize(<flush-happy-stream>);
+ // <annotatable> -- subclass of <object>
+ seal generic make(singleton(<annotatable>));
*** 1.28	96/02/23 02:34:33
--- ./compiler/base/ctv.dylan	96/03/11 02:53:27
***************
*** 153,164 ****
  define class <literal-double-float> (<literal-float>) end;
  define class <literal-extended-float> (<literal-float>) end;
  				       
! define constant $literal-fixed-integer-memo = make(<table>);
! define constant $literal-extended-integer-memo = make(<table>);
! define constant $literal-ratio-memo = make(<table>);
! define constant $literal-single-float-memo = make(<table>);
! define constant $literal-double-float-memo = make(<table>);
! define constant $literal-extended-float-memo = make(<table>);
  
  define method make (class == <literal-integer>, #next next-method,
  		    #key value)
--- 153,170 ----
  define class <literal-double-float> (<literal-float>) end;
  define class <literal-extended-float> (<literal-float>) end;
  				       
! define constant $literal-fixed-integer-memo :: <object-table>
!   = make(<table>);
! define constant $literal-extended-integer-memo :: <object-table>
!   = make(<table>);
! define constant $literal-ratio-memo :: <object-table>
!   = make(<table>);
! define constant $literal-single-float-memo :: <object-table>
!   = make(<table>);
! define constant $literal-double-float-memo :: <object-table>
!   = make(<table>);
! define constant $literal-extended-float-memo :: <object-table>
!   = make(<table>);
  
  define method make (class == <literal-integer>, #next next-method,
  		    #key value)
***************
*** 308,314 ****
  define class <literal-byte-symbol> (<literal-symbol>)
  end class;
  
! define constant $literal-symbol-memo = make(<table>);
  
  define method make (class == <literal-symbol>, #next next-method, #key value)
      => (res :: <literal-symbol>);
--- 314,321 ----
  define class <literal-byte-symbol> (<literal-symbol>)
  end class;
  
! define constant $literal-symbol-memo :: <object-table>
!   = make(<table>);
  
  define method make (class == <literal-symbol>, #next next-method, #key value)
      => (res :: <literal-symbol>);
***************
*** 350,356 ****
    slot literal-value :: <byte-character>, required-init-keyword: value:;
  end class;
  
! define constant $literal-character-memo = make(<table>);
  
  define method make (class == <literal-character>, #next next-method,
  		    #key value)
--- 357,364 ----
    slot literal-value :: <byte-character>, required-init-keyword: value:;
  end class;
  
! define constant $literal-character-memo :: <object-table>
!   = make(<table>);
  
  define method make (class == <literal-character>, #next next-method,
  		    #key value)
***************
*** 432,439 ****
  
  define class <literal-pair-memo-table> (<table>)
  end;
  
! define method table-protocol (table :: <literal-pair-memo-table>)
      => (tester :: <function>, hasher :: <function>);
    values(method (key1 :: <literal-pair>, key2 :: <literal-pair>)
  	     => res :: <boolean>;
--- 440,449 ----
  
  define class <literal-pair-memo-table> (<table>)
  end;
+ seal generic make(singleton(<literal-pair-memo-table>));
+ seal generic initialize(<literal-pair-memo-table>);
  
! define sealed inline method table-protocol (table :: <literal-pair-memo-table>)
      => (tester :: <function>, hasher :: <function>);
    values(method (key1 :: <literal-pair>, key2 :: <literal-pair>)
  	     => res :: <boolean>;
***************
*** 448,454 ****
  	 end);
  end;
  
! define constant $literal-pair-memo = make(<literal-pair-memo-table>);
  
  define method make (class == <literal-pair>, #next next-method,
  		    #key sharable: sharable?, head, tail)
--- 458,465 ----
  	 end);
  end;
  
! define constant $literal-pair-memo :: <literal-pair-memo-table>
!   = make(<literal-pair-memo-table>);
  
  define method make (class == <literal-pair>, #next next-method,
  		    #key sharable: sharable?, head, tail)
***************
*** 533,540 ****
  // if each element is identical even if the vectors themselves are not.
  //
  define class <shallow-equal-table> (<table>) end class;
  
! define method table-protocol (table :: <shallow-equal-table>)
   => (test :: <function>, hash :: <function>);
    values(shallow-equal, shallow-hash);
  end method table-protocol;
--- 544,553 ----
  // if each element is identical even if the vectors themselves are not.
  //
  define class <shallow-equal-table> (<table>) end class;
+ seal generic make(singleton(<shallow-equal-table>));
+ seal generic initialize(<shallow-equal-table>);
  
! define sealed inline method table-protocol (table :: <shallow-equal-table>)
   => (test :: <function>, hash :: <function>);
    values(shallow-equal, shallow-hash);
  end method table-protocol;
***************
*** 565,571 ****
    values(current-id, current-state);
  end method shallow-hash;
  
! define constant $literal-vector-memo = make(<shallow-equal-table>);
  
  define method make (class == <literal-simple-object-vector>, #next next-method,
  		    #key sharable: sharable?, contents)
--- 578,585 ----
    values(current-id, current-state);
  end method shallow-hash;
  
! define constant $literal-vector-memo :: <shallow-equal-table>
!   = make(<shallow-equal-table>);
  
  define method make (class == <literal-simple-object-vector>, #next next-method,
  		    #key sharable: sharable?, contents)
***************
*** 600,606 ****
    slot literal-value :: <byte-string>, required-init-keyword: value:;
  end;
  
! define constant $literal-string-memo = make(<string-table>);
  
  define method make (class == <literal-string>, #next next-method,
  		    #key value)
--- 614,620 ----
    slot literal-value :: <byte-string>, required-init-keyword: value:;
  end;
  
! define constant $literal-string-memo :: <string-table> = make(<string-table>);
  
  define method make (class == <literal-string>, #next next-method,
  		    #key value)
***************
*** 766,768 ****
--- 780,857 ----
    end if;
  end method;
  
+ 
+ // Seals for file ctv.dylan
+ 
+ // <ct-value> -- subclass of <annotatable>
+ seal generic make(singleton(<ct-value>));
+ seal generic initialize(<ct-value>);
+ // <literal> -- subclass of <ct-value>
+ seal generic make(singleton(<literal>));
+ // <eql-ct-value> -- subclass of <ct-value>
+ seal generic make(singleton(<eql-ct-value>));
+ // <eql-literal> -- subclass of <literal>, <eql-ct-value>
+ seal generic make(singleton(<eql-literal>));
+ // <ct-not-supplied-marker> -- subclass of 
+ seal generic make(singleton(<ct-not-supplied-marker>));
+ seal generic initialize(<ct-not-supplied-marker>);
+ // <literal-boolean> -- subclass of 
+ seal generic make(singleton(<literal-boolean>));
+ seal generic initialize(<literal-boolean>);
+ // <literal-true> -- subclass of <literal-boolean>
+ seal generic make(singleton(<literal-true>));
+ // <literal-false> -- subclass of <literal-boolean>
+ seal generic make(singleton(<literal-false>));
+ // <literal-number> -- subclass of <eql-literal>
+ seal generic make(singleton(<literal-number>));
+ // <literal-real> -- subclass of <literal-number>
+ seal generic make(singleton(<literal-real>));
+ // <literal-rational> -- subclass of <literal-real>
+ seal generic make(singleton(<literal-rational>));
+ // <literal-general-integer> -- subclass of <literal-rational>
+ seal generic make(singleton(<literal-general-integer>));
+ // <literal-integer> -- subclass of <literal-general-integer>
+ seal generic make(singleton(<literal-integer>));
+ // <literal-extended-integer> -- subclass of <literal-general-integer>
+ seal generic make(singleton(<literal-extended-integer>));
+ // <literal-ratio> -- subclass of <literal-rational>
+ seal generic make(singleton(<literal-ratio>));
+ // <literal-float> -- subclass of <literal-real>
+ seal generic make(singleton(<literal-float>));
+ // <literal-single-float> -- subclass of <literal-float>
+ seal generic make(singleton(<literal-single-float>));
+ // <literal-double-float> -- subclass of <literal-float>
+ seal generic make(singleton(<literal-double-float>));
+ // <literal-extended-float> -- subclass of <literal-float>
+ seal generic make(singleton(<literal-extended-float>));
+ // <literal-symbol> -- subclass of <eql-literal>, <identity-preserving-mixin>
+ seal generic make(singleton(<literal-symbol>));
+ // <literal-byte-symbol> -- subclass of <literal-symbol>
+ seal generic make(singleton(<literal-byte-symbol>));
+ // <literal-character> -- subclass of <eql-literal>
+ seal generic make(singleton(<literal-character>));
+ // <literal-byte-character> -- subclass of <literal-character>
+ seal generic make(singleton(<literal-byte-character>));
+ // <literal-sequence> -- subclass of 
+ seal generic make(singleton(<literal-sequence>));
+ seal generic initialize(<literal-sequence>);
+ // <literal-list> -- subclass of <literal-sequence>
+ seal generic make(singleton(<literal-list>));
+ // <literal-pair> -- subclass of <literal-list>
+ seal generic make(singleton(<literal-pair>));
+ // <literal-pair-memo-table> -- subclass of <table>
+ seal generic make(singleton(<literal-pair-memo-table>));
+ seal generic initialize(<literal-pair-memo-table>);
+ // <literal-empty-list> -- subclass of <literal-list>, <eql-literal>
+ seal generic make(singleton(<literal-empty-list>));
+ // <literal-vector> -- subclass of <literal-sequence>
+ seal generic make(singleton(<literal-vector>));
+ // <literal-simple-object-vector> -- subclass of <literal-vector>
+ seal generic make(singleton(<literal-simple-object-vector>));
+ // <shallow-equal-table> -- subclass of <table>
+ seal generic make(singleton(<shallow-equal-table>));
+ seal generic initialize(<shallow-equal-table>);
+ // <literal-string> -- subclass of <literal-vector>
+ seal generic make(singleton(<literal-string>));
+ // <literal-byte-string> -- subclass of <literal-string>
+ seal generic make(singleton(<literal-byte-string>));
*** 1.10	96/02/08 19:18:54
--- ./compiler/base/source.dylan	96/03/13 02:31:18
***************
*** 1,5 ****
  module: source
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/source.dylan,v 1.10 96/02/08 19:18:54 ram Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: source
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/source.dylan,v 1.10 1996/02/08 19:18:54 ram Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 287,289 ****
--- 287,307 ----
      end method
  );
  
+ 
+ // Seals for file source.dylan
+ 
+ // <source-location> -- subclass of <object>
+ seal generic make(singleton(<source-location>));
+ seal generic initialize(<source-location>);
+ // <unknown-source-location> -- subclass of <source-location>
+ seal generic make(singleton(<unknown-source-location>));
+ // <source-location-mixin> -- subclass of <object>
+ seal generic make(singleton(<source-location-mixin>));
+ // <big-buffer> -- subclass of <vector>
+ // seal generic make(singleton(<big-buffer>));
+ // seal generic initialize(<big-buffer>);
+ // <source-file> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<source-file>));
+ seal generic initialize(<source-file>);
+ // <file-source-location> -- subclass of <source-location>
+ seal generic make(singleton(<file-source-location>));
*** 1.22	96/01/12 00:58:08
--- ./compiler/base/c-rep.dylan	96/03/11 02:53:27
***************
*** 1,5 ****
  module: c-representation
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/c-rep.dylan,v 1.22 96/01/12 00:58:08 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: c-representation
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/c-rep.dylan,v 1.22 1996/01/12 00:58:08 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 592,594 ****
--- 592,608 ----
  				   data-word-member:, #f)),
  		load-external: #t);
  
+ 
+ // Seals for file c-rep.dylan
+ 
+ // <c-representation> -- subclass of 
+ seal generic make(singleton(<c-representation>));
+ seal generic initialize(<c-representation>);
+ // <general-representation> -- subclass of <c-representation>
+ seal generic make(singleton(<general-representation>));
+ // <heap-representation> -- subclass of <c-representation>
+ seal generic make(singleton(<heap-representation>));
+ // <immediate-representation> -- subclass of <c-representation>
+ seal generic make(singleton(<immediate-representation>));
+ // <data-word-representation> -- subclass of <immediate-representation>
+ seal generic make(singleton(<data-word-representation>));
*** 1.33	96/01/12 00:58:09
--- ./compiler/base/cclass.dylan	96/03/11 03:27:03
***************
*** 1,5 ****
  module: classes
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/cclass.dylan,v 1.33 96/01/12 00:58:09 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: classes
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/cclass.dylan,v 1.33 1996/01/12 00:58:09 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 1076,1078 ****
--- 1076,1113 ----
  define method print-message (proxy :: <proxy>, stream :: <stream>) => ();
    format(stream, "proxy for %s", proxy.proxy-for);
  end;
+ 
+ // Seals for file cclass.dylan
+ 
+ // <cclass> -- subclass of 
+ seal generic make(singleton(<cclass>));
+ seal generic initialize(<cclass>);
+ // <slot-info> -- subclass of <eql-ct-value>, <identity-preserving-mixin>
+ seal generic make(singleton(<slot-info>));
+ seal generic initialize(<slot-info>);
+ // <instance-slot-info> -- subclass of <slot-info>
+ seal generic make(singleton(<instance-slot-info>));
+ // <vector-slot-info> -- subclass of <instance-slot-info>
+ seal generic make(singleton(<vector-slot-info>));
+ // <class-slot-info> -- subclass of <slot-info>
+ seal generic make(singleton(<class-slot-info>));
+ // <each-subclass-slot-info> -- subclass of <slot-info>
+ seal generic make(singleton(<each-subclass-slot-info>));
+ // <virtual-slot-info> -- subclass of <slot-info>
+ seal generic make(singleton(<virtual-slot-info>));
+ // <override-info> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<override-info>));
+ seal generic initialize(<override-info>);
+ // <class-precedence-description> -- subclass of <object>
+ seal generic make(singleton(<class-precedence-description>));
+ seal generic initialize(<class-precedence-description>);
+ // <layout-table> -- subclass of <object>
+ seal generic make(singleton(<layout-table>));
+ seal generic initialize(<layout-table>);
+ // <defined-cclass> -- subclass of <cclass>
+ seal generic make(singleton(<defined-cclass>));
+ // <limited-cclass> -- subclass of <cclass>
+ seal generic make(singleton(<limited-cclass>));
+ // <proxy> -- subclass of <ct-value>, <identity-preserving-mixin>
+ seal generic make(singleton(<proxy>));
+ seal generic initialize(<proxy>);
*** 1.20	96/01/15 12:51:16
--- ./compiler/base/control-flow.dylan	96/03/11 02:53:27
***************
*** 1,5 ****
  Module: flow
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/control-flow.dylan,v 1.20 96/01/15 12:51:16 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  Module: flow
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/control-flow.dylan,v 1.20 1996/01/15 12:51:16 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 196,198 ****
--- 196,235 ----
    component.reoptimize-queue := queueable;
  end;
  
+ 
+ // Seals for file control-flow.dylan
+ 
+ // <region> -- subclass of <source-location-mixin>
+ seal generic make(singleton(<region>));
+ // <linear-region> -- subclass of <region>
+ seal generic make(singleton(<linear-region>));
+ seal generic initialize(<linear-region>);
+ // <simple-region> -- subclass of <linear-region>
+ seal generic make(singleton(<simple-region>));
+ // <compound-region> -- subclass of <linear-region>
+ seal generic make(singleton(<compound-region>));
+ // <empty-region> -- subclass of <compound-region>
+ seal generic make(singleton(<empty-region>));
+ // <join-region> -- subclass of <region>
+ seal generic make(singleton(<join-region>));
+ // <if-region> -- subclass of <join-region>, <dependent-mixin>
+ seal generic make(singleton(<if-region>));
+ seal generic initialize(<if-region>);
+ // <body-region> -- subclass of <join-region>
+ seal generic make(singleton(<body-region>));
+ // <block-region-mixin> -- subclass of 
+ seal generic make(singleton(<block-region-mixin>));
+ // <block-region> -- subclass of 
+ seal generic make(singleton(<block-region>));
+ // <function-region> -- subclass of <block-region>
+ seal generic make(singleton(<function-region>));
+ // <loop-region> -- subclass of <body-region>
+ seal generic make(singleton(<loop-region>));
+ seal generic initialize(<loop-region>);
+ // <exit> -- subclass of <region>
+ seal generic make(singleton(<exit>));
+ seal generic initialize(<exit>);
+ // <return> -- subclass of <exit>, <dependent-mixin>
+ seal generic make(singleton(<return>));
+ // <component> -- subclass of <block-region-mixin>
+ seal generic make(singleton(<component>));
*** 1.14	96/01/12 00:58:11
--- ./compiler/base/cteval.dylan	96/03/11 02:53:27
***************
*** 425,427 ****
--- 425,430 ----
  
  define-ct-evaluator(#"lognot", #(#"<general-integer>"),
  		    curry(ct-eval-rational-function, lognot));
+ 
+ // Seals for file cteval.dylan
+ 
*** 1.12	96/03/02 19:01:13
--- ./compiler/base/ctfunc.dylan	96/03/11 02:53:27
***************
*** 184,186 ****
--- 184,207 ----
  		    signal("Yes, a <ct-entry-point> was actually dumped.");
  		  end method,
  		load-external: #t);
+ 
+ // Seals for file ctfunc.dylan
+ 
+ // <ct-function> -- subclass of 
+ seal generic make(singleton(<ct-function>));
+ seal generic initialize(<ct-function>);
+ // <ct-raw-function> -- subclass of <ct-function>
+ seal generic make(singleton(<ct-raw-function>));
+ // <ct-generic-function> -- subclass of <ct-function>, <eql-ct-value>
+ seal generic make(singleton(<ct-generic-function>));
+ // <ct-open-generic> -- subclass of <ct-generic-function>
+ seal generic make(singleton(<ct-open-generic>));
+ // <ct-sealed-generic> -- subclass of <ct-generic-function>
+ seal generic make(singleton(<ct-sealed-generic>));
+ // <ct-method> -- subclass of <ct-function>
+ seal generic make(singleton(<ct-method>));
+ // <ct-accessor-method> -- subclass of <ct-method>
+ seal generic make(singleton(<ct-accessor-method>));
+ // <ct-entry-point> -- subclass of <ct-value>, <identity-preserving-mixin>
+ seal generic make(singleton(<ct-entry-point>));
+ seal generic initialize(<ct-entry-point>);
*** 1.6	96/01/12 00:58:16
--- ./compiler/base/header.dylan	96/03/11 02:53:28
***************
*** 1,5 ****
  module: header
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/header.dylan,v 1.6 96/01/12 00:58:16 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: header
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/header.dylan,v 1.6 1996/01/12 00:58:16 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 312,314 ****
--- 312,323 ----
      end;
    repeat(0, 1);
  end method;
+ 
+ // Seals for file header.dylan
+ 
+ // <header> -- subclass of <explicit-key-collection>
+ seal generic make(singleton(<header>));
+ seal generic initialize(<header>);
+ // <header-entry> -- subclass of <object>
+ seal generic make(singleton(<header-entry>));
+ seal generic initialize(<header-entry>);
*** 1.12	96/02/08 02:24:47
--- ./compiler/base/tokens.dylan	96/03/11 02:53:30
***************
*** 465,467 ****
--- 465,658 ----
    end;
  end;
  
+ 
+ // Seals for file tokens.dylan
+ 
+ // <tokenizer> -- subclass of <object>
+ seal generic make(singleton(<tokenizer>));
+ // <token> -- subclass of <source-location-mixin>
+ seal generic make(singleton(<token>));
+ // <eof-token> -- subclass of <token>
+ seal generic make(singleton(<eof-token>));
+ seal generic initialize(<eof-token>);
+ // <error-token> -- subclass of <token>
+ seal generic make(singleton(<error-token>));
+ seal generic initialize(<error-token>);
+ // <symbol-token> -- subclass of <token>
+ seal generic make(singleton(<symbol-token>));
+ seal generic initialize(<symbol-token>);
+ // <identifier-token> -- subclass of <symbol-token>
+ seal generic make(singleton(<identifier-token>));
+ // <uniquifier> -- subclass of <object>
+ seal generic make(singleton(<uniquifier>));
+ seal generic initialize(<uniquifier>);
+ // <word-token> -- subclass of <identifier-token>
+ seal generic make(singleton(<word-token>));
+ // <name-token> -- subclass of <word-token>
+ seal generic make(singleton(<name-token>));
+ // <simple-name-token> -- subclass of <name-token>
+ seal generic make(singleton(<simple-name-token>));
+ // <quoted-name-token> -- subclass of <simple-name-token>
+ seal generic make(singleton(<quoted-name-token>));
+ // <begin-word-token> -- subclass of <word-token>
+ seal generic make(singleton(<begin-word-token>));
+ // <define-word-token> -- subclass of <word-token>
+ seal generic make(singleton(<define-word-token>));
+ // <define-bindings-word-token> -- subclass of <word-token>
+ seal generic make(singleton(<define-bindings-word-token>));
+ // <define-word-and-name-token> -- subclass of <define-word-token>, <name-token>
+ seal generic make(singleton(<define-word-and-name-token>));
+ // <define-bindings-word-and-name-token> -- subclass of 
+ seal generic make(singleton(<define-bindings-word-and-name-token>));
+ seal generic initialize(<define-bindings-word-and-name-token>);
+ // <define-and-begin-word-token> -- subclass of 
+ seal generic make(singleton(<define-and-begin-word-token>));
+ seal generic initialize(<define-and-begin-word-token>);
+ // <define-bindings-and-begin-word-token> -- subclass of 
+ seal generic make(singleton(<define-bindings-and-begin-word-token>));
+ seal generic initialize(<define-bindings-and-begin-word-token>);
+ // <constrained-name-token> -- subclass of <symbol-token>
+ seal generic make(singleton(<constrained-name-token>));
+ // <core-word-token> -- subclass of <symbol-token>
+ seal generic make(singleton(<core-word-token>));
+ // <begin-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<begin-token>));
+ // <bind-exit-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<bind-exit-token>));
+ // <class-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<class-token>));
+ // <cleanup-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<cleanup-token>));
+ // <constant-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<constant-token>));
+ // <create-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<create-token>));
+ // <define-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<define-token>));
+ // <else-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<else-token>));
+ // <end-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<end-token>));
+ // <export-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<export-token>));
+ // <finally-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<finally-token>));
+ // <for-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<for-token>));
+ // <from-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<from-token>));
+ // <generic-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<generic-token>));
+ // <handler-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<handler-token>));
+ // <if-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<if-token>));
+ // <in-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<in-token>));
+ // <let-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<let-token>));
+ // <library-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<library-token>));
+ // <local-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<local-token>));
+ // <macro-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<macro-token>));
+ // <method-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<method-token>));
+ // <module-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<module-token>));
+ // <mv-call-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<mv-call-token>));
+ // <otherwise-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<otherwise-token>));
+ // <primitive-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<primitive-token>));
+ // <seal-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<seal-token>));
+ // <set-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<set-token>));
+ // <use-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<use-token>));
+ // <uwp-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<uwp-token>));
+ // <variable-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<variable-token>));
+ // <while-token> -- subclass of <core-word-token>
+ seal generic make(singleton(<while-token>));
+ // <abstract-literal-token> -- subclass of <token>
+ seal generic make(singleton(<abstract-literal-token>));
+ seal generic initialize(<abstract-literal-token>);
+ // <keyword-token> -- subclass of <abstract-literal-token>
+ seal generic make(singleton(<keyword-token>));
+ // <literal-token> -- subclass of <abstract-literal-token>
+ seal generic make(singleton(<literal-token>));
+ // <string-token> -- subclass of <abstract-literal-token>
+ seal generic make(singleton(<string-token>));
+ // <operator-token> -- subclass of <identifier-token>
+ seal generic make(singleton(<operator-token>));
+ // <binary-operator-token> -- subclass of <operator-token>
+ seal generic make(singleton(<binary-operator-token>));
+ // <simple-binary-operator-token> -- subclass of <binary-operator-token>
+ seal generic make(singleton(<simple-binary-operator-token>));
+ // <unary-operator-token> -- subclass of <operator-token>
+ seal generic make(singleton(<unary-operator-token>));
+ // <tilde-token> -- subclass of <unary-operator-token>
+ seal generic make(singleton(<tilde-token>));
+ // <punctuation-token> -- subclass of <token>
+ seal generic make(singleton(<punctuation-token>));
+ seal generic initialize(<punctuation-token>);
+ // <left-paren-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<left-paren-token>));
+ // <right-paren-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<right-paren-token>));
+ // <comma-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<comma-token>));
+ // <dot-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<dot-token>));
+ // <semicolon-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<semicolon-token>));
+ // <left-bracket-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<left-bracket-token>));
+ // <right-bracket-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<right-bracket-token>));
+ // <left-brace-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<left-brace-token>));
+ // <right-brace-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<right-brace-token>));
+ // <double-colon-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<double-colon-token>));
+ // <arrow-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<arrow-token>));
+ // <sharp-paren-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<sharp-paren-token>));
+ // <sharp-bracket-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<sharp-bracket-token>));
+ // <question-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<question-token>));
+ // <double-question-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<double-question-token>));
+ // <ellipsis-token> -- subclass of <punctuation-token>
+ seal generic make(singleton(<ellipsis-token>));
+ // <minus-token> -- subclass of 
+ seal generic make(singleton(<minus-token>));
+ seal generic initialize(<minus-token>);
+ // <equal-token> -- subclass of <punctuation-token>, <binary-operator-token>
+ seal generic make(singleton(<equal-token>));
+ // <double-equal-token> -- subclass of 
+ seal generic make(singleton(<double-equal-token>));
+ seal generic initialize(<double-equal-token>);
+ // <sharp-word-token> -- subclass of <token>
+ seal generic make(singleton(<sharp-word-token>));
+ seal generic initialize(<sharp-word-token>);
+ // <true-token> -- subclass of <sharp-word-token>
+ seal generic make(singleton(<true-token>));
+ // <false-token> -- subclass of <sharp-word-token>
+ seal generic make(singleton(<false-token>));
+ // <next-token> -- subclass of <sharp-word-token>
+ seal generic make(singleton(<next-token>));
+ // <rest-token> -- subclass of <sharp-word-token>
+ seal generic make(singleton(<rest-token>));
+ // <key-token> -- subclass of <sharp-word-token>
+ seal generic make(singleton(<key-token>));
+ // <all-keys-token> -- subclass of <sharp-word-token>
+ seal generic make(singleton(<all-keys-token>));
*** 1.24	96/01/15 12:51:16
--- ./compiler/base/data-flow.dylan	96/03/11 02:53:28
***************
*** 1,5 ****
  Module: flow
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/data-flow.dylan,v 1.24 96/01/15 12:51:16 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  Module: flow
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/data-flow.dylan,v 1.24 1996/01/15 12:51:16 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 285,287 ****
--- 285,328 ----
  // 
  define abstract class <join-assignment> (<abstract-assignment>)
  end;
+ 
+ // Seals for file data-flow.dylan
+ 
+ // <expression> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<expression>));
+ // <queueable-mixin> -- subclass of <object>
+ seal generic make(singleton(<queueable-mixin>));
+ // <dependent-mixin> -- subclass of <queueable-mixin>
+ seal generic make(singleton(<dependent-mixin>));
+ // <dependency> -- subclass of <object>
+ seal generic make(singleton(<dependency>));
+ seal generic initialize(<dependency>);
+ // <leaf> -- subclass of <expression>
+ seal generic make(singleton(<leaf>));
+ // <abstract-variable> -- subclass of <leaf>, <annotatable>
+ seal generic make(singleton(<abstract-variable>));
+ seal generic initialize(<abstract-variable>);
+ // <variable-info> -- subclass of 
+ seal generic make(singleton(<variable-info>));
+ // <definition-site-variable> -- subclass of <abstract-variable>
+ seal generic make(singleton(<definition-site-variable>));
+ // <ssa-variable> -- subclass of <definition-site-variable>
+ seal generic make(singleton(<ssa-variable>));
+ // <initial-definition> -- subclass of <definition-site-variable>
+ seal generic make(singleton(<initial-definition>));
+ // <multi-definition-variable> -- subclass of <abstract-variable>
+ seal generic make(singleton(<multi-definition-variable>));
+ // <initial-variable> -- subclass of <multi-definition-variable>
+ seal generic make(singleton(<initial-variable>));
+ // <operation> -- subclass of 
+ seal generic make(singleton(<operation>));
+ // <join-operation> -- subclass of <operation>
+ seal generic make(singleton(<join-operation>));
+ seal generic initialize(<join-operation>);
+ // <abstract-assignment> -- subclass of 
+ seal generic make(singleton(<abstract-assignment>));
+ // <assignment> -- subclass of <abstract-assignment>
+ seal generic make(singleton(<assignment>));
+ // <join-assignment> -- subclass of <abstract-assignment>
+ seal generic make(singleton(<join-assignment>));
+ seal generic initialize(<join-assignment>);
*** 1.15	96/02/21 16:09:38
--- ./compiler/base/defns.dylan	96/03/11 02:53:28
***************
*** 168,170 ****
--- 168,183 ----
      => ();
    table[name] := merge-category(table, name, <name-token>);
  end;
+ 
+ // Seals for file defns.dylan
+ 
+ // <definition> -- subclass of 
+ seal generic make(singleton(<definition>));
+ // <implicit-definition> -- subclass of <definition>
+ seal generic make(singleton(<implicit-definition>));
+ // <abstract-constant-definition> -- subclass of <definition>
+ seal generic make(singleton(<abstract-constant-definition>));
+ // <function-definition> -- subclass of 
+ seal generic make(singleton(<function-definition>));
+ // <class-definition> -- subclass of 
+ seal generic make(singleton(<class-definition>));
*** 1.9	96/02/18 05:21:24
--- ./compiler/base/dylan-dump.dylan	96/03/14 03:03:57
***************
*** 1,5 ****
  module: dylan-dump
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/dylan-dump.dylan,v 1.9 96/02/18 05:21:24 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: dylan-dump
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/dylan-dump.dylan,v 1.9 1996/02/18 05:21:24 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 331,337 ****
    method (state :: <load-state>) => res :: <list>;
      let contents = load-subobjects-vector(state);
      let res = #();
!     for (i from contents.size - 1 to 0 by -1)
        res := pair(contents[i], res);
        head-maybe-backpatch(res);
        finally res;
--- 331,337 ----
    method (state :: <load-state>) => res :: <list>;
      let contents = load-subobjects-vector(state);
      let res = #();
!     for (i :: <integer> from contents.size - 1 to 0 by -1)
        res := pair(contents[i], res);
        head-maybe-backpatch(res);
        finally res;
***************
*** 356,362 ****
        request-backpatch(x, method (actual) last-pair.tail := actual end);
      end;
      
!     for (i from last-idx - 2 to 0 by -1, 
           res = last-pair then pair(contents[i], res))
        head-maybe-backpatch(res);
        finally res;
--- 356,362 ----
        request-backpatch(x, method (actual) last-pair.tail := actual end);
      end;
      
!     for (i :: <integer> from last-idx - 2 to 0 by -1, 
           res = last-pair then pair(contents[i], res))
        head-maybe-backpatch(res);
        finally res;
***************
*** 401,403 ****
--- 401,406 ----
      res;
    end method
  );
+ 
+ // Seals for file dylan-dump.dylan
+ 
*** 1.13	96/02/19 20:29:51
--- ./compiler/base/expand.dylan	96/03/11 02:53:28
***************
*** 466,468 ****
--- 466,471 ----
      var;
    end;
  end;
+ 
+ // Seals for file expand.dylan
+ 
*** 1.4	95/12/15 16:16:36
--- ./compiler/base/fragments.dylan	96/03/11 02:53:28
***************
*** 131,133 ****
--- 131,147 ----
  end;
  
  
+ 
+ // Seals for file fragments.dylan
+ 
+ // <fragment> -- subclass of <object>
+ seal generic make(singleton(<fragment>));
+ seal generic initialize(<fragment>);
+ // <piece> -- subclass of <object>
+ seal generic make(singleton(<piece>));
+ seal generic initialize(<piece>);
+ // <balanced-piece> -- subclass of <piece>
+ seal generic make(singleton(<balanced-piece>));
+ // <fragment-tokenizer> -- subclass of <tokenizer>
+ seal generic make(singleton(<fragment-tokenizer>));
+ seal generic initialize(<fragment-tokenizer>);
*** 1.4	96/01/12 00:58:16
--- ./compiler/base/lexenv.dylan	96/03/11 02:53:28
***************
*** 49,51 ****
--- 49,62 ----
      end;
    end;
  end;
+ 
+ // Seals for file lexenv.dylan
+ 
+ // <lexenv> -- subclass of <object>
+ seal generic make(singleton(<lexenv>));
+ seal generic initialize(<lexenv>);
+ // <body-lexenv> -- subclass of <lexenv>
+ seal generic make(singleton(<body-lexenv>));
+ // <binding> -- subclass of <object>
+ seal generic make(singleton(<binding>));
+ seal generic initialize(<binding>);
*** 1.3	96/01/12 00:58:19
--- ./compiler/base/rep.dylan	96/03/11 02:53:30
***************
*** 1,5 ****
  module: representation
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/rep.dylan,v 1.3 96/01/12 00:58:19 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: representation
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/rep.dylan,v 1.3 1996/01/12 00:58:19 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 18,20 ****
--- 18,26 ----
  
  define generic representation-has-bottom-value? (rep :: <representation>)
      => res :: <boolean>;
+ 
+ // Seals for file rep.dylan
+ 
+ // <representation> -- subclass of <object>
+ seal generic make(singleton(<representation>));
+ seal generic initialize(<representation>);
*** 1.9	96/02/21 02:43:02
--- ./compiler/base/names.dylan	96/03/11 02:53:28
***************
*** 104,106 ****
--- 104,120 ----
  add-make-dumper
    (#"generated-name", *compiler-dispatcher*, <generated-name>,
     list(generated-name-description, description:, #f));
+ 
+ // Seals for file names.dylan
+ 
+ // <name> -- subclass of <object>
+ seal generic make(singleton(<name>));
+ seal generic initialize(<name>);
+ // <basic-name> -- subclass of <name>
+ seal generic make(singleton(<basic-name>));
+ // <type-cell-name> -- subclass of <name>
+ seal generic make(singleton(<type-cell-name>));
+ // <method-name> -- subclass of <name>
+ seal generic make(singleton(<method-name>));
+ // <generated-name> -- subclass of <name>
+ seal generic make(singleton(<generated-name>));
*** 1.40	96/03/08 05:30:10
--- ./compiler/base/od-format.dylan	96/03/16 22:48:00
***************
*** 1,5 ****
  Module: od-format
! RCS-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/od-format.dylan,v 1.40 96/03/08 05:30:10 rgs Exp Locker: wlott $
  
  /*
  
--- 1,5 ----
  Module: od-format
! RCS-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/od-format.dylan,v 1.40 96/03/08 05:30:10 rgs Exp Locker: rgs $
  
  /*
  
***************
*** 1303,1309 ****
  
  // Table mapping data unit names to a list of pairs (unit-type . data-unit)
  //
! define variable *data-units* = make(<table>);
  
  
  define /* exported */ class <load-state> (<object>)
--- 1303,1309 ----
  
  // Table mapping data unit names to a list of pairs (unit-type . data-unit)
  //
! define variable *data-units* :: <object-table> = make(<table>);
  
  
  define /* exported */ class <load-state> (<object>)
***************
*** 1880,1886 ****
    let nwords = buffer-word(buffer, state.od-next);
    state.od-next := state.od-next + $word-bytes;
    let res = make(<simple-object-vector>, size: nwords);
!   for (i from 0 below nwords)
      res[i] := buffer-word(buffer, fill-at-least($word-bytes, state));
      state.od-next := state.od-next + $word-bytes;
    end for;
--- 1880,1886 ----
    let nwords = buffer-word(buffer, state.od-next);
    state.od-next := state.od-next + $word-bytes;
    let res = make(<simple-object-vector>, size: nwords);
!   for (i :: <integer> from 0 below nwords)
      res[i] := buffer-word(buffer, fill-at-least($word-bytes, state));
      state.od-next := state.od-next + $word-bytes;
    end for;
***************
*** 2255,2266 ****
  
  // Table mapping classes to <make-info> objects.
  //
! define variable *make-dumpers* = make(<object-table>);
  
  // Keep track of what we've complained about already, so we don't spam
  // the reader with the same warnings
  //
! define variable *classes-I-cant-dump* = make(<object-table>);
  
  // In order to avoid using add-method (so dump-od can be sealed), we have a
  // default method for dump-od which does its own dispatching based on the
--- 2255,2266 ----
  
  // Table mapping classes to <make-info> objects.
  //
! define constant *make-dumpers* :: <object-table> = make(<object-table>);
  
  // Keep track of what we've complained about already, so we don't spam
  // the reader with the same warnings
  //
! define constant *classes-I-cant-dump* :: <object-table> = make(<object-table>);
  
  // In order to avoid using add-method (so dump-od can be sealed), we have a
  // default method for dump-od which does its own dispatching based on the
***************
*** 2412,2414 ****
--- 2412,2452 ----
    end for;
    vec;
  end method invert-registry;
+ 
+ // Seals for file od-format.dylan
+ 
+ // <dump-buffer> -- subclass of <object>
+ seal generic make(singleton(<dump-buffer>));
+ seal generic initialize(<dump-buffer>);
+ // <dump-state> -- subclass of <dump-buffer>
+ seal generic make(singleton(<dump-state>));
+ // <data-unit> -- subclass of <object>
+ seal generic make(singleton(<data-unit>));
+ seal generic initialize(<data-unit>);
+ // <load-state> -- subclass of <object>
+ seal generic make(singleton(<load-state>));
+ seal generic initialize(<load-state>);
+ // <dispatcher> -- subclass of <object>
+ seal generic make(singleton(<dispatcher>));
+ seal generic initialize(<dispatcher>);
+ // <empty-object> -- subclass of <object>
+ seal generic make(singleton(<empty-object>));
+ seal generic initialize(<empty-object>);
+ // <end-object> -- subclass of <object>
+ seal generic make(singleton(<end-object>));
+ seal generic initialize(<end-object>);
+ // <forward-ref> -- subclass of <object>
+ seal generic make(singleton(<forward-ref>));
+ seal generic initialize(<forward-ref>);
+ // <basic-handle> -- subclass of <object>
+ seal generic make(singleton(<basic-handle>));
+ seal generic initialize(<basic-handle>);
+ // <extern-handle> -- subclass of <basic-handle>
+ seal generic make(singleton(<extern-handle>));
+ // <local-handle> -- subclass of <basic-handle>
+ seal generic make(singleton(<local-handle>));
+ // <identity-preserving-mixin> -- subclass of 
+ seal generic make(singleton(<identity-preserving-mixin>));
+ // <make-info> -- subclass of <object>
+ seal generic make(singleton(<make-info>));
+ seal generic initialize(<make-info>);
*** 1.4	96/01/12 00:58:19
--- ./compiler/base/params.dylan	96/03/11 02:53:29
***************
*** 1,5 ****
  module: params
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/params.dylan,v 1.4 96/01/12 00:58:19 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: params
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/params.dylan,v 1.4 1996/01/12 00:58:19 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 11,14 ****
--- 11,17 ----
  
  define constant $maximum-integer
    = lognot($minimum-integer);
+ 
+ 
+ // Seals for file params.dylan
  
*** 1.15	96/02/21 02:44:41
--- ./compiler/base/parse-tree.dylan	96/03/11 02:53:29
***************
*** 1101,1103 ****
--- 1101,1288 ----
  		if (pvarref.patvarref-separator) separator: end,
  		pvarref.patvarref-separator);
  end;
+ 
+ // Seals for file parse-tree.dylan
+ 
+ // <property> -- subclass of <object>
+ seal generic make(singleton(<property>));
+ seal generic initialize(<property>);
+ // <bindings> -- subclass of <token>
+ seal generic make(singleton(<bindings>));
+ seal generic initialize(<bindings>);
+ // <parameter-list> -- subclass of <object>
+ seal generic make(singleton(<parameter-list>));
+ seal generic initialize(<parameter-list>);
+ // <parameter> -- subclass of <object>
+ seal generic make(singleton(<parameter>));
+ seal generic initialize(<parameter>);
+ // <keyword-parameter> -- subclass of <parameter>
+ seal generic make(singleton(<keyword-parameter>));
+ // <method-parse> -- subclass of <source-location-mixin>
+ seal generic make(singleton(<method-parse>));
+ seal generic initialize(<method-parse>);
+ // <property-set> -- subclass of <token>
+ seal generic make(singleton(<property-set>));
+ seal generic initialize(<property-set>);
+ // <use-clause> -- subclass of <object>
+ seal generic make(singleton(<use-clause>));
+ seal generic initialize(<use-clause>);
+ // <export-clause> -- subclass of <object>
+ seal generic make(singleton(<export-clause>));
+ seal generic initialize(<export-clause>);
+ // <create-clause> -- subclass of <object>
+ seal generic make(singleton(<create-clause>));
+ seal generic initialize(<create-clause>);
+ // <for-clause> -- subclass of <object>
+ seal generic make(singleton(<for-clause>));
+ seal generic initialize(<for-clause>);
+ // <for-while-clause> -- subclass of <for-clause>
+ seal generic make(singleton(<for-while-clause>));
+ // <for-var-clause> -- subclass of <for-clause>
+ seal generic make(singleton(<for-var-clause>));
+ // <for-in-clause> -- subclass of <for-var-clause>
+ seal generic make(singleton(<for-in-clause>));
+ // <for-step-clause> -- subclass of <for-var-clause>
+ seal generic make(singleton(<for-step-clause>));
+ // <for-from-clause> -- subclass of <for-var-clause>
+ seal generic make(singleton(<for-from-clause>));
+ // <classopt> -- subclass of <object>
+ seal generic make(singleton(<classopt>));
+ seal generic initialize(<classopt>);
+ // <constituent> -- subclass of <token>
+ seal generic make(singleton(<constituent>));
+ seal generic initialize(<constituent>);
+ // <defining-form> -- subclass of <constituent>
+ seal generic make(singleton(<defining-form>));
+ // <modified-defining-form> -- subclass of <defining-form>
+ seal generic make(singleton(<modified-defining-form>));
+ // <define-class-parse> -- subclass of <modified-defining-form>
+ seal generic make(singleton(<define-class-parse>));
+ // <define-constant-parse> -- subclass of <defining-form>
+ seal generic make(singleton(<define-constant-parse>));
+ // <define-generic-parse> -- subclass of <modified-defining-form>
+ seal generic make(singleton(<define-generic-parse>));
+ // <seal-generic-parse> -- subclass of <defining-form>
+ seal generic make(singleton(<seal-generic-parse>));
+ // <define-library-parse> -- subclass of <defining-form>
+ seal generic make(singleton(<define-library-parse>));
+ // <define-method-parse> -- subclass of <modified-defining-form>
+ seal generic make(singleton(<define-method-parse>));
+ // <define-module-parse> -- subclass of <defining-form>
+ seal generic make(singleton(<define-module-parse>));
+ // <define-variable-parse> -- subclass of <defining-form>
+ seal generic make(singleton(<define-variable-parse>));
+ // <define-parse> -- subclass of <modified-defining-form>
+ seal generic make(singleton(<define-parse>));
+ // <define-bindings-parse> -- subclass of <modified-defining-form>
+ seal generic make(singleton(<define-bindings-parse>));
+ // <define-macro-parse> -- subclass of <defining-form>
+ seal generic make(singleton(<define-macro-parse>));
+ // <define-define-macro-parse> -- subclass of <define-macro-parse>
+ seal generic make(singleton(<define-define-macro-parse>));
+ // <define-define-bindings-macro-parse> -- subclass of <define-macro-parse>
+ seal generic make(singleton(<define-define-bindings-macro-parse>));
+ // <define-statement-macro-parse> -- subclass of <define-macro-parse>
+ seal generic make(singleton(<define-statement-macro-parse>));
+ // <define-function-macro-parse> -- subclass of <define-macro-parse>
+ seal generic make(singleton(<define-function-macro-parse>));
+ // <local-declaration> -- subclass of <constituent>
+ seal generic make(singleton(<local-declaration>));
+ // <let> -- subclass of <local-declaration>
+ seal generic make(singleton(<let>));
+ // <let-handler> -- subclass of <local-declaration>
+ seal generic make(singleton(<let-handler>));
+ // <local> -- subclass of <local-declaration>
+ seal generic make(singleton(<local>));
+ // <expression> -- subclass of <constituent>
+ seal generic make(singleton(<expression>));
+ // <literal-ref> -- subclass of <expression>
+ seal generic make(singleton(<literal-ref>));
+ // <binop-series> -- subclass of <expression>
+ seal generic make(singleton(<binop-series>));
+ // <funcall> -- subclass of <expression>
+ seal generic make(singleton(<funcall>));
+ // <dot> -- subclass of <expression>
+ seal generic make(singleton(<dot>));
+ // <varref> -- subclass of <expression>
+ seal generic make(singleton(<varref>));
+ // <macro-statement> -- subclass of <expression>
+ seal generic make(singleton(<macro-statement>));
+ // <assignment> -- subclass of <expression>
+ seal generic make(singleton(<assignment>));
+ // <begin> -- subclass of <expression>
+ seal generic make(singleton(<begin>));
+ // <bind-exit> -- subclass of <expression>
+ seal generic make(singleton(<bind-exit>));
+ // <for> -- subclass of <expression>
+ seal generic make(singleton(<for>));
+ // <if> -- subclass of <expression>
+ seal generic make(singleton(<if>));
+ // <method-ref> -- subclass of <expression>
+ seal generic make(singleton(<method-ref>));
+ // <mv-call> -- subclass of <expression>
+ seal generic make(singleton(<mv-call>));
+ // <primitive> -- subclass of <expression>
+ seal generic make(singleton(<primitive>));
+ // <uwp> -- subclass of <expression>
+ seal generic make(singleton(<uwp>));
+ // <rule> -- subclass of <object>
+ seal generic make(singleton(<rule>));
+ seal generic initialize(<rule>);
+ // <abstract-define-rule> -- subclass of <rule>
+ seal generic make(singleton(<abstract-define-rule>));
+ // <define-rule> -- subclass of <abstract-define-rule>
+ seal generic make(singleton(<define-rule>));
+ // <define-bindings-rule> -- subclass of <abstract-define-rule>
+ seal generic make(singleton(<define-bindings-rule>));
+ // <statement-rule> -- subclass of <rule>
+ seal generic make(singleton(<statement-rule>));
+ // <function-rule> -- subclass of <rule>
+ seal generic make(singleton(<function-rule>));
+ // <pattern> -- subclass of <object>
+ seal generic make(singleton(<pattern>));
+ seal generic initialize(<pattern>);
+ // <pattern-list> -- subclass of <object>
+ seal generic make(singleton(<pattern-list>));
+ seal generic initialize(<pattern-list>);
+ // <pattern-sequence> -- subclass of <object>
+ seal generic make(singleton(<pattern-sequence>));
+ seal generic initialize(<pattern-sequence>);
+ // <simple-pattern> -- subclass of <object>
+ seal generic make(singleton(<simple-pattern>));
+ seal generic initialize(<simple-pattern>);
+ // <variable-pattern> -- subclass of <simple-pattern>
+ seal generic make(singleton(<variable-pattern>));
+ // <bound-variable-pattern> -- subclass of <simple-pattern>
+ seal generic make(singleton(<bound-variable-pattern>));
+ // <identifier-pattern> -- subclass of <simple-pattern>
+ seal generic make(singleton(<identifier-pattern>));
+ // <literal-pattern> -- subclass of <simple-pattern>
+ seal generic make(singleton(<literal-pattern>));
+ // <otherwise-pattern> -- subclass of <literal-pattern>
+ seal generic make(singleton(<otherwise-pattern>));
+ // <arrow-pattern> -- subclass of <literal-pattern>
+ seal generic make(singleton(<arrow-pattern>));
+ // <details-pattern> -- subclass of <simple-pattern>
+ seal generic make(singleton(<details-pattern>));
+ // <pattern-variable> -- subclass of <simple-pattern>
+ seal generic make(singleton(<pattern-variable>));
+ // <property-list-pattern> -- subclass of <object>
+ seal generic make(singleton(<property-list-pattern>));
+ seal generic initialize(<property-list-pattern>);
+ // <pattern-keyword> -- subclass of <object>
+ seal generic make(singleton(<pattern-keyword>));
+ seal generic initialize(<pattern-keyword>);
+ // <auxiliary-rule-set> -- subclass of <object>
+ seal generic make(singleton(<auxiliary-rule-set>));
+ seal generic initialize(<auxiliary-rule-set>);
+ // <auxiliary-rule> -- subclass of <rule>
+ seal generic make(singleton(<auxiliary-rule>));
+ // <template> -- subclass of <object>
+ seal generic make(singleton(<template>));
+ seal generic initialize(<template>);
+ // <paren-template> -- subclass of <template>
+ seal generic make(singleton(<paren-template>));
+ // <pattern-variable-reference> -- subclass of <object>
+ seal generic make(singleton(<pattern-variable-reference>));
+ seal generic initialize(<pattern-variable-reference>);
*** 1.3	96/02/06 15:42:20
--- ./compiler/base/policy.dylan	96/03/11 02:53:29
***************
*** 1,5 ****
  module: policy
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/policy.dylan,v 1.3 96/02/06 15:42:20 wlott Exp Locker: wlott $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: policy
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/policy.dylan,v 1.3 1996/02/06 15:42:20 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 42,44 ****
--- 42,50 ----
         brevity, brevity:, #f,
         debug, debug:, #f)
  );
+ 
+ // Seals for file policy.dylan
+ 
+ // <policy> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<policy>));
+ seal generic initialize(<policy>);
*** 1.3	96/02/09 20:02:37
--- ./compiler/base/errors.dylan	96/03/11 02:53:28
***************
*** 183,185 ****
--- 183,188 ----
   => res :: <source-location>;
    wot.source-location;
  end method;
+ 
+ // Seals for file errors.dylan
+ 
*** 1.10	95/12/15 16:16:36
--- ./compiler/base/signature.dylan	96/03/11 02:53:30
***************
*** 1,6 ****
  Module: signature
  Description: Method/GF signatures and operations on them
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/signature.dylan,v 1.10 95/12/15 16:16:36 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,6 ----
  Module: signature
  Description: Method/GF signatures and operations on them
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/signature.dylan,v 1.10 1995/12/15 16:16:36 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 97,99 ****
--- 97,108 ----
         required?, required:, #f,
         key-default, default:, #f)
  );
+ 
+ // Seals for file signature.dylan
+ 
+ // <signature> -- subclass of <object>
+ seal generic make(singleton(<signature>));
+ seal generic initialize(<signature>);
+ // <key-info> -- subclass of <object>
+ seal generic make(singleton(<key-info>));
+ seal generic initialize(<key-info>);
*** 1.3	96/02/22 04:43:21
--- ./compiler/base/transdef.dylan	96/03/11 02:53:30
***************
*** 1,5 ****
  module: transformers
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/transdef.dylan,v 1.3 96/02/22 04:43:21 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: transformers
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/transdef.dylan,v 1.3 1996/02/22 04:43:21 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 59,61 ****
--- 59,67 ----
    end if;
  end method transformer-specializers;
  
+ 
+ // Seals for file transdef.dylan
+ 
+ // <transformer> -- subclass of <object>
+ seal generic make(singleton(<transformer>));
+ seal generic initialize(<transformer>);
*** 1.14	96/02/16 03:37:28
--- ./compiler/base/type-dump.dylan	96/03/11 02:53:30
***************
*** 1,6 ****
  Module: type-dump
  Description: OD dump/load methods for type system
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/type-dump.dylan,v 1.14 96/02/16 03:37:28 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,6 ----
  Module: type-dump
  Description: OD dump/load methods for type system
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/type-dump.dylan,v 1.14 1996/02/16 03:37:28 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 204,207 ****
--- 204,210 ----
    list(proxy-for, for:, #f),
    load-external: #t
  );
+ 
+ 
+ // Seals for file type-dump.dylan
  
*** 1.26	96/02/12 01:57:30
--- ./compiler/base/variables.dylan	96/03/11 02:53:31
***************
*** 946,948 ****
--- 946,966 ----
    defn & defn.ct-value;
  end;
  
+ 
+ // Seals for file variables.dylan
+ 
+ // <library> -- subclass of <object>
+ seal generic make(singleton(<library>));
+ seal generic initialize(<library>);
+ // <module> -- subclass of <identity-preserving-mixin>
+ seal generic make(singleton(<module>));
+ seal generic initialize(<module>);
+ // <variable> -- subclass of <object>
+ seal generic make(singleton(<variable>));
+ seal generic initialize(<variable>);
+ // <use> -- subclass of <object>
+ seal generic make(singleton(<use>));
+ seal generic initialize(<use>);
+ // <renaming> -- subclass of <object>
+ seal generic make(singleton(<renaming>));
+ seal generic initialize(<renaming>);
*** 1.27	96/03/02 19:01:13
--- ./compiler/base/base-exports.dylan	96/03/13 03:28:41
***************
*** 1,5 ****
  module: dylan-user
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/base-exports.dylan,v 1.27 96/03/02 19:01:13 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: dylan-user
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/base/RCS/base-exports.dylan,v 1.27 96/03/02 19:01:13 rgs Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 61,67 ****
      import: {<general-integer>, <extended-integer>,
  	     $maximum-integer, ratio,
  	     false-or, one-of, <false>, <true>, ignore,
! 	     $minimum-integer, <byte-character>,
  #if (mindy)
               *debug-output*, main, key-exists?,
  #else
--- 61,67 ----
      import: {<general-integer>, <extended-integer>,
  	     $maximum-integer, ratio,
  	     false-or, one-of, <false>, <true>, ignore,
! 	     $minimum-integer, <byte-character>, $not-supplied,
  #if (mindy)
               *debug-output*, main, key-exists?,
  #else
***************
*** 844,847 ****
--- 844,850 ----
    use representation;
    use od-format;
  end;
+ 
+ 
+ // Seals for file base-exports.dylan
  
*** 1.41	96/03/02 19:01:13
--- ./compiler/cback/heap.dylan	96/03/11 02:59:05
***************
*** 1,5 ****
  module: heap
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/cback/RCS/heap.dylan,v 1.41 96/03/02 19:01:13 rgs Exp Locker: rgs $
  copyright: Copyright (c) 1995, 1996  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: heap
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/cback/RCS/heap.dylan,v 1.41 1996/03/02 19:01:13 rgs Exp rgs $
  copyright: Copyright (c) 1995, 1996  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 393,399 ****
        // Dump-o-rama.  Mark it as dumped, queue it, and flag it as referenced
        // so we don't try to import the name.
        info.const-info-dumped? := #t;
!       push-last(state.object-queue, object);
        heap-object-referenced?(object, state) := #t;
      end if;
      //
--- 393,399 ----
        // Dump-o-rama.  Mark it as dumped, queue it, and flag it as referenced
        // so we don't try to import the name.
        info.const-info-dumped? := #t;
!       push(state.object-queue, object);
        heap-object-referenced?(object, state) := #t;
      end if;
      //
***************
*** 738,744 ****
  	    let stream = state.stream;
  	    // The following ugly code should be immensely faster than
  	    // writing a character at a time to a stream.
! 	    for (i from 0 below str.size)
  	      let char = str[i];
  	      select (char)
  		'\\' =>
--- 738,744 ----
  	    let stream = state.stream;
  	    // The following ugly code should be immensely faster than
  	    // writing a character at a time to a stream.
! 	    for (i :: <integer> from 0 below str.size)
  	      let char = str[i];
  	      select (char)
  		'\\' =>
***************
*** 797,806 ****
      end;
    end;
    spew-instance(specifier-type(#"<union>"), state,
! 		union-members: make(<literal-list>,
  				    contents: mems,
  				    sharable: #t),
! 		union-singletons: make(<literal-list>,
  				       contents: sings,
  				       sharable: #t));
  end;
--- 797,806 ----
      end;
    end;
    spew-instance(specifier-type(#"<union>"), state,
! 		union-members: make(<literal-simple-object-vector>,
  				    contents: mems,
  				    sharable: #t),
! 		union-singletons: make(<literal-simple-object-vector>,
  				       contents: sings,
  				       sharable: #t));
  end;
***************
*** 1156,1162 ****
      let getter = slot.slot-getter;
      let slot-name = getter & getter.variable-name;
      if (getter)
!       for (index from 0 below slots.size by 2)
  	if (slots[index] == slot-name)
  	  let val = slots[index + 1];
  	  if (val)
--- 1156,1162 ----
      let getter = slot.slot-getter;
      let slot-name = getter & getter.variable-name;
      if (getter)
!       for (index :: <integer> from 0 below slots.size by 2)
  	if (slots[index] == slot-name)
  	  let val = slots[index + 1];
  	  if (val)
***************
*** 1191,1193 ****
--- 1191,1206 ----
      slot.slot-init-value;
    end;
  end;
+ 
+ // Seals for file heap.dylan
+ 
+ // <state> -- subclass of <object>
+ seal generic make(singleton(<state>));
+ seal generic initialize(<state>);
+ // <global-state> -- subclass of <state>
+ seal generic make(singleton(<global-state>));
+ // <local-state> -- subclass of <state>
+ seal generic make(singleton(<local-state>));
+ // <extra-label> -- subclass of <object>
+ seal generic make(singleton(<extra-label>));
+ seal generic initialize(<extra-label>);
*** 1.24	96/02/16 18:52:58
--- ./compiler/cback/primemit.dylan	96/03/11 02:59:05
***************
*** 1,5 ****
  module: cback
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/cback/RCS/primemit.dylan,v 1.24 96/02/16 18:52:58 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: cback
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/cback/RCS/primemit.dylan,v 1.24 1996/02/16 18:52:58 wlott Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 1580,1582 ****
--- 1580,1585 ----
  		    stringify("((void *)", object, ')'),
  		    *ptr-rep*, #f, file);
     end);
+ 
+ // Seals for file primemit.dylan
+ 
*** 1.14	96/01/14 18:09:27
--- ./compiler/cback/stackanal.dylan	96/03/11 02:59:05
***************
*** 1,5 ****
--- 1,15 ----
  module: stack-analysis
  
+ // Exports the single function "analize-stack-usage".  This function
+ // walks over the given fer-function-region, compiles info about the
+ // stack contents for each possible execution path, and then condenses
+ // it down in order to return the maximum depth which the stack will
+ // achieve. 
+ //
+ // Note that these functions make extensive use of <list>.  Although
+ // <list> is usually an inferior data structure, this module makes
+ // good use of their data sharing properties, and doesn't actually
+ // *save* any data in <list>s.  It should, therefore, be fine.
  
  define class <state> (<object>)
    slot max-depth :: <integer>, init-value: 0;
***************
*** 275,277 ****
--- 285,293 ----
    end;
  end;
  
+ 
+ // Seals for file stackanal.dylan
+ 
+ // <state> -- subclass of <object>
+ seal generic make(singleton(<state>));
+ seal generic initialize(<state>);
*** 1.9	96/03/02 19:12:12
--- ./compiler/cback/cback-exports.dylan	96/03/11 02:59:04
***************
*** 1,5 ****
  module: dylan-user
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/cback/RCS/cback-exports.dylan,v 1.9 96/03/02 19:12:12 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: dylan-user
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/cback/RCS/cback-exports.dylan,v 1.9 96/03/02 19:12:12 rgs Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 88,91 ****
--- 88,94 ----
    export
      build-global-heap, build-local-heap;
  end;
+ 
+ 
+ // Seals for file cback-exports.dylan
  
*** 1.4	96/01/25 00:30:35
--- ./compiler/main/init.dylan	96/03/11 03:00:48
***************
*** 1,5 ****
  module: init
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/main/RCS/init.dylan,v 1.4 96/01/25 00:30:35 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: init
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/main/RCS/init.dylan,v 1.4 1996/01/25 00:30:35 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 8,10 ****
--- 8,13 ----
  // but that would be too much effort.
  
  #f;
+ 
+ // Seals for file init.dylan
+ 
*** 1.13	96/01/12 14:03:13
--- ./compiler/main/lexer.dylan	96/03/11 03:00:48
***************
*** 1170,1182 ****
      // and then when the state machine jams, we just use that latest
      // accepting state's result.
      // 
!     let contents = lexer.source.contents;
!     let length = contents.size;
      let result-class = #f;
      let result-start = lexer.posn;
      let result-end = #f;
      local
!       method repeat (state, posn)
  	if (state.result)
  	  //
  	  // It is an accepting state, so record the result and where
--- 1170,1182 ----
      // and then when the state machine jams, we just use that latest
      // accepting state's result.
      // 
!     let contents :: <file-contents> = lexer.source.contents;
!     let length :: <integer> = contents.size;
      let result-class = #f;
      let result-start = lexer.posn;
      let result-end = #f;
      local
!       method repeat (state :: <state>, posn :: <integer>)
  	if (state.result)
  	  //
  	  // It is an accepting state, so record the result and where
***************
*** 1222,1228 ****
  	      lexer.line := lexer.line + 1;
  	      lexer.line-start := result-end;
  	    #"end-of-line-comment" =>
! 	      for (i from result-end below length,
  		   until: (contents[i] == as(<integer>, '\n')))
  	      finally
  		result-end := i;
--- 1222,1228 ----
  	      lexer.line := lexer.line + 1;
  	      lexer.line-start := result-end;
  	    #"end-of-line-comment" =>
! 	      for (i :: <integer> from result-end below length,
  		   until: (contents[i] == as(<integer>, '\n')))
  	      finally
  		result-end := i;
***************
*** 1350,1352 ****
--- 1350,1375 ----
  define method unget-token (lexer :: <lexer>, token :: <token>) => ();
    lexer.pushed-tokens := pair(token, lexer.pushed-tokens);
  end;
+ 
+ // Seals for file lexer.dylan
+ 
+ // <feature-token> -- subclass of <token>
+ seal generic make(singleton(<feature-token>));
+ seal generic initialize(<feature-token>);
+ // <feature-if-token> -- subclass of <feature-token>
+ seal generic make(singleton(<feature-if-token>));
+ // <feature-else-if-token> -- subclass of <feature-token>
+ seal generic make(singleton(<feature-else-if-token>));
+ // <feature-else-token> -- subclass of <feature-token>
+ seal generic make(singleton(<feature-else-token>));
+ // <feature-end-token> -- subclass of <feature-token>
+ seal generic make(singleton(<feature-end-token>));
+ // <state> -- subclass of <object>
+ seal generic make(singleton(<state>));
+ seal generic initialize(<state>);
+ // <conditional-state> -- subclass of <object>
+ seal generic make(singleton(<conditional-state>));
+ seal generic initialize(<conditional-state>);
+ // <lexer> -- subclass of <tokenizer>
+ seal generic make(singleton(<lexer>));
+ seal generic initialize(<lexer>);
*** 1.57	96/02/22 17:51:32
--- ./compiler/main/main.dylan	96/03/11 03:00:48
***************
*** 742,744 ****
--- 742,750 ----
  #if (mindy)
  collect-garbage(purify: #t);
  #end
+ 
+ // Seals for file main.dylan
+ 
+ // <unit-info> -- subclass of <object>
+ seal generic make(singleton(<unit-info>));
+ seal generic initialize(<unit-info>);
*** 1.1	94/12/12 13:01:36
--- ./compiler/main/set-module.dylan	96/03/11 03:00:48
***************
*** 1,5 ****
  module: main
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/main/RCS/set-module.dylan,v 1.1 94/12/12 13:01:36 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
--- 1,5 ----
  module: main
! rcs-header: $Header: /users/rgs/hackers/ccomp2/compiler/main/RCS/set-module.dylan,v 1.1 1994/12/12 13:01:36 wlott Exp $
  copyright: Copyright (c) 1994  Carnegie Mellon University
  	   All rights reserved.
  
***************
*** 7,9 ****
--- 7,12 ----
  // picking the module we want for the default current module.
  
  #t;
+ 
+ // Seals for file set-module.dylan
+ 
*** 1.6	96/02/21 02:53:19
--- ./compiler/main/main-exports.dylan	96/03/11 03:00:48
***************
*** 125,127 ****
--- 125,130 ----
    use names;
    use errors;
  end;
+ 
+ // Seals for file main-exports.dylan
+ 
*** 1.10	96/02/21 02:53:00
--- ./compiler/main/autodump.dylan	96/03/11 03:00:47
***************
*** 174,176 ****
--- 174,179 ----
        => error("Unknown component %=", component);
    end select;
  end method autodump;
+ 
+ // Seals for file autodump.dylan
+ 
*** 1.1	95/11/14 13:48:02
--- ./compiler/main/bootstrap-exports.dylan	96/03/11 03:00:47
***************
*** 11,13 ****
--- 11,16 ----
      module-definer, library-definer;
  end;
  
+ 
+ // Seals for file bootstrap-exports.dylan
+ 
*** 1.51	96/02/22 17:50:48
--- ./compiler/main/bootstrap.dylan	96/03/11 03:00:47
***************
*** 696,698 ****
--- 696,815 ----
  // Might as well.
  
  %%primitive magic-internal-primitives-placeholder ();
+ 
+ // Seals for file bootstrap.dylan
+ 
+ // <boolean> -- subclass of <object>
+ seal generic make(singleton(<boolean>));
+ seal generic initialize(<boolean>);
+ // <true> -- subclass of <boolean>
+ seal generic make(singleton(<true>));
+ // <false> -- subclass of <boolean>
+ seal generic make(singleton(<false>));
+ // <function> -- subclass of <object>
+ seal generic make(singleton(<function>));
+ seal generic initialize(<function>);
+ // <closure> -- subclass of <function>
+ seal generic make(singleton(<closure>));
+ // <raw-function> -- subclass of <function>
+ seal generic make(singleton(<raw-function>));
+ // <raw-closure> -- subclass of <raw-function>, <closure>
+ seal generic make(singleton(<raw-closure>));
+ // <method> -- subclass of <function>
+ seal generic make(singleton(<method>));
+ // <accessor-method> -- subclass of <method>
+ seal generic make(singleton(<accessor-method>));
+ // <method-closure> -- subclass of <method>, <closure>
+ seal generic make(singleton(<method-closure>));
+ // <generic-function> -- subclass of <function>
+ seal generic make(singleton(<generic-function>));
+ // <symbol> -- subclass of <object>
+ seal generic make(singleton(<symbol>));
+ seal generic initialize(<symbol>);
+ // <type> -- subclass of <object>
+ seal generic make(singleton(<type>));
+ seal generic initialize(<type>);
+ // <singleton> -- subclass of <type>
+ seal generic make(singleton(<singleton>));
+ // <union> -- subclass of <type>
+ seal generic make(singleton(<union>));
+ // <limited-integer> -- subclass of <type>
+ seal generic make(singleton(<limited-integer>));
+ // <byte-character-type> -- subclass of <type>
+ seal generic make(singleton(<byte-character-type>));
+ // <class> -- subclass of <type>
+ seal generic make(singleton(<class>));
+ // <slot-descriptor> -- subclass of <object>
+ seal generic make(singleton(<slot-descriptor>));
+ seal generic initialize(<slot-descriptor>);
+ // <number> -- subclass of <object>
+ seal generic make(singleton(<number>));
+ // <complex> -- subclass of <number>
+ seal generic make(singleton(<complex>));
+ // <real> -- subclass of <complex>
+ seal generic make(singleton(<real>));
+ seal generic initialize(<real>);
+ // <rational> -- subclass of <real>
+ seal generic make(singleton(<rational>));
+ // <general-integer> -- subclass of <rational>
+ seal generic make(singleton(<general-integer>));
+ // <integer> -- subclass of <general-integer>
+ seal generic make(singleton(<integer>));
+ // <extended-integer> -- subclass of <general-integer>
+ seal generic make(singleton(<extended-integer>));
+ // <float> -- subclass of <real>
+ seal generic make(singleton(<float>));
+ // <single-float> -- subclass of <float>
+ seal generic make(singleton(<single-float>));
+ // <double-float> -- subclass of <float>
+ seal generic make(singleton(<double-float>));
+ // <extended-float> -- subclass of <float>
+ seal generic make(singleton(<extended-float>));
+ // <collection> -- subclass of <object>
+ seal generic make(singleton(<collection>));
+ // <explicit-key-collection> -- subclass of <collection>
+ seal generic make(singleton(<explicit-key-collection>));
+ // <stretchy-collection> -- subclass of <collection>
+ seal generic make(singleton(<stretchy-collection>));
+ // <mutable-collection> -- subclass of <collection>
+ seal generic make(singleton(<mutable-collection>));
+ // <sequence> -- subclass of <collection>
+ seal generic make(singleton(<sequence>));
+ // <mutable-explicit-key-collection> -- subclass of 
+ seal generic make(singleton(<mutable-explicit-key-collection>));
+ // <mutable-sequence> -- subclass of 
+ seal generic make(singleton(<mutable-sequence>));
+ // <array> -- subclass of <mutable-sequence>
+ seal generic make(singleton(<array>));
+ // <vector> -- subclass of <array>
+ seal generic make(singleton(<vector>));
+ // <string> -- subclass of <mutable-sequence>
+ seal generic make(singleton(<string>));
+ // <simple-object-vector> -- subclass of <vector>
+ seal generic make(singleton(<simple-object-vector>));
+ seal generic initialize(<simple-object-vector>);
+ // <unicode-string> -- subclass of <vector>, <string>
+ seal generic make(singleton(<unicode-string>));
+ seal generic initialize(<unicode-string>);
+ // <byte-string> -- subclass of <vector>, <string>
+ seal generic make(singleton(<byte-string>));
+ seal generic initialize(<byte-string>);
+ // <list> -- subclass of <mutable-sequence>
+ seal generic make(singleton(<list>));
+ seal generic initialize(<list>);
+ // <empty-list> -- subclass of <list>
+ seal generic make(singleton(<empty-list>));
+ // <pair> -- subclass of <list>
+ seal generic make(singleton(<pair>));
+ // <character> -- subclass of <object>
+ seal generic make(singleton(<character>));
+ seal generic initialize(<character>);
+ // <value-cell> -- subclass of <object>
+ seal generic make(singleton(<value-cell>));
+ seal generic initialize(<value-cell>);
+ // <raw-pointer> -- subclass of <object>
+ seal generic make(singleton(<raw-pointer>));
+ seal generic initialize(<raw-pointer>);
+ // <catcher> -- subclass of <object>
+ seal generic make(singleton(<catcher>));
+ seal generic initialize(<catcher>);
*** 1.5	95/12/11 00:38:58
--- ./runtime/dylan/copy.dylan	96/03/14 02:54:29
***************
*** 1,4 ****
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/copy.dylan,v 1.5 95/12/11 00:38:58 rgs Exp Locker: rgs $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
--- 1,4 ----
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/copy.dylan,v 1.5 1995/12/11 00:38:58 rgs Exp rgs $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
*** 1.22	96/03/08 05:22:35
--- ./runtime/dylan/func.dylan	96/03/16 05:56:31
***************
*** 1,4 ****
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/func.dylan,v 1.22 96/03/08 05:22:35 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
--- 1,4 ----
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/func.dylan,v 1.22 1996/03/08 05:22:35 rgs Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
***************
*** 367,372 ****
--- 367,373 ----
    = method (self :: <generic-function>, nargs :: <integer>)
        let specializers = self.function-specializers;
        let nfixed = specializers.size;
+       if (nfixed ~== nargs)
          if (self.function-rest? | self.function-keywords)
  	  if (nargs < nfixed)
  	    wrong-number-of-arguments-error(#f, nfixed, nargs);
***************
*** 375,409 ****
  	  odd-number-of-keyword/value-arguments-error();
  	end;
        else
- 	if (nargs ~= nfixed)
  	  wrong-number-of-arguments-error(#t, nfixed, nargs);
  	end;
!       end;
        let arg-ptr :: <raw-pointer> = %%primitive extract-args(nargs);
        let (ordered, ambiguous, valid-keywords)
  	= cached-sorted-applicable-methods(self, nfixed, arg-ptr);
!       if (valid-keywords)
  	for (index :: <integer> from nfixed below nargs by 2)
  	  let key :: <symbol> = %%primitive extract-arg (arg-ptr, index);
! 	  unless (valid-keywords == #"all"
! 		    | member?(key,
! 			      check-type(valid-keywords,
! 					 <simple-object-vector>)))
  	    error("Unrecognized keyword: %=", key);
! 	  end unless;
  	end for;
        end if;
!       if (ambiguous == #())
! 	if (ordered == #())
  	  for (index :: <integer> from 0 below nfixed)
  	    let specializer :: <type> = %element(specializers, index);
  	    let arg = %%primitive extract-arg(arg-ptr, index);
  	    %check-type(arg, specializer);
  	  end;
  	  no-applicable-methods-error();
- 	else
- 	  %%primitive invoke-generic-entry
- 	    (ordered.head, ordered.tail, %%primitive pop-args(arg-ptr));
  	end;
        else
  	for (prev :: false-or(<pair>) = #f then remaining,
--- 376,418 ----
  	    odd-number-of-keyword/value-arguments-error();
  	  end;
          else
  	  wrong-number-of-arguments-error(#t, nfixed, nargs);
          end;
!       end if;
        let arg-ptr :: <raw-pointer> = %%primitive extract-args(nargs);
        let (ordered, ambiguous, valid-keywords)
  	= cached-sorted-applicable-methods(self, nfixed, arg-ptr);
!       if (nargs > nfixed)
!         case 
!           (valid-keywords == #f) => #t;
!           (valid-keywords == #"all") =>
!             for (index :: <integer> from nfixed below nargs by 2)
!               check-type(%%primitive extract-arg(arg-ptr, index), <symbol>);
!             end for;
!           otherwise =>
!             check-type(valid-keywords, <simple-object-vector>);
  	    for (index :: <integer> from nfixed below nargs by 2)
  	      let key :: <symbol> = %%primitive extract-arg (arg-ptr, index);
! 	      block (found)
!                 for (i :: <integer> from 0 below valid-keywords.size)
!                   if (%element(valid-keywords, i) == key) found() end if;
!                 end for;
                  error("Unrecognized keyword: %=", key);
!               end block;
  	    end for;
+         end case;
        end if;
!       if (ambiguous.empty?)
! 	if (~ordered.empty?)
! 	  %%primitive invoke-generic-entry
! 	    (ordered.head, ordered.tail, %%primitive pop-args(arg-ptr));
! 	else
  	  for (index :: <integer> from 0 below nfixed)
  	    let specializer :: <type> = %element(specializers, index);
  	    let arg = %%primitive extract-arg(arg-ptr, index);
  	    %check-type(arg, specializer);
  	  end;
  	  no-applicable-methods-error();
  	end;
        else
  	for (prev :: false-or(<pair>) = #f then remaining,
***************
*** 569,575 ****
  
  define variable *debug-generic-threshold* :: <integer> = -1;
  
! define method cached-sorted-applicable-methods
      (gf :: <generic-function>, nargs :: <integer>,
       arg-ptr :: <raw-pointer>)
   => (ordered :: <list>, ambiguous :: <list>,
--- 578,584 ----
  
  define variable *debug-generic-threshold* :: <integer> = -1;
  
! define inline method cached-sorted-applicable-methods
      (gf :: <generic-function>, nargs :: <integer>,
       arg-ptr :: <raw-pointer>)
   => (ordered :: <list>, ambiguous :: <list>,
***************
*** 653,659 ****
  		   else
  		     specializer;
  		   end if;
! 		 (specializer == <byte-character>) =>
  		   <byte-character>;
  		 otherwise => singleton(arg);
  	       end case;
--- 662,673 ----
  		   else
  		     specializer;
  		   end if;
! 		 // (specializer == <byte-character>) =>
! 		 // The following code works around a bug in the current
! 		 // system.  It seems that there is one "<byte-character>"
! 		 // constant per library, so the equality test above tends to
! 		 // fail.
! 		 (specializer.object-class == <byte-character-type>) =>
  		   <byte-character>;
  		 otherwise => singleton(arg);
  	       end case;
*** 1.8	96/03/08 05:22:35
--- ./runtime/dylan/list.dylan	96/03/14 03:06:11
***************
*** 1,4 ****
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/list.dylan,v 1.8 96/03/08 05:22:35 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
--- 1,4 ----
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/list.dylan,v 1.8 1996/03/08 05:22:35 rgs Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
***************
*** 213,219 ****
      block (return)
        for (slow :: <list> = list.tail then slow.tail,
  	   fast :: <list> = list.tail.tail then fast.tail.tail,
! 	   result from 2 by 2)
  	if (slow == fast)
  	  return(#f);
  	elseif (fast == #())
--- 213,219 ----
      block (return)
        for (slow :: <list> = list.tail then slow.tail,
  	   fast :: <list> = list.tail.tail then fast.tail.tail,
! 	   result :: <integer> from 2 by 2)
  	if (slow == fast)
  	  return(#f);
  	elseif (fast == #())
*** 1.9	96/03/13 03:18:46
--- ./runtime/dylan/string.dylan	96/03/13 23:05:44
***************
*** 1,4 ****
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/string.dylan,v 1.9 96/03/13 03:18:46 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
--- 1,4 ----
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/string.dylan,v 1.9 96/03/13 03:18:46 rgs Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
***************
*** 244,249 ****
--- 244,263 ----
  	     => state-copy :: <integer>;
  	   state;
  	 end);
+ end;
+ 
+ define method \= (str1 :: <byte-string>, str2 :: <byte-string>)
+  => (res :: <boolean>);
+   block (return)
+     if (str1.size ~== str2.size) return(#f) end if;
+     for (char1 in str1, char2 in str2)
+       if (char1 ~== char2)
+ 	return(#f);
+       end if;
+     finally
+       #t;
+     end for;
+   end;
  end;
  
  define method copy-sequence
*** 1.13	96/03/08 05:22:35
--- ./runtime/dylan/type.dylan	96/03/15 22:49:07
***************
*** 1,4 ****
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/type.dylan,v 1.13 96/03/08 05:22:35 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
--- 1,4 ----
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/type.dylan,v 1.13 1996/03/08 05:22:35 rgs Exp rgs $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
***************
*** 35,47 ****
    // List of non-singleton types that make up this union type.  None of these
    // types will be subtype? any of the others and <union> types will be
    // expanded.
!   slot union-members :: <list>, setter: #f,
!     init-value: #(), init-keyword: members:;
    //
    // List of the singletons that are part of this union type.  Note: these are
    // the actual objects, not the singleton types.
!   slot union-singletons :: <list>, setter: #f,
!     init-value: #(), init-keyword: singletons:;
  end;
  
  seal generic make (singleton(<union>));
--- 35,47 ----
    // List of non-singleton types that make up this union type.  None of these
    // types will be subtype? any of the others and <union> types will be
    // expanded.
!   slot union-members :: <simple-object-vector>, setter: #f,
!     init-value: #[], init-keyword: members:;
    //
    // List of the singletons that are part of this union type.  Note: these are
    // the actual objects, not the singleton types.
!   slot union-singletons :: <simple-object-vector>, setter: #f,
!     init-value: #[], init-keyword: singletons:;
  end;
  
  seal generic make (singleton(<union>));
***************
*** 54,61 ****
    //
    // First scan across the types using merge-type to build up the members
    // and singletons list.
!   let members = #();
!   let singletons = #();
    for (type :: <type> in types)
      let (new-members, new-singletons) = merge-type(members, singletons, type);
      members := new-members;
--- 54,61 ----
    //
    // First scan across the types using merge-type to build up the members
    // and singletons list.
!   let members :: <list> = #();
!   let singletons :: <list> = #();
    for (type :: <type> in types)
      let (new-members, new-singletons) = merge-type(members, singletons, type);
      members := new-members;
***************
*** 68,80 ****
      if (~(members == #()) & members.tail == #())
        members.head;
      else
!       make(<union>, members: members);
      end;
    else
      if (members == #() & singletons.tail == #())
        make(<singleton>, object: singletons.head);
      else
!       make(<union>, members: members, singletons: singletons);
      end;
    end;
  end;
--- 68,81 ----
      if (~(members == #()) & members.tail == #())
        members.head;
      else
!       make(<union>, members: as(<simple-object-vector>, members));
      end;
    else
      if (members == #() & singletons.tail == #())
        make(<singleton>, object: singletons.head);
      else
!       make(<union>, members: as(<simple-object-vector>, members),
! 	   singletons: as(<simple-object-vector>, singletons));
      end;
    end;
  end;
***************
*** 823,845 ****
  // all-superclasses.  For effeciency, pick off the case where the two
  // classes are == and we cache the result of the last lookup.
  //
  define method %subtype? (class1 :: <class>, class2 :: <class>)
      => res :: <boolean>;
!   case
!     class1 == class2 =>
!       #t;
!     class1 == class2.subtype-success-cache =>
!       #t;
!     class1 == class2.subtype-failure-cache =>
!       #f;
!     member?(class2, class1.all-superclasses) =>
!       class2.subtype-success-cache := class1;
        #t;
!     otherwise =>
!       class2.subtype-failure-cache := class1;
        #f;
!   end case;
! end;
  
  // %subtype?(<direct-instance>,<type>) -- internal gf method.
  //
--- 824,867 ----
  // all-superclasses.  For effeciency, pick off the case where the two
  // classes are == and we cache the result of the last lookup.
  //
+ // define method %subtype? (class1 :: <class>, class2 :: <class>)
+ //     => res :: <boolean>;
+ //   case
+ //     class1 == class2 =>
+ //       #t;
+ //     class2 == class1.subtype-success-cache =>
+ //       #t;
+ //     class2 == class1.subtype-failure-cache =>
+ //       #f;
+ //     member?(class2, class1.all-superclasses) =>
+ //       class1.subtype-success-cache := class1;
+ //       #t;
+ //     otherwise =>
+ //       class1.subtype-failure-cache := class1;
+ //       #f;
+ //   end case;
+ // end;
+ 
  define method %subtype? (class1 :: <class>, class2 :: <class>)
      => res :: <boolean>;
!   // This could be recoded simply as member(class2, class1.superclasses), but
!   // that would marginally slower, and this is in the critical path.
!   if (class1 == class2)
      #t;
!   else
!     let superclasses = class1.all-superclasses;
!     block (return)
!       for (index :: <integer> from 1 below superclasses.size)
! 	// We skip element 0 because it's the same as class1.
! 	if (%element(superclasses, index) == class2)
! 	  return(#t);
! 	end if;
!       finally
  	#f;
!       end for;
!     end block;
!   end if;
! end method %subtype?;
  
  // %subtype?(<direct-instance>,<type>) -- internal gf method.
  //
*** 1.10	96/03/13 03:18:46
--- ./runtime/dylan/vector.dylan	96/03/15 21:19:07
***************
*** 1,4 ****
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/vector.dylan,v 1.10 96/03/13 03:18:46 rgs Exp Locker: wlott $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
--- 1,4 ----
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/vector.dylan,v 1.10 96/03/13 03:18:46 rgs Exp $
  copyright: Copyright (c) 1995  Carnegie Mellon University
  	   All rights reserved.
  module: dylan-viscera
***************
*** 164,169 ****
--- 164,188 ----
  	 end);
  end;
  
+ define sealed inline method fill!
+     (vec :: <simple-vector>, value :: <object>,
+      #key start :: <integer> = 0, end: end-index :: <integer> = vec.size)
+  => (vec :: <simple-vector>);
+   for (index :: <integer> from start below end-index)
+     vec[index] := value;
+   end for;
+   vec;
+ end method fill!;
+ 
+ define sealed inline method as
+     (class == <simple-object-vector>, vector :: <simple-object-vector>)
+     => res :: <simple-object-vector>;
+   vector;
+ end;
+ 
+ // Perhaps this should be inlined eventually, but at present it
+ // tickles a bug in stack analysis
+ //
  define sealed method as
      (class == <simple-object-vector>, collection :: <collection>)
      => res :: <simple-object-vector>;
***************
*** 174,191 ****
    res;
  end method as;
  
! define inline method as
!     (class == <simple-object-vector>, vector :: <simple-object-vector>)
      => res :: <simple-object-vector>;
!   vector;
  end;
  
- define sealed inline method fill!
-     (vec :: <simple-vector>, value :: <object>,
-      #key start :: <integer> = 0, end: end-index :: <integer> = vec.size)
-  => (vec :: <simple-vector>);
-   for (index :: <integer> from start below end-index)
-     vec[index] := value;
-   end for;
-   vec;
- end method fill!;
--- 193,222 ----
    res;
  end method as;
  
! // This method looks to be unduly specific, but the compiler will
! // generate this case whenever you "apply" a function to a list
! //
! define sealed method as
!     (class == <simple-object-vector>, collection :: <list>)
      => res :: <simple-object-vector>;
!   let res = make(<simple-object-vector>, size: collection.size);
!   for (index :: <integer> from 0, element in collection)
!     res[index] := element;
!   end;
!   res;
! end method as;
! 
! // This method looks to be unduly specific, but the compiler will
! // generate this case whenever you "apply" a function to a strechy vector
! //
! define sealed method as
!     (class == <simple-object-vector>, collection :: <stretchy-object-vector>)
!  => (res :: <simple-object-vector>);
!   let sz = collection.size;
!   let res = make(<simple-object-vector>, size: sz);
!   for (index :: <integer> from 0 below sz)
!     res[index] := collection[index];
!   end;
!   res;
  end;
  
*** 1.3	96/03/02 19:21:08
--- ./runtime/dylan/stretchy.dylan	96/03/15 18:55:34
***************
*** 18,78 ****
    make(<stretchy-object-vector>, size: size, fill: fill);
  end method;
  
- define sealed method as
-     (class == <stretchy-vector>, collection :: <collection>)
-     => res :: <stretchy-vector>;
-   let res = make(<stretchy-vector>, size: collection.size);
-   for (index :: <integer> from 0, element in collection)
-     res[index] := element;
-   end;
-   res;
- end;
- 
- define inline method as
-     (class == <stretchy-vector>, vector :: <stretchy-vector>)
-     => res :: <stretchy-vector>;
-   vector;
- end;
- 
- define method map-into (destination :: <stretchy-vector>,
- 			proc :: <function>, sequence :: <sequence>,
- 			#next next-method, #rest more-sequences)
-     => res :: <stretchy-vector>;
-   if (empty?(more-sequences))
-     let sz = size(sequence);
-     if (sz > size(destination)) size(destination) := sz end if;
-     let data = ssv-data(destination);
-     for (key from 0, elem in sequence)
-       destination[key] := proc(elem);
-     end for;
-     destination;
-   else
-     next-method();
-   end if;
- end method map-into;
- 
  
  // <stretchy-object-vector>
  
! // Invariant:  elements [ssv-fill..ssv-data.size] are always set to
! // #f.  Elements [0..ssv-fill] contain user supplied data.
  //
  define class <stretchy-object-vector> (<stretchy-vector>)
    //
    // A <simple-object-vector> holding the vector elements.  Obviously
    // at least as long as the stretchy vector.
!   slot ssv-data :: <simple-object-vector>,
!     required-init-keyword: data:;
    //
    // The current size of the stretchy vector.
!   slot ssv-fill :: <integer>,
!     required-init-keyword: fill:;
  end class <stretchy-object-vector>;
    
! 
! define sealed method make (class == <stretchy-object-vector>,
! 			   #next next-method, #key size = 0, fill)
!     => res :: <stretchy-object-vector>;
    let data-size = case
  		    size < 0 =>
  		      error("size: can't be negative.");
--- 18,45 ----
    make(<stretchy-object-vector>, size: size, fill: fill);
  end method;
  
  
  // <stretchy-object-vector>
  
! // Invariants:
! //   1. ssv-current-size <= ssv-data.size
! //   2. elements [ssv-current-size..ssv-data.size] are always set to #f.  
! //   3. Elements [0..ssv-current-size] contain user supplied data.
  //
  define class <stretchy-object-vector> (<stretchy-vector>)
    //
    // A <simple-object-vector> holding the vector elements.  Obviously
    // at least as long as the stretchy vector.
!   slot ssv-data :: <simple-object-vector> = #[];
    //
    // The current size of the stretchy vector.
!   slot ssv-current-size :: <integer> = 0;
  end class <stretchy-object-vector>;
+ seal generic make(singleton(<stretchy-object-vector>));
  
! define sealed method initialize
!     (object :: <stretchy-object-vector>, #key size :: <integer> = 0, fill)
!  => ();
    let data-size = case
  		    size < 0 =>
  		      error("size: can't be negative.");
***************
*** 85,107 ****
  		    otherwise =>
  		      ceiling/(size + 1024, 1024) * 1024;
  		  end case;
!   let data = make(<simple-object-vector>, size: data-size);
!   fill!(data, fill, end: data-size);
!   next-method(class, fill: size, data: data);
! end method make;
  
! define inline method size (ssv :: <stretchy-object-vector>)
      => size :: <integer>;
!   ssv-fill(ssv);
  end method size;
  
  define method size-setter
      (new :: <integer>, ssv :: <stretchy-object-vector>)
      => new :: <integer>;
!   let fill = ssv-fill(ssv);
!   let data = ssv-data(ssv);
!   if (new > fill)
!     let len = size(data);
      if (new > len)
        let new-len = if (new < 1024)
  		      for (new-len = 16 then new-len * 2,
--- 52,78 ----
  		    otherwise =>
  		      ceiling/(size + 1024, 1024) * 1024;
  		  end case;
!   // The "fill:" keyword assures that elements above ssv-current-size
!   // will be #f...
!   let data = make(<simple-object-vector>, size: data-size, fill: #f);
!   // ...and then we manually fill the other elements if necessary.
!   if (fill) fill!(data, fill, end: size) end if;
!   object.ssv-data := data;
!   object.ssv-current-size := size;
! end method initialize;
  
! define sealed inline method size (ssv :: <stretchy-object-vector>)
      => size :: <integer>;
!   ssv.ssv-current-size;
  end method size;
  
  define method size-setter
      (new :: <integer>, ssv :: <stretchy-object-vector>)
      => new :: <integer>;
!   let current = ssv.ssv-current-size;
!   let data = ssv.ssv-data;
!   if (new > current)
!     let len = data.size;
      if (new > len)
        let new-len = if (new < 1024)
  		      for (new-len = 16 then new-len * 2,
***************
*** 112,175 ****
  		      ceiling/(new + 1024, 1024) * 1024;
  		    end if;
        let new-data = make(<simple-object-vector>, size: new-len);
!       for (index :: <integer> from 0 below fill)
  	new-data[index] := data[index];
        end for;
!       ssv.ssv-data := fill!(new-data, #f, start: fill);
      end if;
    else
!     fill!(data, #f, start: new, end: fill);
    end if;
!   ssv-fill(ssv) := new;
  end method size-setter;
  
  
! define method element
      (ssv :: <stretchy-object-vector>, key :: <integer>,
       #key default = $not-supplied)
      => result :: <object>;
    case
!     key >= 0 & key < size(ssv) =>
!       ssv-data(ssv)[key];
!     default == $not-supplied =>
        element-error(ssv, key);
      otherwise =>
        default;
    end case;
  end method element;
  
! define method element-setter (value, ssv :: <stretchy-object-vector>,
! 			      key :: <integer>)
      => value :: <object>;
    if (key < 0)
      element-error(ssv, key);
    else
!     if (key >= size(ssv))
!       size(ssv) := key + 1;
      end if;
!     ssv-data(ssv)[key] := value;
    end if;
  end method element-setter;
  
  define method add! (ssv :: <stretchy-object-vector>, new-element)
      => ssv :: <stretchy-object-vector>;
!   let data = ssv-data(ssv);
!   let fill = size(ssv);
!   if (fill = size(data))
!     let data-size = if (fill < 1024)
! 		      fill * 2;
  		    else 
! 		      fill + 1024;
  		    end if;
      let new-data = replace-subsequence!(make(<simple-object-vector>,
  					     size: data-size),
! 					data, end: fill);
!     ssv-data(ssv) := new-data;
!     new-data[fill] := new-element;
    else 
!     data[fill] := new-element;
    end if;
!   ssv-fill(ssv) := fill + 1;
    ssv;
  end method add!;
  
--- 83,195 ----
  		      ceiling/(new + 1024, 1024) * 1024;
  		    end if;
        let new-data = make(<simple-object-vector>, size: new-len);
!       for (index :: <integer> from 0 below current)
  	new-data[index] := data[index];
        end for;
!       ssv.ssv-data := fill!(new-data, #f, start: current);
      end if;
    else
!     fill!(data, #f, start: new, end: current);
    end if;
!   ssv.ssv-current-size := new;
  end method size-setter;
  
  
! define sealed inline method element
      (ssv :: <stretchy-object-vector>, key :: <integer>,
       #key default = $not-supplied)
      => result :: <object>;
    case
!     (key >= 0 & key < ssv.size) =>
!       // Warning: unchecked reference.  However, if we're *sure* we
!       // satisfy the invariants, we're be safe.
!       %element(ssv.ssv-data, key);
!     (default == $not-supplied) =>
        element-error(ssv, key);
      otherwise =>
        default;
    end case;
  end method element;
  
! define sealed inline method element-setter
!     (value, ssv :: <stretchy-object-vector>, key :: <integer>)
      => value :: <object>;
    if (key < 0)
      element-error(ssv, key);
    else
!     if (key >= ssv.size)
!       ssv.size := key + 1;
      end if;
!     // Warning: unchecked reference.  However, if we're *sure* we
!     // satisfy the invariants, we're be safe.
!     %element(ssv.ssv-data, key) := value;
    end if;
  end method element-setter;
  
+ // This method is identical to the one in "array.dylan", except that it
+ // is more tightly specialized to a single sealed class.  If you need to 
+ // make a general change, you should probably grep for "outlined-iterator" 
+ // and change all matching locations.
+ //
+ define inline method forward-iteration-protocol
+     (array :: <stretchy-object-vector>)
+     => (initial-state :: <integer>,
+ 	limit :: <integer>,
+ 	next-state :: <function>,
+ 	finished-state? :: <function>,
+ 	current-key :: <function>,
+ 	current-element :: <function>,
+ 	current-element-setter :: <function>,
+ 	copy-state :: <function>);
+   values(0,
+ 	 array.size,
+ 	 method (array :: <stretchy-object-vector>, state :: <integer>)
+ 	     => new-state :: <integer>;
+ 	   state + 1;
+ 	 end,
+ 	 method (array :: <stretchy-object-vector>, state :: <integer>,
+ 		 limit :: <integer>)
+ 	     => done? :: <boolean>;
+ 	   state == limit;
+ 	 end,
+ 	 method (array :: <stretchy-object-vector>, state :: <integer>)
+ 	     => key :: <integer>;
+ 	   state;
+ 	 end,
+ 	 method (array :: <stretchy-object-vector>, state :: <integer>)
+ 	     => element :: <object>;
+ 	   element(array, state);
+ 	 end,
+ 	 method (new-value :: <object>, array :: <stretchy-object-vector>,
+ 		 state :: <integer>)
+ 	     => new-value :: <object>;
+ 	   element(array, state) := new-value;
+ 	 end,
+ 	 method (array :: <stretchy-object-vector>, state :: <integer>)
+ 	     => state-copy :: <integer>;
+ 	   state;
+ 	 end);
+ end;
+ 
  define method add! (ssv :: <stretchy-object-vector>, new-element)
      => ssv :: <stretchy-object-vector>;
!   let data = ssv.ssv-data;
!   let current = ssv.size;
!   if (current == data.size)
!     let data-size = if (current < 1024)
! 		      current * 2;
  		    else 
! 		      current + 1024;
  		    end if;
      let new-data = replace-subsequence!(make(<simple-object-vector>,
  					     size: data-size),
! 					data, end: current);
!     ssv.ssv-data := new-data;
!     new-data[current] := new-element;
    else 
!     data[current] := new-element;
    end if;
!   ssv.ssv-current-size := current + 1;
    ssv;
  end method add!;
  
***************
*** 178,192 ****
  		            count :: false-or(<integer>))
      => ssv :: <stretchy-object-vector>;
    unless (count & (count == 0))
!     let data = ssv-data(ssv);
!     let sz = size(ssv);
      local
        method copy (src :: <integer>, dst :: <integer>,
  		   deleted :: <integer>)
  	  => ();
  	case
  	  src == sz =>
! 	    ssv-fill(ssv) := sz - deleted;
  	  otherwise =>
  	    data[dst] := data[src];
  	    copy(src + 1, dst + 1, deleted);
--- 198,212 ----
  		            count :: false-or(<integer>))
      => ssv :: <stretchy-object-vector>;
    unless (count & (count == 0))
!     let data = ssv.ssv-data;
!     let sz = ssv.size;
      local
        method copy (src :: <integer>, dst :: <integer>,
  		   deleted :: <integer>)
  	  => ();
  	case
  	  src == sz =>
! 	    ssv.ssv-current-size := sz - deleted;
  	  otherwise =>
  	    data[dst] := data[src];
  	    copy(src + 1, dst + 1, deleted);
***************
*** 196,202 ****
  			      deleted :: <integer>)
  	  => ();
  	if (src == sz)
! 	  ssv-fill(ssv) := sz - deleted;
  	else 
  	  let this-element = data[src];
  	  case
--- 216,222 ----
  			      deleted :: <integer>)
  	  => ();
  	if (src == sz)
! 	  ssv.ssv-current-size := sz - deleted;
  	else 
  	  let this-element = data[src];
  	  case
***************
*** 231,233 ****
--- 251,291 ----
    end unless;
    ssv;
  end method remove!;
+ 
+ define sealed method as
+     (class == <stretchy-vector>, collection :: <collection>)
+  => (res :: <stretchy-object-vector>);
+   let res = make(<stretchy-object-vector>, size: collection.size);
+   for (index :: <integer> from 0, element in collection)
+     res[index] := element;
+   end;
+   res;
+ end;
+ 
+ define inline method as
+     (class == <stretchy-vector>, vector :: <stretchy-vector>)
+  => (res :: <stretchy-vector>);
+   vector;
+ end;
+ 
+ define method map-into (destination :: <stretchy-object-vector>,
+ 			proc :: <function>, sequence :: <sequence>,
+ 			#next next-method, #rest more-sequences)
+     => res :: <stretchy-vector>;
+   if (empty?(more-sequences))
+     let sz = size(sequence);
+     if (sz == #f)
+       error("Cannot map unbounded sequences into stretchy-vectors.");
+     elseif (sz > size(destination))
+       size(destination) := sz
+     end if;
+     let data = ssv-data(destination);
+     for (key :: <integer> from 0, elem in sequence)
+       destination[key] := proc(elem);
+     end for;
+     destination;
+   else
+     next-method();
+   end if;
+ end method map-into;
+ 
*** 1.8	96/03/13 03:18:46
--- ./runtime/dylan/table.dylan	96/03/16 23:06:44
***************
*** 1,6 ****
  module:	    dylan-viscera
  Author:	    Nick Kramer (nkramer@cs.cmu.edu)
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/table.dylan,v 1.8 96/03/13 03:18:46 rgs Exp Locker: wlott $
  Synopsis:   Implements <table>, <object-table>, <equal-table>, 
              and <value-table>.
  
--- 1,6 ----
  module:	    dylan-viscera
  Author:	    Nick Kramer (nkramer@cs.cmu.edu)
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/dylan/RCS/table.dylan,v 1.8 96/03/13 03:18:46 rgs Exp $
  Synopsis:   Implements <table>, <object-table>, <equal-table>, 
              and <value-table>.
  
***************
*** 512,525 ****
    end for;
  end method string-hash;
  
! define method table-protocol (ht :: <object-table>) 
   => (key-test :: <function>, key-hash :: <function>);
    values(\==, object-hash);
  end method table-protocol;
  
  seal generic table-protocol (<simple-object-table>);
  
! define sealed method table-protocol (ht :: <equal-table>) 
   => (key-test :: <function>, key-hash :: <function>);
    values(\=, equal-hash);
  end method table-protocol;
--- 512,526 ----
    end for;
  end method string-hash;
  
! define sealed inline method table-protocol (ht :: <object-table>) 
   => (key-test :: <function>, key-hash :: <function>);
    values(\==, object-hash);
  end method table-protocol;
  
+ // Just in case we decide to unseal the above method
  seal generic table-protocol (<simple-object-table>);
  
! define sealed inline method table-protocol (ht :: <equal-table>) 
   => (key-test :: <function>, key-hash :: <function>);
    values(\=, equal-hash);
  end method table-protocol;
*** 1.10	96/02/21 02:39:22
--- ./runtime/print/print.dylan	96/03/15 19:22:42
***************
*** 2,8 ****
  author: chiles@cs.cmu.edu
  synopsis: This file implements object printing.
  copyright: See below.
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/print/RCS/print.dylan,v 1.10 96/02/21 02:39:22 wlott Exp Locker: wlott $
  
  //======================================================================
  //
--- 2,8 ----
  author: chiles@cs.cmu.edu
  synopsis: This file implements object printing.
  copyright: See below.
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/print/RCS/print.dylan,v 1.10 1996/02/21 02:39:22 wlott Exp $
  
  //======================================================================
  //
***************
*** 962,969 ****
    let singletons = type.union-singletons;
    local
      method print-singletons (stream :: <stream>)
!       if (singletons.tail == #())
! 	print-specializer(singleton(singletons.head), stream);
        else
  	pprint-logical-block
  	  (stream,
--- 962,969 ----
    let singletons = type.union-singletons;
    local
      method print-singletons (stream :: <stream>)
!       if (singletons.size == 1)
! 	print-specializer(singleton(singletons.first), stream);
        else
  	pprint-logical-block
  	  (stream,
***************
*** 980,987 ****
  	   suffix: ")");
        end if;
      end method print-singletons;
!   if (members == #())
!     if (singletons == #())
        write("{empty type}", stream);
      else
        print-singletons(stream);
--- 980,987 ----
  	   suffix: ")");
        end if;
      end method print-singletons;
!   if (members.empty?)
!     if (singletons.empty?)
        write("{empty type}", stream);
      else
        print-singletons(stream);
***************
*** 999,1005 ****
  		 end unless;
  		 print-specializer(member, stream);
  	       finally
! 		 unless (singletons == #())
  		   unless (first?)
  		     write(", ", stream);
  		     pprint-newline(#"fill", stream);
--- 999,1005 ----
  		 end unless;
  		 print-specializer(member, stream);
  	       finally
! 		 unless (singletons.empty?)
  		   unless (first?)
  		     write(", ", stream);
  		     pprint-newline(#"fill", stream);
*** 1.5	96/02/21 02:39:59
--- ./runtime/format/format.dylan	96/03/13 16:42:58
***************
*** 2,8 ****
  author: chiles@cs.cmu.edu
  synopsis: This file implements a simple mechanism for formatting output.
  copyright: See below.
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/format/RCS/format.dylan,v 1.5 96/02/21 02:39:59 wlott Exp Locker: wlott $
  
  //======================================================================
  //
--- 2,8 ----
  author: chiles@cs.cmu.edu
  synopsis: This file implements a simple mechanism for formatting output.
  copyright: See below.
! rcs-header: $Header: /users/rgs/hackers/ccomp2/runtime/format/RCS/format.dylan,v 1.5 1996/02/21 02:39:59 wlott Exp $
  
  //======================================================================
  //
***************
*** 229,235 ****
      (char :: <byte-character>, bd :: <buffer-desc>, arg)
      => consumed-arg? :: <boolean>;
    let stream = bd.stream;
!   select (char by \=)
      ('s'), ('S') =>
        if (instance?(arg, <byte-string>))
  	// Simulate "write-message" upon the argument.  This code must be
--- 229,235 ----
      (char :: <byte-character>, bd :: <buffer-desc>, arg)
      => consumed-arg? :: <boolean>;
    let stream = bd.stream;
!   select (char by \==)
      ('s'), ('S') =>
        if (instance?(arg, <byte-string>))
  	// Simulate "write-message" upon the argument.  This code must be