home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / gcc / gcc261a.zoo / cat1 / g++.1 < prev    next >
Encoding:
Text File  |  1994-11-04  |  26.7 KB  |  595 lines

  1.  
  2.  
  3.  
  4. G++(1)                      GNU Tools                      G++(1)
  5.  
  6.  
  7. N✓NA✓AM✓ME✓E
  8.        g++ - GNU project C++ Compiler (v2.4)
  9.  
  10. S✓SY✓YN✓NO✓OP✓PS✓SI✓IS✓S
  11.        g++ [✓[_✓o_✓p_✓t_✓i_✓o_✓n | _✓f_✓i_✓l_✓e_✓n_✓a_✓m_✓e ]...
  12.  
  13. D✓DE✓ES✓SC✓CR✓RI✓IP✓PT✓TI✓IO✓ON✓N
  14.        The C and C++ compilers are integrated; g✓g+✓++✓+ is a script to
  15.        call g✓gc✓cc✓c w✓wi✓it✓th✓h o✓op✓pt✓ti✓io✓on✓ns✓s t✓to✓o  r✓re✓ec✓co✓og✓gn✓ni✓iz✓ze✓e  C✓C+✓++✓+.✓.   g✓gc✓cc✓c  processes
  16.        input  files  through  one or more of four stages: prepro-
  17.        cessing, compilation, assembly,  and  linking.   This  man
  18.        page  contains  full  descriptions  for  _✓o_✓n_✓l_✓y C++ specific
  19.        aspects of the compiler, though it also contains summaries
  20.        of some general-purpose options.  For a fuller explanation
  21.        of the compiler, see g✓gc✓cc✓c(1✓1).
  22.  
  23.        C++ source files use one of the suffixes `.✓.C✓C',  `.✓.c✓cc✓c',  or
  24.        `.✓.c✓cx✓xx✓x'; preprocessed C++ files use the suffix `.✓.i✓ii✓i'.
  25.  
  26. O✓OP✓PT✓TI✓IO✓ON✓NS✓S
  27.        There  are many command-line options, including options to
  28.        control details of optimization, warnings, and code gener-
  29.        ation,  which  are  common  to both g✓gc✓cc✓c and g✓g+✓++✓+.  For full
  30.        information on all options, see g✓gc✓cc✓c(1✓1).
  31.  
  32.        Options must be separate: `-✓-d✓dr✓r' is  quite  different  from
  33.        `-✓-d✓d -✓-r✓r '.
  34.  
  35.        Most `-✓-f✓f' and `-✓-W✓W' options have two contrary forms: -✓-f✓f_✓n_✓a_✓m_✓e
  36.        and -✓-f✓fn✓no✓o-✓-_✓n_✓a_✓m_✓e (or -✓-W✓W_✓n_✓a_✓m_✓e and  -✓-W✓Wn✓no✓o-✓-_✓n_✓a_✓m_✓e).  Only  the  non-
  37.        default forms are shown here.
  38.  
  39.  
  40.        -✓-c✓c     Compile  or  assemble  the source files, but do not
  41.               link.  The compiler output is an object file corre-
  42.               sponding to each source file.
  43.  
  44.        -✓-D✓D_✓m_✓a_✓c_✓r_✓o
  45.               Define macro _✓m_✓a_✓c_✓r_✓o with the string `1✓1' as its defi-
  46.               nition.
  47.  
  48.        -✓-D✓D_✓m_✓a_✓c_✓r_✓o=✓=_✓d_✓e_✓f_✓n
  49.               Define macro _✓m_✓a_✓c_✓r_✓o as _✓d_✓e_✓f_✓n.
  50.  
  51.        -✓-E✓E     Stop after the preprocessing stage; do not run  the
  52.               compiler proper.  The output is preprocessed source
  53.               code, which is sent to the standard output.
  54.  
  55.        -✓-f✓fa✓al✓ll✓l-✓-v✓vi✓ir✓rt✓tu✓ua✓al✓l
  56.               Treat all possible  member  functions  as  virtual,
  57.               implicitly.   All member functions (except for con-
  58.               structor functions and n✓ne✓ew✓w or d✓de✓el✓le✓et✓te✓e member  opera-
  59.               tors) are treated as virtual functions of the class
  60.               where they appear.
  61.  
  62.  
  63.  
  64. GNU Tools                   30apr1993                           1
  65.  
  66.  
  67.  
  68.  
  69.  
  70. G++(1)                      GNU Tools                      G++(1)
  71.  
  72.  
  73.               This does not mean that all calls to  these  member
  74.               functions  will  be made through the internal table
  75.               of virtual functions.   Under  some  circumstances,
  76.               the  compiler  can determine that a call to a given
  77.               virtual function can be  made  directly;  in  these
  78.               cases the calls are direct in any case.
  79.  
  80.        -✓-f✓fd✓do✓ol✓ll✓la✓ar✓rs✓s-✓-i✓in✓n-✓-i✓id✓de✓en✓nt✓ti✓if✓fi✓ie✓er✓rs✓s
  81.               Permit  the use of `$✓$' in identifiers.  Traditional
  82.               C allowed the character `$✓$' to form part of identi-
  83.               fiers;  by  default,  GNU C also allows this.  How-
  84.               ever, ANSI C forbids `$✓$' in  identifiers,  and  GNU
  85.               C++  also  forbids  it by default on most platforms
  86.               (though on some platforms it's enabled  by  default
  87.               for GNU C++ as well).
  88.  
  89.        -✓-f✓fe✓el✓li✓id✓de✓e-✓-c✓co✓on✓ns✓st✓tr✓ru✓uc✓ct✓to✓or✓rs✓s
  90.               Use  this  option  to  instruct  the compiler to be
  91.               smarter  about  when  it  can  elide  constructors.
  92.               Without this flag, GNU C++ and cfront both generate
  93.               effectively the same code for:
  94.  
  95.               A foo ();
  96.               A x (foo ());   // x initialized by `foo ()', no ctor called
  97.               A y = foo ();   // call to `foo ()' heads to tempo-
  98.               rary,
  99.                               // y is initialized from the tempo-
  100.               rary.
  101.  
  102.               Note  the difference!  With this flag, GNU C++ ini-
  103.               tializes `y✓y' directly from the call to f✓fo✓oo✓o (✓()✓) with-
  104.               out going through a temporary.
  105.  
  106.        -✓-f✓fe✓en✓nu✓um✓m-✓-i✓in✓nt✓t-✓-e✓eq✓qu✓ui✓iv✓v
  107.               Normally  GNU C++ allows conversion of e✓en✓nu✓um✓m to i✓in✓nt✓t,
  108.               but not the other way around.  Use this  option  if
  109.               you want GNU C++ to allow conversion of i✓in✓nt✓t to e✓en✓nu✓um✓m
  110.               as well.
  111.  
  112.        -✓-f✓fe✓ex✓xt✓te✓er✓rn✓na✓al✓l-✓-t✓te✓em✓mp✓pl✓la✓at✓te✓es✓s
  113.               Produce smaller code for template declarations,  by
  114.               generating  only  a  single  copy  of each template
  115.               function where it is defined.  To use  this  option
  116.               successfully, you must also mark all files that use
  117.               templates with either `#✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n' (the
  118.               definition)  or `#✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓in✓nt✓te✓er✓rf✓fa✓ac✓ce✓e' (declarations).
  119.  
  120.               When     your     code     is     compiled     with
  121.               `-✓-f✓fe✓ex✓xt✓te✓er✓rn✓na✓al✓l-✓-t✓te✓em✓mp✓pl✓la✓at✓te✓es✓s', all template instantiations
  122.               are external.  You must arrange for  all  necessary
  123.               instantiations  to  appear  in  the  implementation
  124.               file; you can do this with a  t✓ty✓yp✓pe✓ed✓de✓ef✓f  that  refer-
  125.               ences  each instantiation needed.  Conversely, when
  126.               you    compile    using    the    default    option
  127.  
  128.  
  129.  
  130. GNU Tools                   30apr1993                           2
  131.  
  132.  
  133.  
  134.  
  135.  
  136. G++(1)                      GNU Tools                      G++(1)
  137.  
  138.  
  139.               `-✓-f✓fn✓no✓o-✓-e✓ex✓xt✓te✓er✓rn✓na✓al✓l-✓-t✓te✓em✓mp✓pl✓la✓at✓te✓es✓s',  all template instantia-
  140.               tions are explicitly internal.
  141.  
  142.        -✓-f✓fn✓no✓o-✓-g✓gn✓nu✓u-✓-l✓li✓in✓nk✓ke✓er✓r
  143.               Do not output global initializations (such  as  C++
  144.               constructors  and  destructors) in the form used by
  145.               the GNU linker (on systems where the GNU linker  is
  146.               the  standard  method  of handling them).  Use this
  147.               option when you want to use a non-GNU linker, which
  148.               also  requires  using  the c✓co✓ol✓ll✓le✓ec✓ct✓t2✓2 program to make
  149.               sure the system linker  includes  constructors  and
  150.               destructors.   (c✓co✓ol✓ll✓le✓ec✓ct✓t2✓2  is included in the GNU CC
  151.               distribution.)  For systems  which  _✓m_✓u_✓s_✓t  use  c✓co✓ol✓l-✓-
  152.               l✓le✓ec✓ct✓t2✓2,  the compiler driver g✓gc✓cc✓c is configured to do
  153.               this automatically.
  154.  
  155.        -✓-f✓fm✓me✓em✓mo✓oi✓iz✓ze✓e-✓-l✓lo✓oo✓ok✓ku✓up✓ps✓s
  156.  
  157.        -✓-f✓fs✓sa✓av✓ve✓e-✓-m✓me✓em✓mo✓oi✓iz✓ze✓ed✓d
  158.               These flags are used to get the compiler to compile
  159.               programs  faster using heuristics.  They are not on
  160.               by default since they are only effective about half
  161.               the time.  The other half of the time programs com-
  162.               pile more slowly (and take more memory).
  163.  
  164.               The first time the compiler must build a call to  a
  165.               member function (or reference to a data member), it
  166.               must (1) determine  whether  the  class  implements
  167.               member  functions  of  that name; (2) resolve which
  168.               member function to call  (which  involves  figuring
  169.               out  what  sorts  of  type  conversions  need to be
  170.               made); and (3) check the visibility of  the  member
  171.               function  to  the  caller.   All of this adds up to
  172.               slower compilation.  Normally, the  second  time  a
  173.               call  is made to that member function (or reference
  174.               to that data member), it must go through  the  same
  175.               lengthy  process  again.  This means that code like
  176.               this
  177.  
  178.                 cout << "This " << p << " has " << n << " legs.\n";
  179.  
  180.               makes six passes through all three steps.  By using
  181.               a software cache, a ``hit''  significantly  reduces
  182.               this  cost.   Unfortunately, using the cache intro-
  183.               duces another layer of  mechanisms  which  must  be
  184.               implemented,   and  so  incurs  its  own  overhead.
  185.               `-✓-f✓fm✓me✓em✓mo✓oi✓iz✓ze✓e-✓-l✓lo✓oo✓ok✓ku✓up✓ps✓s' enables the software cache.
  186.  
  187.               Because access privileges (visibility)  to  members
  188.               and  member  functions may differ from one function
  189.               context to the next, g✓g+✓++✓+  may  need  to  flush  the
  190.               cache. With the `-✓-f✓fm✓me✓em✓mo✓oi✓iz✓ze✓e-✓-l✓lo✓oo✓ok✓ku✓up✓ps✓s' flag, the cache
  191.               is flushed after every function that  is  compiled.
  192.               The   `-fsave-memoized'   flag   enables  the  same
  193.  
  194.  
  195.  
  196. GNU Tools                   30apr1993                           3
  197.  
  198.  
  199.  
  200.  
  201.  
  202. G++(1)                      GNU Tools                      G++(1)
  203.  
  204.  
  205.               software cache, but when  the  compiler  determines
  206.               that  the  context  of  the  last function compiled
  207.               would yield the same access privileges of the  next
  208.               function  to compile, it preserves the cache.  This
  209.               is most helpful when defining many member functions
  210.               for  the  same  class: with the exception of member
  211.               functions which are friends of other classes,  each
  212.               member  function has exactly the same access privi-
  213.               leges as every other, and the  cache  need  not  be
  214.               flushed.
  215.  
  216.        -✓-f✓fn✓no✓o-✓-d✓de✓ef✓fa✓au✓ul✓lt✓t-✓-i✓in✓nl✓li✓in✓ne✓e
  217.               Do  not  make  member  functions  inline by default
  218.               merely because they are defined  inside  the  class
  219.               scope.   Otherwise,  when  you  specify  -✓-O✓O, member
  220.               functions defined inside class scope  are  compiled
  221.               inline  by  default;  i.e.,  you  don't need to add
  222.               `i✓in✓nl✓li✓in✓ne✓e' in front of the member function name.
  223.  
  224.        -✓-f✓fn✓no✓o-✓-s✓st✓tr✓ri✓ic✓ct✓t-✓-p✓pr✓ro✓ot✓to✓ot✓ty✓yp✓pe✓e
  225.               Consider the declaration i✓in✓nt✓t f✓fo✓oo✓o (✓()✓);✓;.  In C++, this
  226.               means that the function f✓fo✓oo✓o takes no arguments.  In
  227.               ANSI C, this is declared i✓in✓nt✓t f✓fo✓oo✓o(✓(v✓vo✓oi✓id✓d)✓);✓;.  With  the
  228.               flag  `-✓-f✓fn✓no✓o-✓-s✓st✓tr✓ri✓ic✓ct✓t-✓-p✓pr✓ro✓ot✓to✓ot✓ty✓yp✓pe✓e',  declaring functions
  229.               with no arguments is equivalent  to  declaring  its
  230.               argument  list  to be untyped, i.e., i✓in✓nt✓t f✓fo✓oo✓o (✓()✓);✓; is
  231.               equivalent to saying i✓in✓nt✓t f✓fo✓oo✓o (✓(.✓..✓..✓.)✓);✓;.
  232.  
  233.        -✓-f✓fn✓no✓on✓nn✓nu✓ul✓ll✓l-✓-o✓ob✓bj✓je✓ec✓ct✓ts✓s
  234.               Normally, GNU C++  makes  conservative  assumptions
  235.               about  objects  reached  through  references.   For
  236.               example, the compiler must check that  `a✓a'  is  not
  237.               null in code like the following:
  238.                   obj &a = g ();
  239.                   a.f (2);
  240.               Checking that references of this sort have non-null
  241.               values requires extra  code,  however,  and  it  is
  242.               unnecessary   for   many  programs.   You  can  use
  243.               `-✓-f✓fn✓no✓on✓nn✓nu✓ul✓ll✓l-✓-o✓ob✓bj✓je✓ec✓ct✓ts✓s' to omit the checks for null, if
  244.               your  program doesn't require the default checking.
  245.  
  246.        -✓-f✓fh✓ha✓an✓nd✓dl✓le✓e-✓-s✓si✓ig✓gn✓na✓at✓tu✓ur✓re✓es✓s
  247.  
  248.        -✓-f✓fn✓no✓o-✓-h✓ha✓an✓nd✓dl✓le✓e-✓-s✓si✓ig✓gn✓na✓at✓tu✓ur✓re✓es✓s
  249.               These options control the recognition of the s✓si✓ig✓gn✓na✓a-✓-
  250.               t✓tu✓ur✓re✓e  and  s✓si✓ig✓go✓of✓f constructs for specifying abstract
  251.               types.  By default, these constructs are not recog-
  252.               nized.
  253.  
  254.        -✓-f✓ft✓th✓hi✓is✓s-✓-i✓is✓s-✓-v✓va✓ar✓ri✓ia✓ab✓bl✓le✓e
  255.               The  incorporation  of user-defined free store man-
  256.               agement into C++ has made  assignment  to  t✓th✓hi✓is✓s  an
  257.               anachronism.   Therefore, by default GNU C++ treats
  258.               the type of t✓th✓hi✓is✓s in a member function of c✓cl✓la✓as✓ss✓s X✓X to
  259.  
  260.  
  261.  
  262. GNU Tools                   30apr1993                           4
  263.  
  264.  
  265.  
  266.  
  267.  
  268. G++(1)                      GNU Tools                      G++(1)
  269.  
  270.  
  271.               be  X✓X  *✓*c✓co✓on✓ns✓st✓t.   In  other  words, it is illegal to
  272.               assign to t✓th✓hi✓is✓s  within  a  class  member  function.
  273.               However,   for  backwards  compatibility,  you  can
  274.               invoke    the     old     behavior     by     using
  275.               `-✓-f✓ft✓th✓hi✓is✓s-✓-i✓is✓s-✓-v✓va✓ar✓ri✓ia✓ab✓bl✓le✓e'.
  276.  
  277.        -✓-g✓g     Produce debugging information in the operating sys-
  278.               tem's native format (for DBX or SDB or DWARF).  GDB
  279.               also  can work with this debugging information.  On
  280.               most systems that use DBX format, `-✓-g✓g' enables  use
  281.               of  extra  debugging  information that only GDB can
  282.               use.
  283.  
  284.               Unlike most other C compilers, GNU CC allows you to
  285.               use  `-✓-g✓g'  with `-✓-O✓O'.  The shortcuts taken by opti-
  286.               mized  code  may  occasionally  produce  surprising
  287.               results:  some variables you declared may not exist
  288.               at all; flow of control may briefly move where  you
  289.               did  not expect it; some statements may not be exe-
  290.               cuted because  they  compute  constant  results  or
  291.               their  values were already at hand; some statements
  292.               may execute in different places because  they  were
  293.               moved out of loops.
  294.  
  295.               Nevertheless  it proves possible to debug optimized
  296.               output.  This makes it reasonable to use the  opti-
  297.               mizer for programs that might have bugs.
  298.  
  299.        -✓-I✓I_✓d_✓i_✓r    Append  directory  _✓d_✓i_✓r to the list of directories
  300.               searched for include files.
  301.  
  302.        -✓-L✓L_✓d_✓i_✓r   Add directory _✓d_✓i_✓r to the list of directories to be
  303.               searched for `-✓-l✓l'.
  304.  
  305.        -✓-l✓l_✓l_✓i_✓b_✓r_✓a_✓r_✓y
  306.                 Use the library named _✓l_✓i_✓b_✓r_✓a_✓r_✓y when linking.  (C++
  307.               programs often require `-lg++' for successful link-
  308.               ing.)
  309.  
  310.        -✓-n✓no✓os✓st✓td✓di✓in✓nc✓c
  311.               Do  not  search the standard system directories for
  312.               header files.  Only the directories you have speci-
  313.               fied with -✓-I✓I options (and the current directory, if
  314.               appropriate) are searched.
  315.  
  316.        -✓-n✓no✓os✓st✓td✓di✓in✓nc✓c+✓++✓+
  317.               Do not search for  header  files  in  the  standard
  318.               directories  specific  to  C++, but do still search
  319.               the other standard directories.   (This  option  is
  320.               used when building libg++.)
  321.  
  322.        -✓-O✓O     Optimize.   Optimizing  compilation  takes somewhat
  323.               more time, and a lot more memory for a large  func-
  324.               tion.
  325.  
  326.  
  327.  
  328. GNU Tools                   30apr1993                           5
  329.  
  330.  
  331.  
  332.  
  333.  
  334. G++(1)                      GNU Tools                      G++(1)
  335.  
  336.  
  337.        -✓-o✓o _✓f_✓i_✓l_✓e
  338.                Place output in file _✓f_✓i_✓l_✓e.
  339.  
  340.        -✓-S✓S     Stop  after the stage of compilation proper; do not
  341.               assemble.  The output is an assembler code file for
  342.               each non-assembler input file specified.
  343.  
  344.        -✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l
  345.               Attempt  to  support  some aspects of traditional C
  346.               compilers.
  347.  
  348.               Specifically, for both C and C++ programs:
  349.  
  350.           +✓o   In the preprocessor, comments convert to nothing at
  351.               all,  rather  than  to a space.  This allows tradi-
  352.               tional token concatenation.
  353.  
  354.           +✓o   In the preprocessor, macro arguments are recognized
  355.               within  string constants in a macro definition (and
  356.               their values are stringified, though without  addi-
  357.               tional quote marks, when they appear in such a con-
  358.               text).  The preprocessor always considers a  string
  359.               constant to end at a newline.
  360.  
  361.           +✓o   The  preprocessor  does  not  predefine  the  macro
  362.               _✓__✓_S✓ST✓TD✓DC✓C_✓__✓_ when you  use  `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l',  but  still
  363.               predefines_✓__✓_G✓GN✓NU✓UC✓C_✓__✓_  (since the GNU extensions indi-
  364.               cated   by   _✓__✓_G✓GN✓NU✓UC✓C_✓__✓_   are   not    affected    by
  365.               `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l').  If you need to write header files
  366.               that  work   differently   depending   on   whether
  367.               `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l'  is in use, by testing both of these
  368.               predefined macros you can distinguish  four  situa-
  369.               tions:  GNU C, traditional GNU C, other ANSI C com-
  370.               pilers, and other old C compilers.
  371.  
  372.           +✓o   In the preprocessor, comments convert to nothing at
  373.               all,  rather  than  to a space.  This allows tradi-
  374.               tional token concatenation.
  375.  
  376.           +✓o   In the preprocessor, macro arguments are recognized
  377.               within  string constants in a macro definition (and
  378.               their values are stringified, though without  addi-
  379.               tional quote marks, when they appear in such a con-
  380.               text).  The preprocessor always considers a  string
  381.               constant to end at a newline.
  382.  
  383.           +✓o   The  preprocessor  does  not  predefine  the  macro
  384.               _✓__✓_S✓ST✓TD✓DC✓C_✓__✓_ when you  use  `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l',  but  still
  385.               predefines_✓__✓_G✓GN✓NU✓UC✓C_✓__✓_  (since the GNU extensions indi-
  386.               cated   by   _✓__✓_G✓GN✓NU✓UC✓C_✓__✓_   are   not    affected    by
  387.               `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l').  If you need to write header files
  388.               that  work   differently   depending   on   whether
  389.               `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l'  is in use, by testing both of these
  390.               predefined  macros   you   can   distinguish   four
  391.  
  392.  
  393.  
  394. GNU Tools                   30apr1993                           6
  395.  
  396.  
  397.  
  398.  
  399.  
  400. G++(1)                      GNU Tools                      G++(1)
  401.  
  402.  
  403.               situations:  GNU C, traditional GNU C, other ANSI C
  404.               compilers, and other old C compilers.
  405.  
  406.  
  407.           +✓o   String ``constants'' are not necessarily  constant;
  408.               they  are  stored  in writable space, and identical
  409.               looking constants are allocated separately.
  410.  
  411.               For C++ programs only (not C),  `-✓-t✓tr✓ra✓ad✓di✓it✓ti✓io✓on✓na✓al✓l'  has
  412.               one  additional  effect: assignment to t✓th✓hi✓is✓s is per-
  413.               mitted.   This  is  the  same  as  the  effect   of
  414.               `-✓-f✓ft✓th✓hi✓is✓s-✓-i✓is✓s-✓-v✓va✓ar✓ri✓ia✓ab✓bl✓le✓e'.
  415.  
  416.        -✓-U✓U_✓m_✓a_✓c_✓r_✓o
  417.               Undefine macro _✓m_✓a_✓c_✓r_✓o.
  418.  
  419.        -✓-W✓Wa✓al✓ll✓l  Issue  warnings  for  conditions  which  pertain to
  420.               usage  that  we  recommend  avoiding  and  that  we
  421.               believe  is easy to avoid, even in conjunction with
  422.               macros.
  423.  
  424.        -✓-W✓We✓en✓nu✓um✓m-✓-c✓cl✓la✓as✓sh✓h
  425.               Warn when converting between different  enumeration
  426.               types.
  427.  
  428.        -✓-W✓Wo✓ov✓ve✓er✓rl✓lo✓oa✓ad✓de✓ed✓d-✓-v✓vi✓ir✓rt✓tu✓ua✓al✓l
  429.               In  a  derived  class,  the  definitions of virtual
  430.               functions must match the type signature of  a  vir-
  431.               tual function declared in the base class.  Use this
  432.               option to request warnings  when  a  derived  class
  433.               declares  a  function  that  may  be  an  erroneous
  434.               attempt to define a virtual function: that is, warn
  435.               when  a  function  with  the same name as a virtual
  436.               function in the base class, but with a type  signa-
  437.               ture  that doesn't match any virtual functions from
  438.               the base class.
  439.  
  440.        -✓-W✓Wt✓te✓em✓mp✓pl✓la✓at✓te✓e-✓-d✓de✓eb✓bu✓ug✓gg✓gi✓in✓ng✓g
  441.               When using templates in  a  C++  program,  warn  if
  442.               debugging is not yet fully available.
  443.  
  444.        -✓-w✓w     Inhibit all warning messages.
  445.  
  446.        +✓+e✓e_✓N    Control  how virtual function definitions are used,
  447.               in a fashion compatible with c✓cf✓fr✓ro✓on✓nt✓t 1.x.
  448.  
  449.  
  450.  
  451. P✓PR✓RA✓AG✓GM✓MA✓AS✓S
  452.        Two `#✓#p✓pr✓ra✓ag✓gm✓ma✓a' directives are supported  for  GNU  C++,  to
  453.        permit  using  the same header file for two purposes: as a
  454.        definition of interfaces to a given object class,  and  as
  455.        the  full definition of the contents of that object class.
  456.  
  457.  
  458.  
  459.  
  460. GNU Tools                   30apr1993                           7
  461.  
  462.  
  463.  
  464.  
  465.  
  466. G++(1)                      GNU Tools                      G++(1)
  467.  
  468.  
  469.        #✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓in✓nt✓te✓er✓rf✓fa✓ac✓ce✓e
  470.               Use this directive  in  header  files  that  define
  471.               object classes, to save space in most of the object
  472.               files that  use  those  classes.   Normally,  local
  473.               copies  of  certain  information  (backup copies of
  474.               inline member functions, debugging information, and
  475.               the  internal  tables  that implement virtual func-
  476.               tions) must  be  kept  in  each  object  file  that
  477.               includes  class  definitions.   You  can  use  this
  478.               pragma to avoid such duplication.   When  a  header
  479.               file  containing `#✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓in✓nt✓te✓er✓rf✓fa✓ac✓ce✓e' is included in
  480.               a compilation, this auxiliary information will  not
  481.               be  generated  (unless  the  main input source file
  482.               itself uses  `#✓#p✓pr✓ra✓ag✓gm✓ma✓a  i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n').   Instead,
  483.               the  object  files  will  contain  references to be
  484.               resolved at link time.
  485.  
  486.        #✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n
  487.  
  488.        #✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n "✓"_✓o_✓b_✓j_✓e_✓c_✓t_✓s.✓.h✓h"✓"
  489.               Use this pragma in a main input file, when you want
  490.               full output from included header files to be gener-
  491.               ated (and made  globally  visible).   The  included
  492.               header   file,   in   turn,   should  use  `#✓#p✓pr✓ra✓ag✓gm✓ma✓a
  493.               i✓in✓nt✓te✓er✓rf✓fa✓ac✓ce✓e'.  Backup copies of inline  member  func-
  494.               tions,  debugging  information,  and  the  internal
  495.               tables used to implement virtual functions are  all
  496.               generated in implementation files.
  497.  
  498.               If  you  use `#✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n' with no argu-
  499.               ment, it applies to an include file with  the  same
  500.               basename  as  your  source  file;  for  example, in
  501.               `a✓al✓ll✓lc✓cl✓la✓as✓ss✓s.✓.c✓cc✓c', `#✓#p✓pr✓ra✓ag✓gm✓ma✓a i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n'  by  itself
  502.               is    equivalent    to    `#✓#p✓pr✓ra✓ag✓gm✓ma✓a   i✓im✓mp✓pl✓le✓em✓me✓en✓nt✓ta✓at✓ti✓io✓on✓n
  503.               "✓"a✓al✓ll✓lc✓cl✓la✓as✓ss✓s.✓.h✓h"✓"'.  Use the string argument if you want
  504.               a  single  implementation file to include code from
  505.               multiple header files.
  506.  
  507.               There is no way to split up the contents of a  sin-
  508.               gle header file into multiple implementation files.
  509.  
  510. F✓FI✓IL✓LE✓ES✓S
  511.        file.h             C header (preprocessor) file
  512.        file.i             preprocessed C source file
  513.        file.C             C++ source file
  514.        file.cc            C++ source file
  515.        file.cxx           C++ source file
  516.        file.s             assembly language file
  517.        file.o             object file
  518.        a.out              link edited output
  519.        _✓T_✓M_✓P_✓D_✓I_✓R/cc*         temporary files
  520.        _✓L_✓I_✓B_✓D_✓I_✓R/cpp         preprocessor
  521.        _✓L_✓I_✓B_✓D_✓I_✓R/cc1plus     compiler
  522.        _✓L_✓I_✓B_✓D_✓I_✓R/collect     linker  front  end   needed   on   some
  523.  
  524.  
  525.  
  526. GNU Tools                   30apr1993                           8
  527.  
  528.  
  529.  
  530.  
  531.  
  532. G++(1)                      GNU Tools                      G++(1)
  533.  
  534.  
  535.        machines
  536.        _✓L_✓I_✓B_✓D_✓I_✓R/libgcc.a    GCC subroutine library
  537.        /lib/crt[01n].o    start-up routine
  538.        _✓L_✓I_✓B_✓D_✓I_✓R/ccrt0       additional start-up routine for C++
  539.        /lib/libc.a        standard C library, see _✓i_✓n_✓t_✓r_✓o(3)
  540.        /usr/include       standard directory for #✓#i✓in✓nc✓cl✓lu✓ud✓de✓e files
  541.        _✓L_✓I_✓B_✓D_✓I_✓R/include     standard  gcc  directory  for  #✓#i✓in✓nc✓cl✓lu✓ud✓de✓e
  542.        files
  543.        _✓L_✓I_✓B_✓D_✓I_✓R/g++-include additional g++ directory for #✓#i✓in✓nc✓cl✓lu✓ud✓de✓e
  544.  
  545.        _✓L_✓I_✓B_✓D_✓I_✓R is usually /✓/u✓us✓sr✓r/✓/l✓lo✓oc✓ca✓al✓l/✓/l✓li✓ib✓b/✓/_✓m_✓a_✓c_✓h_✓i_✓n_✓e/_✓v_✓e_✓r_✓s_✓i_✓o_✓n.
  546.        _✓T_✓M_✓P_✓D_✓I_✓R comes from the environment variable T✓TM✓MP✓PD✓DI✓IR✓R (default
  547.        /✓/u✓us✓sr✓r/✓/t✓tm✓mp✓p if available, else /✓/t✓tm✓mp✓p).
  548.  
  549. S✓SE✓EE✓E A✓AL✓LS✓SO✓O
  550.        gcc(1),  cpp(1),  as(1),  ld(1),  gdb(1),  adb(1), dbx(1),
  551.        sdb(1).
  552.        `g✓gc✓cc✓c', `c✓cp✓pp✓p', `a✓as✓s',`✓`ld'✓',✓, and `g✓gd✓db✓b' entries in i✓in✓nf✓fo✓o.
  553.        _✓U_✓s_✓i_✓n_✓g _✓a_✓n_✓d _✓P_✓o_✓r_✓t_✓i_✓n_✓g _✓G_✓N_✓U _✓C_✓C _✓(_✓f_✓o_✓r  _✓v_✓e_✓r_✓s_✓i_✓o_✓n  _✓2_✓._✓0_✓),  Richard  M.
  554.        Stallman;  _✓T_✓h_✓e _✓C _✓P_✓r_✓e_✓p_✓r_✓o_✓c_✓e_✓s_✓s_✓o_✓r, Richard M. Stallman; _✓D_✓e_✓b_✓u_✓g_✓-
  555.        _✓g_✓i_✓n_✓g _✓w_✓i_✓t_✓h _✓G_✓D_✓B_✓: _✓t_✓h_✓e _✓G_✓N_✓U _✓S_✓o_✓u_✓r_✓c_✓e_✓-_✓L_✓e_✓v_✓e_✓l _✓D_✓e_✓b_✓u_✓g_✓g_✓e_✓r,  Richard  M.
  556.        Stallman and Roland H. Pesch; _✓U_✓s_✓i_✓n_✓g _✓a_✓s_✓: _✓t_✓h_✓e _✓G_✓N_✓U _✓A_✓s_✓s_✓e_✓m_✓b_✓l_✓e_✓r,
  557.        Dean Elsner, Jay Fenlason & friends; _✓g_✓l_✓d_✓: _✓t_✓h_✓e _✓G_✓N_✓U  _✓l_✓i_✓n_✓k_✓e_✓r,
  558.        Steve Chamberlain and Roland Pesch.
  559.  
  560.  
  561. B✓BU✓UG✓GS✓S
  562.        For  instructions  on how to report bugs, see the GCC man-
  563.        ual.
  564.  
  565.  
  566. C✓CO✓OP✓PY✓YI✓IN✓NG✓G
  567.        Copyright (c) 1991, 1992, 1993 Free  Software  Foundation,
  568.        Inc.
  569.  
  570.        Permission  is  granted  to  make  and distribute verbatim
  571.        copies of this manual provided the  copyright  notice  and
  572.        this permission notice are preserved on all copies.
  573.  
  574.        Permission is granted to copy and distribute modified ver-
  575.        sions of this manual under  the  conditions  for  verbatim
  576.        copying,  provided  that the entire resulting derived work
  577.        is distributed under the  terms  of  a  permission  notice
  578.        identical to this one.
  579.  
  580.        Permission  is granted to copy and distribute translations
  581.        of this manual into another language, under the above con-
  582.        ditions for modified versions, except that this permission
  583.        notice may be included in  translations  approved  by  the
  584.        Free  Software  Foundation  instead  of  in  the  original
  585.        English.
  586.  
  587. A✓AU✓UT✓TH✓HO✓OR✓RS✓S
  588.        See the GNU CC Manual for the contributors to GNU CC.
  589.  
  590.  
  591.  
  592. GNU Tools                   30apr1993                           9
  593.  
  594.  
  595.