Merge commit 'e20d7001c3f7150400169fecb0bf0eefdf122fe2' into vm-check

Conflicts:

libguile/stacks.c

fix marking of double-cell subrs

* libguile/gc-mark.c (scm_gc_mark_dependencies): Mark the name, generic,
  and properties of subrs.

Merge commit 'e092357058850a6f998bf462bdc5504c6379c96f' into vm-check

Merge commit 'feccd2d3100fd2964d4c2df58ab3da7ce4949a66' into vm-check

Merge commit 'cce8b2ce93703aff953750fb40cb53176ea66504' into vm-check

Merge commit '4c9e29ec38350a5206aa3e8e72ad4376512ada2b' into vm-check

Merge commit 'ad5f5ada1d50ecdab634d60ffe3a13b9193156aa' into vm-check

Merge commit '95a040cd2be7ad03bf197edbdb1fec2c52749ef6' into vm-check

Merge commit '6290d3f10927f887102a164ccb1a7291cc62288d' into vm-check

Merge commit '5bb2d903b9e54fdd5858a16ba11fa91a9dc0c692' into vm-check

Merge commit '04795a1cb259c20896fb2edb50c58086027281b0' into vm-check

Merge commit '202271f291971cf14175f5a1a193955f72d43d79' into vm-check

Merge commit 'c010924a71f942100dc7b4021d5ef1c6decf9c85' into vm-check

Merge commit '53d81399bef1d9396665e79fb6b9c25eb8e2a6ad' into vm-check

Also cherry-picks the changes from 1405f1b60fa178303484cd428068ecd01ff6d322

Conflicts:

module/ice-9/session.scm

Merge commit 'ab878b0f8e675a741a7dd56f52638a7cc0419907' into vm-check

Merge commit 'cbee5075d69cb057c4af4c5e24319da90367897f' into vm-check

Merge commit '32a2609de06af65341e6b4db6961557b788821e8' into vm-check

Merge commit 'e95d11110b7af0f528404d28209c3a464ab7074d' into vm-check

Merge commit '752be95a475132506c35922d284884cf776149d0' into vm-check

Conflicts:

INSTALL

Merge commit '8b0174c879bf74981efe702a00471ed5b8e6912e' into vm-check

revert annotation support in syncase. another day perhaps.

* module/ice-9/syncase.scm: Revert support for annotations, as I'm seeing
  wierd problems whereby syntax-object->datum does not fully strip its
  input.

Fix errors when stripping annotations

* module/ice-9/annotate.scm (set-annotation-stripped!): Fix prototype to
  correspond to what syncase needs.

* module/ice-9/psyntax.scm (strip-annotation): Use `if', not `when', for
  portability.

* module/ice-9/psyntax-pp.scm: Regenerate.

actually use syncase's source information tracking. rock!

* module/ice-9/annotate.scm (deannotate/source-properties): Version of
  deannotate that sets source properties on the resulting expressions.

* module/ice-9/syncase.scm (sc-macro, syncase): Annotate expressions
  before they go into syncase, and deannotate/source-properties when they
  come out. The upshot is that syncase now understands source
  information, yay!

modify psyntax so it produced annotated source if given annotated source

* module/ice-9/psyntax.scm (build-annotated): New helper, used by the
  output constructors.
  (build-application, build-conditional, build-lexical-reference)
  (build-lexical-assignment, build-global-reference)
  (build-global-assignment, build-global-definition, build-lambda)
  (build-primref, build-data, build-sequence, build-let)
  (build-named-let, build-letrec, build-lexical-var): Use
  build-annotated, so we produce annotated source if we have source
  information.

* module/ice-9/psyntax-pp.scm: Regenerated.

support source-level annotations in syncase

* module/ice-9/annotate.scm (<annotation>): Slightly more concise
  printing.
  (annotate): Don't create annotations if we have no source info.

* module/ice-9/psyntax.scm (annotation?): Remove this definition, as we
  now provide annotation support.

* module/ice-9/psyntax-pp.scm: Regenerated.

