Good techniques to use Makefiles in VisualStudio?

Question

I know the ideal way to build projects is without requiring IDE based project files, since it theoretically causes all sort of trouble with automation and what not. But I've yet to work on a project that compiles on Windows that doesn't depend on the VisualStudio project (Ok, obviously some Open Source stuff gets done with Cygwin, but I'm being general here).

On the other hand if we just use VS to run a makefile, we loose all the benefits of the compile options window, and it becomes a pain to maintain the external makefile.

So how do people that use VS actually handle external makefiles? I have yet to find a painless system to do this...

Or in reality most people don't do this, although its preached as good practice?

Answer 1

Ideally perhaps, in practice no.

Makefiles would be my preference as the build master, however, the developers spend all their time inside the visual studio IDE and when they make a change, it's to the vcproj file, not the makefile. So if I'm doing the global builds with makefiles, it's too easily put out of synch with the project/solution files in play by 8 or 10 others.

The only way I can stay in step with the whole team is to run devenv.exe on the solution files directly in my build process scripts.

There are very few makefiles in my builds, where there are they are in the pre-build or custom build sections or a separate utility project.

Answer 2

I haven't tried it myself yet, but Microsoft has a Make implementation called NMake which seems to have a Visual Studio integration:

• NMake
• Creating NMake Projects

Answer 3

Visual Studio since VS2005, uses "msbuild" to define and run builds. When you fiddle with project settings in the Visual Studio designer - let's say you turn XML doc generation on or off, or you add a new dependency, or you add a new project or Assembly reference - Visual Studio will update the .csproj (or .vbproj, etc) file, which is an msbuild file.

Like Java's ant or Nant before it, msbuild uses an XML schema to describe the project and build. It is run from VS when you do a "F6" build, and you can also run it from the command line, without ever opening VS or running devenv.exe.

So, use the VS tool for development and command-line msbuild for automated builds - same build, and same project structure.

Answer 4

One possibility is to use CMake - you describe with a script how you project is to be built, and CMake generates the Visual Studio solution/project files for you.

And if you need to build your project from the command line, or in a continuous integration tool, you use CMake to generate a Makefile for NMake.

And if you project is a cross-platform one - you can run CMake to generate the makefiles for the toolchain of your choice.

A simple CMake script looks like this:

project(hello)
add_executable(hello hello.cpp)

Compare these two lines with a makefile or the way you setup a simple project in your favorite IDE.

In a nutshell CMake does not only cross-platform-enables your project it also makes it cross-IDE. If you like to just test your project with eclipse or KDevelop, or codeblocks, just run CMake to generate the corresponding project files.

Well, in practice it is no always so easy, but the CMake idea just rocks.

For example, if you consider using CMake with Visual Studio there is some tweaking required to obtain the familiar VS project feeling, main obstacle is to organize your header and source files, but it is possible - check the CMake wiki (and by writting a short script you might even simplify this task).

Answer 5

We use a NAnt script, which at the compile step calls MSBuild. Using NAnt allows us to perform both pre- and post-build tasks, such as setting version numbers to match source control revision numbers, collating code coverage information, assembling and zipping deployment sources. But still, at the heart of it, it's MSBuild that's actually doing the compiling.

You can integrate a NAnt build as a custom tool into the IDE, so that it can be used both on a build or continuous integration server and by the developers in the same way.

Answer 6

We have a program that parses the vcproj files and generates makefile fragments from that. (These include the list of files and the #defines, and there is some limited support for custom build steps.) These fragments are then included by a master makefile which does the usual GNU make stuff.

(This is all for one of the systems we target; its tools have no native support for Visual Studio.)

This didn't require a huge amount of work. A day to set it up, then maybe a day or two in total to beat out some problems that weren't obvious immediately. And it works fairly well: the compiler settings are controlled by the master makefile (no more fiddling with those tiny text boxes), and yet anybody can add new files and defines to the build in the usual way.

That said, the combinatorical problems inherent to Visual Studio's treatment of build configurations remain.