On 13 January 2011 11:09, Achilleas Margaritis wrote:
> On Wed, Jan 12, 2011 at 6:16 PM, David Brown <da...@westcontrol.com> wrote:
>>
>> I can see how such a feature could be useful, but is there any reason why it
>> should be part of gcc, rather than a separate program that takes a cpp file
>> and generates an hpp file? Such a program would be much easier to develop
>> and maintain than a new gcc pragma, and more flexible (for example, it could
>> be used with other compilers). Your timestamp checking features are easily
>> accomplished with make.
A makefile is a better place to do it than in the compiler, as well as
the reasons David gave, a separate tool invoked by make allows
project-specific filename conventions. Otherwise, if it was done by
the compiler, should it consider any of foo.cpp, foo.cp, foo.cxx,
foo.cc, foo.C etc. as a valid source for foo.hpp? Or are only
certain transformations allowed e.g. .cpp -> .hpp, .cc -> .hh, .cxx ->
.hxx (?)
You also don't need any special pragma, just list foo.hpp as a
dependency and define a rule for generating foo.hpp from foo.cpp
main.o: foo.hpp
foo.hpp: foo.cpp
cpp2hpp $^ -o $@
That would work, and the code would be 100% valid C++ without a
non-portable pragma.
> The GCC contains all the necessary code for parsing C++. An external
> program would have to use a custom parser (which is a lot of work,
> since C++ is a very complex language), or LLVM (which may or may not
> be 100% compatible with GCC yet, and which may or may not contain all
> the GCC features). Doing it from within GCC guarantees code reuse and
> consistency with the compiler, plus compatibility with the new c++
> standard, which GCC already largely implements.
The tool doesn't need to fully parse C++, it only needs to recognise a
definition and produce a declaration for it,
> Furthermore, the compiler would need to handle the clash of
> declarations between the generated header and the implementation file.
> As any compiler is implemented right now, declaring the same class
> twice will generate an error.
That would only be a problem if foo.cpp includes foo.hpp, but why
would it do that if foo.hpp is generated?
> Additionally, providing such a functionality through GCC would not
> have the maintenance overhead of an externally managed application:
> once GCC is updated to a version with this functionality, this
> functionality would become instantly available.
>
> Finally, GCC is one of the most visible projects when it comes to c++
> compilers. If GCC had such a functionality, I think that many people
> would jump to the opportunity to use this functionality, and therefore
> it could be part of the language standard in the far future.
I seriously doubt that. The modules proposal Ian referred to is far
more likely to become part of the standard.
However, if you think this feature would be useful you are free to
implement it, or pay someone else to do so - that's the beauty of Free
Software.