* module/ice-9/syncase.scm: Use (ice-9 annotate).

* module/language/scheme/expand.scm (eval-when): Define the eval-when
  transformer.

fix eval-when statements in boot-9

* module/ice-9/boot-9.scm: Fix a couple eval-when statements.

Replace eval-case with eval-when

* module/ice-9/boot-9.scm (eval-when): Replace eval-case with eval-when.
  Eval-when is *much* simpler, and more expressive to boot. Perhaps in
  the future we'll get 'visit and 'revisit too.

* module/ice-9/deprecated.scm (eval-case): Provide mostly-working
  deprecated version of eval-case.

* module/ice-9/boot-9.scm (defmacro, define-macro): Relax condition: we
  can make defmacros that are not at the toplevel now. But in the future
  we should replace this implementation of defmacros with one written in
  syntax-case.
  (define-module, use-modules, use-syntax): Allow at non-toplevel.
  (define-public, defmacro-public, export, re-export): Don't evaluate at
  compile-time, I can't see how that helps things. Allow `export' and
  `re-export' at non-toplevel.

* module/ice-9/getopt-long.scm:
* module/ice-9/i18n.scm:
* module/oop/goops.scm:
* module/oop/goops/compile.scm:
* module/oop/goops/dispatch.scm: Switch to use eval-when, not
  eval-case.

* module/language/scheme/compile-ghil.scm (eval-when): Replace eval-case
  transformer with eval-when transformer. Sooooo much simpler, and it
  will get better once we separate expansion from compilation.

* module/language/scheme/expand.scm (quasiquote): Hm, expand quasiquote
  properly. Not hygienic. Syncase needed.
  (lambda): Handle internal defines with docstrings propertly.

fixups to expand.scm

* module/language/scheme/expand.scm: Some changes to avoid unnecessary
  begins or empty lets, and properly handle internal defines (finally).

add separate expansion phase, to detwingle things a bit

* module/language/scheme/expand.scm: New module, implements a separate
  expansion phase, not interleaved with compilation.

* module/language/scheme/amatch.scm: Helper for expand.scm, it's pmatch
  with support for annotated source.

* module/ice-9/Makefile.am (SOURCES): Add annotate.scm to build list --
  early on because it will be used in the compiler.

* module/ice-9/annotate.scm: Fix the printer, default to unstripped
  (whatever that is), and add a deannotator.

* module/system/base/compile.scm (call-with-compile-error-catch): Fix for
  new representation of source locations.

* module/Makefile.am (SCHEME_LANG_SOURCES): Add amatch and expand.

fix printer in struct docs

* doc/ref/api-compound.texi (Vtables): Fix example printer.

add annotation module

* module/ice-9/annotate.scm: Add annotation module, for source location
  tracking with syncase, and for internal use in the compiler.

Remove "compiled closures" ("cclos") in favor of a simpler mechanism.

The idea is to introduce `gsubrs' whose arity is encoded in their type
(more precisely in the sizeof (void *) - 8 MSBs).  This removes the
indirection introduced by cclos and simplifies the code.

* libguile/__scm.h (CCLO): Remove.

* libguile/debug.c (scm_procedure_source, scm_procedure_environment):
  Remove references to `scm_tc7_cclo'.

* libguile/eval.c (scm_trampoline_0, scm_trampoline_1,
  scm_trampoline_2): Replace `scm_tc7_cclo' with `scm_tc7_gsubr'.

* libguile/eval.i.c (CEVAL): Likewise.  No longer make PROC the first
  argument.  Directly invoke `scm_gsubr_apply ()' instead of jump to the
  `evap(N+1)' label or call to `SCM_APPLY ()'.

