Build Seed7

The way to compile the interpreter depends on the operating system and the development tools used. You need a stand-alone C compiler and a make utility to compile the interpreter. A C compiler, which is only usable from an IDE, is not so useful, since some Seed7 programs (e.g. The Seed7 compiler s7c) need to call the C compiler as well. In case a make utility is missing under Windows the program make7.exe can be downloaded from

https://sourceforge.net/projects/seed7/files/bin

In this directory is also a Seed7 installer for Windows (seed7_05_20230709_win.exe).

Several makefiles are prepared in 'seed7/src' for various combinations of operating system, make utility, C compiler and shell:

makefile name	operating system	make prog	C compiler	shell
mk_linux.mak	Linux/Unix/BSD	(g)make	gcc	sh
mk_clang.mak	Linux/Unix/BSD	(g)make	clang	sh
mk_icc.mak	Linux/Unix/BSD	(g)make	icc	sh
mk_tcc_l.mak	Linux/Unix/BSD	(g)make	tcc	sh
mk_cygw.mak	Windows (Cygwin)	(g)make	gcc	sh
mk_msys.mak	Windows (MSYS)	mingw32-make	gcc	sh
mk_mingw.mak	Windows (MinGW)	mingw32-make	gcc	cmd.exe
mk_mingc.mak	Windows (MinGW)	make7	gcc	cmd.exe
mk_nmake.mak	Windows (MinGW)	nmake	gcc	cmd.exe
mk_msvc.mak	Windows (MSVC)	nmake	cl	cmd.exe
mk_bcc32.mak	Windows (bcc32)	make	bcc32	cmd.exe
mk_bccv5.mak	Windows (bcc32)	make	bcc32 V5.5	cmd.exe
mk_clangw.mak	Windows (clang)	(g)make	clang	cmd.exe
mk_tcc_w.mak	Windows (tcc)	(g)make	tcc	cmd.exe
mk_djgpp.mak	DOS	(g)make	gcc	cmd.exe
mk_osx.mak	macOS	make	gcc	sh
mk_osxcl.mak	macOS	make	clang	sh
mk_freebsd.mk	FreeBSD	make	clang/gcc	sh
mk_emccl.mak	Linux/Unix/BSD	make	emcc + gcc	sh
mk_emccw.mak	Windows (emcc)	mingw32-make	emcc + gcc	cmd.exe

Detailed explanations how to compile the interpreter (s7) can be found in the chapters below. In the optimal case you just copy one makefile from above to 'makefile' and do (with the corresponding make program):

make depend
make

When the interpreter (s7) is compiled successfully the executable and the libraries are placed in the 'bin' directory. Additionally a symbolic link to the executable is placed in the 'prg' directory (Under Windows symbolic links are not supported, so a copy of the executable is placed in the 'prg' directory).

After a successful compilation of the Seed7 interpreter (s7) the Seed7 compiler (s7c) can be compiled with:

make s7c

The compiler executable is copied to the 'bin' directory.

You can check interpreter and compiler with a test suite (chk_all.sd7). This step is optional and it will take some time. It is recommended to run the test suite but you can also run it later. To run the test suite do:

make test

There are some tools written in Seed7. If you compile these tools now they are installed with the final step. You can skip this step and compile (and install) the tools later. Compile the tools with:

make utils

Finally Seed7 can be installed with:

sudo make install

To do several compilation attempts in succession you need to execute the command

make clean

before you do 'make depend' again.

For Linux the compilation process is the simplest. Besides C compiler and a make utility you need some packages:

• The C development libraries and header files (e.g. glibc-devel or libc6-dev)
• The header files for ncurses (e.g. ncurses-devel, libncurses-devel or libncurses5-dev)
• The development package of X11 (e.g. libX11-devel or libx11-dev)

The file 'makefile' is (almost) identical to 'mk_linux.mak' and that file is already prepared to compile under Linux. Go to the 'seed7/src' directory and type:

make depend
make

After the compilation the interpreter executable can be found in the 'bin' directory and the 'prg' directory will contain a link to the executable.

In some distributions the X11 library directory is not in $PATH. In this case the value of the SYSTEM_DRAW_LIBS variable in the makefile must be changed. Replace the -lX11 by the path and the name of your libXll (e.g. /usr/X11/lib/libX11.so or /usr/X11R6/lib/libX11.a).

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS.

Probably you can do it just the same way as under Linux. If there are problems and the makefile needs to be adjusted please let me know. If you send the changed makefile to me I can include it in the release.

If gcc and mingw32-make from MinGW are installed use a console, go to the 'seed7\src' directory and type:

copy /Y mk_mingw.mak makefile
mingw32-make depend
mingw32-make

To compile under MSYS (a Unix shell window from the MinGW tools) go to the 'seed7/src' directory and type:

cp mk_msys.mak makefile
mingw32-make depend
mingw32-make

If gmake uses Unix shell commands even if started from a Windows console, you can use gmake together with mk_msys.mak from a Windows console also.

To compile with gcc from MinGW and nmake from Windows use a console, go to the 'seed7\src' directory and type:

copy /Y mk_nmake.mak makefile
nmake depend
nmake

After the compilation the interpreter executable can be found in the 'bin' directory and it is also copied to prg/s7.exe.

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS. Keep in mind to use the same 'make' utility as before.

The Seed7 installer for Windows uses an encapsulated gcc in the directory 'seed7\gcc'. This gcc can be invoked via the file 'seed7\bin\call_gcc.bat'. This ensures the encapsulated gcc and another gcc do not interfere with each other. The makefile 'mk_mingc.mak' invokes gcc via 'call_gcc.bat' and ar via 'call_ar.bat'.

To use Seed7 from GitHub with the encapsulated gcc:

• Decide for a place for the seed7 directory from GitHub.
• This place should differ from the place of the seed7 directory created by the installer.
• Clone Seed7 into the new place with 'git clone https://github.com/ThomasMertes/seed7.git'.
• The clone creates a new seed7 directory.
• Copy the installers seed7\gcc directory to the GitHub created seed7 directory.
• Go to the GitHub created 'seed7\src' (with the cd command).

Use the make7 command and always use the option '-f mk_mingc.mak':

make7 -f mk_mingc.mak clean
make7 -f mk_mingc.mak depend
make7 -f mk_mingc.mak

Don't forget '-f mk_mingc.mak' for later build commands. E.g.:

make7 -f mk_mingc.mak s7c
make7 -f mk_mingc.mak test
make7 -f mk_mingc.mak utils

After switching from the installers version to the GitHub version it is necessary to change the paths with:

make7 -f mk_mingc.mak install

After an update from GitHub (git pull in the seed7 directory) the commands starting from

make7 -f mk_mingc.mak clean

can be used to compile the new version.

To compile Seed7 with cl and nmake (C compiler and make utility from a big big software company) it is necessary, that cl and nmake can be executed from a console window. The script vcvarsall.bat sets up the environment for cl and nmake. This script is in the directory

...Visual Studio\2019\Community\VC\Auxiliary\Build

or for a professional installation in the directory

...Visual Studio\2019\Professional\VC\Auxiliary\Build

Note that 2019 is the year of the MSVC release. In a 32-bit operating system use a console and execute:

...Studio\2019\Community\VC\Auxiliary\Build\vcvarsall x86

In older versions of MSVS the script was named vcvars32.bat. In a 64-bit operating system you need to execute:

...Studio\2019\Community\VC\Auxiliary\Build\vcvarsall x64

Afterwards the environment is set up for MSVC. In newer versions of MSVC the include files and libraries are in the "Windows Kits" directory. In this case it is necessary to define the environment variables INCLUDE and LIB. To do that look for: Control Panel -> System and Security -> System -> Advanced system settings -> Environment Variables. With "Windows Kits" the include files are in the directory:

...Windows Kits\<main_version>\Include\<detailled_version>

The actual include files are in the sub directories 'um', 'ucrt' and 'shared'. Add the absolute paths of these three directories to the INCLUDE environment variable. E.g.:

C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\um
C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\ucrt
C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\shared

On such installations the libraries are in the directory:

...Windows Kits\<main_version>\Lib\<detailled_version>

For 32-bit compilation the actual libraries are in the sub directories 'um\x86' and 'ucrt\x86'. For 64-bit compilation the actual libraries are in the sub directories 'um\x64' and 'ucrt\x64'. Add the absolute paths of the 32-bit or 64-bit directories to the LIB environment variable. E.g.:

C:\Program Files (x86)\Windows Kits\10\Lib\10.0.19041.0\um\x86
C:\Program Files (x86)\Windows Kits\10\Lib\10.0.19041.0\ucrt\x86

or for 64-bit compilation:

C:\Program Files (x86)\Windows Kits\10\Lib\10.0.19041.0\um\x64
C:\Program Files (x86)\Windows Kits\10\Lib\10.0.19041.0\ucrt\x64

Don't forget to restart a console window after environment variables have changed.

After everything has been set up for MSVC you can go to the 'seed7\src' directory and type:

copy /Y mk_msvc.mak makefile
nmake depend
nmake

