From kde-core-devel  Mon Sep 17 20:05:26 2001
From: Lubos Lunak <l.lunak () sh ! cvut ! cz>
Date: Mon, 17 Sep 2001 20:05:26 +0000
To: kde-core-devel
Subject: Fwd: Re: Reducing the number of conflicts in libraries
X-MARC-Message: https://marc.info/?l=kde-core-devel&m=100075715612503

----------  Předaná zpráva  ----------

Subject: Fwd: Re: Reducing the number of conflicts in libraries
Date: Mon, 17 Sep 2001 15:56:13 -0400
From: "Christophe Prud'homme" <prudhomm@MIT.EDU>
To: Lubos Lunak <l.lunak@sh.cvut.cz>

Hi unfortunately I don't have write access to kde-code-devel :(
I forward my email to you

best regards
C.

----------  Forwarded Message  ----------

Subject: Re: Reducing the number of conflicts in libraries
Date: Mon, 17 Sep 2001 15:55:17 -0400
From: Christophe Prud'homme <prudhomm@mit.edu>
To: kde-core-devel@mail.kde.org
Cc: kde-devel@mail.kde.org

Hum tell me if I am wrong but I think there is a mechanism in Gcc
to handle inline-function(if noinlining) and per-class vtable location
It can also be used in dealing with template instantiation  problems (see
 below) Consider the class MyClass

MyClass.hpp

#ifdef __GNUC__
#pragma interface
#endif

class MyClass
{};


MyClass.cpp

#ifdef __GNUC__
#pragma implementation
#endif

// implementation here ,,,


Not that it work also for templates using the -fexternal-template
go to
info:/gcc/Template

-- Copy of Info goc on G++ using
   info:/gcc/C++ Interface

`#pragma interface'
 `#pragma interface "SUBDIR/OBJECTS.h"'
      Use this directive in *header files* that define object classes,
      to save space in most of the object files that use those classes.
      Normally, local copies of certain information (backup copies of
      inline member functions, debugging information, and the internal
      tables that implement virtual functions) must be kept in each
      object file that includes class definitions.  You can use this
      pragma to avoid such duplication.  When a header file containing
      `#pragma interface' is included in a compilation, this auxiliary
      information will not be generated (unless the main input source
      file itself uses `#pragma implementation').  Instead, the object
      files will contain references to be resolved at link time.

      The second form of this directive is useful for the case where you
      have multiple headers with the same name in different directories.
      If you use this form, you must specify the same string to `#pragma
      implementation'.

 `#pragma implementation'
 `#pragma implementation "OBJECTS.h"'
      Use this pragma in a *main input file*, when you want full output
      from included header files to be generated (and made globally
      visible).  The included header file, in turn, should use `#pragma
      interface'.  Backup copies of inline member functions, debugging
      information, and the internal tables used to implement virtual
      functions are all generated in implementation files.

      If you use `#pragma implementation' with no argument, it applies to
      an include file with the same basename(1) as your source file.
      For example, in `allclass.cc', giving just `#pragma implementation'
      by itself is equivalent to `#pragma implementation "allclass.h"'.

      In versions of GNU C++ prior to 2.6.0 `allclass.h' was treated as
      an implementation file whenever you would include it from
      `allclass.cc' even if you never specified `#pragma
      implementation'.  This was deemed to be more trouble than it was
      worth, however, and disabled.

      If you use an explicit `#pragma implementation', it must appear in
      your source file *before* you include the affected header files.

      Use the string argument if you want a single implementation file to
      include code from multiple header files.  (You must also use
      `#include' to include the header file; `#pragma implementation'
      only specifies how to use the file--it doesn't actually include
      it.)

      There is no way to split up the contents of a single header file
      into multiple implementation files.

    `#pragma implementation' and `#pragma interface' also have an effect
 on function inlining.

    If you define a class in a header file marked with `#pragma
 interface', the effect on a function defined in that class is similar to
 an explicit `extern' declaration--the compiler emits no code at all to
 define an independent version of the function.  Its definition is used
 only for inlining with its callers.

    Conversely, when you include the same header file in a main source
 file that declares it as `#pragma implementation', the compiler emits
 code for the function itself; this defines a version of the function
 that can be found via pointers (or by callers compiled without
 inlining).  If all calls to the function can be inlined, you can avoid
 emitting the function by compiling with `-fno-implement-inlines'.  If
 any calls were not inlined, you will get linker errors.



bye

--

| Christophe Prud'homme, http://augustine.mit.edu/~prudhomm
| ICQ UIN: 24560867 Alias: Jesunix
|
| In theory, theory and practice are the same. In practice they are
| different.