This is ../../gcc-3.4/gcc/doc/gccint.info, produced by makeinfo version
4.2 from ../../gcc-3.4/gcc/doc/gccint.texi.

Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding Free
Software", the Front-Cover texts being (a) (see below), and with the
Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

   (a) The FSF's Front-Cover Text is:

   A GNU Manual

   (b) The FSF's Back-Cover Text is:

   You have freedom to copy and modify this GNU Manual, like GNU
software.  Copies published by the Free Software Foundation raise
funds for GNU development.
INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gccint: (gccint).            Internals of the GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the internals of the GNU compilers.

   Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA

File: gccint.info,  Node: Host Misc,  Prev: Filesystem,  Up: Host Config

Host Misc
=========

`FATAL_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits after serious errors.  The default is the system-provided
     macro `EXIT_FAILURE', or `1' if the system doesn't define that
     macro.  Define this macro only if these defaults are incorrect.

`SUCCESS_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits without serious errors.  (Warnings are not serious errors.)
     The default is the system-provided macro `EXIT_SUCCESS', or `0' if
     the system doesn't define that macro.  Define this macro only if
     these defaults are incorrect.

`USE_C_ALLOCA'
     Define this macro if GCC should use the C implementation of
     `alloca' provided by `libiberty.a'.  This only affects how some
     parts of the compiler itself allocate memory.  It does not change
     code generation.

     When GCC is built with a compiler other than itself, the C `alloca'
     is always used.  This is because most other implementations have
     serious bugs.  You should define this macro only on a system where
     no stack-based `alloca' can possibly work.  For instance, if a
     system has a small limit on the size of the stack, GCC's builtin
     `alloca' will not work reliably.

`COLLECT2_HOST_INITIALIZATION'
     If defined, a C statement (sans semicolon) that performs
     host-dependent initialization when `collect2' is being initialized.

`GCC_DRIVER_HOST_INITIALIZATION'
     If defined, a C statement (sans semicolon) that performs
     host-dependent initialization when a compilation driver is being
     initialized.

`SMALL_ARG_MAX'
     Define this macro if the host system has a small limit on the total
     size of an argument vector.  This causes the driver to take more
     care not to pass unnecessary arguments to subprocesses.

   In addition, if `configure' generates an incorrect definition of any
of the macros in `auto-host.h', you can override that definition in a
host configuration header.  If you need to do this, first see if it is
possible to fix `configure'.


File: gccint.info,  Node: Fragments,  Next: Collect2,  Prev: Host Config,  Up: Top

Makefile Fragments
******************

   When you configure GCC using the `configure' script, it will
construct the file `Makefile' from the template file `Makefile.in'.
When it does this, it can incorporate makefile fragments from the
`config' directory.  These are used to set Makefile parameters that are
not amenable to being calculated by autoconf.  The list of fragments to
incorporate is set by `config.gcc'; *Note System Config::.

   Fragments are named either `t-TARGET' or `x-HOST', depending on
whether they are relevant to configuring GCC to produce code for a
particular target, or to configuring GCC to run on a particular host.
Here TARGET and HOST are mnemonics which usually have some relationship
to the canonical system name, but no formal connection.

   If these files do not exist, it means nothing needs to be added for a
given target or host.  Most targets need a few `t-TARGET' fragments,
but needing `x-HOST' fragments is rare.

* Menu:

* Target Fragment:: Writing `t-TARGET' files.
* Host Fragment::   Writing `x-HOST' files.


File: gccint.info,  Node: Target Fragment,  Next: Host Fragment,  Up: Fragments

Target Makefile Fragments
=========================

   Target makefile fragments can set these Makefile variables.

`LIBGCC2_CFLAGS'
     Compiler flags to use when compiling `libgcc2.c'.

`LIB2FUNCS_EXTRA'
     A list of source file names to be compiled or assembled and
     inserted into `libgcc.a'.

`Floating Point Emulation'
     To have GCC include software floating point libraries in `libgcc.a'
     define `FPBIT' and `DPBIT' along with a few rules as follows:
          # We want fine grained libraries, so use the new code
          # to build the floating point emulation libraries.
          FPBIT = fp-bit.c
          DPBIT = dp-bit.c
          
          
          fp-bit.c: $(srcdir)/config/fp-bit.c
                  echo '#define FLOAT' > fp-bit.c
                  cat $(srcdir)/config/fp-bit.c >> fp-bit.c
          
          dp-bit.c: $(srcdir)/config/fp-bit.c
                  cat $(srcdir)/config/fp-bit.c > dp-bit.c

     You may need to provide additional #defines at the beginning of
     `fp-bit.c' and `dp-bit.c' to control target endianness and other
     options.