* libguile/evalext.c (scm_self_evaluating_p): Remove reference to
  `scm_tc7_cclo'.

* libguile/gc-card.c (scm_i_sweep_card, scm_i_tag_name): Likewise.

* libguile/gc-mark.c (scm_gc_mark_dependencies): Likewise.

* libguile/goops.c (scm_class_of): Likewise.

* libguile/print.c (iprin1): Likewise.

* libguile/gsubr.c (create_gsubr): Use `unsigned int's for REQ, OPT and
  RST.  Use `scm_tc7_gsubr' instead of `scm_makcclo ()' in the default
  case.
  (scm_gsubr_apply): Remove calls to `SCM_GSUBR_PROC ()'.
  (scm_f_gsubr_apply): Remove.

* libguile/gsubr.h (SCM_GSUBR_TYPE): New definition.
  (SCM_GSUBR_MAX): Changed to 33.
  (SCM_SET_GSUBR_TYPE, SCM_GSUBR_PROC, SCM_SET_GSUBR_PROC,
  scm_f_gsubr_apply): Remove.

* libguile/procprop.c (scm_i_procedure_arity): Remove reference to
  `scm_tc7_cclo'; add proper handling of `scm_tc7_gsubr'.

* libguile/procs.c (scm_makcclo, scm_make_cclo): Remove.
  (scm_procedure_p): Remove reference to `scm_tc7_cclo'.
  (scm_thunk_p): Likewise, plus add proper `scm_tc7_gsubr' handling.

* libguile/procs.h (SCM_CCLO_LENGTH, SCM_MAKE_CCLO_TAG,
  SCM_SET_CCLO_LENGTH, SCM_CCLO_BASE, SCM_SET_CCLO_BASE, SCM_CCLO_REF,
  SCM_CCLO_SET, SCM_CCLO_SUBR, SCM_SET_CCLO_SUBR, scm_makcclo,
  scm_make_cclo): Remove.

* libguile/stacks.c (read_frames): Remove reference to `scm_f_gsubr_apply'.

* libguile/tags.h (scm_tc7_cclo): Remove.
  (scm_tc7_gsubr): New.
  (scm_tcs_subrs): Add `scm_tc7_gsubr'.

Add subr invocation benchmark.

* benchmark-suite/Makefile.am (SCM_BENCHMARKS): Add `subr.bm'.

make the ES compiler more readable via use of ->

* module/language/ecmascript/compile-ghil.scm: Use -> to make the ES
  compiler more readable. Fix bugs in do, while, and for, whereby we were
  missing ->boolean calls.

use -> macro in scheme->ghil compiler

* module/language/scheme/compile-ghil.scm (->): New macro, makes GHIL
  generation a bit more palatable. Use it in all the transformers.

slight optimization in transform-record, note in optimize*

* module/language/ghil/compile-glil.scm (optimize*): Add a note.

* module/system/base/syntax.scm (transform-record): Access the common
  slots once at the beginning. Cuts down on the number of toplevel refs
  needed by the generated code.

introduce -> binding inside transform-record body expressions

* module/system/base/syntax.scm (transform-record): Introduce a ->
  binding inside the body, that produces records of the same type.

* module/language/ghil/compile-glil.scm (optimize*): Remove our ->ghil
  definition, as transform-record introduces a -> binding for us. Nice.

first stabs as s-expression-driven transformation of GHIL

* module/language/ghil/compile-glil.scm (optimize*): Rewritten optimizer
  -- not yet in use, but it's closer to the code that I'd like to write.

* module/system/base/syntax.scm (transform-record): New crazy macro,
  makes GHIL a little less painful to work with.

common slot accessors are procedures-with-setters

* module/system/base/syntax.scm (define-type): Common slot accessors are
  also procedures-with-setters.

use common slots mechanism in ghil

* module/system/base/syntax.scm (define-type): Fix getter for common
  slot.

* module/language/ghil.scm (<ghil>): Use the common slots mechanism.

define-type has #:common-slots

* module/system/base/syntax.scm (define-type): Accept a #:common-slots
  argument, defining slots that are in all instances of this type.

fix variable not initialized spurious warnings

* libguile/vm-i-system.c: Work around some spurious "variable not
  initialized" messages on Etch's gcc.

don't crash etch's gcc

* libguile/vm-engine.h: Don't allocate registers in registers if we're on
  Etch's GCC.

export procedure-arguments from ice-9 session

* module/system/vm/program.scm (program-arguments): New function, used by
  procedure-arguments.

* module/ice-9/session.scm (procedure-arguments): New exported function,
  returns an alist describing the given procedure.

Aggregate makefiles for `module/system' and `module/language'.

