overview of bootstrapping caml light

overview of bootstrapping caml light

[Lyn A Headley]

[il y a un sommaire pauvre de ce message au fin]

dear caml-list,

I have been trying to understand the bootstrapping process
which takes place during caml light installation.  If you'll
indulge me, I'd like to present my view of what is going on,
to see if I have the right idea, and then ask some questions.

The first step is building the runtime system(written in C).  This
includes an interpreter for the caml light abstract machine.  Then the
produced executable, "runtime", is invoked on the file "compiler,"
which I *think* is a byte-compiled implementation of a *subset* of the
caml-light language. In this way the core library, actual compiler,
linker, librarian, and toplevel are compiled into bytecode.

my questions:

1.) does the included bytecode file "compiler" implement only a subset
of the language? It seems that this is indeed the case, otherwise
there would be no point in compiling the subdirectory "compiler,"
would there?  And yet, if it is a subset, why?  I mean why not just
include a bytecoded compiler for the *entire* language?  Basically I
am wondering why the subdirectory "compiler" is included in the
distribution.

2.) How do src/runtime/parsing.c, src/runtime/lexing.c, 
src/compiler/parser.ml, src/compiler/lexer.ml, src/lex,
and src/yacc fit into this whole picture?

-------------------------------------------------------
[en francais]

j'essaye comprendre le processus de 'bootstrapping'.

questions:

1) est-ce que le fichier (dossier?) 'compiler' travaille pour un petit 
part de la langue caml?  

2) comment est-ce-que l'analysis de la syntaxe travaile?

Re: overview of bootstrapping caml light

[Xavier Leroy]

> I have been trying to understand the bootstrapping process
> which takes place during caml light installation.  If you'll
> indulge me, I'd like to present my view of what is going on,
> to see if I have the right idea, and then ask some questions.
> 
> The first step is building the runtime system(written in C).  This
> includes an interpreter for the caml light abstract machine.  Then the
> produced executable, "runtime", is invoked on the file "compiler,"
> which I *think* is a byte-compiled implementation of a *subset* of the
> caml-light language. In this way the core library, actual compiler,
> linker, librarian, and toplevel are compiled into bytecode.

No, it's not a subset, it's the previous generation compiler for the
whole language. The essence of bootstrapping is to use the N-th
generation compiler to compile the (N+1)-th generation compiler.

For Caml Light, the N-th generation compiler is composed of the
bytecode files src/{camlcomp,camllink,camllibr,camllex} and the (N+1)-th
generation is built in compiler/camlcomp, linker/camllink,
librar/camllibr, lex/camllex, and toplevel/camltop. The parts written
in C (camlrun and camlyacc) are outside the bootstrapping cycle, since
they can be rebuilt independently at any time.

For general background on bootstrapping, and in particular the use of
T-diagrams to understand what's happening, see section 11.2 of the
Dragon book (Aho, Sethi, Ullman, "Compilers -- principles, techniques
and tools").

Also note that the Caml Light bootstrapping process does not handle
changes in the abstract machine very well. This has been fixed in
Objective Caml, which follows exactly the T-diagram approach.

Hope this helps,

- Xavier Leroy