Man Linux: Main Page and Category List

NAME

       plld - Create a SWI-Prolog embedded executable

SYNOPSIS

       plld options c-files o-files pl-files

DESCRIPTION

       The utility plld 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 pl, 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  pl.   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
              plld 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 plld 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 pl 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 plld 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,
              -lpl  (-lplmt if pl supports threading) 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 plld: -D__SWI_PROLOG__ and
              -D__SWI_EMBEDDED__.

       -pl-options*
              Specify  additional  options  for  pl.   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 prolog-bugs@swi.psy.uva.nl.

       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.

SEE ALSO

       pl(1) SWI-Prolog Reference Manual, http://www.swi-prolog.org

COPYRIGHT

       Copyright (C) 1991-2006, HCS, University of Amsterdam

AUTHOR

       Jan Wielemaker

                                  Feb 8, 2006