Every Flavour Beans

My friend alerted me a month ago about Nuwen’s build of MinGW toolchain that has version 4(currently 4.2.1) build of g++ compiler. Now that’s awesome. But that is not all: it also comes with C++ Boost 1.35 bundled as part of it, among many other useful C++ libraries.

Consider this post to be an update of my previous post “Setting Up C++ Development Environment on Windows with EasyEclipse and MinGW.” I will be using the following components in this post to setup the development environment for C++:

1. Eclipse Ganymede for C++ instead of EasyEclipse for C++.
2. Nuwen’s MinGW 3.9 Distro instead of official MinGW build.

Download/Install Eclipse Ganymede for C/C++ and Nuwen’s MinGW for Windows

1. Download Nuwen’s MinGW distro and extract it in a directory. Try to extract it in a directory that doesn’t contain spaces or special characters in it: a good place to extract will be C:\MinGW.
   

   

2. Download Eclipse Ganymede IDE for C++ and extract it a directory.
   

   

3. Run the Eclipse executable from the directory where you have extracted it(you can later place a shortcut to the Eclipse executable on the windows desktop/start menu/quick launch bar/etc. for quick access). When you try to create a new C++ project in Eclipse, MinGW will be automatically detected and be listed as one of the available toolchains. Automatic detection works the best if you extract in the directory as recommended in Step 1.

   

4. You can check the version of the g++ compiler from the command prompt.
   C:\> cd C:\MinGW\bin
   C:\> g++ -v
   gcc version 4.2.1-dw2 (mingw32-2)

   (You don’t have the change the working directory to MinGW bin directory if its location is in the PATH variable.)

5. Let’s write some C++ code making use of a Boost library and try compiling the code. Here is a screenshot of an example HelloWorld program(click to see the large version):

   

It’s such a good thing for me to have discovered a MinGW build with g++ v4 and Boost bundled in it at around the same time that Eclipse Ganymede was released, I have to thank Stephen T Lavavej for bringing the C++ development experience on Windows a bit closer to that of GNU/Linux. Head to Nuwen’s MinGW page to learn what all is included in the distribution. You may also be interested in my previous post that I referred to at the beginning of this post.

Now for some more paying with the g++ 4.2.1 compiler on Windows ;)