* am/guilec (.scm.go): Create the target's directory, in case
  $(builddir) != $(srcdir).

* configure.in: Don't output any makefile under `module/system' or
  `module/language'.

* module/Makefile.am (SUBDIRS): Remove `language' and `system'.  Add `.'
  to the front.
  (modpath, SOURCES, SCHEME_LANG_SOURCES, ECMASCRIPT_LANG_SOURCES,
  GHIL_LANG_SOURCES, GLIL_LANG_SOURCES, ASSEMBLY_LANG_SOURCES,
  BYTECODE_LANG_SOURCES, OBJCODE_LANG_SOURCES, VALUE_LANG_SOURCES): New
  variables, taken from former `Makefile.am' files in sub-directories.

unbork the repl

* module/system/repl/repl.scm (meta-reader): Whoops, unbork the repl.

in meta-reader, return directly if the peeked char is EOF

* module/system/repl/repl.scm (meta-reader): If the (next-char #t)
  returns EOF, return that EOF directly, as it seems that with guile -q,
  the subsequent `read' actually waits for another C-d. Dunno why.

use umask when making permissions on .go files

* module/system/base/compile.scm (call-with-output-file/atomic): Temp
  files get created 0600. After we're done writing, chmod them to
  something in line with the user's umask.

use nobase in am/guilec

* am/guilec (nobase_mod_DATA): Use nobase_mod_DATA so we install to the
  correct dir for foo/bar.scm.

parse division vs regexps properly

* module/language/ecmascript/tokenize.scm (make-tokenizer/1): Whoops, fix
  the cases in which we detect that division is valid.

compile for-in

* module/language/ecmascript/base.scm (prop-keys): New method, returns
  the list of keys of props of this instance.

* module/language/ecmascript/impl.scm: Refactor the global object into a
  special kind of module object. Provide a prop-keys implementation for
  module objects.

* module/language/ecmascript/compile-ghil.scm (comp): Compile for-in.

* module/language/ecmascript/impl.scm: Reshuffly things, and implement
  make-enumerator, a helper for use in for-in statements.

* module/language/ecmascript/parse.scm (parse-ecmascript): Fix parsing of
  for (var foo in bar) {}...

fix "for" compilation

* module/language/ecmascript/compile-ghil.scm (comp): Whoops, fix `for'
  compilation.

add scheme integration to js via `require'

* module/language/ecmascript/impl.scm: Add <js-module-object>, that wraps
  a module. Add js-require, a javascript-happy function that returns an
  object that wraps a Guile module. Bind it to `require' in the default
  environment.

ecmascript tokens have source info

* module/language/ecmascript/tokenize.scm: Attach source information to
  tokens. We have to enhance the lalr parser to actually let this
  information propagate through, though...

throw SyntaxError on bad syntax

* module/language/ecmascript/parse.scm (syntax-error):
* module/language/ecmascript/tokenize.scm (syntax-error): Throw an error
  on bad syntax.

more arithmetic on non-numbers

* module/language/ecmascript/compile-ghil.scm (comp): Convert to number
  on unary +.

* module/language/ecmascript/impl.scm: Define -, *, /, <, <=, >=, >
  operations on non-numbers.

+ for strings, global js object, new Foo() works

* module/language/ecmascript/array.scm (*array-prototype*): Declare the
  constructor.

* module/language/ecmascript/base.scm (pput, pdel): Remove some needless
  checks.
  (new): Move definition of new here, and use the constructor.

* module/language/ecmascript/compile-ghil.scm (compile-ghil): Add a stub
  so that when we load a compiled JS program, we make sure the runtime
  has been booted.

* module/language/ecmascript/function.scm (js-constructor): Export a
  js-constructor method instead of a new method.

* module/language/ecmascript/impl.scm (<js-global-object>): Define a new
  class for the global "this" object, wrapping bindings from the current
  module.
  (init-js-bindings!): Define the dozen or so global properties, in the
  current module.
  (+): Define addition operations for non-numbers. This is efficient
  because the generics are only dispatched if the fast-path fails.

compile ecmascript's parser. yay! instant load-time!

* module/language/ghil/compile-glil.scm (codegen): If there are more than
  255 arguments, make a list and use apply instead of calling directly.

* module/language/Makefile.am: Now we can compile parse.scm. Yay!

* module/language/scheme/compile-ghil.scm: Add a note.

* module/language/ecmascript/compile-ghil.scm: Add a note.

be smarter about allocating local variables, reusing slots if possible

* module/language/Makefile.am: OK, we can compile compile-ghil.scm now,
  thankfully.

* module/language/ecmascript/compile-ghil.scm (ormatch): New macro, a
  wrapper around pmatch to avoid some of the more egregious
  non-tail recursiveness.
  (comp): Use ormatch.

* module/language/ghil.scm (unparse-ghil): The body of bind and mv-bind
  is a single expression, not a list of expressions.

* module/language/ghil/compile-glil.scm (codegen): Be more clever when
  allocating "local" variables -- if a variable goes out of scope, its
  index can be re-used later.

* module/language/glil.scm (parse-glil, unparse-ghil): The "rest" of a
  mv-bind is a flag, not a list. The "ra" of an mv-call is a label, not a
  GLIL expression.

* module/language/objcode/spec.scm (collapse-locals, decompile-value):
  When decompiling a value, process the bindings list differently.
  Comments in the code.

* module/language/scheme/compile-ghil.scm (define-scheme-translator): Fix
  the generated error procedure.
  (let): Re-indent.
  (letrec): Re-indent.

* module/system/base/syntax.scm (record-case): If the body of a clause is
  null, fill it with the unspecified value.

implement break and continue, work around overly recursive pmatch expansion

* libguile/vm-i-system.c (goto/args): On a tail call to a different
  procedure, init the locals to valid scheme values. Shouldn't matter for
  well-compiled scheme, but inspecting uninitialized locals could give
  garbage, or badly-compiled code could cause a crash.

* module/language/Makefile.am (NOCOMP_SOURCES): For the moment, don't
  compile compile-ghil.scm. I need to fix this.

* module/language/ecmascript/compile-ghil.scm (load-toplevel): Sigh, and
  disable stack checking in the evaluator too. Grr.
  (comp): Implement (unnamed) break and continue.

* module/language/ecmascript/parse.scm (parse-ecmascript): Fix var
  statements in `for' -- though it still doesn't work.

Fix `.go' compilation for $(builddir) != $(srcdir).

* am/guilec (.scm.go): Use "-o $@" to make sure the output file ends up
  in $(builddir).

Add `-o'/`--output' option to "guile-tools compile".

* module/system/base/compile.scm (compile-file): Add optional
  OUTPUT-FILE argument.

* scripts/compile (fail): New procedure.
  (%options): Add `-o'/`--output' option.
  (compile): Handle `-o'.

implement do, while, for

* module/language/ecmascript/compile-ghil.scm (comp): Use ghil-bind when
  making temp vars, so that disassembly understands things. Implement do,
  while, and for.

* module/language/ecmascript/parse.scm (parse-ecmascript): Some tweaks.

* module/language/ecmascript/impl.scm (language): Export ->boolean.

implement more operations

* module/language/ecmascript/base.scm: Implement some more robust
  property getters that convert strings to symbols. Implement
  has-property?.

* module/language/ecmascript/compile-ghil.scm (comp): Implement lots more
  mathematical operators. We now do all expressions; on to statements.

* module/language/ecmascript/impl.scm: Define some math helpers. They
  probably need to call ->number on some things.

* module/language/ecmascript/parse.scm (parse-ecmascript): Fix a typo.

clean up ++ and -- a little bit

* module/language/ecmascript/compile-ghil.scm (comp): Define let1 and
  begin1 helpers. Use them in pre- and post- increment and decrement.

implement ++, --, new, delete, void, typeof

* module/language/ecmascript/compile-ghil.scm (@impl): Implement with
  @implv.
  (comp): Implement ++ and -- (pre- and post-). Quite a pain. I'll be
  looking for ways to simplify this notation. Also implement new, delete,
  and void.

* module/language/ecmascript/impl.scm: Implement typeof.

handle "this" in ecmascript

* module/language/ecmascript/base.scm:
* module/language/ecmascript/compile-ghil.scm:
* module/language/ecmascript/impl.scm:
* module/language/ecmascript/parse.scm: Compile "method calls" in such a
  way that "this" gets propagated correctly.

implement more of the standard runtime

* module/language/Makefile.am:
* module/language/ecmascript/impl.scm:
* module/language/ecmascript/array.scm:
* module/language/ecmascript/base.scm:
* module/language/ecmascript/function.scm: Split out the runtime into
  different files. Implement more of the spec's runtime.

Fix interpretation of `(ice-9 getopt-long)'.

* module/ice-9/getopt-long.scm (define-one-option-spec-field-accessor,
  define-one-option-spec-field-modifier): Eval-case for `load-toplevel'
  as well so that the interpreter can load this module.

Fix compilation of `(ice-9 getopt-long)'.

* module/ice-9/getopt-long.scm (option-spec-fields): Enclose in a
  `(load-toplevel compile-toplevel)' `eval-case'.
  (define-one-option-spec-field-accessor,
  define-one-option-spec-field-modifier): Enclose in a
  `compile-toplevel'-only `eval-case'.

Add `-L'/`--load-path' option to "guile-tools compile".

* scripts/compile (%options): Add `-L'/`--load-path'.
  (parse-args): Have `load-path' default to '().
  (compile): Handle `--load-path' option.

Change "guile-tools compile" to use SRFI-37 to process options.

* scripts/compile (%options): Rewrite in SRFI-37 style.
  (parse-args): New procedure.
  (compile): Update to SRFI-37.

Make the `module-defer-observers-mutex' recursive.

* module/ice-9/boot-9.scm (module-defer-observers-mutex): Made
  recursive.  See
  http://lists.gnu.org/archive/html/guile-devel/2009-02/msg00068.html
  for an example where it matters.

support foo["bar"] in addition to foo.bar

* module/language/ecmascript/parse.scm (parse-ecmascript): And update the
  function declaration forms for the new var syntax.

* module/language/ecmascript/compile-ghil.scm (comp): Support foo["bar"]
  in addition to foo.bar.

* module/language/ecmascript/impl.scm (pget, pput): Some fixes for when
  we get non-symbols -- it can happen, yo. I suppose we should allow for
  non-string keys too..

implement object literals

* module/language/ecmascript/impl.scm:
* module/language/ecmascript/compile-ghil.scm (comp): Object literals.

* module/language/ecmascript/parse.scm (parse-ecmascript): Fix some
  object literal parsing.

var at toplevel works too

* module/language/ecmascript/compile-ghil.scm (comp): Fix the var form at
  toplevel.

property gets and puts implemented, yays

* module/language/ecmascript/compile-ghil.scm (@impl): Ok, don't recurse
  on args here.
  (comp): Implement property gets and puts and lexical assignment.
  (comp-body): Fix scanning of var forms.

* module/language/ecmascript/impl.scm (prop-attrs): Allow for the prop
  attr array to be #f.

* module/language/ecmascript/parse.scm (parse-ecmascript): Fix assignment
  parsing.

add array support

* module/language/ecmascript/compile-ghil.scm (@impl): Whoops, fix this
  macro.
  (comp): Handle array literals.

* module/language/ecmascript/impl.scm: Add support for arrays.

further ecmascript work

* libguile/vm-i-system.c (drop, return): Declare drop and return as
  popping one arg from the stack.

* module/language/ghil/compile-glil.scm:
* module/language/glil/compile-assembly.scm (make-meta): Adjust so that
  we declare 'drop and 'return calls as popping one arg from the stack.

* module/language/ecmascript/compile-ghil.scm (comp, comp-body): Flesh
  out a bit more. Most significantly, scoping within functions obeys
  javascript semantics better, modulo bits about with() forms.

* module/language/ecmascript/impl.scm: Define some runtime helper
  routines.
* module/language/Makefile.am (SOURCES): Add impl.scm.

* module/language/ecmascript/parse.scm (parse-ecmascript): Minor tweaks.

* module/language/ecmascript/tokenize.scm (read-identifier): Identifiers
  now read as symbols, not strings.

add more ecmascript compilation -- functions work now

* module/language/ecmascript/parse.scm (parse-ecmascript): Lambdas always
  just have one member in their bodies.

* module/language/ecmascript/compile-ghil.scm (comp): Add some more silly
  compilers.

Add `load-unsigned-integer' instruction.

* libguile/vm-i-loader.c (load_unsigned_integer): New loader.

* module/language/assembly.scm (byte-length): Handle
  `load-unsigned-integer'.

* module/language/assembly/compile-bytecode.scm (write-bytecode):
  Likewise.

* module/language/glil/compile-assembly.scm (dump-object): Emit a
  `load-unsigned-integer' instruction for positive integers.  This fixes
  loading of integers greater than 2^31 - 1.

* testsuite/Makefile.am (vm_test_files): Add `t-literal-integers.scm'.

* doc/ref/vm.texi (Loading Instructions): Add `load-unsigned-integer'.

world's stupidest ecmascript compiler

* module/language/ecmascript/spec.scm: Add language spec for ecmascript.

* module/language/ecmascript/compile-ghil.scm: Add a stupid compiler.

* module/language/Makefile.am: Buildage.

add ecmascript parser

* module/language/ecmascript/parse-lalr.scm: Add the Boucher/Bison lalr
  parser. This is from guile-lib, but with : changed to -> so as not to
  molest `prefix' keywords. Should probably be elsewhere.

* module/language/ecmascript/parse.scm: Add parser for ECMAScript. Rules
  from the spec, 3rd edition.

* module/language/ecmascript/tokenize.scm: Add ECMAScript tokenizer,
  hand-written. Neat stuff.

* module/language/Makefile.am: Autofoo.

lengths written out in native endianness

* module/language/assembly/compile-bytecode.scm (write-bytecode): Write
  out the lengths that are mapped to struct scm_objcode using native
  endianness.

avoid deprecated functions in SCM_VALIDATE_VECTOR_LEN

* libguile/validate.h (SCM_VALIDATE_VECTOR_LEN): Don't use deprecated
  functions.

Add tests for the stack inspection API.

* test-suite/tests/eval.test (stack->frames): New procedure.
  ("stacks"): New test prefix.

Add new GOOPS tests for built-in types.

* test-suite/tests/goops.test ("classes for built-in types"): New test
  prefix.

Add test for `procedure-properties'.

* test-suite/Makefile.am (SCM_TESTS): Add `tests/procprop.test'.

better alignment

* module/language/assembly.scm (align-program): Whoops, align programs
  properly.

* module/language/glil/compile-assembly.scm (compile-assembly): Start
  with addr=-1, for the unserialized load-program byte.
  (glil->assembly): Align programs in all cases.

Change `compiled-file-name' to preserve the input file's directory.

* module/system/base/compile.scm (compiled-file-name): Prepend "(dirname
  file)" so that "guile-tools compile foo/bar.scm" produces
  "foo/bar.go", not "bar.go".

