Computing at

Aberdeen
Where professionals meet would-be
professionals

Home C++ & Fortran development in

About Windows using the MinGW-
Software technologies

Our MSc Degrees

W64 GCC and NetBeans
Readings A page dedicated to the setup and the usage of the C++ and Fortran GCC binary
compilation workchains in the Netbeans IDE
Apply

Pinterest Boards
Preconditions
1. The MinGW-W64 GCC toolchain (including MSYS2) has been installed as per
Search …
the instructions provided in our page on “How to install the GCC for
Windows“.
2. NetBeans (version 8.2 or higher) has been properly installed. Although the
RECENT POSTS following instructions are likely to work with NetBeans versions older than
32 vs 64 Bit in Windows – Has your 8.2, it is recommended to update either to such version or to the current
binary been compiled for a 32 Bit version at the time of reading. This is important if you also want to use
or for a 64 Bit environment? NetBeans to develop Fortran source code and to compile it using the GCC.
Detailed installation instructions are available from the corresponding
Extras for the ideal degree
Netbeans website page. Please note that is important to run the NetBeans
Be a creative thinker for job
installer as an Administrator, just to avoid early termination issues linked to
security
the lack of administrative priviledges at some point during the installation Follow
Entrepreneurship degree cancelled process.
Being an entrepreneurial student 3. The GCC C/C++/Fortran plugin for NetBeans (ver 8.xx) has been properly
installed. See the “Configuring Netbeans IDE 8.0 for C/C++/Fortran”
instructable. Note that you are expected to have already installed MinGW-
CATEGORIES W64 and MSYS2 as per point 1 above. Hence, most of the instructions in the
development said instructable are not relevant. Only consider sections “Enabling
C/C++/Fortran in the IDE” at the beginning and “Verifying the Installation”
events
at the end of the instructable.
hackday
4. NetBeans has detected all the installed components of the MinGW-W64 GCC
masters programme
toolchain. To check that is the case, go to menu Tools > Options and select
service design tab C/C++. This should show the right path to the relevant binaries, e.g.
software factory 5.
software technologies

start up tools

startup events

startups
Uncategorized

working world

@ABZ_SOFT_ENT
My Tweets

RECENT COMMENTS
The startup is the c… on
GSJ and NHTG event in
March
Another Weekend of F…
on Build a happy startup

Paths to the various C/C++ toolchain executables detected by Netbeans

ARCHIVES
January 2016 Note that QMake (an alternative to make and CMake) is not needed if you are not

December 2015 using the Qt application framework to create GUIs for your C++ programs.
All toolchain components have been automatically detected by NetBeans
November 2015
from the Windows Path environment variable. Different toolchains can be
March 2015
selected (e.g., corresponding to different GCC versions, architectures, or
February 2015
compilers).
October 2014

August 2014 Finally, note that during its installation, NetBeans uses the Windows Path
July 2014 environment variable and other setups to find the path of the various
executables it needs for its compilation toolchains. So, for instance, Java
June 2014
binaries are detected by looking in the directory
May 2014
C:\ProgramData\Oracle\Java\javapath. Conversely, MinGW GCC toolchain
April 2014
executables as the one shown in the above picture are detected using the
March 2014 Windows path (and thus the various MINGW_HOME and MSYS_HOME
February 2014 specific system environment variables. Their setup is described in the
January 2014 “MinGW toolchain installation instructable “). Hence, if environment
December 2013 variables heve not been (correctly) set at Netbeans installation time, the
corresponding executables will not be found by the IDE. If you expect
November 2013
NetBeans to automatically find and record them correctly at startup after
October 2013
the (missing) program path and the specific environment variables have
been correctly set in Windows, you will be wrong. This is because NetBeans
records the paths to the needed toolchain binaries at installation time only,
META
and keeps complaiing later on if it does not find them in the path recorded
Register there and then, either because the latter was wrong or because it had been
Log in left blank at NetBeans installation time . Consequently, you would need to
Entries RSS set the correct path to the needed toolchain executables manually in
Comments RSS NetBeans. As far as Java is concerned, this can be done by opening the
NetBeans configuration file netbeans.conf (typically in the directory
WordPress.com
C:\Program Files\NetBeans 8.2\etc or equivalent) and modifyiong the line
that specifies the JDK default home location, which looks like

netbeans_jdkhome="C:\Program Files\Java\jdk1.8.0_101"

However, as C/C++/Fortran source code editing compilation is managed

through a plugin (as opposed to Java), the path to each specific GCC
toolchain executable needs to be edited directly in the Tools > Options >
C/C++ tab.

Further points to consider