Over the years many beginning programmers have shown me two different versions of C++ code for swapping the values of two variables. I am now starting to get tired of correcting the wrong version of the two, especially because of the disappointment that I get to see written on the face of those who thought theirs to be a very clever way of writing code. (Even if the version was correct, I don't know why they take such personal pride in the code. Obviously they have not invented the code; it has been circling the Internet or the general student community for many years, from where they have merely copied it.)

The first and the correct version for swapping values of two variables, in C++, is like this:

Simple, straightforward, and correct.

The second, wrong version goes like this:

The openly asserted advantage of this version is that one variable is saved in this case. But the real, hidden attraction is that it appears to be smartly written code. If only the version was correct too. The problem with this version, of course, is that it is useless for any type that doesn't support arithmetic operations. It works fine for integer type for example, most of the times at least. It is not guaranteed to work even for floating point variables. But what if I want to swap the values of two Colour objects? Two Shape objects? The requirement that the type support addition and subtraction operations for its objects to be swappable is very absurd.

More problems with the second "smart" version:

1. The code fails utterly when you pass references to the same variable!
   Show Plain Text
   C++:

   1. int a;
   2. //read something into a
   3. ::swap(a, a);  //BOOM! 'a' is now corrupted and beyond recovery.

   The call to swap() in this case should have been a "no operation" like it will be with the first version.

2. The code fails even for the integers when the the sum of two passed variables exceeds the maximum integer limit on that machine.
3. The code is also needlessly unnatural. Human beings don't swap things by indulging in addition and subtraction activities. Unless a person knows that the second version works for at least the integer type (some of the times), or verifies it manually by working through it logically or with a large number of example cases, it is difficult to just see and "get" that the code indeed does the swapping operation.
4. The second version indeed uses one less variable than the first version but at the same time uses three additional arithmetic operations.

There are similar clever ways to swap two variables(using XOR operation, or macros for example), but all of them have one or more problems of similar kind. The best way to swap two variables is definitely the natural way to do it. By the way, parts of the above explanation apply to swapping variables in most other languages too(can't think one where it doesn't). Clever code is useless code if it isn't also correct at the same time.

CppUnit is the most popular unit testing framework available for the C++ language today. So integrating it with one of the most popular IDEs available for the C++ language should be very appealing indeed. If you have not yet configured CppUnit library to work with the Eclipse IDE yet, here is a step-by-step procedure to do the same. By the end of it you will be able to create C++ classes and functions, write unit tests for them, run them and see the results, all from with-in the Eclipse IDE. This is for the Windows users; can be adapted for GNU/Linux users but there are shorter procedures for them.

You can either use Eclipse Europa for C++ as the IDE or other IDEs based on it like EasyEclipse, Wascana etc. And of course MinGW or someother C++ toolchain must already be installed and configured with your Eclipse IDE; if not, read the MinGW and EasyEclipse configuration post for more information; it's for older version of the Eclipse and configuration is much simpler for Eclipse Europa.

Downloading and Preparing the CppUnit Package

You can skip this section and the next one if you already have CppUnit library built/installed on your system and you know where its include and library files reside. Jump over to the last section in that case.

1. Download CppUnit package from its sourceforge.net page.
   
   Extract it to a directory of your choice. I will assume that it is extracted to 'c:\cpp\cppunit'. This directory should look like this:
   
   (If the downloaded archive file gets extracted to a directory named cppunit-1.12.0 then just rename it to cppunit.)
2. What we downloaded in the above step is the CppUnit source code. We need to build this source code to create a library file which we can then use in the C++ programs. CppUnit can be built from sources either from the command line or from the Eclipse IDE itself. To build it from the Eclipse IDE, we still need to generate at least one file from the MSYS command line. Go to your MSYS installation directory and click on msys.bat file in it. In the MSYS console window, change to the CppUnit directory(c:\cpp\cppunit in our example) and run the ./configure command.

   

   This will create the cppunit/config-auto.h file that we need. Close the MSYS command window.

Building CppUnit Package from the Source Code in Eclipse IDE

1. Start the Eclipse IDE and create a new C++ project in it by going to File -> New -> C++ Project, enter a name(say, "CppUnitBuild") in the Project Name text box, select "Static Library" from the Project Types pane and "MinGW GCC" from the Toolchain pane.

   

   You can also choose to select "Shared Library" if you want to build CppUnit as a shared library. Similary, select "Cygwin GCC" if that is the toolchain you prefer.

   Click Finish when done.

2. Now we need to import the entire CppUnit source code into this project. Right-click on the newly created project(CppUnitBuild) and select the "Import" menu item. In the "Import" dialog box, expand the "General" tab, select "File System" and click the Next button. Click "Browse" and browse to the c:\cppunit\src\cppunit directory and click the "Select All" button and click Finish.

   

   This will select and import all the source(.cpp) and header(.h) files of the CppUnit package into the CppUnitBuild project.

3. Next step is to add the CppUnit include directory to the compiler's include path. Right-click on the project(CppUnitBuild), select "Properties" and go to C/C++ Build -> Settings node. In the right pane, go to Tool Settings -> GCC C++ Compiler -> Directories. Click the "Add" button located near the "Include Paths (-I)" text box(see the screenshot below), click "File System..." button and browse to c:\cpp\cppunit\include directory.

   

4. Finally, build the project by pressing Ctrl-B or by right-clicking on the project and selecting "Build Project."
   At the end of the build process, a static CppUnit library(libCppUnitBuild.a) should be built in the Debug subdirectory of the project directory in your Eclipse workspace(If you build using the Release configuration, the library will be generated in Release subdirectory instead). If you had opted for a shared library earlier, then [1] suggests that you define CPPUNIT_DLL_BUILD variable by going to Project -> Properties -> C/C++ Build -> Settings -> GCC C++ Compiler -> Preprocessor -> Define Symbols (-D). You will see a file named libCppUnitBuild.dll generated in this case.

   Let us test it with a sample C++ project.

Unit Testing C++ Programs using CppUnit in Eclipse IDE

1. From the Eclipse IDE, create a new project by going to File -> New -> C++ Project, enter a name(say "CppUnitDemo") in the Project Name text field, select Executable -> Empty Project from the Project Types pane and "MinGW GCC" from the Toolchain pane and click Finish.
2. Now you can create a sample C++ class and write unit tests for it. A faster way would be to download this sample zip file that contains all the files required for testing. Download and extract it to some directory and then import all its contents to the CppUnitDemo project(right-click on project name and select Import, just like we did in Step 2 of second section). You can also drag and drop these files on the project name in Eclipse.
3. Add CppUnit include directory to the project's include path just like we did in Step 3 of second section. But remember to add the path to the CppUnitDemo project, not to the CppUnitBuild project! We also need to add the CppUnit library file that we have generated in the second part of this post to our CppUnitDemo project.

   Right-click on the project name, select Properties, select C/C++ Build -> Settings node, select the Tools Settings tab, select MinGW C++ Linker -> Libraries node, click the Add button near "Libraries (-l)" text box and enter CppUnitBuild in the popped-up dialog box. Similary, click the Add button near "Library search path (-L)" text box, click "File System..." button and browse to the path where the CppUnit library file was generated([your-eclipse-workspace]\CppUnitBuild\Debug\; The generated file might be in the Release sub-directory if you had chosen a Release build configuration to build the CppUnitBuild project earlier).

   

   If you had built CppUnit as a shared library earlier, then you need to define CPPUNIT_DLL at this stage; see Step 6 for more details.

4. Right-click on the project name and select "Build Project" to build the project and right-click on the project name and select Run As -> Local C/C++ Application, select 'gdb debugger' and click OK to run the project. You should see two dots in the output to represent that the two unit tests present in the sample files ran successfully. You can now create your C++ classes, write unit tests for them and then run the tests. Need help in getting started with writing unit tests using CppUnit? Here's a CppUnit cookbook for you and you can also download the CppUnit documentation.

Next up is how to integrate CppUnit Qt GUI test runner in Eclipse IDE. Then I will write about how to integrate CxxTest unit testing framework with the Eclipse IDE. Doxygen integration may follow, so hang tight ;)