If it is necessary to compile again you need to do a

nmake clean

to clean the files from a previous compilation attempt.

After the compilation the interpreter executable can be found in the 'bin' directory and it is also copied to prg/s7.exe. Note that the build process saves all environment variables in the file seed7/bin/cl_env.ini. Every time the Seed7 compiler calls cl it restores the environment variables from the file seed7/bin/cl_env.ini beforehand. This change of the environment happens in the Seed7 compiler and the original environment of the console remains unchanged. This means that the Seed7 compiler (s7c) can be used without the need to call vcvarsall.bat.

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS. Keep in mind to use the 'nmake' command as before.

To compile Seed7 with bcc32 and make (C compiler and make utility from a smaller software company) use a console, go to the 'seed7\src' directory and type:

copy /Y mk_bcc32.mak makefile
make depend
make

After the compilation the interpreter executable can be found in the 'bin' directory and it is also copied to prg/s7.exe. For the older version of bcc32 (Version 5.5, which is available in the Internet) use:

copy /Y mk_bccv5.mak makefile
make depend
make

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS.

To compile Seed7 with tcc (Tiny C Compiler) and mingw32-make you need version 0.9.27 of tcc. The support for tcc under Windows is experimental.

You need to decide, which archiver utility should be used to create libraries. In the makefile mk_tcc_w.mak the value ARCHIVER defines the archiver utility to be used. For the ar utility from MinGW (ar should be in the search path) use the following lines (this is the default):

ARCHIVER = ar -r
# ARCHIVER = tiny_libmaker

As an alternative the tiny_libmaker utility can be used. Note that tiny_libmaker supports only 32-bit executables. You might need to copy tiny_libmaker.exe to the directory tcc. You need to change mk_tcc_w.mak also. Use the lines:

# ARCHIVER = ar -r
ARCHIVER = tiny_libmaker

Additionally you need some things:

• The include file winsock2.h (copy it to tcc\include)

Then use a console, go to the 'seed7\src' directory and type:

copy /Y mk_tcc_w.mak makefile
make depend
make

After the compilation the interpreter executable can be found in the 'bin' directory and it is also copied to prg/s7.exe. Note that tcc for Windows has some bugs. The program chk_all.sd7 shows this bugs. Therefore Seed7 does not support the compilation with tcc under windows officially.

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS. Keep in mind to use the same 'make' utility as before.

To compile Seed7 with Cygwin several Cygwin packages need to be installed. From the category Devel the following packages are needed: binutils, gcc-core, libncurses-devel and make. From category X11 the package libX11-devel is needed. To use graphic programs it is necessary to install Cygwin/X. Instructions to install Cygwin/X can be found in the Internet. To test the installation start a Cygwin window and do:

make --version
gcc --version

If the Cygwin gcc does not have the name gcc it is necessary to edit the file 'mk_cygw.mak'. The line containing

CC = gcc

must be changed to define the name of your gcc. If gcc and make work well change to the 'seed7/src' directory and do:

cp mk_cygw.mak makefile
make depend
make

After the compilation the interpreter executable can be found in the 'bin' directory and the 'prg' directory will contain a link to the executable.

Cygwin sometimes has problems with symlinks. This is indicated by an error message which ends with:

bin/as.exe: cannot execute binary file

The presence of a Cygwin symlink problem can be checked in the directory /usr/i686-pc-cygwin/bin (or the corresponding directory mentioned in the error message). If the file /usr/i686-pc-cygwin/bin/as.exe is a small file with less than 100 bytes and starts with

!<symlink>

it is some Cygwin symlink. To fix this error just copy the symlink destination over the file as.exe (after making a backup of the original symlink file as.exe). Additionally it might also be necessary to do the same for ld.exe (and maybe for some other symlinks as well).

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS.

Emscripten provides a C compiler (emcc) that targets JavaScript and WebAssembly. How to download and install Emscripten is described here.

The makefiles mk_emccl.mak and mk_emccw.mak are provided for compiling with emcc under Linux and Windows. Besides emcc you also need gcc (under Windows use gcc from MinGW) and node.js. When you download emsdk you get also a version of node.js.

To compile Seed7 under Linux use a terminal window and activate the PATH and other environment variables for emcc (with 'source ./emsdk_env.sh' in the emsdk directory). Afterwards go to the directory 'seed7/src' (with cd) and type:

cp mk_emccl.mak makefile
make depend
make

To compile Seed7 under Windows use a console window and activate the PATH and other environment variables for emcc (with 'emsdk_env.bat' in the emsdk directory). Afterwards go to the directory 'seed7\src' (with cd) and type:

copy /Y mk_emccw.mak makefile
mingw32-make depend
mingw32-make

After compilation of Seed7 the Seed7 interpreter (s7.js) can be started (in the directory 'seed7/prg') with:

node s7.js hello

Note that the Emscripten version of Seed7 is experimental. Due to limitations of Emscripten and missing Seed7 driver libraries several things do not work as they should:

• In Emscripten stdout is always line buffered.
• Reading from stdin is not possible (EOF is reached immediately).
• Processes cannot be started.
• Sockets cannot be used.
• Graphics from node.js would need libraries that access win32 or X11 via native calls.

When you execute

node s7.js aS7Program

you might get an error like:

exception thrown: RangeError: Maximum call stack size exceeded

In this case you can raise the allowed stack size. Execute node.js as follows (chose a sufficient stack-size):

node --stack-size=8192 s7.js chkstr

You can also raise the allowed stack size of node.js permanently. Under Windows this is done with the command editbin (from Visual-C). The stack is increased (in the directory of node.exe) with:

editbin /stack:33554432 node.exe

If the stack problems are triggered by emscripten the file .emscripten in your home directory must be also adjusted. Change the NODE_JS entry to:

NODE_JS = ['node', '--stack-size=8192']

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS. Keep in mind to use the same 'make' utility as before.

You need gcc and make from DJGPP. Make sure that the search PATH leads to gcc and make from DJGPP. Additionally the environment variable DJGPP must be set to a path leading to DJGPP.ENV. Note that make from DJGPP has some limitations:

• It does not understand the option -f. So copying mk_djgpp.mak to makefile is really mandatory.
• It does not support redirecting command output. So you will see all errors and warnings created by test programs.

Use the command line, go to the 'seed7\src' directory and type:

copy /Y mk_djgpp.mak makefile
make depend
make

After the compilation the interpreter executable can be found in the 'bin' directory and it is also copied to prg/s7.exe. If your get errors you can try mk_djgp2.mak instead. DOS usually supports only files with 8.3 file names (8 Ascii character name + dot + 3 Ascii character extension). The C source and header files of Seed7 all use this convention. Seed7 library files use longer file names. The DOS version of Seed7 maps long file names like reference.s7i to REFERE~1.S7I. Dosbox uses the same mapping so it should just work. Dosemu uses a different mapping, so the libraries are not found. In that case I suggest to copy files with long names in the 'lib' directory:

copy reference.s7i REFERE~1.S7I
copy hashsetof.s7i HASHSE~1.S7I
copy environment.s7i ENVIRO~1.S7I
copy null_file.s7i NULL_F~1.S7I
copy external_file.s7i EXTERN~1.S7I
copy clib_file.s7i CLIB_F~1.S7I
copy enable_io.s7i ENABLE~1.S7i
copy graph_file.s7i GRAPH_~1.S7I

Note that the DOS version of Seed7 currently does not support graphics, sockets, processes and databases.

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS.

To compile under macOS you need You need to install Xcode. Xcode can be installed from the App Store or from Apple's developer site if a specific version is needed.

For the next steps a terminal window is needed. A terminal window is opened by clicking the launchpad icon in the dock, typing terminal in the search field, then clicking on the terminal icon.

The Homebrew package manager needs to be installed. Use a terminal window and the following command to install it:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Homebrew uses the brew command to install software. If the brew command is unknown it might be necessary to add it to the PATH. If the zsh shell is used this can be done with:

(echo; echo 'eval "$(/opt/homebrew/bin/brew shellenv)"') >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

Depending on the version of macOS it might be necessary to also install XQuartz (the X11 support of macOS). XQuartz can be installed using brew:

brew install --cask xquartz

After installing XQuartz the computer should be rebooted. If the x11 lib is not found it can be installed using brew:

brew install libx11
brew install libxrender

If /usr/local/include/X11 does not exist the brew location must be linked to to /usr/local/include, so the C compiler can find it:

sudo mkdir /usr/local/include
sudo ln -s /opt/homebrew/include/X11 /usr/local/include/X11

In newer versions of macOS gcc is based on clang. You can use this gcc, but it is not the original gcc. To obtain the original gcc you have to download it from a repository like Homebrew. To compile Seed7 with gcc (the clang based gcc or the original gcc) start a terminal, go to the 'seed7/src' directory and type:

cp mk_osx.mak makefile
make depend
make

To compile Seed7 with clang use the following commands:

cp mk_osxcl.mak makefile
make depend
make

After the compilation the interpreter executable can be found in the 'bin' directory and the 'prg' directory will contain a link to the executable.

