Provided by: swi-prolog-nox_7.6.4+dfsg-2ubuntu1_amd64 bug


       swipl-ld - Create a SWI-Prolog embedded executable


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


       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.

       -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

              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++

              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  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

       -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.

              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.

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

              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__.

              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

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

              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.

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

              Passed as Prolog input files


       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

       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.


       swipl(1) SWI-Prolog Reference Manual,


       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.


       Jan Wielemaker

                                           Feb 8, 2006                                     SWI(1)