[1] http://cppunit.sourceforge.net/cppunit-wiki/CppUnitWithEclipse - the sample zip file and other help for creating this tutorial were taken from this wiki page.

By the end of this post, you will be able to create C++ projects in the Eclipse IDE and build them using the SCons build tool. SCons is an alternative build tool to GNU make/Makefiles. You can read more about SCons on its website(and ask yourself why are you reading this post in the first place!).

Install MinGW, Eclipse CDT, Python and SCons on Windows

1. Skip this step if you have a working Eclipse for C++ installation.

   If the MinGW toolchain is not already installed on your Windows system, download and install MinGW, MSYS and gdb debugger from MinGW's download page. Similarly download and install the latest version of Eclipse for C++(Europa) if it's not already installed. If you are willing to take my recommendation, I suggest you start with EasyEclipse for C++ IDE which comes with many useful C++ plugins pre-installed. When you install EasyEclipse/Eclipse Europa for C++, it will automatically detect the MinGW installation and will configure all paths properly, but if for some reason you come across any problem(or if you are using an older version of Eclipse), take a look at my earlier post on how to configure MinGW with Eclipse IDE.

   Alternatively you can download and install the Wascana Desktop Developer which comes with Eclipse Europa, CDT plugin, MinGW toolchain (among other things) all integrated together as one piece. Read my post about the Wascana IDE for more information.

2. Skip the step if you already have a working Python installation.

   I am assuming that Eclipse CDT and C++ development toolchain(MinGW) are properly setup on your system. Before we can go ahead and install the SCons build tool, we need to install Python first, as SCons depends on a working Python installation. Download your favourite Python distribution for Windows and install it. I use Python from the python.org website but feel free to use any implementation that you like, such as ActivePython.

   

   Download Python binaries for Windows.
   Run the installer to install it. I will assume that we have installed it in C:\Python25 directory.

