* Bump fasl version for release
 * src/bootfiles/20c/boot-20d.lisp
   * Boot file for building the release with a new fasl version.

A normal build can be done using boot-20c.lisp.

entries with just the file path, removing the revision number, date,
author and state.  The actual information is now computed during
compilation and stored in the fasl itself.  (See ticket:48.)

let's update the fasl version to 20b.

To build this, use boot-2010-07-1-cross as the cross-compile script
and -B src/bootfiles/20a/boot-2010-07-1.lisp for cross-build-world.sh.

If there are any restarts, choose the clobber-it restart.

bootfiles/20a/boot-20b.lisp:
o Bootstrap the change to fasl version 20b.

bootfiles/20a/boot-2010-07-1.lisp:
o Load boot-20b.lisp.

compiler/byte-comp.lisp:
o Update byte-fasl-file-version to 20b.

may get confused with source locations if the reader macros are
installed.

boot-2010-02-1 as the bootstrap file.  You should probably also use
the new -P option for build.sh to generate and update the po files
while building.

unicode-utf16-extfmt-2009-06-11.

change.  No cross-compile needed.

compiler/byte-comp.lisp:
o Update version

bootfiles/19c/boot-19d.lisp:
o Boot file for updating the fasl version.  Use this if building from
  a snapshot.  Or you can use a 19d build for this.

bootfiles/boot-19c.lisp:
o Bootfile for 19c.

compiler/byte-comp.lisp:
o Make the fasl file version #x19c

tools/build.sh:
o Update bootfile directory to 19b.

Use boot-19c.lisp to bootstrap this change.

Use boot-19b.lisp to bootstrap this change.

		(declare (notinline 1+))
		(declare (optimize (speed 0)))
		(declare (optimize (debug 0)))
		(unwind-protect
		    (block b5 (1+ (unwind-protect
	                           (if a (return-from b5 -30179678) c)))))))
	 => assertion failed (EQUAL (C::BYTE-BLOCK-INFO-START-STACK
	                            EXTENSIONS:INFO)

	* src/compiler/byte-comp.lisp (walk-block): #+nil an
	assertion.  Reported by Paul Dietz.

	                  '(lambda (a b c)
	                      (declare (optimize (speed 0) (debug 0)))
	                        (logcount
	                          (let ((v3 (if a (block b3 a) b)))
	                          c))))
	         46611128 -69 -133775)
	=> segmentation violation

	* src/compiler/byte-comp.lisp (output-branch): Always emit
	conditional branches even if they go to the following instruction,
	because conditional branches have the side effect of popping the
	eval stack.  Reported by Paul Dietz.

Use boot18 to bootstrap this change.

	byte-fasl-file-version.

	* src/code/sysmacs.lisp (register-lisp-runtime-feature):
	(register-lisp-feature): Don't quote the given feature.

	* src/code/misc.lisp: Register more features, mostly for sparc.

	delete argument type checks in safe code; see also the
	comment there.

	of two-arg-+.

	* src/compiler/byte-comp.lisp (generate-byte-code-for-ref):
	Don't use two-arg versions for mv-combinations.

	bootstrapping.

	* src/bootfiles/18e/boot16.lisp: New file.

	* src/docs/cmu-user/extensions.tex (Dynamic-Extent Declarations):
	New section.

	* src/compiler/x86/macros.lisp (dynamic-extent-allocation):
	Rename from stack-allocation, save an instruction.
	(allocation): Don't call trust-dynamic-extent-declaration-p.

	* src/compiler/x86/alloc.lisp (%dynamic-extent-start)
	(%dynamic-extent-end): New vops.
	(list-or-list*): Add constant arg dynamic-extent.
	(fixed-alloc): Likewise.

	* src/compiler/generic/vm-ir2tran.lisp (do-fixed-alloc): Call
	fixed-alloc with dynamic-extent arg.

	* src/compiler/hppa/alloc.lisp (%dynamic-extent-start)
	(%dynamic-extent-end): Add dummy vops.
	* src/compiler/mips/alloc.lisp:
	* src/compiler/ppc/alloc.lisp:
	* src/compiler/alpha/alloc.lisp:
	* src/compiler/rt/alloc.lisp: Likewise.

	* src/compiler/seqtran.lisp (mapper-transform): Add dynamic-extent
	declarations.

	* src/compiler/node.lisp (continuation): Add slot
	dynamic-extent.
	(cleanup): Add :dynamic-extent to type of slot kind.

	* src/compiler/knownfun.lisp (dynamic-extent-closure-safe):
	New attribute.

	* src/compiler/ir2tran.lisp (ir2-stack-allocate): New function.
	(ir2-convert-closure): Handle dynamic-extent case differently.
	(%dynamic-extent, %dynamic-extent-start, %dynamic-extent-end)
	<ir2-convert>: New optimizers.
	(list, list*): Handle dynamic-extent.

	* src/compiler/ir1tran.lisp (*trust-dynamic-extent-declarations*)
	(*dynamic-extent-trace*): New variables.
	(trust-dynamic-extent-declaration-p): New function.
	(process-dynamic-extent-declaration)
	(dynamic-extent-allocation-p, dynamic-extent-closure-args)
	(gen-%dynamic-extent, with-dynamic-extent): New functions/macros.
	(ir1-convert-combination): Handle dynamic-extent closure args.
	(ir1-convert-combination-args): Add arg dynamic-extent-args.
	Set continuation-dynamic-extent for these args.
	(process-dynamic-extent-declaration): Rewritten.
	(ir1-convert-dynamic-extent-bindings): New function.
	(ir1-convert-special-bindings): Call it.
	(ir1-convert-lambda-body): Handle dynamic-extent rest lists.
	(let): Handle dynamic-extent vars.
	(let*): Call ir1-convert-dynamic-extent-bindings.

	* src/compiler/globaldb.lisp (*trust-dynamic-extent-declarations*)
	(trust-dynamic-extent-declaration-p): Remove.

	* src/compiler/fndb.lisp: Add dynamic-extent-closure-safe
	attribute to assorted functions.

	* src/compiler/envanal.lisp (environment-analyze): Call
	find-dynamic-extent-safe-closures.
	(emit-cleanups): Handle :dynamic-extent cleanups.
	(*suppress-dynamic-extent-closure-safe*): New variable.
	(mark-dynamic-extent-safe-closures)
	(find-dynamic-extent-safe-closures): New functions.

	* src/compiler/byte-comp.lisp (compute-produces-and-consumes):
	Treat :dynamic-extent like :tagbody cleanups.

	* src/code/exports.lisp ("C"): Export ir2-stack-allocate,
	%dynamic-extent, %dynamic-extent-start, %dynamic-extent-end.

	* src/code/byte-interp.lisp (%dynamic-extent):
	(%dynamic-extent-start, %dynamic-extent-end): New functions.
	(toplevel): Enable block compilation.

	simple-program-error.

	* src/compiler/byte-comp.lisp (annotate-full-call): "Inline"
	slot accessors only if they are called with the right number
	of arguments.

	:expected-type, which lead to the conditions which were not
	displayable because the corresponding condition slots are
	not bound.

	* src/code/seq.lisp (coerce):
	* src/code/list.lisp (nreconc):
	* src/code/interr.lisp (invalid-array-index-error):
	* src/code/bignum.lisp (bignum-to-float):
	* src/code/byte-interp.lisp (%byte-car, %byte-cdr): Fix
	type-errors to include :datum and/or :expected-type.

	Add &more handling to the byte-compiler and -interpreter.
	Reported by Paul Werkowski on cmucl-imp.

	* src/compiler/byte-comp.lisp (make-xep-for): Handle &more.

	* src/code/byte-interp.lisp (hairy-byte-function): Change
	type of rest-arg-p slot.
	(invoke-xep): Handle &more.

 The LAMBDA-ENVIRONMENT of a node is sometimes nil.

