[CMake] cmake support Eclipse

Tue Jul 31 10:15:46 EDT 2007

I have been following this thread and I guess it is time to chime it  
a bit with what I know. First my background. I used Eclipse since '03  
for Java development then switched in mid '06 to C++ development with  
Eclipse/CDT so I have a fair amount of experience with Eclipse, Ant  
and about a year of full time CDT and CMake.

I am just going to rattle off some answers/corrections to the various  
items that have been posted in this thread:

Eclipse Plugin Development: Usually you develop a plugin for Eclipse  
using their PDE (Plugin Development Environment). This is almost  
certainly going to be written in Java with maybe a small JNI module  
if you absolutely need to jump across the Java/Native bridge to do  
something in the C++ world. Eclipse will manage the build of your  
plugin using what ever build mechanism Eclipse uses for Java.

CDT Projects: There are 2 kinds of CDT projects; 'Managed Makefile'  
and 'Makefile'. In the 'Managed Makefile' project Eclipse basically  
does the project management for you and then creates a Makefile  
behind the scenes and then invokes that makefile to build your  
project. In a 'Makefile' project you bring your own makefile to the  
project. CDT just provides the IDE environment. The major downside to  
the 'Managed Makefile' project is that there is really only 1  
'Target' in your project, so anything past a basic "hello World" or  
"Hello Library" is beyond the capability of CDT (at least how I  
understand it), which is why I am guess that most people use the  
"Makefile" project so they can have 1 project with lots of  
"targets" ( Library, Executable, Testing harness).

Right Tool for the Right Job: As stated in previous messages, CMake  
is a great "Generator" of 'project files' ( Makefile, Xcode, VS,  
Nmake) for typically C/C++ projects. ( I have no experience with any  
other language + CMake). Ant is a just as awesome build system for  
Java. Use the right tool for the right job. If I am doing Java Dev,  
CMake will NEVER enter the picture. If I am doing C/C++ dev then Ant  
will NEVER enter the picture. If CMake generated an Ant xml file for  
java projects then you may be onto something.

Cmake File Editing: There is a plugin at http://www.cthing.com/ 
CMakeEd.asp that adds a nice editor to Eclipse that makes editing  
CMake files easier. It offers syntax highlighting, command completion  
and integrated documentation. Very nicely done.

Current CMake/Eclipse Integration: http://www.cmake.org/Wiki/ 
CMake:Eclipse (which I wrote) goes over the current state of affairs  
in using CMake with Eclipse. Generally after bootstrapping the  
process things are pretty smooth as cmake will make sure your  
makefiles are up to date if you change the CMakeLists.txt file. Where  
things are NOT smooth is if you are making MAJOR changes to your  
CMakeLists.txt files then I find that I need to use an external  
"Terminal" program to clean things out and re-invoke ccmake to set my  
project up again.

On the Eclipse download page http://www.eclipse.org/downloads/ there  
is a specific selection to download just the base eclipse + CDT  
without all the extra java IDE stuff. This works rather nicely. If  
you need to have some XML editing capability (say for paraview  
development) then you can easily download the proper XML editors for  
that function.

<opinion>CMake would have an extremely difficult time luring java  
developers from Ant or Maven to use Cmake for a build system and vice  
versa, Ant would have a difficult time luring c/c++ developers from  
cmake. Each party should concentrate on what they do best.</opinion>

Sorry for top posting..
-- 
Mike Jackson   Senior Research Engineer
Innovative Management & Technology Services

On Jul 31, 2007, at 3:05 AM, Eric Noulard wrote:

> 2007/7/31, Brandon Van Every <bvanevery at gmail.com>:
>> On 7/30/07, Andy Dingfelder <DingfelderA at sirtrack.com> wrote:
>>
>>> Building java apps it typically done using Maven or Ant, and I  
>>> see no
>>> need to re-invent the wheel and use cmake to do that.
>>
>> I do.  If you want Eclipse developer mindshare, then ultimately you
>> want CMake to work as a Java build tool as well.
>
> I'm following this interesting thread and here I must say
> that I disagree.
>
> CMake I think should never became "A Java build tool"
> CMake "may" add java support which may end up
> in generating ant build files.
>
> Ant is a build tool which may be compared to make
> (ant is much much much nicer and powerful than make though)
> CMake (from my point of view) is a build tool GENERATOR.
>
>> You may not need any
>> of that at first, but you aren't going to get a snowball of support
>> unless CMake is handling basic Java builds.  That's the strategic
>> risk.  Strategically, if Ant figures out how to do C/C++,
>
> Ant already does, see cc Task:
> http://ant-contrib.sourceforge.net/cc.html
>
>> and CMake
>> doesn't figure out how to do Java, then CMake will lose in the  
>> Eclipse world.
>
> Not so sure, even if I'm no eclipse expert.
> If CMake is able to generate Eclipse project files and/or with
> eventual Ant build files then I'm pretty sure CMake will get in the  
> Eclipse
> world very soon.
>
> Java IDE is only a part of what Eclipse is for and I'm not sure
> it will be the more prominent one in the mid-term.
>
> Major vendors for embedded (generally cross compiled) tools
> goes for eclipse "platform" http://www.linuxdevices.com/news/ 
> NS9149933313.html
> because eclipse is a "cool" development platform
> (<flame type=free> as soon as you have enough RAM </flame>:))
> Java devel. is certainly not the main target for them.
>
> Now that CMake cross-compiling support is emerging I think that
> CMake is on a very good path to get into Eclipse world as soon
> as CMake would be able to generated eclipse CDT project files.
>
>> But some approaches are more likely to get accepted by large numbers
>> of people than others.  Bootstrapping CMake is more cool than using
>> Ant to take care of what CMake is supposed to take care of.  Coolness
>> inspires.
>
> I'm not sure to get your point but I will elaborate a little more on
> Ant vs CMake.
>
> I think you underestimate what Ant
> and the wealth of optional tasks are able to do, I suggest you go
> to http://ant.apache.org/manual/ and browse tasks.
> You'll see that high level ant tasks enables you to do ftp, ssh, scp,
> cvs, subversion, rpm building in a easy way.
> As far as I know CMake does not have those capabilities.
> The differences I see between CMake and Ant is the fact
> that CMake is a two-level tool (L1 = generate , L2 = build)
> with very limited extensibility (MACRO or EXECUTE_PROCESS)
> whereas Ant is a single-level tool with extensive extensibility  
> possibilities,
> i.e. anything a Java program can do may be turned into an Ant task.
>
> That said I LOVE CMake very much, because of this 2 level aspect
> from my point of view CMake is missing a powerful extensibility  
> mechanism.
> Before going to CMake (from hand-written Makefile and some Ant  
> build files)
> I was interesting in SCons because SCons offers you python and
> not a limited scripting language.
> I did go to CMake because CMake was better at GENERATING
> build files for several build tools including Visual Studio project  
> files.
>
>
> My 2 cents on CMake, Ant, Eclipse and the like.
> -- 
> Erk
> _______________________________________________
> CMake mailing list
> CMake at cmake.org
> http://www.cmake.org/mailman/listinfo/cmake