FB build configuration options

FreeBASIC

previous page next page
FB build configuration options
 
The FB makefile aswell as the compiler/rtlib/gfxlib2 source code offers some configuration options. If you build FB by using the FB makefile, then it makes sense to use the FB makefile's configuration options. If you build FB by compiling the sources manually (without using the FB makefile), then of course you can only use the source code configuration options, and you are responsible for putting the FB setup together properly yourself.

The compiler and rtlib/gfxlib2 source code both handle some #defines which allow for some configuration. For example, #defining ENABLE_STANDALONE when building the compiler (by specifying -d ENABLE_STANDALONE on the fbc command line) will adjust the compiler for a standalone setup. As another example, #defining DISABLE_FFI when building the rtlib (by specifying -DDISABLE_FFI on the gcc command line) will cause the rtlib to be built without using the libffi headers (ffi.h). This disables Threadcall support in the rtlib, but can be useful if you do not have libffi.

When using the FB makefile, you can set some variables on the make command line or inside config.mk that affect how the makefile will invoke the fbc/gcc compilers and what directory layout it will use for the FB setup. This includes cases where the makefile will automatically pass the configuration options on to the compiler/rtlib/gfxlib2 source code. For example, specifying ENABLE_STANDALONE=1 to the FB makefile causes it to use -d ENABLE_STANDALONE when building the new compiler (to make it standalone) and to put the newly built compiler and libraries into the standalone directory layout.

FB makefile commands

  • none or all
The default - builds everything that needs to be built
  • compiler, rtlib, gfxlib2
Used to build a specific component only. For example, this can be used to build an rtlib for a specific target, in order to be able to cross-compile FB programs (such as the compiler) for that target.
  • clean[-component]
Used to remove built files. make clean removes all built files, while for example make clean-compiler removes only the files built for the compiler, allowing the compiler to be recompiled more quickly, without the need to rebuild the whole rtlib/gfxlib2 code.
  • install[-component], uninstall[-component]
Used to copy the built files into the directory specified by the prefix variable, or remove them from there. This is most useful to install the normal build into /usr/local on Linux/BSD systems. For the standalone build, make install will also work and copy over or remove the files. However, the standalone build uses an incompatible directory layout and should not be installed into /usr/local or similar directories because of this.

Note that it is fine to run the newly built FB setup right from the directory where it was compiled; make install is not necessary to make it work (unless the prefix path was hard-coded into the compiler via ENABLE_PREFIX).

Additionally there are install-includes and uninstall-includes commands, which copy/remove just the FB includes (header files). Note that there is no make includes or similar command, as the includes do not need to be built.

FB makefile configuration

The following variables are intended to be set on the make command line or inside a file called config.mk next to the FB makefile which is read in by the FB makefile. config.mk is useful for setting variables in a permanent way such that you do not have to specify them manually everytime when invoking make.

Make command line example:

$ make CFLAGS='-O2 -g'

config.mk example:

CFLAGS = -O2 -g

  • FBFLAGS, FBCFLAGS, FBLFLAGS
Extra fbc flags to be used when compiling and/or linking the compiler. The default is -maxerr 1 (check the FB makefile for more details). Typically this is used to add options such as -g -exx to build a debug version the compiler.
  • CFLAGS
Extra gcc flags to be used when compiling rtlib and gfxlib2. The default is -O2 (check the FB makefile for more details). Typically this is overridden for debugging purposes by doing CFLAGS=-g.
  • prefix
The FB installation path. The default is /usr/local. Note: MSYS maps /usr/local to C:\msys\1.0\local.

This is only used...
      • by the makefile's install and uninstall commands,
      • in the compiler (hard-coded) if ENABLE_PREFIX was used
Note that in combination with bash on Win32 (e.g. from DJGPP or MSYS) it's necessary to use forward slashes instead of backslashes in directory paths, for example: prefix=C:/MinGW
  • TARGET
This variable can be set to a gcc toolchain triplet such as i686-pc-linux-gnu or x86_64-w64-mingw32 in order to cross-compile using that GCC cross-compiler toolchain. The makefile will use fbc -target $(TARGET) instead of fbc, and $(TARGET)-gcc instead of gcc.

For example, on a Debian GNU/Linux system with the i686-w64-mingw32 GCC cross-compiler installed, you can build the win32 rtlib like this:

# Build the win32 rtlib/gfxlib2
make rtlib gfxlib2 TARGET=i686-w64-mingw32