preparation for the 18e release. This change makes it necessary to
intervene during the rebuild: when loading the FASL files, a
continuable error related to fasl-file-version mismatch will be
signalled. Say

   (setq cl::*skip-fasl-file-version-check* t)

then select the CONTINUE restart, and the build should proceed without
problems.

The function GENERATE-BYTE-CODE-FOR-REF is calling COMBINATION-ARGS on
the return value of CONTINUATION-DEST. In the situation that I have
run into, the return value is of type MV-COMBINATION instead of
COMBINATION, so an error occurs.

Changing the COMBINATION-ARGS to BASIC-COMBINATION-ARGS seems to fix
the problem...

  - change the FASL file format to store fasl-file version as uint32,
    rather than a single octet. This requires small changes to the
    FASL dumper and two FOP functions
  - change the FASL-FILE-FORMAT to #x18d for each of the backends
  - change the byte-code version number to #x18d
  - make the FASL file version checking errors continuable
  - add a variable CL::*SKIP-FASL-FILE-VERSION-CHECK* that avoids the
    version check
  - add a bootfile that bootstraps this change

Loading an old FASL file results in the following behaviour:

,----
| Error in function COMMON-LISP::CHECK-VERSION:
|    #<Stream for file "/usr/local/lib/cmucl/lib/subsystems/defsystem-library.x86f">
|    was compiled for fasl-file version 3E3F02, but this is version 18D
| Restarts:
|   0: [CONTINUE] Load #<Stream for file "/usr/local/lib/cmucl/lib/subsystems/defsystem-library.x86f"> anyway
|   1:            Return NIL from load of #p"modules:defsystem-library".
|   2:            Return NIL from load of "home:.cmucl-init".
|   3: [ABORT   ] Skip remaining initializations.
`----

  variable with no refs since the compiler deletes such variables.

EQLness must be preserved, and the IR1 stage does not emit a
make-load-form for named constants so dumping them may fail.

It is a benign revision as no structures are redefined. At some later
point the definitions in compiler/objdef could be removed, perhaps
in sync with some other type change.

the byte compiler - a necessary branch was being flushed.

inline functions or slot accessors as though they were non-mv calls.

NATIVE-COMPILE-COMPONENT) to ensure that cleanup code has block numbers.
Also added some MAYBE-MUMBLE calls for *COMPILE-PROGRESS*.
 

changes were needed:
  -- make NLX entry blocks look like successors of the
     corresponding entry block in life analysis.  This makes sure that any
     values live only at the NLX entry point are seen to be live at the place
     where the catcher is created.
  -- Push a :NLX-ENTRY marker on the stack when we are doing the simulation and
     we come to a place where we are going to recurse in the byte interpreter
     to create a catcher.  The marker protects values underneath it from being
     considered dead.  When we come to the corresponding breakup, we remove the
     marker.

compute the number of args.  Added push-n-under to disassembler.