align programs on 8-byte boundaries

* module/language/assembly.scm (addr+): New helper.
  (align-program): New function, aligns a (load-program) form, currently
  to 8-byte boundaries.

* module/language/glil/compile-assembly.scm (<subprogram>): Record the
  object table and the program code separately, so that we can align the
  program after the object table has been written.
  (glil->assembly): Use addr+.
  (dump-object): Rework to fold `addr' through dumping of compound
  objects, so that procedures can be aligned properly.

re-enable assembly packing

* module/language/glil/compile-assembly.scm (glil->assembly): Enable
  assembly packing, for e.g. (make-int8:0).

a slight add-method speedup

* module/oop/goops.scm (add-method-in-classes!): Use memq instead of
  memv.

generate the fixed-offset accessors at compile-time

* module/language/scheme/compile-ghil.scm (define-scheme-translator):
  Only add an else clause if the transformer didn't have one.

* module/oop/goops.scm (min-fixnum, max-fixnum): Define at compile-time
  as well.
  (@slot-ref, @slot-set!): Only define transformers for these at
  compile-time. Avoids loading up the compiler unnecessarily. Also, allow
  for the `n' to be determined lexically, in which case we dispatch to
  the primitive.
  (num-standard-pre-cache, define-standard-accessor-method)
  (bound-check-get, standard-get, standard-set): Rework the fixed-offset
  getters and setters so that they can be computed at compile-time.
  Accessors to fields with n > num-standard-pre-cache will be dispatched
  to the primitive instead of within the VM.