`CRTSTUFF_T_CFLAGS'
     Special flags used when compiling `crtstuff.c'.  *Note
     Initialization::.

`CRTSTUFF_T_CFLAGS_S'
     Special flags used when compiling `crtstuff.c' for shared linking.
     Used if you use `crtbeginS.o' and `crtendS.o' in `EXTRA-PARTS'.
     *Note Initialization::.

`MULTILIB_OPTIONS'
     For some targets, invoking GCC in different ways produces objects
     that can not be linked together.  For example, for some targets GCC
     produces both big and little endian code.  For these targets, you
     must arrange for multiple versions of `libgcc.a' to be compiled,
     one for each set of incompatible options.  When GCC invokes the
     linker, it arranges to link in the right version of `libgcc.a',
     based on the command line options used.

     The `MULTILIB_OPTIONS' macro lists the set of options for which
     special versions of `libgcc.a' must be built.  Write options that
     are mutually incompatible side by side, separated by a slash.
     Write options that may be used together separated by a space.  The
     build procedure will build all combinations of compatible options.

     For example, if you set `MULTILIB_OPTIONS' to `m68000/m68020
     msoft-float', `Makefile' will build special versions of `libgcc.a'
     using the following sets of options:  `-m68000', `-m68020',
     `-msoft-float', `-m68000 -msoft-float', and `-m68020 -msoft-float'.

`MULTILIB_DIRNAMES'
     If `MULTILIB_OPTIONS' is used, this variable specifies the
     directory names that should be used to hold the various libraries.
     Write one element in `MULTILIB_DIRNAMES' for each element in
     `MULTILIB_OPTIONS'.  If `MULTILIB_DIRNAMES' is not used, the
     default value will be `MULTILIB_OPTIONS', with all slashes treated
     as spaces.

     For example, if `MULTILIB_OPTIONS' is set to `m68000/m68020
     msoft-float', then the default value of `MULTILIB_DIRNAMES' is
     `m68000 m68020 msoft-float'.  You may specify a different value if
     you desire a different set of directory names.

`MULTILIB_MATCHES'
     Sometimes the same option may be written in two different ways.
     If an option is listed in `MULTILIB_OPTIONS', GCC needs to know
     about any synonyms.  In that case, set `MULTILIB_MATCHES' to a
     list of items of the form `option=option' to describe all relevant
     synonyms.  For example, `m68000=mc68000 m68020=mc68020'.