Under macOS the X11 library is usually found in '/usr/X11R6/lib'. For unknown reasons the Xcode (macOS) linker normally does not search libraries in '/usr/X11R6/lib'. Therefore 'mk_osx.mak' defines the following linker flag:

LDFLAGS = -L/usr/X11R6/lib

Besides this 'mk_osx.mak' is almost identical to 'mk_linux.mak' and 'makefile'. If the X11 library is in a different directory you need to change the LDFLAGS value to that directory.

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS.

To compile under Android you need to install the termux app on the Android device. Afterwards use the following commands:

pkg install clang
pkg install make
pkg install git
git clone https://github.com/ThomasMertes/seed7.git
cd seed7/src

Under termux the command gcc refers also to clang. There are two ways to compile Seed7 with termux. The first way uses the makefile mk_clang.mak. To compile with mk_clang.mak use the following commands:

make -f mk_clang.mak depend
make -f mk_clang.mak
make -f mk_clang.mak s7c

The second way to compile Seed7 uses makefile. To compile with makefile use the following commands:

make depend
make
make s7c

The remaining steps to build and install Seed7 are explained above in the chapter REMAINING BUILD STEPS. If you decided to use the 'make' parameter

-f mk_cygw.mak

you must continue to use this parameter with 'make'.

Seed7 supports database access. Therefore the client library packages of the databases must be installed. On my computer the names of the client library packages are:

The client libraries are sufficient for Seed7 to access the databases. Seed7 provides replacements for the C header files used by the database client libraries. To use the original header files under Linux database client development packages must be installed. On my computer the names of the client development packages are:

In most cases errors indicate that some development package of your distribution is missing. If your operating system is Linux, BSD or Unix not all development packages with header files might be installed. In this case you get some errors after typing 'make depend'.

• Errors such as

  chkccomp.c:56:20: fatal error: stdlib.h: No such file or directory
  s7.c:30:20: fatal error: stdlib.h: No such file or directory
  

indicate that the development package of the C library is missing. I don't know the name of this package in your distribution (under Ubuntu it has the name libc6-dev and under openSUSE Tumbleweed the name is glibc-devel), but you can search in your package manager for C development libraries and header files.

• Errors such as

  con_inf.c:54:18: error: term.h: No such file or directory
  kbd_inf.c:53:18: error: term.h: No such file or directory
  trm_inf.c:47:18: error: term.h: No such file or directory
  

indicate that the curses or ncurses development package is missing. I don't know the name of this package in your distribution (under Ubuntu it has the name libncurses5-dev and under openSUSE Tumbleweed the name is ncurses-devel), but you can search in your package manager for a curses/ncurses package which mentions that it contains the header files. To execute programs, you also need to install the non-developer package of curses/ncurses (in most cases it will already be installed because it is needed by other packages).

• Errors such as

  drw_x11.c:38:19: error: X11/X.h: No such file or directory
  drw_x11.c:39:22: error: X11/Xlib.h: No such file or directory
  drw_x11.c:40:23: error: X11/Xutil.h: No such file or directory
  drw_x11.c:45:24: error: X11/keysym.h: No such file or directory
  

indicate that the X11 development package is missing. Under Ubuntu this package has the name libx11-dev and is described as:

X11 client-side library (development headers)

Under openSUSE Tumbleweed this package is named libX11-devel and is described as:

Development files for the Core X11 protocol library