This page only focuses on how to set up C++ and Fortran projects in
NetBeans for executables to be generated using MinGW. However, adapting
the GCC C++ MinGW toolchain setup in Netbeans under Windows to the
generation of C executables is pretty straightforward anyway.
Note that although often referred to as the “C/C++ plugin”, the NetBeans
plugin for the GCC also includes support for Fortran programming by
default. Unfortunately, this is not very clear and beginners may struggle to
find a way of creating Fortran programs using the “C/C++” plugin. In reality,
once you properly install the GCC plugin, Fortran support in NetBeans is
automatically included and ready to be used. It’s just that plugin developers
did not implement ways to make Fortran support explicitly visible upfront.
In other words, you must first create a Fortran project as if it were a C/C++
project (it is not possible to select a “Fortran Project” as such) and then tell
NetBeans that such project is actually a Fortran one. To know more, see
section “Setting up a Fortran project” below.

Setting up a C++ project in NetBeans

Selecting File > New Project > C/C++ presents a list of choices that depend on the
specific task at hand, i.e.

Different kinds of C++ projects that

Netbeans can create

Very likely, you may want to create a new project from scratch (i.e., a C/C++
Application) rather than a project from existing sources or a library.
To create an empty project with still-to-be-written source files, select “C/C++
Application“. Netbeans will suggest a project setup configuration like this:

Project setup configuration in Netbeans

It is possible to select different toolchains if more than one is installed and

detected by NetBeans. It is not strictly necessary to create a Main file; in all those
cases where you may want to use existing source code, you should avoid creating
a Main file unless you need it to correctly compile and run the resulting
executable. Press the Finish button to complete the setup and to let NetBeans
create an empty project.

You now have two options:

1. Create new source code files to contain your functions or classes.

2. Include existing source code files in your project.

In both cases, right-click on the “Source Files” in the Projects hierarchy tree:

Netbeans project
hierarchy tree

and select one of the following three options:

New file – you are presented with a list of different types to choose from
Add existing items – use this option if you want to add a single file or a
collection of files distributed across different file system directories.
Add existing items from folders – use this option if you want to add multiple
files from one or more specific directories, which can be selected and linked
to the file directory hierarchy of your project.

Setting up a Fortran project in

NetBeans
As hinted, it is not possible to select “Fortran project” from File > New Project.
However, things are not as difficult as they appear. Just proceed as follows.

1. Create a new Fortran project as if it were a C/C++ project, selecting one of

the following options depending on what you may want to do:

Select your kind of Fortran project as if it

were a C/C++ one

2. Once an option has been selected (e.g., a C++ Application, with the
understanding that this will later become a Fortran Application), Netbeans
will suggest a project setup configuration like this:

How to tell Netbeans that your C/C++ project is actually a Fortran project

Simply go to the line that deals with the Main File and select a Fortran
versions from the drop-down menu. We use the latest “Fortran 2008”
version, which allows free-format source code.

Even if you don’t create a main file at this point in time, you can always add
new source code files later on. In this case, NetBeans allows you to specify
source code in your project as Fortran files (either in the old Fortran77
“fixed format” if you have legacy issues or in the Modern Fortran “free
format” if you don’t).

Job done – you now have a Fortran project up and running. The GCC NetBeans
plugin will look at the extension of source code files associated to your project to
decide whether to use a C++ or a Fortran toolchain.

Setting the GCC-related project

properties
You can now either create a simple C++/Fortran main file to generate an
executable that displays the usual “Hello world” message or a much more
sophisticated set of files for a real application. In both cases, you will need to
make sure that the right toolchain compilation options, libraries, and directories
to be included have been all set up correctly for your specific project. To do so,
right-click on the project root folder in the NetBeans project hierarchy tree (see
the corresponding picture above) and select the “Properties” item located at the
bottom of the drop-down menu. By default, the Project Properties window will
appear and the General category of properties will be shown as below.

Netbeans Project Properties windows showing the General category

It is worth going through the various categories, as setting these properly makes
the difference between your software compiling (and running) and a series of
compile-time or run-time errors that may drive you crazy because – despite such
errors – your source code is actually correct.

Warning: We will only focus on some core project properties whose setup is
essential for correct compilation, linkage and execution. Several other properties,
which are not critical to begin C++/Fortran software development with the
MinGW port of the GCC, are out of the scope of this instructable and are thus not
covered. To know more on project property setups in NetBeans, please refer to the
NetBeans help pages.

General category of project properties

Source Folders – You can check that the IDE shows the right source code
(root) folder. If this is not right, the GCC compiler will look elsewhere, will
not find anything and it will either (rightly) complain or simply report that
there was no actual compilation task to do.
Manage Configurations – This menu allow you to choose whether your GCC
toolchain configuration is set up for Debug or for Release.
Choosing Debug enables the various NetBeans (and GCC) debugging
option but produces slightly less optimised code. To be used as a
default util when your code is ready to be released to its users.
Choosing Release optimises the GCC compilation process and produces
a slightly more performant executable code.
In each case, you may want to use different GCC compilation and/or linkage
and/or execution options. See the GCC Manual for further information on
this.

Build category of project properties