`MULTILIB_EXCEPTIONS'
     Sometimes when there are multiple sets of `MULTILIB_OPTIONS' being
     specified, there are combinations that should not be built.  In
     that case, set `MULTILIB_EXCEPTIONS' to be all of the switch
     exceptions in shell case syntax that should not be built.

     For example the ARM processor cannot execute both hardware floating
     point instructions and the reduced size THUMB instructions at the
     same time, so there is no need to build libraries with both of
     these options enabled.  Therefore `MULTILIB_EXCEPTIONS' is set to:
          *mthumb/*mhard-float*

`MULTILIB_EXTRA_OPTS'
     Sometimes it is desirable that when building multiple versions of
     `libgcc.a' certain options should always be passed on to the
     compiler.  In that case, set `MULTILIB_EXTRA_OPTS' to be the list
     of options to be used for all builds.  If you set this, you should
     probably set `CRTSTUFF_T_CFLAGS' to a dash followed by it.

`SPECS'
     Unfortunately, setting `MULTILIB_EXTRA_OPTS' is not enough, since
     it does not affect the build of target libraries, at least not the
     build of the default multilib.  One possible work-around is to use
     `DRIVER_SELF_SPECS' to bring options from the `specs' file as if
     they had been passed in the compiler driver command line.
     However, you don't want to be adding these options after the
     toolchain is installed, so you can instead tweak the `specs' file
     that will be used during the toolchain build, while you still
     install the original, built-in `specs'.  The trick is to set
     `SPECS' to some other filename (say `specs.install'), that will
     then be created out of the built-in specs, and introduce a
     `Makefile' rule to generate the `specs' file that's going to be
     used at build time out of your `specs.install'.


File: gccint.info,  Node: Host Fragment,  Prev: Target Fragment,  Up: Fragments

Host Makefile Fragments
=======================

   The use of `x-HOST' fragments is discouraged.  You should do so only
if there is no other mechanism to get the behavior desired.  Host
fragments should never forcibly override variables set by the configure
script, as they may have been adjusted by the user.

   Variables provided for host fragments to set include:

`X_CFLAGS'
`X_CPPFLAGS'
     These are extra flags to pass to the C compiler and preprocessor,
     respectively.  They are used both when building GCC, and when
     compiling things with the just-built GCC.

`XCFLAGS'
     These are extra flags to use when building the compiler.  They are
     not used when compiling `libgcc.a'.  However, they _are_ used when
     recompiling the compiler with itself in later stages of a
     bootstrap.

`BOOT_LDFLAGS'
     Flags to be passed to the linker when recompiling the compiler with
     itself in later stages of a bootstrap.  You might need to use this
     if, for instance, one of the front ends needs more text space than
     the linker provides by default.

`EXTRA_PROGRAMS'
     A list of additional programs required to use the compiler on this
     host, which should be compiled with GCC and installed alongside
     the front ends.  If you set this variable, you must also provide
     rules to build the extra programs.


File: gccint.info,  Node: Collect2,  Next: Header Dirs,  Prev: Fragments,  Up: Top

`collect2'
**********

   GCC uses a utility called `collect2' on nearly all systems to arrange
to call various initialization functions at start time.

   The program `collect2' works by linking the program once and looking
through the linker output file for symbols with particular names
indicating they are constructor functions.  If it finds any, it creates
a new temporary `.c' file containing a table of them, compiles it, and
links the program a second time including that file.

   The actual calls to the constructors are carried out by a subroutine
called `__main', which is called (automatically) at the beginning of
the body of `main' (provided `main' was compiled with GNU CC).  Calling
`__main' is necessary, even when compiling C code, to allow linking C
and C++ object code together.  (If you use `-nostdlib', you get an
unresolved reference to `__main', since it's defined in the standard
GCC library.  Include `-lgcc' at the end of your compiler command line
to resolve this reference.)

   The program `collect2' is installed as `ld' in the directory where
the passes of the compiler are installed.  When `collect2' needs to
find the _real_ `ld', it tries the following file names:

   * `real-ld' in the directories listed in the compiler's search
     directories.

   * `real-ld' in the directories listed in the environment variable
     `PATH'.

   * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
     if specified.

   * `ld' in the compiler's search directories, except that `collect2'
     will not execute itself recursively.

   * `ld' in `PATH'.

   "The compiler's search directories" means all the directories where
`gcc' searches for passes of the compiler.  This includes directories
that you specify with `-B'.

   Cross-compilers search a little differently:

   * `real-ld' in the compiler's search directories.

   * `TARGET-real-ld' in `PATH'.

   * The file specified in the `REAL_LD_FILE_NAME' configuration macro,
     if specified.

   * `ld' in the compiler's search directories.

   * `TARGET-ld' in `PATH'.

   `collect2' explicitly avoids running `ld' using the file name under
which `collect2' itself was invoked.  In fact, it remembers up a list
of such names--in case one copy of `collect2' finds another copy (or
version) of `collect2' installed as `ld' in a second place in the
search path.

   `collect2' searches for the utilities `nm' and `strip' using the
same algorithm as above for `ld'.


File: gccint.info,  Node: Header Dirs,  Next: Type Information,  Prev: Collect2,  Up: Top

Standard Header File Directories
********************************

   `GCC_INCLUDE_DIR' means the same thing for native and cross.  It is
where GCC stores its private include files, and also where GCC stores
the fixed include files.  A cross compiled GCC runs `fixincludes' on
the header files in `$(tooldir)/include'.  (If the cross compilation
header files need to be fixed, they must be installed before GCC is
built.  If the cross compilation header files are already suitable for
GCC, nothing special need be done).

   `GPLUSPLUS_INCLUDE_DIR' means the same thing for native and cross.
It is where `g++' looks first for header files.  The C++ library
installs only target independent header files in that directory.

   `LOCAL_INCLUDE_DIR' is used only by native compilers.  GCC doesn't
install anything there.  It is normally `/usr/local/include'.  This is
where local additions to a packaged system should place header files.

   `CROSS_INCLUDE_DIR' is used only by cross compilers.  GCC doesn't
install anything there.

   `TOOL_INCLUDE_DIR' is used for both native and cross compilers.  It
is the place for other packages to install header files that GCC will
use.  For a cross-compiler, this is the equivalent of `/usr/include'.
When you build a cross-compiler, `fixincludes' processes any header
files in this directory.


File: gccint.info,  Node: Type Information,  Next: Funding,  Prev: Header Dirs,  Up: Top

Memory Management and Type Information
**************************************

   GCC uses some fairly sophisticated memory management techniques,
which involve determining information about GCC's data structures from
GCC's source code and using this information to perform garbage
collection and implement precompiled headers.

   A full C parser would be too overcomplicated for this task, so a
limited subset of C is interpreted and special markers are used to
determine what parts of the source to look at.  The parser can also
detect simple typedefs of the form `typedef struct ID1 *ID2;' and
`typedef int ID3;', and these don't need to be specially marked.

   The two forms that do need to be marked are:

struct ID1 GTY(([options]))
{
  [fields]
};

typedef struct ID2 GTY(([options]))
{
  [fields]
} ID3;

* Menu:

* GTY Options::		What goes inside a `GTY(())'.
* GGC Roots::		Making global variables GGC roots.
* Files::		How the generated files work.


File: gccint.info,  Node: GTY Options,  Next: GGC Roots,  Up: Type Information

The Inside of a `GTY(())'
=========================

   Sometimes the C code is not enough to fully describe the type
structure.  Extra information can be provided by using more `GTY'
markers.  These markers can be placed:
   * In a structure definition, before the open brace;

   * In a global variable declaration, after the keyword `static' or
     `extern'; and

   * In a structure field definition, before the name of the field.

   The format of a marker is

GTY (([name] ([param]), [name] ([param]) ...))
 The parameter is either a string or a type name.

   When the parameter is a string, often it is a fragment of C code.
Three special escapes may be available:

`%h'
     This expands to an expression that evaluates to the current
     structure.

`%1'
     This expands to an expression that evaluates to the structure that
     immediately contains the current structure.

`%0'
     This expands to an expression that evaluates to the outermost
     structure that contains the current structure.

`%a'
     This expands to the string of the form `[i1][i2]...' that indexes
     the array item currently being marked.  For instance, if the field
     being marked is `foo', then `%1.foo%a' is the same as `%h'.

   The available options are:

`length'
     There are two places the type machinery will need to be explicitly
     told the length of an array.  The first case is when a structure
     ends in a variable-length array, like this:

     struct rtvec_def GTY(()) {
       int num_elem;		/* number of elements */
       rtx GTY ((length ("%h.num_elem"))) elem[1];
     };
      In this case, the `length' option is used to override the
     specified array length (which should usually be `1').  The
     parameter of the option is a fragment of C code that calculates
     the length.

     The second case is when a structure or a global variable contains a
     pointer to an array, like this:
          tree *
            GTY ((length ("%h.regno_pointer_align_length"))) regno_decl;
     In this case, `regno_decl' has been allocated by writing something
     like
            x->regno_decl =
              ggc_alloc (x->regno_pointer_align_length * sizeof (tree));
     and the `length' provides the length of the field.

     This second use of `length' also works on global variables, like:

       static GTY((length ("reg_base_value_size")))
         rtx *reg_base_value;

`skip'
     If `skip' is applied to a field, the type machinery will ignore it.
     This is somewhat dangerous; the only safe use is in a union when
     one field really isn't ever used.

`desc'
`tag'
`default'
     The type machinery needs to be told which field of a `union' is
     currently active.  This is done by giving each field a constant
     `tag' value, and then specifying a discriminator using `desc'.
     For example,
          struct tree_binding GTY(())
          {
            struct tree_common common;
            union tree_binding_u {
              tree GTY ((tag ("0"))) scope;
              struct cp_binding_level * GTY ((tag ("1"))) level;
            } GTY ((desc ("BINDING_HAS_LEVEL_P ((tree)&%0)"))) scope;
            tree value;
          };

     In the `desc' option, the "current structure" is the union that it
     discriminates.  Use `%1' to mean the structure containing it.
     (There are no escapes available to the `tag' option, since it's
     supposed to be a constant.)

     Each `tag' should be different.  If no `tag' is matched, the field
     marked with `default' is used if there is one, otherwise no field
     in the union will be marked.

`param_is'
`use_param'
     Sometimes it's convenient to define some data structure to work on
     generic pointers (that is, `PTR') and then use it with a specific
     type.  `param_is' specifies the real type pointed to, and
     `use_param' says where in the generic data structure that type
     should be put.

     For instance, to have a `htab_t' that points to trees, one should
     write

       htab_t GTY ((param_is (union tree_node))) ict;

`paramN_is'
`use_paramN'
     In more complicated cases, the data structure might need to work on
     several different types, which might not necessarily all be
     pointers.  For this, `param1_is' through `param9_is' may be used to
     specify the real type of a field identified by `use_param1' through
     `use_param9'.

`use_params'
     When a structure contains another structure that is parameterized,
     there's no need to do anything special, the inner structure
     inherits the parameters of the outer one.  When a structure
     contains a pointer to a parameterized structure, the type
     machinery won't automatically detect this (it could, it just
     doesn't yet), so it's necessary to tell it that the pointed-to
     structure should use the same parameters as the outer structure.
     This is done by marking the pointer with the `use_params' option.

`deletable'
     `deletable', when applied to a global variable, indicates that when
     garbage collection runs, there's no need to mark anything pointed
     to by this variable, it can just be set to `NULL' instead.  This
     is used to keep a list of free structures around for re-use.

`if_marked'
     Suppose you want some kinds of object to be unique, and so you put
     them in a hash table.  If garbage collection marks the hash table,
     these objects will never be freed, even if the last other
     reference to them goes away.  GGC has special handling to deal
     with this: if you use the `if_marked' option on a global hash
     table, GGC will call the routine whose name is the parameter to
     the option on each hash table entry.  If the routine returns
     nonzero, the hash table entry will be marked as usual.  If the
     routine returns zero, the hash table entry will be deleted.

     The routine `ggc_marked_p' can be used to determine if an element
     has been marked already; in fact, the usual case is to use
     `if_marked ("ggc_marked_p")'.

`maybe_undef'
     When applied to a field, `maybe_undef' indicates that it's OK if
     the structure that this fields points to is never defined, so long
     as this field is always `NULL'.  This is used to avoid requiring
     backends to define certain optional structures.  It doesn't work
     with language frontends.

`chain_next'
`chain_prev'
     It's helpful for the type machinery to know if objects are often
     chained together in long lists; this lets it generate code that
     uses less stack space by iterating along the list instead of
     recursing down it.  `chain_next' is an expression for the next
     item in the list, `chain_prev' is an expression for the previous
     item.  The machinery requires that taking the next item of the
     previous item gives the original item.

`reorder'
     Some data structures depend on the relative ordering of pointers.
     If the type machinery needs to change that ordering, it will call
     the function referenced by the `reorder' option, before changing
     the pointers in the object that's pointed to by the field the
     option applies to.  The function must be of the type `void ()(void
     *, void *, gt_pointer_operator, void *)'.  The second parameter is
     the pointed-to object; the third parameter is a routine that,
     given a pointer, can update it to its new value.  The fourth
     parameter is a cookie to be passed to the third parameter.  The
     first parameter is the structure that contains the object, or the
     object itself if it is a structure.

     No data structure may depend on the absolute value of pointers.
     Even relying on relative orderings and using `reorder' functions
     can be expensive.  It is better to depend on properties of the
     data, like an ID number or the hash of a string instead.

`special'
     The `special' option is used for those bizarre cases that are just
     too hard to deal with otherwise.  Don't use it for new code.


File: gccint.info,  Node: GGC Roots,  Next: Files,  Prev: GTY Options,  Up: Type Information

Marking Roots for the Garbage Collector
=======================================

   In addition to keeping track of types, the type machinery also
locates the global variables that the garbage collector starts at.
There are two syntaxes it accepts to indicate a root:

  1. extern GTY (([options])) [type] ID;

  2. static GTY (([options])) [type] ID;

   These are the only syntaxes that are accepted.  In particular, if you
want to mark a variable that is only declared as

int ID;
 or similar, you should either make it `static' or you should create a
`extern' declaration in a header file somewhere.


File: gccint.info,  Node: Files,  Prev: GGC Roots,  Up: Type Information

Source Files Containing Type Information
========================================

   Whenever you add `GTY' markers to a new source file, there are three
things you need to do:

  1. You need to add the file to the list of source files the type
     machinery scans.  There are three cases:

       a. For a back-end file, this is usually done automatically; if
          not, you should add it to `target_gtfiles' in the appropriate
          port's entries in `config.gcc'.

       b. For files shared by all front ends, this is done by adding the
          filename to the `GTFILES' variable in `Makefile.in'.

       c. For any other file used by a front end, this is done by
          adding the filename to the `gtfiles' variable defined in
          `config-lang.in'.  For C, the file is `c-config-lang.in'.
          This list should include all files that have GTY macros in
          them that are used in that front end, other than those
          defined in the previous list items.  For example, it is
          common for front end writers to use `c-common.c' and other
          files from the C front end, and these should be included in
          the `gtfiles' variable for such front ends.


  2. If the file was a header file, you'll need to check that it's
     included in the right place to be visible to the generated files.
     For a back-end header file, this should be done automatically.
     For a front-end header file, it needs to be included by the same
     file that includes `gtype-LANG.h'.  For other header files, it
     needs to be included in `gtype-desc.c', which is a generated file,
     so add it to `ifiles' in `open_base_file' in `gengtype.c'.

     For source files that aren't header files, the machinery will
     generate a header file that should be included in the source file
     you just changed.  The file will be called `gt-PATH.h' where PATH
     is the pathname relative to the `gcc' directory with slashes
     replaced by -, so for example the header file to be included in
     `objc/objc-parse.c' is called `gt-objc-objc-parse.c'.  The
     generated header file should be included after everything else in
     the source file.  Don't forget to mention this file as a
     dependency in the `Makefile'!

  3. If a new `gt-PATH.h' file is needed, you need to arrange to add a
     `Makefile' rule that will ensure this file can be built.  This is
     done by making it a dependency of `s-gtype', like this:

     gt-path.h : s-gtype ; @true

   For language frontends, there is another file that needs to be
included somewhere.  It will be called `gtype-LANG.h', where LANG is
the name of the subdirectory the language is contained in.  It will
need `Makefile' rules just like the other generated files.


File: gccint.info,  Node: Funding,  Next: GNU Project,  Prev: Type Information,  Up: Top

Funding Free Software
*********************

   If you want to have more free software a few years from now, it makes
sense for you to help encourage people to contribute funds for its
development.  The most effective approach known is to encourage
commercial redistributors to donate.

   Users of free software systems can boost the pace of development by
encouraging for-a-fee distributors to donate part of their selling price
to free software developers--the Free Software Foundation, and others.

   The way to convince distributors to do this is to demand it and
expect it from them.  So when you compare distributors, judge them
partly by how much they give to free software development.  Show
distributors they must compete to be the one who gives the most.

   To make this approach work, you must insist on numbers that you can
compare, such as, "We will donate ten dollars to the Frobnitz project
for each disk sold."  Don't be satisfied with a vague promise, such as
"A portion of the profits are donated," since it doesn't give a basis
for comparison.

   Even a precise fraction "of the profits from this disk" is not very
meaningful, since creative accounting and unrelated business decisions
can greatly alter what fraction of the sales price counts as profit.
If the price you pay is $50, ten percent of the profit is probably less
than a dollar; it might be a few cents, or nothing at all.

   Some redistributors do development work themselves.  This is useful
too; but to keep everyone honest, you need to inquire how much they do,
and what kind.  Some kinds of development make much more long-term
difference than others.  For example, maintaining a separate version of
a program contributes very little; maintaining the standard version of a
program for the whole community contributes much.  Easy new ports
contribute little, since someone else would surely do them; difficult
ports such as adding a new CPU to the GNU Compiler Collection
contribute more; major new features or packages contribute the most.

   By establishing the idea that supporting further development is "the
proper thing to do" when distributing free software for a fee, we can
assure a steady flow of resources into making more free software.

     Copyright (C) 1994 Free Software Foundation, Inc.
     Verbatim copying and redistribution of this section is permitted
     without royalty; alteration is not permitted.


File: gccint.info,  Node: GNU Project,  Next: Copying,  Prev: Funding,  Up: Top

The GNU Project and GNU/Linux
*****************************

   The GNU Project was launched in 1984 to develop a complete Unix-like
operating system which is free software: the GNU system.  (GNU is a
recursive acronym for "GNU's Not Unix"; it is pronounced "guh-NEW".)
Variants of the GNU operating system, which use the kernel Linux, are
now widely used; though these systems are often referred to as "Linux",
they are more accurately called GNU/Linux systems.

   For more information, see:
     `http://www.gnu.org/'
     `http://www.gnu.org/gnu/linux-and-gnu.html'


File: gccint.info,  Node: Copying,  Next: GNU Free Documentation License,  Prev: GNU Project,  Up: Top

GNU GENERAL PUBLIC LICENSE
**************************

                         Version 2, June 1991
     Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
     
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.

Preamble
========

   The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

   When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it in
new free programs; and that you know you can do these things.

   To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

   For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

   We protect your rights with two steps: (1) copyright the software,
and (2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

   Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

   Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

   The precise terms and conditions for copying, distribution and
modification follow.

    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  0. This License applies to any program or other work which contains a
     notice placed by the copyright holder saying it may be distributed
     under the terms of this General Public License.  The "Program",
     below, refers to any such program or work, and a "work based on
     the Program" means either the Program or any derivative work under
     copyright law: that is to say, a work containing the Program or a
     portion of it, either verbatim or with modifications and/or
     translated into another language.  (Hereinafter, translation is
     included without limitation in the term "modification".)  Each
     licensee is addressed as "you".

     Activities other than copying, distribution and modification are
     not covered by this License; they are outside its scope.  The act
     of running the Program is not restricted, and the output from the
     Program is covered only if its contents constitute a work based on
     the Program (independent of having been made by running the
     Program).  Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
     source code as you receive it, in any medium, provided that you
     conspicuously and appropriately publish on each copy an appropriate
     copyright notice and disclaimer of warranty; keep intact all the
     notices that refer to this License and to the absence of any
     warranty; and give any other recipients of the Program a copy of
     this License along with the Program.

     You may charge a fee for the physical act of transferring a copy,
     and you may at your option offer warranty protection in exchange
     for a fee.

  2. You may modify your copy or copies of the Program or any portion
     of it, thus forming a work based on the Program, and copy and
     distribute such modifications or work under the terms of Section 1
     above, provided that you also meet all of these conditions:

       a. You must cause the modified files to carry prominent notices
          stating that you changed the files and the date of any change.

       b. You must cause any work that you distribute or publish, that
          in whole or in part contains or is derived from the Program
          or any part thereof, to be licensed as a whole at no charge
          to all third parties under the terms of this License.

       c. If the modified program normally reads commands interactively
          when run, you must cause it, when started running for such
          interactive use in the most ordinary way, to print or display
          an announcement including an appropriate copyright notice and
          a notice that there is no warranty (or else, saying that you
          provide a warranty) and that users may redistribute the
          program under these conditions, and telling the user how to
          view a copy of this License.  (Exception: if the Program
          itself is interactive but does not normally print such an
          announcement, your work based on the Program is not required
          to print an announcement.)

     These requirements apply to the modified work as a whole.  If
     identifiable sections of that work are not derived from the
     Program, and can be reasonably considered independent and separate
     works in themselves, then this License, and its terms, do not
     apply to those sections when you distribute them as separate
     works.  But when you distribute the same sections as part of a
     whole which is a work based on the Program, the distribution of
     the whole must be on the terms of this License, whose permissions
     for other licensees extend to the entire whole, and thus to each
     and every part regardless of who wrote it.

     Thus, it is not the intent of this section to claim rights or
     contest your rights to work written entirely by you; rather, the
     intent is to exercise the right to control the distribution of
     derivative or collective works based on the Program.

     In addition, mere aggregation of another work not based on the
     Program with the Program (or with a work based on the Program) on
     a volume of a storage or distribution medium does not bring the
     other work under the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
     under Section 2) in object code or executable form under the terms
     of Sections 1 and 2 above provided that you also do one of the
     following:

       a. Accompany it with the complete corresponding machine-readable
          source code, which must be distributed under the terms of
          Sections 1 and 2 above on a medium customarily used for
          software interchange; or,

       b. Accompany it with a written offer, valid for at least three
          years, to give any third party, for a charge no more than your
          cost of physically performing source distribution, a complete
          machine-readable copy of the corresponding source code, to be
          distributed under the terms of Sections 1 and 2 above on a
          medium customarily used for software interchange; or,

       c. Accompany it with the information you received as to the offer
          to distribute corresponding source code.  (This alternative is
          allowed only for noncommercial distribution and only if you
          received the program in object code or executable form with
          such an offer, in accord with Subsection b above.)

     The source code for a work means the preferred form of the work for
     making modifications to it.  For an executable work, complete
     source code means all the source code for all modules it contains,
     plus any associated interface definition files, plus the scripts
     used to control compilation and installation of the executable.
     However, as a special exception, the source code distributed need
     not include anything that is normally distributed (in either
     source or binary form) with the major components (compiler,
     kernel, and so on) of the operating system on which the executable
     runs, unless that component itself accompanies the executable.

     If distribution of executable or object code is made by offering
     access to copy from a designated place, then offering equivalent
     access to copy the source code from the same place counts as
     distribution of the source code, even though third parties are not
     compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
     except as expressly provided under this License.  Any attempt
     otherwise to copy, modify, sublicense or distribute the Program is
     void, and will automatically terminate your rights under this
     License.  However, parties who have received copies, or rights,
     from you under this License will not have their licenses
     terminated so long as such parties remain in full compliance.

  5. You are not required to accept this License, since you have not
     signed it.  However, nothing else grants you permission to modify
     or distribute the Program or its derivative works.  These actions
     are prohibited by law if you do not accept this License.
     Therefore, by modifying or distributing the Program (or any work
     based on the Program), you indicate your acceptance of this
     License to do so, and all its terms and conditions for copying,
     distributing or modifying the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
     Program), the recipient automatically receives a license from the
     original licensor to copy, distribute or modify the Program
     subject to these terms and conditions.  You may not impose any
     further restrictions on the recipients' exercise of the rights
     granted herein.  You are not responsible for enforcing compliance
     by third parties to this License.

  7. If, as a consequence of a court judgment or allegation of patent
     infringement or for any other reason (not limited to patent
     issues), conditions are imposed on you (whether by court order,
     agreement or otherwise) that contradict the conditions of this
     License, they do not excuse you from the conditions of this
     License.  If you cannot distribute so as to satisfy simultaneously
     your obligations under this License and any other pertinent
     obligations, then as a consequence you may not distribute the
     Program at all.  For example, if a patent license would not permit
     royalty-free redistribution of the Program by all those who
     receive copies directly or indirectly through you, then the only
     way you could satisfy both it and this License would be to refrain
     entirely from distribution of the Program.

     If any portion of this section is held invalid or unenforceable
     under any particular circumstance, the balance of the section is
     intended to apply and the section as a whole is intended to apply
     in other circumstances.

     It is not the purpose of this section to induce you to infringe any
     patents or other property right claims or to contest validity of
     any such claims; this section has the sole purpose of protecting
     the integrity of the free software distribution system, which is
     implemented by public license practices.  Many people have made
     generous contributions to the wide range of software distributed
     through that system in reliance on consistent application of that
     system; it is up to the author/donor to decide if he or she is
     willing to distribute software through any other system and a
     licensee cannot impose that choice.

     This section is intended to make thoroughly clear what is believed
     to be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
     certain countries either by patents or by copyrighted interfaces,
     the original copyright holder who places the Program under this
     License may add an explicit geographical distribution limitation
     excluding those countries, so that distribution is permitted only
     in or among countries not thus excluded.  In such case, this
     License incorporates the limitation as if written in the body of
     this License.

  9. The Free Software Foundation may publish revised and/or new
     versions of the General Public License from time to time.  Such
     new versions will be similar in spirit to the present version, but
     may differ in detail to address new problems or concerns.

     Each version is given a distinguishing version number.  If the
     Program specifies a version number of this License which applies
     to it and "any later version", you have the option of following
     the terms and conditions either of that version or of any later
     version published by the Free Software Foundation.  If the Program
     does not specify a version number of this License, you may choose
     any version ever published by the Free Software Foundation.

 10. If you wish to incorporate parts of the Program into other free
     programs whose distribution conditions are different, write to the
     author to ask for permission.  For software which is copyrighted
     by the Free Software Foundation, write to the Free Software
     Foundation; we sometimes make exceptions for this.  Our decision
     will be guided by the two goals of preserving the free status of
     all derivatives of our free software and of promoting the sharing
     and reuse of software generally.

                                NO WARRANTY

 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
     WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
     LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
     HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
     WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
     NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE
     QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
     PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
     SERVICING, REPAIR OR CORRECTION.

 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
     WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
     MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE
     LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
     INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
     INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
     DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
     OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY
     OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
     ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

                      END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs
=============================================

   If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.

   To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

     ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES.
     Copyright (C) YEAR  NAME OF AUTHOR
     
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software Foundation,
     Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

   Also add information on how to contact you by electronic and paper
mail.

   If the program is interactive, make it output a short notice like
this when it starts in an interactive mode:

     Gnomovision version 69, Copyright (C) YEAR NAME OF AUTHOR
     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
     type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

   The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License.  Of course, the
commands you use may be called something other than `show w' and `show
c'; they could even be mouse-clicks or menu items--whatever suits your
program.

   You should also get your employer (if you work as a programmer) or
your school, if any, to sign a "copyright disclaimer" for the program,
if necessary.  Here is a sample; alter the names:

     Yoyodyne, Inc., hereby disclaims all copyright interest in the program
     `Gnomovision' (which makes passes at compilers) written by James Hacker.
     
     SIGNATURE OF TY COON, 1 April 1989
     Ty Coon, President of Vice

   This General Public License does not permit incorporating your
program into proprietary programs.  If your program is a subroutine
library, you may consider it more useful to permit linking proprietary
applications with the library.  If this is what you want to do, use the
GNU Library General Public License instead of this License.