# Install it into /usr/local/lib/i686-w64-mingw32-freebasic
make install-rtlib install-gfxlib2 TARGET=i686-w64-mingw32
It will supplement the existing fbc installation in /usr/local, like a plugin, and from now on you can cross-compile FB programs for win32 by doing:

fbc -target i686-w64-mingw32 ...
  • FBC, CC, AR
These variables specify the fbc, gcc and ar programs used during the build. You can specify them to override the defaults, for example:

      • make FBC=~/FreeBASIC-0.90.1-linux/fbc CC="gcc -m32"
FBC affects the compiler source code only, while CC and AR are used for rtlib and gfxlib2.
  • V=1
V for verbose. By default, the makefile does not display the full command lines used during compilation, but just prints out the latest tool and file name combination to give a better visual indication of the build progress. It also makes warnings and errors stand out more in the console window. If the variable V is set, the echoing tricks are disabled and full command lines will be shown, as GNU make normally does.
  • ENABLE_STANDALONE=1
Build a standalone FB setup instead of the normal Unix-style setup, see also: the standalone vs. normal comparison. This causes the makefile to use the standalone directory layout and to use -d ENABLE_STANDALONE when building the compiler.
  • ENABLE_PREFIX=1
This causes the makefile to use -d ENABLE_PREFIX=$(prefix) when building the compiler.
  • ENABLE_SUFFIX=foo
This causes the makefile to use -d ENABLE_SUFFIX=$(ENABLE_SUFFIX) when building the compiler, and to append the given suffix string to the fbc executable's and lib/ directories' names.

For example, using ENABLE_PREFIX=-0.24 will give you bin/fbc-0.24.exe and a lib/freebasic-0.24/ directory, instead of the default bin/fbc.exe and lib/freebasic/. This allows installing multiple versions of compiler and runtime in parallel.

Note: The include/freebasic/ directory name is not affected, and the FB headers are always shared by all installed FB versions (FB's headers and their directory layouts are designed to be able to do that).

This is only supported for the normal (non-standalone) build. It is not needed for the standalone build, because everyone of those can be in a separate installation directory anyways, while normal (non-standalone) builds may have to share a common installation directory such as /usr/local or C:\MinGW.
  • ENABLE_LIB64=1
This causes the makefile to use -d ENABLE_LIB64 when building the compiler. 64bit libraries are placed into lib64/freebasic/ instead of lib/freebasic/.

Compiler source code configuration (FBFLAGS)

  • -d ENABLE_STANDALONE
This makes the compiler behave as a standalone tool that cannot rely on the system to have certain programs or libraries. See the normal vs. standalone comparison for more information.
  • -d ENABLE_SUFFIX=foo
This makes the compiler append the given suffix to the lib/freebasic/ directory name when searching for its own lib/freebasic/ directory. For example, -d ENABLE_SUFFIX=-0.24 causes it to look for lib/freebasic-0.24/ instead of lib/freebasic/. Corresponding the ENABLE_SUFFIX=foo makefile option, this adjust the compiler to work in the new directory layout.
  • -d ENABLE_PREFIX=/some/path
This causes the given prefix path to be hard-coded into the compiler, disabling the use of Exepath(). Thus it will no longer be relocatable. This is useful if its known that the compiler does not need to be relocatable, or if exepath() does not work properly (for example, in FB 0.90.1, this is the case for FreeBSD).
  • -d ENABLE_LIB64
This makes the compiler search 64bit libraries in lib64/freebasic/ instead of lib/freebasic/. This only affects the normal (non-standalone) build. 32bit libraries are still searched in lib/freebasic/.

rtlib and gfxlib2 source code configuration (CFLAGS)

  • -DDISABLE_X11
With this, the Unix rtlib/gfxlib2 will not use X11 headers, disabling gfxlib2's X11 graphics driver and some of the rtlib's Linux console functionality (affects multikey() and console mouse handling).
  • -DDISABLE_GPM
With this, the Linux rtlib will not use General Purpose Mouse headers (gpm.h), disabling the Linux GetMouse functionality.
  • -DDISABLE_FFI
With this, the rtlib will not use libffi headers (ffi.h), disabling the Threadcall functionality.
  • -DDISABLE_OPENGL
With this, the gfxlib2 will not use OpenGL headers, disabling the OpenGL graphics drivers.


previous page start next page