Ubuntu Manpage: swipl-ld - Create a SWI-Prolog embedded executable

Provided by: swi-prolog-nox_7.2.3-2_amd64

NAME

       swipl-ld - Create a SWI-Prolog embedded executable

SYNOPSIS

       swipl-ld options c-files o-files pl-files

DESCRIPTION

The utility swipl-ld is a front-end for the C-compiler and linker to create a stand-alone
executable from a series of C/C++ and Prolog input files. It extracts information from the
SWI-Prolog executable swipl, after which it scans the arguments and breaks them into
several categories. It then calls the C-compiler to create an executable containing the
user's C-code and the SWI-Prolog kernel. After this, it will call the development
environment to create a Prolog saved state from the prolog files and finally it will
create the target executable by concatenating the state to the emulator. See also
qsave_program/2 from the SWI-Prolog manual.

Options
-pl prolog
Specifies the prolog version to use. The default is swipl. This flag may be used
to choose between different versions installed on your system, or to specify a
modified version. A modified version should understands the flags -dump-runtime-
variables -f file -F file -g goal -t toplevel.

-help Shows options briefly

-nostate
Just relinks the kernel. The newly linked kernel can only function in the presence
of the development system. Any supplied prolog sourcefiles are ignored, and so are
the options -goal -toplevel -initfile. -class This is the preferred way to attach
external modules to Prolog if dynamic loading is not supported on your system.

-c Compile C or C++ source-files into object files. This turns swipl-ld into a
replacement for the C or C++ compiler where proper options such as the location of
the include directory are passed automatically to the compiler.

-E Invoke the C preprocessor. Used to make swipl-ld a replacement for the C or C++
compiler.

-shared
Link C, C++ or object files into a shared object (DLL) that can be loaded by the
load_foreign_library/1 predicate. If used with -c it sets the proper options to
compile a C or C++ file ready for linking into a shared object.

-embed-shared
Embed SWI-Prolog into a DLL/Shared object rather than an executable. See the
reference manual for details.

-dll Windows only Same as -embed-shared Backward compatibility.

-F base
By default, none is passed to the swipl command to create the saved state. Using
-F xpce you can specify loading xpce.rc, making XPCE available to the saved state.

-goal goal
The goal that is initially executed when the toplevel is started using
PL_toplevel(). E.i. the default. -g flag for the new executable.

-toplevel goal
The goal that is executed as the main toplevel goal. E.i. the default. -t flag
for the new executable.

-initfile file
The file that is loaded by the toplevel. E.i. the default. -f flag for the new
executable.

-class {runtime,kernel,development}
Set the save-class of the Prolog saved-state that is created. If runtime
(default), the resulting system leave interpretation of all arguments to the
application. If kernel all predicates will be locked for the tracer. Finally, if
development the state is saved `as-is' and the resulting system processes options
just as the basic SWI-Prolog executable does. See also qsave_program/2 in the SWI-
Prolog reference manual.

-v Verbose operation. This echos the commands before executing them. Note that some
commands are printed as shell commands, but actually executed by swipl-ld itself
for compatibility with the Win32 platforms.

-f Fake operation. Together with -v this prints the commands that need to be executed
without actually doing anything.

-Ecppargument ...
If the first option is -E, all subsequent options are appended and handed to the
program selected by SWI-Prolog configure to run cpp.

-o file
Specifies the name of the final executable. The default is a.out.

-cc C-compiler
Specify the compiler to use for *.c files. Default is the compiler used to compile
SWI-Prolog itself, as read from the feature c_cc.

-c++ C++-compiler
Specify the compiler to use for C++ input files. If the C-compiler is gcc this is
g++, otherwise c++ is assumed.

-ld linker
Specifies the linker to use. Default is the C-compiler. On Win32 platforms, the
default is link.exe.

-llibrary
Specifies a C-library for linking the application. By default, -lswipl as well as
the libraries required by the SWI-Prolog kernel will be passed to the C-compiler.

-Llibrary-directory
Specifies an additional library directory for the C-compiler. By default, the
runtime directory for the current architecture is passed.

-g|-I*|-D*|-U*|-O*|-W*
Passed to the compiler as c-flags. By default, the SWI-Prolog include directory is
passed as additional include directory. The following -D flags are added by swipl-
ld: -D__SWI_PROLOG__ and -D__SWI_EMBEDDED__.

-pl-options*
Specify additional options for swipl. The first character following -pl-options
determines the option-separator. The remainder of the argument is split using this
separator and the parts are added to the option list for Prolog. See also -cc-
options and -ld-options

-ld-options*
Additional options passed to the linker. For example: -ld-options,-Bstatic

-cc-options*
Additional options passed to both C- and C++-compiler.

*.o Passed as input files to the linker.

*.c Compiled using the C-compiler, after which the object-file is passed to the linker.
The object file is deleted at cleanup.

*.cc|*.C|*.cxx|*.cpp
Compiled using the C++-compiler, after which the object-file is passed to the
linker. The object file is deleted at cleanup.

*.pl|*.qlf
Passed as Prolog input files

BUGS

       Parsing  the  options  and  distributing  them  over  the  various  programs  is  probably
       incomplete. Feel free to modify it and please forward generally  useful  modifications  to
       bugs@swi-prolog.org.

       Some  care  has  to be taken that the state created with qsave_program/2 is self-contained
       (i.e. contains no references to the Prolog libraries).  Also,  as  the  state  is  created
       using  the development environment rather then the user's emulator, the Prolog code cannot
       use directives that rely on the C-code added by the user.

COPYRIGHT

       Copyright (C) 1991-2010, University of Amsterdam, VU University,  Amsterdam  This  program
       may be used under the terms of the LGPL, version 2 or later.

AUTHOR