/usr/lib/swi-prolog/doc/Manual/compilation.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

<html>
<head>
<title>SWI-Prolog 7.1.10 Reference Manual: Section 2.10</title><link rel="home" href="index.html">
<link rel="contents" href="Contents.html">
<link rel="index" href="DocIndex.html">
<link rel="summary" href="summary.html">
<link rel="previous" href="debugoverview.html">
<link rel="next" href="flags.html">

<style type="text/css">

/* Style sheet for SWI-Prolog latex2html
*/

dd.defbody
{ margin-bottom: 1em;
}

dt.pubdef, dt.multidef
{ color: #fff;
padding: 2px 10px 0px 10px;
margin-bottom: 5px;
font-size: 18px;
vertical-align: middle;
overflow: hidden;
}

dt.pubdef { background-color: #0c3d6e; }
dt.multidef { background-color: #ef9439; }

.bib dd
{ margin-bottom: 1em;
}

.bib dt
{ float: left;
margin-right: 1.3ex;
}

pre.code
{ margin-left: 1.5em;
margin-right: 1.5em;
border: 1px dotted;
padding-top: 5px;
padding-left: 5px;
padding-bottom: 5px;
background-color: #f8f8f8;
}

div.navigate
{ text-align: center;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
}

div.title
{ text-align: center;
padding-bottom: 1em;
font-size: 200%;
font-weight: bold;
}

div.author
{ text-align: center;
font-style: italic;
}

div.abstract
{ margin-top: 2em;
background-color: #f0f0f0;
border: 1px dotted;
padding: 5px;
margin-left: 10%; margin-right:10%;
}

div.abstract-title
{ text-align: center;
padding: 5px;
font-size: 120%;
font-weight: bold;
}

div.toc-h1
{ font-size: 200%;
font-weight: bold;
}

div.toc-h2
{ font-size: 120%;
font-weight: bold;
margin-left: 2em;
}

div.toc-h3
{ font-size: 100%;
font-weight: bold;
margin-left: 4em;
}

div.toc-h4
{ font-size: 100%;
margin-left: 6em;
}

span.sec-nr
{
}

span.sec-title
{
}

span.pred-ext
{ font-weight: bold;
}

span.pred-tag
{ float: right;
padding-top: 0.2em;
font-size: 80%;
font-style: italic;
color: #fff;
}

div.caption
{ width: 80%;
margin: auto;
text-align:center;
}

/* Footnotes */
.fn {
color: red;
font-size: 70%;
}

.fn-text, .fnp {
position: absolute;
top: auto;
left: 10%;
border: 1px solid #000;
box-shadow: 5px 5px 5px #888;
display: none;
background: #fff;
color: #000;
margin-top: 25px;
padding: 8px 12px;
font-size: larger;
}

sup:hover span.fn-text
{ display: block;
}

/* Lists */

dl.latex
{ margin-top: 1ex;
margin-bottom: 0.5ex;
}

dl.latex dl.latex dd.defbody
{ margin-bottom: 0.5ex;
}

/* PlDoc Tags */

dl.tags
{ font-size: 90%;
margin-left: 5ex;
margin-top: 1ex;
margin-bottom: 0.5ex;
}

dl.tags dt
{ margin-left: 0pt;
font-weight: bold;
}

dl.tags dd
{ margin-left: 3ex;
}

td.param
{ font-style: italic;
font-weight: bold;
}

/* Index */

dt.index-sep
{ font-weight: bold;
font-size: +1;
margin-top: 1ex;
}

/* Tables */

table.center
{ margin: auto;
}

table.latex
{ border-collapse:collapse;
}

table.latex tr
{ vertical-align: text-top;
}

table.latex td,th
{ padding: 2px 1em;
}

table.latex tr.hline td,th
{ border-top: 1px solid black;
}

table.frame-box
{ border: 2px solid black;
}

</style>
</head>
<body style="background:white">
<div class="navigate"><a class="nav" href="index.html"><img src="home.gif" alt="Home"></a>
<a class="nav" href="Contents.html"><img src="index.gif" alt="Contents"></a>
<a class="nav" href="DocIndex.html"><img src="yellow_pages.gif" alt="Index"></a>
<a class="nav" href="summary.html"><img src="info.gif" alt="Summary"></a>
<a class="nav" href="debugoverview.html"><img src="prev.gif" alt="Previous"></a>
<a class="nav" href="flags.html"><img src="next.gif" alt="Next"></a>
</div>
<h2 id="sec:compilation"><a id="sec:2.10"><span class="sec-nr">2.10</span> <span class="sec-title">Compilation</span></a></h2>

<a id="sec:compilation"></a>

<p><h3 id="sec:develcomp"><a id="sec:2.10.1"><span class="sec-nr">2.10.1</span> <span class="sec-title">During 
program development</span></a></h3>

<a id="sec:develcomp"></a>

<p>During program development, programs are normally loaded using the 
list abbreviation (<code>?- [load].</code>). It is common practice to 
organise a project as a collection of source files and a <em>load file</em>, 
a Prolog file containing only <a id="idx:usemodule12:55"></a><span class="pred-ext">use_module/[1,2]</span> 
or <a id="idx:ensureloaded1:56"></a><a class="pred" href="consulting.html#ensure_loaded/1">ensure_loaded/1</a> 
directives, possibly with a definition of the <em>entry point</em> of 
the program, the predicate that is normally used to start the program. 
This file is often called <code>load.pl</code>. If the entry point is 
called
<em>go</em>, a typical session starts as:

<pre class="code">
% swipl
&lt;banner&gt;

1 ?- [load].
&lt;compilation messages&gt;
true.

2 ?- go.
&lt;program interaction&gt;
</pre>

<p>When using Windows, the user may open <code>load.pl</code> from the 
Windows explorer, which will cause <b>swipl-win.exe</b> to be started in 
the directory holding <code>load.pl</code>. Prolog loads <code>load.pl</code> 
before entering the top level. If Prolog is started from an interactive 
shell, one may choose the type <code>swipl -s load.pl</code>.

<p><h3 id="sec:runcomp"><a id="sec:2.10.2"><span class="sec-nr">2.10.2</span> <span class="sec-title">For 
running the result</span></a></h3>

<a id="sec:runcomp"></a>

<p>There are various options if you want to make your program ready for 
real usage. The best choice depends on whether the program is to be used 
only on machines holding the SWI-Prolog development system, the size of 
the program, and the operating system (Unix vs. Windows).

<p><h4 id="sec:plscript"><a id="sec:2.10.2.1"><span class="sec-nr">2.10.2.1</span> <span class="sec-title">Using 
PrologScript</span></a></h4>

<a id="sec:plscript"></a>

<p>A Prolog source file can be used directly as a Unix program using the 
Unix <code>#!</code> magic start. The same mechanism is useful for 
specifying additional parameters for running a Prolog file on Windows. 
The Unix
<code>#!</code> magic is allowed because if the first letter of a Prolog 
file is <code>#</code>, the first line is treated as a comment.<sup class="fn">11<span class="fn-text">The <code>#</code>-sign 
can be the legal start of a normal Prolog clause. In the unlikely case 
this is required, leave the first line blank or add a header comment.</span></sup> 
To create a Prolog script, make the first line start like this:
<blockquote>
<code>#!/path/to/swipl</code> &lt;<var>options</var>&gt; <code>-s</code>
</blockquote>

<p>Prolog recognises this starting sequence and causes the interpreter 
to receive the following argument list:
<blockquote>
<code>/path/to/swipl</code> &lt;<var>options</var>&gt; <code>-s</code> &lt;<var>script</var>&gt; <code>--</code> &lt;<var>ScriptArguments</var>&gt;
</blockquote>

<p>Instead of <strong>-s</strong>, the user may use <strong>-f</strong> 
to stop Prolog from looking for a personal initialisation file.

<p>Here is a simple script doing expression evaluation:

<pre class="code">
#!/usr/bin/swipl -q -t main -f

eval :-
        current_prolog_flag(argv, Argv),
        append(_, [--|Args], Argv),
        concat_atom(Args, ' ', SingleArg),
        term_to_atom(Term, SingleArg),
        Val is Term,
        format('~w~n', [Val]).

main :-
        catch(eval, E, (print_message(error, E), fail)),
        halt.
main :-
        halt(1).
</pre>

<p>And here are two example runs:

<pre class="code">
% eval 1+2
3
% eval foo
ERROR: Arithmetic: `foo/0' is not a function
%
</pre>

<p><b>The Windows version</b> supports the <code>#!</code> construct 
too, but here it serves a rather different role. The Windows shell 
already allows the user to start Prolog source files directly through 
the Windows file-type association. However, Windows makes it rather 
complicated to provide additional parameters for opening an individual 
Prolog file. If the file starts with <code>#!</code>, the first line is 
analysed to obtain additional command line arguments. The example below 
runs the system in `quiet' mode.

<pre class="code">
#!/usr/bin/swipl -q -s

....
</pre>

<p>Note the use of <code>/usr/bin/swipl</code>, which specifies the 
interpreter. This argument is ignored in the Windows version, but must 
be present to ensure best cross-platform compatibility.

<p><h4 id="sec:shellscript"><a id="sec:2.10.2.2"><span class="sec-nr">2.10.2.2</span> <span class="sec-title">Creating 
a shell script</span></a></h4>

<a id="sec:shellscript"></a>

<p>With the introduction of <em>PrologScript</em> (see <a class="sec" href="compilation.html">section 
2.10.2.1</a>), using shell scripts as explained in this section has 
become redundant for most applications.

<p>Especially on Unix systems and not-too-large applications, writing a 
shell script that simply loads your application and calls the entry 
point is often a good choice. A skeleton for the script is given below, 
followed by the Prolog code to obtain the program arguments.

<pre class="code">
#!/bin/sh

base=&lt;absolute-path-to-source&gt;
PL=swipl

exec $PL -q -f '$base/load -t go -- **
</pre>

<pre class="code">
go :-
        current_prolog_flag(argv, Arguments),
        append(_SytemArgs, [--|Args], Arguments), !,
        go(Args).

go(Args) :-
        ...
</pre>

<p>On Windows systems, similar behaviour can be achieved by creating a 
shortcut to Prolog, passing the proper options or writing a <code>.bat</code> 
file.

<p><h4 id="sec:makestate"><a id="sec:2.10.2.3"><span class="sec-nr">2.10.2.3</span> <span class="sec-title">Creating 
a saved state</span></a></h4>

<a id="sec:makestate"></a>

<p>For larger programs, as well as for programs that are required to run 
on systems that do not have the SWI-Prolog development system installed, 
creating a saved state is the best solution. A saved state is created 
using <a id="idx:qsaveprogram12:57"></a><span class="pred-ext">qsave_program/[1,2]</span> 
or the <strong>-c</strong> command line option. A saved state is a file 
containing machine-independent<sup class="fn">12<span class="fn-text">The 
saved state does not depend on the CPU instruction set or endianness. 
Saved states for 32- and 64-bits are not compatible. Typically, saved 
states only run on the same version of Prolog on which they have been 
created.</span></sup> intermediate code in a format dedicated for fast 
loading. Optionally, the emulator may be integrated in the saved state, 
creating a single file, but machine-dependent, executable. This process 
is described in <a class="sec" href="runtime.html">chapter 10</a>.

<p><h4 id="sec:cmdlinecomp"><a id="sec:2.10.2.4"><span class="sec-nr">2.10.2.4</span> <span class="sec-title">Compilation 
using the -c command line option</span></a></h4>

<a id="sec:cmdlinecomp"></a>

<p>This mechanism loads a series of Prolog source files and then creates 
a saved state as <a id="idx:qsaveprogram2:58"></a><a class="pred" href="runtime.html#qsave_program/2">qsave_program/2</a> 
does. The command syntax is:

<pre class="code">
% swipl [option ...] [-o output] -c file.pl ...
</pre>

<p>The <var>options</var> argument are options to <a id="idx:qsaveprogram2:59"></a><a class="pred" href="runtime.html#qsave_program/2">qsave_program/2</a> 
written in the format below. The option names and their values are 
described with
<a id="idx:qsaveprogram2:60"></a><a class="pred" href="runtime.html#qsave_program/2">qsave_program/2</a>.
<blockquote>
<code>--</code><em>option-name</em><code>=</code><em>option-value
</em></blockquote>

<p>For example, to create a stand-alone executable that starts by 
executing main/0 and for which the source is loaded through
<code>load.pl</code>, use the command

<pre class="code">
% swipl --goal=main --stand_alone=true -o myprog -c load.pl
</pre>

<p>This performs exactly the same as executing

<pre class="code">
% swipl
&lt;banner&gt;

?- [load].
?- qsave_program(myprog,
                 [ goal(main),
                   stand_alone(true)
                 ]).
?- halt.
</pre>

<p></body></html>
swi-prolog-nox 6.6.4-2ubuntu1 / usr / lib / swi-prolog / doc / Manual / compilation.html