don't re-enter the compiler during method dispatch

* libguile/goops.c (scm_make): In the pre-inst `make', default
  `procedure' to #f, and read a `make-procedure' instead of
  `compile-env'.

* libguile/goops.h (scm_si_make_procedure): This instead of
  scm_si_compile_env.

* module/oop/goops.scm (make-method): Remove this unused function. Users
  should use (make <method> ...) directly.
  (method): Capture `make-procedure' instead of `procedure' in the case
  that the body calls a next-method. Allows for the kind of
  "recompilation" that we were using before, but with closures instead of
  re-entering the compiler. Type-specific compilation is still
  interesting, but probably should be implemented in another way.
  (initialize): Default #:procedure to #f, and
  s/compile-env/make-procedure/.

* module/oop/goops/compile.scm (code-table-lookup): Just return the
  cmethod, not the entry -- since the entry is now just (append types
  cmethod).
  (compile-make-procedure): New procedure, returns a form that, when
  evaluated/compiled, will yield a procedure of one argument, the
  next-method. When called with a next-method, the procedure returns an
  actual method implementation. compile-make-procedure returns #f if the
  body doesn't call next-method.
  (compile-method): Unify to always return procedures. Much cleaner and
  *much* faster in the compiled case. In the interpreted case, there
  might be a slight slowdown, but if there is one it should be slight.

