[using gcc book] ch1 rewrite

[Chris Devers <cdevers at pobox dot com>]

(Substantially a re-post of a message from yesterday.)

I've prepared a significant rewrite of frontends.texi, which constitutes
chapter 1 of the _Using GCC_ book.

I would like to solicit commentary on whether this revised text is clear,
technically accurate, and gets the important points across succinctly.

The deadline for submitting the manuscript is *TODAY*, so any notes at all
("yes it's fine, print it", "no leave it all alone", etc) would be nice :)

The revised text follows:

<excerpt>

@node G++ and GCC
@chapter Programming Languages Supported by GCC

@cindex GCC
@cindex GNU Compiler Collection
@cindex GNU C Compiler
@cindex Ada
@cindex Fortran
@cindex Java
@cindex Objective-C
@cindex treelang
GCC stands for ``GNU Compiler Collection.''  GCC is an integrated
distribution of compilers for several major programming languages.  These
languages currently include C, C++, Objective-C, Java, Fortran, and Ada.

The abbreviation @dfn{GCC} has multiple meanings in common use.
Historically, the abbreviation stood for ``GNU C Compiler''; this sense
of the name is still common when the emphasis is on compiling C programs.
However, the name is now defined generically for the compiler collection
as a whole, referring to all languages supported by the suite.  Finally,
the name is also used when speaking of the @dfn{language-independent}
component of GCC: code shared among the compilers for all supported
languages.

The language-independent component of GCC includes the majority of the
optimizers, as well as the ``back ends'' that generate machine code for
various processors.

The part of a compiler that is specific to a particular language is
called the ``front end.''  In addition to the front ends that are
integrated components of GCC, there are several other front ends that
are maintained separately.  These support languages such as Pascal,
Mercury, and COBOL.  To use these, they must be built together with
GCC proper.

@cindex C++
@cindex G++
@cindex Ada
@cindex GNAT
Most of the compilers for languages other than C have their own names.
The C++ compiler is G++, the Ada compiler is GNAT, and so on.  When we
talk about compiling one of those languages, we might refer to that
compiler by its own name, or as GCC@.  Either is correct.

@cindex compiler compared to C++ preprocessor
@cindex intermediate C version, nonexistent
@cindex C intermediate output, nonexistent
Historically, compilers for many languages, including C++ and Fortran,
have been implemented as ``preprocessors'' which emit another high
level language such as C@.  None of the compilers included in GCC are
implemented this way; they all generate machine code directly.  This
sort of preprocessor should not be confused with the @dfn{C
preprocessor}, which is an integral feature of the C, C++, and
Objective-C languages.

</excerpt>




How does this look to people? This is the last major area of revision in
the text, so if people are happy with it then we're in pretty good shape.


As noted in a couple of messages yesterday, the plan is to submit the
final draft of the manuscript today, so any commentary within the next six
hours or so would be greatly appreciated.

Sorry for submitting this for additional review at such a late stage in
the process.

(Also, is the GNU proofreaders list kaput? The archives show little but
spam for any of the past three or four months...)


As before, thank you very much for any help you can offer.



-- 
Chris Devers    cdevers@pobox.com

printf, n.
One of several related, dauntingly complex input/output formatting
functions specified in the ANSI C library together with Dr. Kevorkian's
hotline number.

    -- from _The Computer Contradictionary_, Stan Kelly-Bootle, 1995