3. Now we are ready to install the SCons build tool. Download the windows installer from SCons website and run the installer to install it.

   

   SCons installer will automatically detect the location where Python is installed during installation. After the installer is finished, you can start building C++ programs using SCons from the command-line. In fact, it would be a good idea to do a few checks to make sure that everything we have done until now is setup properly. On the windows command prompt, run the following:

   C:\> python -V
   C:\> scons -v

   (note the uppercase V for the python command)

   

   You can further create a sample C++ program along with an SConstruct build file and try building from the command-line using the scons tool. Proceed to the next step if everything works out as expected.

Installing and Configuring SConsBuilder plugin in Eclipse

1. We need to install the SCons plugin in Eclipse now. The installation procedure is explained on the SConsBuilder web page but I will repeat those instructions here for convenience:
   1. Go to Help -> Software Updates -> Find and Install..
   2. Choose "Search for new features to install".. and click "Next"
   3. Click the "New Remote Site.." button
   4. Enter "SCons Build" or something like that in the "Name" field and enter http://nic-nac-project.de/~lothar/eclipse/update/ in the "URL" field

   

   You may be interested in having a look at the documented feature list of this plugin. You can confirm the installation of SConsBuilder plugin from Help -> About -> Plug-in Details.

2. Next we need to configure the SCons plugin in Eclipse. To do so, go to Window -> Preferences -> C++ -> SCons.

   

   Enter the values as you see in the above screenshot. No other field matters to us right now except for the first one('SCons executable') but you need to give valid values in all of them; which means that even if you have no intention of using CppUnit, you still need to make sure that the text fields in its section(CppUnit include and library directories) have valid values(any valid path will do). Of course, when using CppUnit, you need to check the "Use CppUnit" checkbox and enter the correct include and library paths in its fields.

   Restart Eclipse if you are prompted to.

