home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 6 / FreshFish_September1994.bin / gnu / info / gcc.info-10 (.txt) < prev    next >
GNU Info File  |  1994-09-02  |  41KB  |  697 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.54 from the input
  2. file gcc.texi.
  3.    This file documents the use and the internals of the GNU compiler.
  4.    Published by the Free Software Foundation 675 Massachusetts Avenue
  5. Cambridge, MA 02139 USA
  6.    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
  7.    Permission is granted to make and distribute verbatim copies of this
  8. manual provided the copyright notice and this permission notice are
  9. preserved on all copies.
  10.    Permission is granted to copy and distribute modified versions of
  11. this manual under the conditions for verbatim copying, provided also
  12. that the sections entitled "GNU General Public License" and "Protect
  13. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  14. original, and provided that the entire resulting derived work is
  15. distributed under the terms of a permission notice identical to this
  16.    Permission is granted to copy and distribute translations of this
  17. manual into another language, under the above conditions for modified
  18. versions, except that the sections entitled "GNU General Public
  19. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  20. permission notice, may be included in translations approved by the Free
  21. Software Foundation instead of in the original English.
  22. File: gcc.info,  Node: Incompatibilities,  Next: Fixed Headers,  Prev: External Bugs,  Up: Trouble
  23. Incompatibilities of GNU CC
  24. ===========================
  25.    There are several noteworthy incompatibilities between GNU C and most
  26. existing (non-ANSI) versions of C.  The `-traditional' option
  27. eliminates many of these incompatibilities, *but not all*, by telling
  28. GNU C to behave like the other C compilers.
  29.    * GNU CC normally makes string constants read-only.  If several
  30.      identical-looking string constants are used, GNU CC stores only one
  31.      copy of the string.
  32.      One consequence is that you cannot call `mktemp' with a string
  33.      constant argument.  The function `mktemp' always alters the string
  34.      its argument points to.
  35.      Another consequence is that `sscanf' does not work on some systems
  36.      when passed a string constant as its format control string or
  37.      input.  This is because `sscanf' incorrectly tries to write into
  38.      the string constant.  Likewise `fscanf' and `scanf'.
  39.      The best solution to these problems is to change the program to use
  40.      `char'-array variables with initialization strings for these
  41.      purposes instead of string constants.  But if this is not possible,
  42.      you can use the `-fwritable-strings' flag, which directs GNU CC to
  43.      handle string constants the same way most C compilers do.
  44.      `-traditional' also has this effect, among others.
  45.    * `-2147483648' is positive.
  46.      This is because 2147483648 cannot fit in the type `int', so
  47.      (following the ANSI C rules) its data type is `unsigned long int'.
  48.      Negating this value yields 2147483648 again.
  49.    * GNU CC does not substitute macro arguments when they appear inside
  50.      of string constants.  For example, the following macro in GNU CC
  51.           #define foo(a) "a"
  52.      will produce output `"a"' regardless of what the argument A is.
  53.      The `-traditional' option directs GNU CC to handle such cases
  54.      (among others) in the old-fashioned (non-ANSI) fashion.
  55.    * When you use `setjmp' and `longjmp', the only automatic variables
  56.      guaranteed to remain valid are those declared `volatile'.  This is
  57.      a consequence of automatic register allocation.  Consider this
  58.      function:
  59.           jmp_buf j;
  60.           
  61.           foo ()
  62.           {
  63.             int a, b;
  64.           
  65.             a = fun1 ();
  66.             if (setjmp (j))
  67.               return a;
  68.           
  69.             a = fun2 ();
  70.             /* `longjmp (j)' may occur in `fun3'. */
  71.             return a + fun3 ();
  72.           }
  73.      Here `a' may or may not be restored to its first value when the
  74.      `longjmp' occurs.  If `a' is allocated in a register, then its
  75.      first value is restored; otherwise, it keeps the last value stored
  76.      in it.
  77.      If you use the `-W' option with the `-O' option, you will get a
  78.      warning when GNU CC thinks such a problem might be possible.
  79.      The `-traditional' option directs GNU C to put variables in the
  80.      stack by default, rather than in registers, in functions that call
  81.      `setjmp'.  This results in the behavior found in traditional C
  82.      compilers.
  83.    * Programs that use preprocessor directives in the middle of macro
  84.      arguments do not work with GNU CC.  For example, a program like
  85.      this will not work:
  86.           foobar (
  87.           #define luser
  88.                   hack)
  89.      ANSI C does not permit such a construct.  It would make sense to
  90.      support it when `-traditional' is used, but it is too much work to
  91.      implement.
  92.    * Declarations of external variables and functions within a block
  93.      apply only to the block containing the declaration.  In other
  94.      words, they have the same scope as any other declaration in the
  95.      same place.
  96.      In some other C compilers, a `extern' declaration affects all the
  97.      rest of the file even if it happens within a block.
  98.      The `-traditional' option directs GNU C to treat all `extern'
  99.      declarations as global, like traditional compilers.
  100.    * In traditional C, you can combine `long', etc., with a typedef
  101.      name, as shown here:
  102.           typedef int foo;
  103.           typedef long foo bar;
  104.      In ANSI C, this is not allowed: `long' and other type modifiers
  105.      require an explicit `int'.  Because this criterion is expressed by
  106.      Bison grammar rules rather than C code, the `-traditional' flag
  107.      cannot alter it.
  108.    * PCC allows typedef names to be used as function parameters.  The
  109.      difficulty described immediately above applies here too.
  110.    * PCC allows whitespace in the middle of compound assignment
  111.      operators such as `+='.  GNU CC, following the ANSI standard, does
  112.      not allow this.  The difficulty described immediately above
  113.      applies here too.
  114.    * GNU CC complains about unterminated character constants inside of
  115.      preprocessor conditionals that fail.  Some programs have English
  116.      comments enclosed in conditionals that are guaranteed to fail; if
  117.      these comments contain apostrophes, GNU CC will probably report an
  118.      error.  For example, this code would produce an error:
  119.           #if 0
  120.           You can't expect this to work.
  121.           #endif
  122.      The best solution to such a problem is to put the text into an
  123.      actual C comment delimited by `/*...*/'.  However, `-traditional'
  124.      suppresses these error messages.
  125.    * Many user programs contain the declaration `long time ();'.  In the
  126.      past, the system header files on many systems did not actually
  127.      declare `time', so it did not matter what type your program
  128.      declared it to return.  But in systems with ANSI C headers, `time'
  129.      is declared to return `time_t', and if that is not the same as
  130.      `long', then `long time ();' is erroneous.
  131.      The solution is to change your program to use `time_t' as the
  132.      return type of `time'.
  133.    * When compiling functions that return `float', PCC converts it to a
  134.      double.  GNU CC actually returns a `float'.  If you are concerned
  135.      with PCC compatibility, you should declare your functions to return
  136.      `double'; you might as well say what you mean.
  137.    * When compiling functions that return structures or unions, GNU CC
  138.      output code normally uses a method different from that used on most
  139.      versions of Unix.  As a result, code compiled with GNU CC cannot
  140.      call a structure-returning function compiled with PCC, and vice
  141.      versa.
  142.      The method used by GNU CC is as follows: a structure or union
  143.      which is 1, 2, 4 or 8 bytes long is returned like a scalar.  A
  144.      structure or union with any other size is stored into an address
  145.      supplied by the caller (usually in a special, fixed register, but
  146.      on some machines it is passed on the stack).  The
  147.      machine-description macros `STRUCT_VALUE' and
  148.      `STRUCT_INCOMING_VALUE' tell GNU CC where to pass this address.
  149.      By contrast, PCC on most target machines returns structures and
  150.      unions of any siz