This allows you to specify both compiler and linker setups. The GCC NetBeans
plugin provides support for C, C++, Fortran, and Assembler. We will explicitly
discuss C++ and Fortran setups in the following. To begin with, NetBeans has the
possibility of setting up global Build category features, i.e.

General Build category project setup options

At this configuration level, you can choose

1. Which toolchain (tool collection) to use, in case you use different compilers
or, more likely, different GCC versions. In most cases, however, you will have
installed and/or enabled just one such version, so this setting may actually
be left as it is.
2. What kind of configuration you want to build, i.e., whether it is an
Application, a Dynamic Library, or a Static Library. In most cases, it will be
an Application, i.e. a standalone executable that can be run on its own.

The build category allows the specification of compilation setups for C++ and
Fortran as well as for the linkage of C++/Fortran-compiled programs.

C++ Compiler
The C++ Compiler setup window (see below) should be thoroughly checked to
make sure that a C++ program can actually compile, link, and run.

C++ Compiler setup options

Apart from some basic options, most default compiler options are left blank.
While this is fine for a Hello World program, more substantial developments
generally require a careful setup of at least some of these C++ compilation
options, namely:

Include Directories – These are directories that contain header files needed
for compilation purposes. For instance, compiling C++ software that uses the
OpenCV library requires the inclusion of few directories that contain a
range of OpenCV header files. Avoiding to include required header
directories would result in a compilation failure.
Include Headers – If just a few specific header files (located in different
directoris) are required, these can be indicated here rather than including
whole directories in the above slot.
Development Mode – Debug is the default mode (and it is suggested to leave
it as it is, unless something else is specifically required. Different modes can
be selected if needed (e.g., Performance Release, Test Coverage).
Warning Level – This specifies how verbose the compiler can be; range goes
from No Warnings to More Warnings (with Some Warnings being the
default). You can also render Warnings as Errors if you need to enforce a
strict approach. Increasing warnings may be useful at the beginning, during
debugging and any time you may have compilation problems.
Architecture – This instruct the compiler to use 64 bits (the default) or 32
bits (to cross-compile for an i686 machine or for an x86_64 machine
running Win32).
C++ Standard – By default, this is the latest-ish version, i.e. C++11, but it
could be an earlier version in case of legacy code.

Fortran Compiler
The Fortran Compiler setup window (see below) is similar to the C++ one.

Fortran compiler setup options

The relevant options are the same already discussed in the C++ compilation case,
so they will not be repeated here.

Linker
The Linker setup window (see below) is another critical window that needs to be
checked to guarantee that a C++ or Fortran program can actually compile, link,
and run.

Linker options

The linker basically associates code from existing external libraries to your own
code, enabling the latter to call the corresponding functions/objects contained in
the former. Hence, the following two options should be carefully checked:

Additional Library Directories – This allows the specification of a list of

directories where to find the libraries that need to be linked to the
executable to be produced.
Libraries – This allows the specification of the actual libraries that need to
be linked to the executable to be produced. It should be noted that MinGW
accepts either static libraries (with extension .a) and dynamic libraries (with
extension .so). Note that the GCC requires that static libraries are prefixed
with the keyword lib and have extension .a, e.g., libmyownlib.a. The lib
prefix is required by the GCC linker to find the static library. Although it is
possible to give a shared library the .dll extension, this is not recommended
as the GCC uses the ELF (Executable Linkable Format), while the Microsoft
Linker uses the older COFF (Common Object File Format). By giving a shared
library the extension .so, you are indicating that this is a GCC-shared
library rather than a Windows-specific one. In the past, there were issues
with MinGW GCC linking dynamic libraries with extension .dll directly.
Hence, it was recommended to create a static library lib.a with exported
symbols from .dll and link against it instead. However, since 2013 at least it
appears that it should be fine to link directly against .dll. Users reported
success with the MinGW-w64 distribution from 2013 onwards and had no
issues with that.

Run
The Run setup window (see below) is another critical window that should be
checked to make sure that a C++ or Fortran executable can actually run.

Run setup options

The only relevant thing to note here is making sure to select either “Standard
Output” or “External terminal” as the Console Type, otherwise the executable will
not run and Netbeans will throw an error. Selecting the Standard Output option,
NetBeans will show executable results in one of the IDE panes. Conversely,
selecting the Esternal Terminal option a Windows terminal (command prompt)
will be opened and all executable output will be redirected there.

Compiling and running a Hello World

test project
C++ Hello World project
The following should work straightforwardly:

1 #include <iostream>
2
3 int main()
4 {
5 std::cout << "Hello World from Cpp!\n";
6 return 0;
7 }

Fortran Hello World project

The following should work straightforwardly:

PRINT*, ‘Hello World from Fortran’

END

Page last updated by ECOMPAT on 13/10/2016

Share this:

 Twitter  Facebook  Google

Like

Be the first to like this.

Blog at WordPress.com.