Note that under X11 'client' means: The program which wants to draw. A X11 'server' is the place where the drawings are displayed. So, you must search for a X11 client developer package with headers. If you use X11 in some way (you don't do everything from the text console) the non-developer package of X11 will already be installed.

• Errors such as

  common.h:35:17: fatal error: gmp.h: No such file or directory
  

indicate that the GMP development package is missing. I don't know the name of this package in your distribution. Under Linux Mint this package has the name libgmp-dev and is described as: Multiprecision arithmetic library developers tools.

• Errors such as

  gcc chkccomp.c -o chkccomp
  chkccomp.c:28:10: fatal error: base.h: No such file or directory
  compilation terminated.
  

  or

  del version.h
  process_begin: CreateProcess(NULL, del version.h, ...) failed.
  make (e=2): The system cannot find the file specified.
  mingw32-make: *** [clean] Error 2
  

indicate that your makefile contains commands for the cmd.exe (or command.com) Windows console, but your 'make' program uses a Unix shell (/usr/bin/sh) to execute them. Either use a makefile which uses Unix shell commands (e.g. mk_msys.mak or mk_cygw.mak) or take care that the 'make' program uses cmd.exe (or command.com) to execute the commands.

• Errors such as

  s7.c:28:21: error: version.h: No such file or directory
  

indicate that you forgot to run 'make depend' before running 'make'. Since such an attempt produces several unneeded files it is necessary now to run 'make clean', 'make depend' and 'make'.

• The 'make' utility sometimes writes an error like

  depend:1: *** multiple target patterns.  Stop.
  

This indicates that an old 'depend' file (probably a relict of an earlier 'make' command with a different makefile) does not fit to the current makefile. To get rid of this error remove the file 'depend'. After that the compilation process must be started from scratch with 'make clean', 'make depend' and 'make'.

• If you use bcc32 an error like

  Error E2194: Could not find file 'Studio\7.0\bin\bcc32.exe'
  

can happen. This indicates that the search path where bcc32.exe is found contains a space and the 'make' program is not capable to handle spaces in a search path. Creating the batch file 'seed7\src\bcc32.bat' with the content

bcc32.exe %*

helps. As alternate solution 'bcc32.exe' and 'bcc32.cfg' can be copied to the 'seed7\src' directory (this solution should be avoided, since it does not consider updates of bcc32).

• If you use cl (from msvc) an error like

  NMAKE : fatal error U1077: 'cl' : return code '0xc0000135'
  

indicates that you forgot to execute vcvars32 before executing 'make depend' or 'make'. A message box, which complains that mspdb100.dll was not found, indicates also that vcvars32 was not executed.

• If you use clang under Windows an error like

  chkccomp.c:60:10: fatal error: 'stdlib.h' file not found
  

indicates that the include file search path is not set up. If clang is based on the VC toolchain it is necessary to call vcvars32 from the commandline to set up the environment.

• A linker error like

  ld: library not found for -lX11
  

indicates that the linker was not able to find the X11 library. The X11 library can have the name libX11.so (dynamic library) or libX11.a (static library). You need to search for this library (the dynamic library should normally be preferred). After you found it the LDFLAGS definition in your makefile must be changed. E.g.: If you found libX11.so in '/usr/X11R6/lib' the LDFLAGS assignment should be changed from

LDFLAGS =

to

LDFLAGS = -L/usr/X11R6/lib

• If you use icc an error like

  .../compiler/include/math.h(1216):
  error: identifier "_LIB_VERSION_TYPE" is undefined
    _LIBIMF_EXT _LIB_VERSIONIMF_TYPE _LIBIMF_PUBVAR _LIB_VERSIONIMF;
  

indicates, that the math.h include file of icc uses _LIB_VERSION_TYPE. Recently the support for_LIB_VERSION_TYPE has been removed from glibc. Fortunately there is a definition of _LIB_VERSION_TYPE in math.h just a few lines above in a part deactivated by an #if. The #if line starts with:

#if (!defined(__linux__) || !defined(__USE_MISC)) && ...

I added a condition and the line now starts with:

#if (1 || !defined(__linux__) || !defined(__USE_MISC)) && ...

This fixed the error.

• Other errors

  If you got other errors I would like to know about. Please send an mail with detailed information to seed7-users@lists.sourceforge.net or to my mail address, which can be found at the Seed7 Homepage (look for Links). The detailed information should include:

  • Operating system
  • Distribution used
  • C compiler
  • The version of Seed7 you wanted to compile.
  • The complete log of error messages
  • The file src/version.h

The warnings can usually be ignored. Seed7 is compiled with the highest warning level (-Wall). Additionally there are also some warnings requested (such as -Wstrict-prototypes) which are not part of -Wall. The warnings can be classified to the following cases:

• Warnings about float used instead of double because of the prototype: There are functions which use float parameters or return float values. Gcc has the opinion that only double parameters and double results should be used and warns about that.
• Warnings about conversion from double to float for isnan.

  fltlib.c:1144:27: warning: conversion from 'floatType' {aka 'double'} to 'float' may change value [-Wfloat-conversion]
   1144 |     if (unlikely(os_isnan(number) ||
  

  The conversion from double to float keeps NaN values and it does not convert a normal number into a NaN value. This way it is always safe to check for NaN after a double has been converted to float.
• Warnings about unused parameter 'arguments'.

  actlib.c
  actlib.c(204): warning C4100: 'arguments': unreferenced formal parameter
  

  All primitive action functions use one parameter named 'arguments'. This is necessary to access primitive actions with function pointers. Some primitive actions do not use 'arguments' which causes this warning.
• Warnings about signed/unsigned instead of unsigned/signed because of the prototype.
• Warnings about 'variablename' may be used uninitialized.

  dcllib.c
  dcllib.c(512) : warning C4701: potentially uninitialized local variable 'created_object' used
  

  These are false complaints. Interestingly C compilers are not able to recognize if the states of two variables are connected. Such as a global fail_flag variable and a local condition variable (cond). The connection is: As long as fail_flag is FALSE the cond variable is initialized. If the fail_flag is TRUE the cond variable is not used and therefore it could be in an uninitialized state. At several places connected variable states are used which are not recognized by the optimizer and are therefore flagged with a warning. I accept such warnings in performance critical paths. I am not willing to do "unnecessary" initializations in performance critical paths of the program. At places that are not performance critical I do some of this "unnecessary" initializations just to avoid such warnings.
• Warnings about unary minus operator applied to unsigned.

  int_rtl.c
  int_rtl.c(662): warning C4146: unary minus operator applied to unsigned type, result still unsigned
  

  Applying the unary minus operator to an unsigned value is done on purpose. In the two's complement representation the most negative integer has no corresponding positive integer. C considers negating the most negative number as undefined behavior. For unsigned integers there is no undefined behavior. So an unsigned is negated to have well defined behavior.
• Warnings about unsafe functions that should be replaced.

  scanner.c
  scanner.c(203): warning C4996: 'strcpy': This function or variable may be unsafe. Consider using strcpy_s instead.
  

  There are doubts about the safety these "_s" functions. The buffer size must be provided as additional parameter. For code that does not consider buffer sizes there is a high probability that the size parameter is also wrong. For this reason these "safe" functions are not supported by many C libraries. So in portable C code they cannot be used.
• Warnings about "deprecated" POSIX functions.

  traceutl.c
  traceutl.c(526): warning C4996: 'fileno': The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name: _fileno.
  

  The reasoning about ISO C and C++ conformant names is absurd. This is just an attemt to force a vendor lock-in. If all POSIX function names are changed the program will not compile elsewhere. To avoid the vendor lock-in the file os_decls.h defines macros like os_fileno which are used in the source files of Seed7. Depending on the operating system os_fileno is defined as fileno or _fileno. This avoids these strange warnings and a vendor lock-in.
• Warnings about array subscript partly outside array bounds.

  s7.c:226:33: warning: array subscript 'struct rtlArrayStruct[0]' is partly outside array bounds of 'unsigned char[16]' [-Warray-bounds=]
  

  The structs of arrays and strings are defined with one element. When an array or string is created the actual number of elements is allocated with malloc(). For empty arrays and empty strings the allocated size is smaller than the corresponding struct (that contains one element). This is not a problem, because the non-existing element in of an empty array or string will never be accessed.
• Warnings about unknown conversion type characters 'I' in format strings. The MinGW gcc checks format strings and warns about the type character 'I' format strings. These warnings can be ignored, because the actual C run-time library (msvcrt) accepts format strings with 'I'.
• Warnings about passing argument with different width due to prototype: Some compilers write such warnings for formal boolean (boolType) parameters and actual boolean arguments. Since the types of parameter and argument are identical and a prototype is specified this warning can be considered as false alarm.

Sometimes errors are triggered, when a Seed7 program runs. This can happen because of reasons unrelated to Seed7.

A run-time error like

error while loading shared libraries: libtinfo.so.5:
cannot open shared object file: No such file or directory

indicates that the library libtinfo.so.5 is missing. This happened, when starting a program that was dynamically linked to ncurses. Obviously the dependency of the ncurses package was set wrong. I fixed this by downloading libtinfo.so.5 and copying it to the directory /lib64.

A comprehensive test of the s7 interpreter and the s7c compiler can be done in the directory 'prg' with the command:

./s7 chk_all

Under Windows using ./ might not work. Just omit the ./ and type:

s7 chk_all

The program 'chk_all' uses several check programs to do its work. First a check program is interpreted and the output is compared to a reference. Then the program is compiled and executed and this output is also checked. Finally the C code generated by the compiled compiler is checked against the C code generated by the interpreted compiler. The checks of the compiler are repeated with several compiler options. If everything works correct the output is (after the usual information from the interpreter):

compiling the compiler - okay
chkint ........... okay
chkovf ........... okay
chkflt ........... okay
chkbin ........... okay
chkchr ........... okay
chkstr ........... okay
chkidx ........... okay
chkbst ........... okay
chkarr ........... okay
chkprc ........... okay
chkbig ........... okay
chkbool ........... okay
chkenum ........... okay
chkscan ........... okay
chkjson ........... okay
chkbitdata ........... okay
chkset ........... okay
chkhsh ........... okay
chkfil ........... okay
chkexc ........... okay

This verifies that interpreter and compiler work correct.

The functions to operate with bigInteger values are defined in the file 'big_rtl.c'. This functions provide reasonable performance for the usual bigInteger computations. If for some reason the bigInteger performance of 'big_rtl.c' is not enough it is possible to replace 'big_rtl.c' with 'big_gmp.c'. The file 'big_gmp.c' uses the GMP library to do the bigInteger computations. To use the GMP library use the following steps:

You need the GMP library (one of gmp.lib/gmp.dll/gmp.a/gmp.so) and the gmp.h include file.

The use of GMP must be enabled explicit in the makefile. In the makefile (that you use) is an echo statement with:

#define USE_GMP 0

To enable GMP just change the 0 in this echo statement to 1. Remember to do a

make clean

after you changed the makefile. When Seed7 is compiled with

make depend

the program chkccomp.c checks if it is possible to compile and link a small test program with the GMP library. If the small test program works correct the definitions to use 'big_gmp.c' are written to version.h:

#define BIG_GMP_LIBRARY 2
#define BIGINT_LIB BIG_GMP_LIBRARY

Additionally the option to link the GMP library is added to SYSTEM_BIGINT_LIBS. SYSTEM_BIGINT_LIBS can be found in version.h:

#define SYSTEM_BIGINT_LIBS "-lgmp"

The file macros will also contain a definition of SYSTEM_BIGINT_LIBS:

SYSTEM_BIGINT_LIBS = -lgmp

If everything works as expected the GMP library will be used automatically.

If chkccomp.c does not succceed with the small GMP test program the file version.h will contain definitions to use 'big_rtl.c' as bigInteger library:

#define BIG_RTL_LIBRARY 1
#define BIGINT_LIB BIG_RTL_LIBRARY

In this case either the include file gmp.h is missing or the GMP library cannot be linked. By default chkccomp.c uses "-lgmp" as option to link the GMP library. If a different option should be used it can be added to the makefile used to compile Seed7. The section to create chkccomp.h: can be extended with a line like

echo "#define BIGINT_LIBS \" option to link GMP \"" >> chkccomp.h

to write a definition of BIGINT_LIBS to the file chkccomp.h.

The GMP library might be used by other libraries as well. In some cases the other users of the GMP library use a custom memory allocator. By design all users of GMP share the same custom memory allocator. Memory could be freed with the wrong allocator and this corrupts the heap. If you see buffer overflow errors or corrupt heap memory you should switch back to the default bigInteger library.

The C code of Seed7 can be grouped into several categories: Interpreter main, Parser, Interpreter core, Primitive action functions, General helper functions, Runtime library, Drivers and Compiler data library.

The main() function of the interpreter calls the Parser to create an internal program representation and afterwards it calls the Interpreter core to execute this program.

The interpreter main is licensed under the GPL.

The Seed7 parser (analyzer) reads Seed7 programs from a file or string and creates an internal representation for them.

The Seed7 parser is licensed under the GPL.

The interpreter core executes the internal representation of a program. In doing so primitive action functions are called.

The interpreter core is licensed under the GPL.

The *lib.c files contain interpreter functions which execute "PRIMITIVE ACTIONS" (in doing so they can call functions from the runtime library. The PRIMITIVE ACTION functions are called from the interpreter core.

The primitive action functions are licensed under the GPL.

General helper functions are used by Parser, Interpreter core and Primitive action functions.

The general helper functions are licensed under the GPL.

The functions defined in the runtime library are called from interpreted and compiled code (The Seed7 runtime library is linked to every compiled Seed7 program).

The runtime library is licensed under the LGPL.

The drivers are also part of the runtime library. Depending on operating system and C compiler the makefile decides, which driver is used.

The drivers are licensed under the LGPL.

The functions in the compiler data library manipulate compiler and interpreter internal data such as "type", "ref_list" and "reference". The compiler data library is linked to the interpreter and to some compiled Seed7 programs such as the Seed7 compiler (s7c) itself.

The compiler data library is licensed under the GPL.

The makefiles use programs to write definitions to version.h . These are stand-alone programs that are not linked to the interpreter or to the runtime library.

The programs used by the makefiles are licensed under the GPL.

One of the main jobs of the makefile is creating a version.h file. This is done with 'make depend' (or 'gmake depend' or 'nmake depend'). The version.h file contains several #defines which contain information over available features and the way they are available. Other #defines can be found in config.h.

The program chkccomp.c is compiled and executed by the makefile. Chkccomp checks properties of C compiler, include files, linker, run-time library and operating systems. The result is written to version.h