* module/oop/goops/dispatch.scm (method-cache-install!): Adapt to removal
  of compute-entry-with-cmethod.

flush output when writing .go files

* module/system/base/compile.scm (call-with-output-file/atomic): Close
  the port we are writing to before renaming it, so that we flush output.
  Might fix some 0-length write errors that Jao was seeing.

inline record predicates into record-case

* module/system/base/syntax.scm (record-case): Inline record predicates
  into the record-case. Shaves off a few more milliseconds from a GOOPS
  load.

no keyword arguments in GHIL / GLIL, just optional args -- faster compiles

* module/system/base/syntax.scm (define-record): So, in the generated
  constructors, allow optional arguments, but not keyword arguments.
  Conses much less in the constructors.
  (define-record/keywords): And the old define-record is here.

* module/language/ghil.scm (parse-ghil):
* module/language/ghil/compile-glil.scm (codegen):
* module/language/scheme/compile-ghil.scm (translate-1, quote)
  (quasiquote): Don't use keywords in this compiler hotpath.

* module/system/base/language.scm (<language>):
* module/system/repl/common.scm (<repl>):
* module/system/vm/debug.scm (<debugger>): Use define-record/keywords.

Update `NEWS'.

Small cleanup relative to the use of double cells for subrs.

* libguile/procs.c (scm_c_make_subr): Remove comments about the number
  of subrs, improve formatting.