This chapter covers:
The preferred way to distribute GNU software is distribution of the source code. However, it can be a non-trivial exercise to build GNU Pascal on some non-UNIX systems, so we also provide ready-to-run binaries for a number of platforms. See section Installation instructions for a GPC binary distribution how to install a binary distribution.
GPC is based on GNU CC; you will need the GCC sources to build it. It must be the same version as the one GPC is implemented with. Although you need GCC to build the GNU Pascal compiler, you don't need GCC to compile Pascal programs once GNU Pascal is installed. Because GNU Pascal shares its backend with GNU CC, it should run on any system supported by GNU CC. A full list of platforms supported by GNU CC can be found in chapter 4 of the GCC manual, "Using and Porting GNU CC"
Here is the generic procedure for installing GNU Pascal on a Unix system. See section Configuration dependent compilation notes for extra information needed to install GPC on certain platforms.
% ../gcc-2.7.2.1/configure --prefix=/usrwill do the job. This creates all the necessary config files, links and Makefile in the GCC object directory.
--local-prefix
option below.
fixincludes
script.
PATH
environment variable such that the necessary GNU tools come
before the standard system tools.
% make LANGUAGES=c(Just `make' would also build the C++ and Objective C compilers). You do not need to install the compiler you just built, but leave the objects in place, since GPC will directly load most of the GCC object files.
-------------------------------------------------------------------------- Configuration summary: Building a native i386-freebsd2.1.0 compiler GPC sources in: . GCC sources in: ../gcc-2.7.2.1 GCC object code in: ../gcc-2.7.2.1 GCC version: 2.7.2.1 Compiler for GPC: gcc Compiler for libgpc.a: gcc Compiler flags: -g -O Installation path: /usr/bin, /usr/lib/gcc-lib/i386-freebsd2.1.0/2.7.2.1 -------------------------------------------------------------------------- Now, type `make' to build the compiler and runtime system.
% makeOptionally, you may supply CFLAGS, LDFLAGS or RTSFLAGS. CFLAGS is used for compiler and RTS, RTSFLAGS are for RTS only, i.e.: `make CFLAGS="-O2" RTSFLAGS=-Wall'
make -n install
command does, and if you are satisfied run it without the -n
option
to install the compiler (gpc1), front end (gpc), run time system (libgpc.a)
to the same place where gcc was installed.
It is sort of stupid to have a separate incarnation of `gcc.c'; the
difference now is that `gpc' also searches from library `libgpc.a'
and `-lm'. In addition `gcc.c' specifies the interface to the
Pascal compiler (gpc1). This command will vanish when `gcc' knows how to
compile Pascal programs.
For alpha OSF/1 v3.2 (GCC 2.6.3): If your linker starts to output error messages like:
Warning: Linking some objects which contain exception information sections and some which do not. This may cause fatal runtime exception handling problems (last obj encountered without exceptions was <OBJ/LIB>)
I do not know why these started to appear, but you can get rid of these if you do as follows in the GPC object directory.
You need to trigger the Makefile dependencies, e.g. by doing the touch
command below. What happens is that it re-generates the version.c and
rts/version.c files, which need to be recompiled with ALPHA_BUG
defined.
Example:
% touch Makefile % make MY_CFLAGS=-DALPHA_BUG other-make-flags-you-want-to-use
You cannot build GNU CC (or GNU Pascal) by itself on MS-DOS; it will not compile under any MS-DOS compiler except itself. The official MS-DOS port of GCC is called djgpp, and it is available from `simtel.coast.net' and it has mirrors all over the world. The `configure' script is replaced by an MS-DOS batch file called `configure.bat' wich does essentially the same. Detailed instructions are in the file `config/msdos/README.dj' of the GNU Pascal source distribution.
EMX is a FreeWare 32-bit DOS extender which adds some properties of UNIX to the DOS and OS/2 operating systems written by Eberhard Mattes. You can find it, for example, via anonymous `ftp' on the server `ftp.uni-stuttgart.de' in the directory `pub/systems/os2/emx*'.
The EMX extender for DOS and OS/2 makes it relatively easy to port GNU tools--such as the GNU Pascal Compiler--to these platforms. However, it is not straightforward to compile it.
dmake
make utility.
You have compiled GNU C such that the object files are
still in place. It is important that GNU C is the version
matching ot GNU Pascal which is currently 2.7.2.1.
If you have problems compiling GNU C: The directory
`config/emx' contains drive-independent versions
of `dostage1.cmd' and `makeexe.cmd'.
If you are running DOS, you are in trouble now because
the DOS command line is limited to 128 characters. If you
succeed to compile GPC for EMX on a DOS system, please let
us know. (However you can compile GPC for DJGPP on a DOS
system.)
cd \emx pkunzip -d c:\gpc-2721
configur make
make install
cygwin32 is a project to make it easy to port Unix applications to machines which run an OS which supports the Win32 API - i.e. Microsoft Windows 95 and Windows NT. Currently, cygwin32 is in beta stage; it is available from `ftp://ftp.cygnus.com/pub/gnu-win32/' Don't use gcc sources from the cygwin32 distribution. These are not just modified from FSF gcc-2.7.2 to support the Windows 95/NT target, they are the "current development release", and too different from FSF gcc to be compatible with GNU Pascal, which is based on FSF sources.
Instead, apply `config/cygwin32/gcc-2.7.2.cygwin32-beta16.diff' to FSF gcc-2.7.2 to add cygwin32 platform support to gcc. The GNU pascal sources already have the cygwin32 support, so no further patching of gpc is needed
Currently, cygwin32 is not self-hosting: the preferred way to build the cygwin32-gpc binary is to use a unix system with a cygwin32 targeting crosscompiler. See section Crossbuilding a compiler.
GNU Pascal does not yet fully support the stack calling convention of the Win32 API, thus making it impossible to access system DLL's.
GNU Pascal can function as a cross-compiler for many machines, but not all. Also, only a few combinations have been tested. If you need information about GNU tools in a cross-configuration, `ftp://ftp.cygnus.com/pub/embedded/crossgcc/' is the place to be.
Since GNU Pascal generates assembler code, you probably need a cross-assembler that GNU Pascal can run, in order to produce object files. If you want to link on other than the target machine, you need a cross-linker as well. You also need header files and libraries suitable for the target machine that you can install on the host machine.
To compile and run a program using a cross-compiler involves several steps:
It is most convenient to do all of these steps on the same host machine, since then you can do it all with a single invocation of GNU Pascal. This requires a suitable cross-assembler and cross-linker. For some targets, the GNU assembler and linker are available.
No special actions have to be taken to configure GNU Pascal as a crosscompiler. Cross-compiler specific configuration is done only for GCC. Section 4.2 of "Using and Porting GNU CC" deals with cross-configurations in great detail. Once cross-binutils and a C library for the target machine are in place, GCC can be configured (from the GCC object directory). Suppose we are on a FreeBSD system and want a cross-compiler that produces code that runs on MS-DOS:
% ../gcc-2.7.2.1/configure --prefix=/usr --target=i386-go32
This creates all the necessary config files, links and Makefile in the GCC object directory. Now, proceed with the compilation and installation process like in the case of the native configuration described before. Do not remove files from the GCC object directory; the cross-compiler is used to compile the GNU Pascal runtime system (RTS) for the target system.
Once you have verified the C crosscompiler, the Pascal cross-compiler can be configured and built. Note that the `configure' script does not require any cross-compiler related switches because GPC inherits all of this from GNU CC.
Sample output for a FreeBSD->msdos cross configuration:
-------------------------------------------------------------------------- Configuration summary: Building a i386-go32 crosscompiler hosted by i386-unknown-freebsd2.1.0 GPC sources in: ../gpc-2.0 GCC sources in: ../gcc-2.7.2.1 GCC object code in: ../gcc GCC version: 2.7.2.1 Compiler for GPC: gcc Compiler for libgpc.a: i386-go32-gcc Compiler flags: -g -O Cross-ar utility: i386-go32-ar Cross-ranlib utility: i386-go32-ranlib Installation path: /usr/bin, /usr/lib/gcc-lib/i386-go32/2.7.2.1 -------------------------------------------------------------------------- Now, type `make' to build the compiler and runtime system.
Building a cross-compiler requires cross-binutils for your target,
i386-go32 in this examples. If `configure' is not able to find
`i386-go32-ar' and/or `i386-go32-ranlib', you may have to run it
again with again with --with-ar=your-cross-ar
or
--with-ranlib=your-cross-ranlib
switches.
Then, `make' and `make install' the cross-compiler like you would for a native configuration.
Yet another possibility is crossbuilding : Using a crosscompiler to build GNU Pascal results in a compiler binary that runs on the cross-target platform. A possible reason why anybody would want to do this, is when the platform on which you want to run the GNU Pascal compiler, is not self-hosting. An example is cygwin32.
To crossbuild GNU Pascal, you have to install a crosscompiler for your target first. This is covered in chapter 4 of "Using and Porting GNU CC". Assuming you want to build a native cygwin32 Pascal compiler on a FreeBSD system, configure GCC:
% ../gcc-2.7.2.1/configure --prefix=/usr --build=i386-freebsd \ --host=i386-cygwin32 --target=i386-cygwin32
Build it:
% make CFLAGS=-O2 LANGUAGES=c
Now, configure and build GPC. The output of `configure' should look like:
-------------------------------------------------------------------------- Configuration summary: Building a i386-cygwin32 crosscompiler hosted by i386-cygwin32 GPC sources in: ../gpc-2.0 GCC sources in: ../gcc-2.7.2.1 GCC object code in: ../gcc GCC version: 2.7.2.1 Compiler for GPC: i386-cygwin32-gcc Compiler for libgpc.a: i386-cygwin32-gcc Compiler flags: -g -O Cross-ar utility: i386-cygwin32-ar Cross-ranlib utility: i386-cygwin32-ranlib Installation path: /usr/bin, /usr/lib/gcc-lib/i386-cygwin32/2.7.2.1 -------------------------------------------------------------------------- Now, type `make' to build the compiler and runtime system.
Again, `configure' should be able to detect and configure this setup without additional flags. If not, specify `--with-ar', `--with-ranlib', `--with-gcc' and/or `--with-rtsgcc' as appropriate.
A cross-built compiler must be installed by hand.
To install a binary distribution, cd to the main directory and unpack the archive while preserving the stored directory structure. In concrete, to install a ZIP archive under DOS with PKunzip, type
C:\> pkunzip -d archive
where archive is the name of the distribution file. To install a TGZ archive under a UNIX compatible system, become root, then extract the archive from the root of the filesystem:
# tar xzf archive.tar.gz
If you are using a `tar' utility other than GNU tar, it might be necessary to do the above in two steps:
# gzip -d archive.tar.gz # tar xf archive.tar
Binary distributions include `libgcc.' and `specs', files that are normally part of gcc. If you have gcc installed, they will be replaced unless you manually install the archive.