3. We are almost done here! Now create a C++ project from File -> New Project and select one of the templates from the New Project window, say "Empty Project". Try not to select any Makefile related project templates though, as we will be using SCons as our build tool. After the project is created we can convert it to an SCons project by going to File -> Other -> C++ -> Convert to SCons Project(search around if it's not there, it may be present in a different category in your Eclipse distribution).

   

   Note: To remove the SCons nature from the project, follow the same menus: File -> Other -> Convert to SCons Project.

   You will see a new file created in your Project view called SContruct which you might identify as the SCons build script.

   

   I remove the default generated code in the SConstruct file and type my own build instructions in it. The other thing you can notice are the new build command menu items in the project context menu(I couldn't find any other way to access these build commands). Right-click on the project to see it.

   

   Select "SCons Build" from the available build commands in the context menu and your C++ project should be built using the SCons build tool using the instructions provided in the SConstruct file. You can now continue adding more C++ source files, more directories and SConscript build files.

Troubleshooting?

• Verify if you can compile C++ programs in Eclipse before starting with any SCons stuff. This would help find out if MinGW is properly configured with Eclipse. See this post for help. (You may be using Cygwin toolchain, I am just taking MinGW as an example.)
• Make sure that you install Python and SCons at locations that do not contain space(s) in their paths. This is not always required but it is a good rule to follow anyway.
• Make sure that running 'python -V' and 'scons -v' on the command-line returns some output and not an error.
• Make sure that all the fileds on SCons preference page have valid values. Use the screenshot shown above for guidance.

SConsBuilder plugin for Eclipse is not the perfect solution for working with SCons; instead it only barely gets the job done. In the absence of any other better alternatives, all we can do is to hope and pray that the plugin gets more love from its developers and improves with the time.

Wascana Desktop Developer is a completely standalone, Eclipse-based C++ development environment for the Windows platform which packages everything that is needed for developing applications using the C++ language. Download the installer, go through the installation wizard and you have a complete C++ IDE ready to go; unlike EasyEclipse for C++, no additional software or any further configuration is needed. It is based on the popular Eclipse platform and uses the CDT plugin and the MinGW compiler tools to provide the necessary functionality. Called CDT for Windows earlier, it is now renamed to Wascana Desktop Developer to avoid any trademark issues. The latest version, Wascana 0.9.3, was released a few days ago and it comes with the following components integrated into it:

1. Rich development environment of the Eclipse platform.
2. Eclipse CDT Plugin.
3. MinGW and MSYS C++ development tools.
4. wxWidgets and SDL C++ libraries.

Wascana is currently under active development mode and I am guessing that the version ready to be used by a typical user would be released as Wascana 1.0. Those who are interested can download and try it out right away, there is nothing scary in the 0.9.3 version and it is fully functional and extremely stable. What more is planned for the future? From Doug's blog(Wascana's creator), it looks like:

1. Integrated support for Boost.
2. More C++ libraries; like, perhaps, the game development library Ogre 3D.
3. Support for Microsoft compiler and debugger(MinGW and Cygwin are already there).
4. .NET support and a GUI Builder.
5. Support for GNU/Linux and Mac OS X platforms.

So if you see the above list you realise that it is not going to be a thin layer of packaging to just integrate the Eclipse and MinGW tools together, but rather going to be a complete, rich development environment for C++ developers, which in future might become, according to Wascana's creator, as good an IDE as Microsoft Visual C++ for Windows, perhaps with full community involvement. Except for (5) above, I am excited about the future roadmap of Wascana.

Things I personally would like to see in the future versions of Wascana:

1. Good support for Unit testing. CppUnit, CxxTest, almost anything will do.
2. Some of the popular C++ libraries: Boost, ACE, Loki etc.
3. More C++ related plugins like Doxygen. [Plugins to enable profiling, static analysis and logging support would be good too.]
4. SCons-Builder! I know that every C++ programmer has his own favourite build tool(bjam, cmake, nmake, etc) but SCons is too good to be ignored I believe.
5. Test support for CVS as well as Subversion plugins. Not high priority.

Much of the above stuff should actually be better supported by the core Eclipse C++ project(Eclipse + CDT) but I will not be the one complaining if they are instead well supported by the other Eclipse based C++ IDEs like Wascana, EasyEclipse etc :) Also, I don't expect all of the above to be an integral part of a future Wascana release(except Boost and unit testing libraries); if they are tested thoroughly enough to make sure that they work well with every new Wascana release, it would work for me. This lack of documentation regarding which versions of plugins work with which versions of Eclipse has been the biggest gripe for me.

[I will make a proper dream-list of the features I would like to see in what could be my perfect C++ IDE and will post it in a separate blog entry.]

Getting Started with Wascana Desktop Developer 0.9.3

To try Wascana out, download the latest version from Wascana's sourceforge.net page. Go through the installation wizard and when finished, run the application from the Start menu(or use the Desktop shortcut).

From inside Wascana, create a new C++ project(File -> C++ Project; Makefile Project -> Hello World C++ Project -> MinGW GCC) and try to build it.

Project -> Build Project will build it. Run -> Run as Local C/C++ Application will create the run configuration and then will run the application(Ctrl-F11 will run it from the next time). (Edit first if you frown like me at the default generated code. When starting a real C++ project though, you can either create an empty C++ project or import an existing project using File -> Import...).

More Options in Wascana

As you can see, we have created an example C++ project, built it and run it in Wascana Desktop Developer without having to download and install MinGW/MSYS or any other software and without having to bother setting up the PATH variable. Of course, if you want to use your own version of MinGW toolchain, you can override the packaged MinGW version by preceding/replacing path to Wascana's MinGW/MSYS with that of yours in Wascana preferences(Project -> Properties):

Need to run some tool from the command line outside of Wascana? Run MSYS command line tool that comes with Wasacana(Start -> Wascana -> Wascana MSYS or Desktop shortcut):

Last Words

Wascana is a great idea in its current form and has the potential to become one of the best C++ development environments in the future. I do hope that (1) the support for Windows application development in the future versions of Wascana won't come in the way of pure C++ development(where GUI or Microsoft library support is not needed) and (2) even if Doug offers a commercial version of it in the future, a community version is always made available. Keep a watch on the blog of Doug Schaefer, Wascana's creator and an Eclipse CDT developer, for more information.