1003 lines
54 KiB
XML
1003 lines
54 KiB
XML
<?xml version="1.0"?>
|
|
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd" [
|
|
<!ENTITY tex "TeX">
|
|
<!ENTITY latex "LaTeX">
|
|
]>
|
|
<book id="enigma-documentation.xml" lang="en">
|
|
<title>Enigma</title>
|
|
<!-- %**end of header -->
|
|
<bookinfo>
|
|
<legalnotice>
|
|
<para>This manual is for Enigma, version 0.1.
|
|
Copyright © 2010 Niels Serup</para>
|
|
<blockquote>
|
|
<para>Permission is granted to copy, distribute and/or modify this document
|
|
under the terms of the GNU Free Documentation License, Version 1.3 or
|
|
any later version published by the Free Software Foundation; with no
|
|
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A
|
|
copy of the license is included in the section entitled "GNU Free
|
|
Documentation License".</para>
|
|
<para>This document is also available under the terms of the Creative Commons
|
|
Attribution-Share Alike 3.0 (or any later version) Unported license. A
|
|
copy of the license is available at
|
|
<ulink url="http://creativecommons.org/licenses/by-sa/3.0/legalcode">http://creativecommons.org/licenses/by-sa/3.0/legalcode</ulink>.</para>
|
|
</blockquote>
|
|
|
|
</legalnotice>
|
|
</bookinfo>
|
|
<chapter label="" xreflabel="Enigma" id="Top">
|
|
<title>Enigma</title>
|
|
<para>This manual is for Enigma, version 0.1.
|
|
Copyright © 2010 Niels Serup</para>
|
|
<blockquote>
|
|
<para>Permission is granted to copy, distribute and/or modify this document
|
|
under the terms of the GNU Free Documentation License, Version 1.3 or
|
|
any later version published by the Free Software Foundation; with no
|
|
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A
|
|
copy of the license is included in the section entitled "GNU Free
|
|
Documentation License".</para>
|
|
<para>This document is also available under the terms of the Creative Commons
|
|
Attribution-Share Alike 3.0 (or any later version) Unported license. A
|
|
copy of the license is available at
|
|
<ulink url="http://creativecommons.org/licenses/by-sa/3.0/legalcode">http://creativecommons.org/licenses/by-sa/3.0/legalcode</ulink>.</para>
|
|
</blockquote>
|
|
<para>New versions of this manual will be available at
|
|
<ulink url="http://metanohi.org/projects/enigma/">http://metanohi.org/projects/enigma/</ulink>.</para>
|
|
</chapter>
|
|
|
|
<chapter label="1" id="Introduction">
|
|
<title>A short introduction</title>
|
|
<para>Today, in the world of programming, the commonly used programming
|
|
languages have — to some extent — adapted the same basic
|
|
syntax. Both C, C++, Java, Python and Ruby (and others) all share
|
|
several paradigms, even though they are still very different. Enigma, on
|
|
the other hand, is very different from the “common” languages. See
|
|
this small program to get an idea of Enigma:</para>
|
|
<screen>{/a,b/
|
|
a 2 ! multiply = c;
|
|
b c ! add = return;
|
|
} = odd-add;
|
|
|
|
9 4 ! odd-add | stdout temp ! write;
|
|
</screen>
|
|
<para role="continues">Here, 9 is first multiplied with 2 and then added to 4. The
|
|
program then prints the result (22).</para>
|
|
<para>With only a few constructs and built-in variables, Enigma is quite small
|
|
and relatively simple. Any logic can be expressed in Enigma. The above
|
|
example may seem odd, but its aspects will be dealt with in the next
|
|
chapter.</para>
|
|
<para>Enigma is <emphasis>not</emphasis> the kind of programming language that likes to
|
|
control programmers. When programming in Enigma, one creates functions
|
|
that call other functions — instead of creating functions that are
|
|
called by built-in functions.</para>
|
|
<para>On the other hand, Enigma is very restrictive. There are limits to
|
|
certain things. If these limits were not present, chaos would
|
|
ensue. Perhaps.</para>
|
|
<para><indexterm role="cp"><primary>pointers</primary></indexterm>Like many other languages, Enigma is quite fond of pointers. In Enigma,
|
|
all variables are pointers. When <literal>x</literal> is assigned to <literal>a</literal>, and
|
|
<literal>b</literal> is assigned to <literal>a</literal>, changing <literal>b</literal> also changes
|
|
<literal>a</literal>. As a matter of fact, when two pointers points to the same
|
|
place, they are <emphasis role="bold">forever</emphasis> linked together.</para>
|
|
<para>Enigma is not recommended for serious use. Use with <emphasis role="bold">caution</emphasis>!</para>
|
|
</chapter>
|
|
|
|
<chapter label="2" id="Language">
|
|
<title>The language</title>
|
|
<para>Enigma consists of functions. Any file being parsed is a
|
|
function. Within functions there can be local variables. These variables
|
|
are to disappear when the function exits.</para>
|
|
<para>Functions have return values. These values can be determined by the
|
|
programmer.</para>
|
|
<para>Within functions, there are commands. These commands constitute the very
|
|
base of Enigma. Commands can interact with built-in functions, meaning
|
|
that writing to and reading from files, calculating, as well as
|
|
manipulating strings and lists, is possible.</para>
|
|
<para>There are no simple types. Enigma lies in the world of objects. Numbers,
|
|
strings, lists.. It's just objects. Also, all commands must end with a
|
|
semicolon<literal>;</literal></para>
|
|
|
|
<sect1 label="2.1" id="Operators">
|
|
<title>Operators</title>
|
|
<para><indexterm role="cp"><primary>operators</primary></indexterm>Enigma has 4 operators: <literal>!</literal>, <literal>=</literal>, <literal>|</literal>, and
|
|
<literal>*</literal>. <literal>!</literal> and <literal>=</literal> are the most important ones.</para>
|
|
<para>To assign values to variables, use the <literal>=</literal> operator. For example:</para>
|
|
<screen>obj = hello-string;
|
|
</screen>
|
|
<para>Here, the variable <literal>hello-string</literal> receives the object <literal>obj</literal>. Note
|
|
the syntax. The objects comes first. Unless <literal>hello-string</literal> is
|
|
already defined, it is created as a local variable.</para>
|
|
<para>Now, say we have a function called <literal>think</literal> and we want to send
|
|
objects to it. This is how that's done:</para>
|
|
<screen>obj1 obj2 obj3 ! think;
|
|
</screen>
|
|
<para>There are no limits to the amount of objects that can be sent to a
|
|
function. Whitespace characters are used to separate objects, also when
|
|
assigning them to a variable. There <emphasis>is</emphasis> a difference between
|
|
using one object and more objects as arguments, though. When using only
|
|
one object, that object is simply used, but when using more objects, a
|
|
list containing all objects is created and transmitted instead. So, in
|
|
reality, when assigning two or more objects to a variable, the variable
|
|
points to a list with the objects. More about lists later.</para>
|
|
<para>The <literal>|</literal> operator is merely a shortcut operator. It can merge
|
|
several commands into one, long command. See the following example:</para>
|
|
<screen># Long version
|
|
a ! b = c;
|
|
d c ! e = c;
|
|
# Short version
|
|
a ! b | d temp ! e = c;
|
|
</screen>
|
|
<para>Here, <literal>a</literal> is sent to <literal>b</literal>, which is then — together with
|
|
<literal>d</literal> — sent to <literal>e</literal> and saved in <literal>c</literal>. The <literal>|</literal> acts
|
|
like the semicolon, but it copies the return value of the last function
|
|
(in this case <literal>b</literal>) and stores the value in the local variable
|
|
<literal>temp</literal>. Hackers are encouraged to use this operator.</para>
|
|
<para>The final operator, <literal>*</literal>, has the same function as <literal>=</literal>, except
|
|
that it works on a global level. So, if the code is <literal>b = a;</literal> and
|
|
<literal>a</literal> does not exist, it is created — in the global space.</para>
|
|
</sect1>
|
|
|
|
<sect1 label="2.2" id="Numbers">
|
|
<title>Numbers</title>
|
|
<para><indexterm role="cp"><primary>numbers</primary></indexterm>Numbers in Enigma can be arbitrarily large. They are written as one
|
|
usually writes numbers. Currently only the decimal system is supported.</para>
|
|
<screen>7587 = age;
|
|
2556 ! numfunc;
|
|
</screen>
|
|
</sect1>
|
|
|
|
<sect1 label="2.3" id="Strings">
|
|
<title>Strings</title>
|
|
<para><indexterm role="cp"><primary>strings</primary></indexterm><indexterm role="cp"><primary>characters</primary></indexterm>Strings are defined using the <literal>"</literal> character.</para>
|
|
<screen>"This is a string!" " This too!" ! add;
|
|
"A" = A;
|
|
"Now comes
|
|
a newline" = nl;
|
|
"\"\\\n\t\
|
|
" = escaped;
|
|
</screen>
|
|
</sect1>
|
|
|
|
<sect1 label="2.4" id="Lists">
|
|
<title>Lists</title>
|
|
<para><indexterm role="cp"><primary>lists</primary></indexterm><indexterm role="cp"><primary>arrays</primary></indexterm>Lists are special in Enigma. They are used a lot, but unlike eg. numbers
|
|
and strings they cannot be defined in their own syntax. When one writes
|
|
this:</para>
|
|
<screen>123 "witch" = lst;
|
|
</screen>
|
|
<para>..one creates a list. Lists can be nested.</para>
|
|
</sect1>
|
|
|
|
<sect1 label="2.5" id="Booleans">
|
|
<title>Booleans</title>
|
|
<para><indexterm role="cp"><primary>booleans</primary></indexterm>Booleans are used a lot in Enigma. The predefined variables <literal>true</literal>
|
|
and <literal>false</literal> can be used.</para>
|
|
</sect1>
|
|
|
|
<sect1 label="2.6" id="Files">
|
|
<title>Files</title>
|
|
<para><indexterm role="cp"><primary>files</primary></indexterm>Files can only be created using the built-in function <literal>open</literal>. Files
|
|
are either readable or writeable. If a file is writeable, text written
|
|
to the file may optionally be appended to any existing text.</para>
|
|
<para><indexterm role="cp"><primary>read</primary></indexterm><indexterm role="cp"><primary>write</primary></indexterm><indexterm role="cp"><primary>open</primary></indexterm><indexterm role="cp"><primary>close</primary></indexterm></para>
|
|
<screen>"a" "r" ! open = f1;
|
|
"b" "w" ! open = f2;
|
|
"c" "a" ! open = f3;
|
|
|
|
# Read one character
|
|
f1 ! read | stdout temp ! write;
|
|
# Write a string
|
|
f2 "Aaar" ! write;
|
|
# Append a string
|
|
f3 "Ouu" ! write;
|
|
|
|
f1!close;f2!close;f3!close;
|
|
</screen>
|
|
<para>To read an entire file, one must use a loop
|
|
construct. See <xref linkend="Loops"></xref>. When there are no more characters left, the
|
|
<literal>read</literal> function returns an empty string. Using equality testing,
|
|
reading a complete file is thus possible. See <xref linkend="Conditionals"></xref>.</para>
|
|
<screen>filename "r" ! open = f;
|
|
{f ! read = c; stdout c ! write; c "" ! equal ! not = return;} ! loop;
|
|
</screen>
|
|
<para>At this point, it may not be obvious why this works. This will be
|
|
explained in the next sections.</para>
|
|
</sect1>
|
|
|
|
<sect1 label="2.7" id="Functions">
|
|
<title>Functions</title>
|
|
<para><indexterm role="cp"><primary>functions</primary></indexterm>Functions are defined and called using the following syntax:</para>
|
|
<screen># Defining them
|
|
{stdout "Hello" ! write;} = func;
|
|
{/x,y/stdout "x=" x ", y=" y!write;} = coorprint;
|
|
{stdout args ! write;} = aprint;
|
|
|
|
# Calling them
|
|
!func; # Outputs "Hello"
|
|
52 12 ! coorprint; # Outputs "x=52, y=12"
|
|
999 "abc" 21 ! aprint; # Outputs "999 abc 21"
|
|
</screen>
|
|
<para>Arguments can thus be accessed either by using the <literal>/.../</literal> syntax
|
|
in the beginning of the function or by using the local <literal>args</literal>
|
|
variable. Furthermore, to make <emphasis>all</emphasis> new variables save in the
|
|
global space, prepend the function content with a <literal>*</literal>. This will
|
|
have the same effect as replacing all <literal>=</literal> signs in the function
|
|
with the <literal>*</literal> operator.</para>
|
|
<para>Remember that your file is also a function, just without the curly
|
|
brackets. This means that when working on the top level of your program,
|
|
<literal>args</literal> actually refer to the arguments specified on the command
|
|
line. All arguments are strings, but built-in functions that can convert
|
|
them to numbers exist.</para>
|
|
<para>The previous example functions did not have any return values. This is
|
|
merely because they didn't need such things. To define a return value,
|
|
the return value must be sent to the special variable <literal>return</literal>.</para>
|
|
<screen>{/a,b/a b ! multiply = return;} = 2mul;
|
|
33 3 ! 2mul = 2mult;
|
|
stdout 2mult ! write;
|
|
</screen>
|
|
<para>The execution of a function does <emphasis role="bold"><emphasis>not</emphasis></emphasis> stop when a value
|
|
is assigned to <literal>return</literal>. This has both advantages and
|
|
disadvantages.</para>
|
|
<para>Many things are almost impossible to do without the built-in
|
|
functions. Some are completely impossible. See <xref linkend="Built-In"></xref>. As all
|
|
objects in Enigma are pointers, several built-in functions actually
|
|
modify the objects sent to them as arguments. To solve this problem, one
|
|
must use the <literal>clone</literal> function.</para>
|
|
</sect1>
|
|
|
|
<sect1 label="2.8" id="Conditionals">
|
|
<title>Conditionals</title>
|
|
<para>Any value can be related to another value. 78 is less than 85. 2 equals
|
|
2. "Hi" is not "Bye". Enigma comes with a basic set of functions that
|
|
can be used to test these relations. The functions <literal>greater</literal>,
|
|
<literal>lesser</literal>, <literal>equal</literal>, <literal>not</literal>, <literal>or</literal> and <literal>and</literal> are
|
|
available. These functions return either true or false. To run a
|
|
function on the condition that a relational function has returned true,
|
|
use the function <literal>act</literal>.</para>
|
|
<para>While <literal>lesser</literal> and <literal>greater</literal> are aimed at numbers only,
|
|
and <literal>and</literal>, <literal>or</literal> and <literal>not</literal> are aimed at booleans only,
|
|
<literal>equal</literal> can be used on all objects. It tests for all equalities.</para>
|
|
<screen>2 = a;
|
|
4 = b;
|
|
|
|
a 2 ! add | temp b ! equal = cond1;
|
|
"47" ! num | temp 48 ! greater = cond2;
|
|
|
|
cond1 cond2 ! and | temp write stdout "4 = 4 and 47 > 48\n" ! act;
|
|
cond1 cond2 ! or | temp write stdout "4 = 4 or 47 > 48\n" ! act;
|
|
cond2 ! not | cond1 temp ! and | temp write stdout "4 = 4 and !(47 >
|
|
48)\n" ! act;
|
|
</screen>
|
|
<para>Even simpler, one can do this (though there's no real need for it):</para>
|
|
<screen># Instead of stdout "Hello" !write;
|
|
true write stdout "Hello" !act;
|
|
</screen>
|
|
</sect1>
|
|
|
|
<sect1 label="2.9" id="Loops">
|
|
<title>Loops</title>
|
|
<para>There are several ways to loop pieces of code in Enigma. One can create
|
|
a function that calls itself, for example. It is, however, advised to
|
|
use the <literal>loop</literal> function.</para>
|
|
<screen># Infinite loop
|
|
{stdout "Forever\n" ! write; true = return;} ! loop;
|
|
</screen>
|
|
<para><literal>loop</literal> works a bit like <literal>act</literal>, except that it runs on the
|
|
premise of the return value of the function it calls. If it returns
|
|
true, or any other value that can be considered true (non-zero numbers,
|
|
non-empty strings, files, etc.), it runs the function again. If it
|
|
returns false, the loop stops. It naturally runs the first time no
|
|
matter what (no return value has been created yet).</para>
|
|
</sect1>
|
|
|
|
<sect1 label="2.10" id="Undefined">
|
|
<title>Undefined behaviour</title>
|
|
<para>Enigma is still new. The way built-in functions act, the way error
|
|
messages appear, and the way some odd details of the language works are
|
|
still undefined. In general, when something seems likely to work, it
|
|
will work. But it's not necessarily defined to work.</para>
|
|
</sect1>
|
|
</chapter>
|
|
|
|
<chapter label="3" id="Future">
|
|
<title>Future aspects</title>
|
|
<para>As Enigma is right now, it is quite limited. The only way that it can
|
|
interact with the rest of one's system is by reading and writing files
|
|
and by executing shell commands using the <literal>system</literal> built-in
|
|
function. This obviously needs to be improved. A foreign function
|
|
interface system must be implemented in version 0.2. It should be
|
|
possible for Enigma to do everything C can.</para>
|
|
<para>The number of built-in functions seems reasonable, but it may be a good
|
|
idea to implement a few more. These eventual functions should be focused
|
|
on making things easier. Specifically, an import function should be
|
|
considered. It is possible to create an import function in Enigma
|
|
directly, but it's not exactly fast. Introducing a “compile” function
|
|
should solve that.</para>
|
|
</chapter>
|
|
|
|
<chapter label="4" id="Implementations">
|
|
<title>Implementations</title>
|
|
<para><indexterm role="pg"><primary>enigma</primary></indexterm>As of right now (beginning of June 2010) there is only one
|
|
implementation. It is written in Java and is called enigma (with a
|
|
lowercase e). The code is bulky and was not written by an experienced
|
|
Java hacker. For v0.2 it may be a good idea to write the interpreter in
|
|
C instead. Implementing a foreign function interface should be easier
|
|
that way.</para>
|
|
<para>The current implementation can be downloaded at
|
|
<ulink url="http://metanohi.org/projects/enigma">http://metanohi.org/projects/enigma</ulink>.</para>
|
|
</chapter>
|
|
|
|
<chapter label="5" id="Comparison">
|
|
<title>Comparison with other languages</title>
|
|
<sect1 label="5.1" id="Compared-assigning">
|
|
<title>Assigning values</title>
|
|
<blockquote>
|
|
<para><emphasis role="bold">C:</emphasis></para>
|
|
<screen>
|
|
type var = value;
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Python:</emphasis></para>
|
|
<screen>
|
|
var = value
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Enigma:</emphasis></para>
|
|
<screen>
|
|
value = var;
|
|
</screen>
|
|
</blockquote>
|
|
</sect1>
|
|
|
|
<sect1 label="5.2" id="Compared-conditionals">
|
|
<title>Conditionals</title>
|
|
<blockquote>
|
|
<para><emphasis role="bold">C:</emphasis></para>
|
|
<screen>
|
|
if ((a == 2 && b < 5) || (c != 4 && !d)) do_something();
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Python:</emphasis></para>
|
|
<screen>
|
|
if (a == 2 and b < 5) or (c != 4 and not d):
|
|
do_something()
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Enigma:</emphasis></para>
|
|
<screen>
|
|
a 2 ! equal = cond-a;
|
|
b 5 ! lesser = cond-b;
|
|
c 4 ! equal ! not = cond-c;
|
|
d ! not = cond-d;
|
|
cond-a cond-b ! and = ncond-ab;
|
|
cond-c cond-d ! and = ncond-cd;
|
|
ncond-ab ncond-cd ! or = actcond;
|
|
actcond do-something ! act;
|
|
</screen>
|
|
</blockquote>
|
|
</sect1>
|
|
|
|
<sect1 label="5.3" id="Compared-looping">
|
|
<title>Looping</title>
|
|
<blockquote>
|
|
<para><emphasis role="bold">C:</emphasis></para>
|
|
<screen>
|
|
while (thinking) run();
|
|
|
|
for (int i = 0; i < 18; i++) run(i);
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Python:</emphasis></para>
|
|
<screen>
|
|
while thinking: run()
|
|
|
|
for i in range(18): run(i)
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Enigma:</emphasis></para>
|
|
<screen>{!run; thinking ! clone = return;} ! loop;
|
|
|
|
0 = i;
|
|
{i ! run; i 1 ! add; i 18 ! equal = return;} ! loop;
|
|
</screen>
|
|
</blockquote>
|
|
</sect1>
|
|
|
|
<sect1 label="5.4" id="Compared-functions">
|
|
<title>Functions</title>
|
|
<blockquote>
|
|
<para><emphasis role="bold">C:</emphasis></para>
|
|
<screen>int time(float space) {
|
|
return (int) space / 3;
|
|
}
|
|
|
|
t = time(81.65);
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Python:</emphasis></para>
|
|
<screen>
|
|
def time(space):
|
|
return int(space / 3)
|
|
|
|
t = time(81.65)
|
|
</screen>
|
|
</blockquote>
|
|
<blockquote>
|
|
<para><emphasis role="bold">Enigma:</emphasis></para>
|
|
<screen>{/space/space 3 ! divide ! clone ! round = return;} = time;
|
|
|
|
81.65 ! time = t;
|
|
</screen>
|
|
</blockquote>
|
|
</sect1>
|
|
</chapter>
|
|
|
|
<chapter label="6" id="Built-In">
|
|
<title>Built-in values and functions</title>
|
|
<sect1 label="6.1" id="Built-In-values">
|
|
<title>Values</title>
|
|
<para><indexterm role="cp"><primary>built-in values</primary></indexterm>The following variables are special and can be accessed anytime. They can
|
|
even be overwritten.</para>
|
|
<screen>args, return, temp, stdin, stderr, stdout, zero, true, false, none, @pi,
|
|
@e, cwd, cpd, fnm
|
|
</screen>
|
|
<para><literal>zero</literal> is a fake writable file that does nothing. <literal>none</literal> is an
|
|
abstract variable with an internal value of.. none. <literal>@pi</literal> is
|
|
Pi. <literal>@e</literal> is Euler's number. <literal>cwd</literal> is the directory from which
|
|
Enigma is run, <literal>cpd</literal> is the directory in which the current program
|
|
file resides, and <literal>fnm</literal> is the filename of the current program
|
|
file. The rest are self-explanatory — and <literal>args</literal>, <literal>return</literal>
|
|
and <literal>temp</literal> are extra special.</para>
|
|
</sect1>
|
|
|
|
<sect1 label="6.2" id="Built-In-functions">
|
|
<title>Functions</title>
|
|
<para><indexterm role="cp"><primary>built-in functions</primary></indexterm>Enigma has few built-in functions. But they do exist.</para>
|
|
<para role="continues"><literal>str(OBJECT...)</literal>: Converts all supplied values to strings.</para>
|
|
<para role="continues"><literal>num(OBJECT...)</literal>: Converts all supplied values to numbers.</para>
|
|
<para role="continues"><literal>list(OBJECT...)</literal>: Puts all supplied values in a list and destroys
|
|
nested lists at one level.</para>
|
|
<para role="continues"><literal>bool(OBJECT...)</literal>: Converts all supplied values to booleans.</para>
|
|
<para role="continues"><literal>code(OBJECT...)</literal>: Converts all supplied values to code strings.</para>
|
|
<para role="continues"><literal>repr(OBJECT...)</literal>: Converts all supplied values to representational
|
|
strings. Strings get prepended and appended by " characters, code
|
|
objects are surrounded by { and }, and so on.</para>
|
|
<para role="continues"><literal>type(OBJECT...)</literal>: Converts all supplied values to type strings
|
|
(string, number, file, etc.).</para>
|
|
<para role="continues"><literal>len(OBJECT...)</literal>: Converts all supplied values to their length. This
|
|
can be used for both strings and lists.</para>
|
|
<para role="continues"><literal>clone(OBJECT...)</literal>: Clones all supplied values. When an object is
|
|
cloned, its value is assigned to a new variable. The list of clones is
|
|
returned.</para>
|
|
<para role="continues"><literal>slice(LIST|STRING, NUMBER, NUMBER)</literal>: Returns a list value sliced
|
|
according to the first and second number if the first variable is a
|
|
list variable, or a substring if the first variable is a string
|
|
variable.</para>
|
|
<para role="continues"><literal>loop(FUNCTION, [OBJECT]...)</literal>: Executes function until it returns
|
|
false. Sends the rest of the specified variables (if any) to the
|
|
function as arguments.</para>
|
|
<para role="continues"><literal>open(STRING, STRING)</literal>: Opens the file by the name of the first
|
|
string, using the second string as its guide as to how it should be
|
|
opened. "r" means to read, "w" means to write, and "a" means to
|
|
append. Returns a file object.</para>
|
|
<para role="continues"><literal>close(FILE...)</literal>: Closes files.</para>
|
|
<para role="continues"><literal>read(FILE)</literal>: Reads one character of a file and returns it. If no
|
|
more characters are present, an empty string is returned.</para>
|
|
<para role="continues"><literal>write(FILE, STRING)</literal>: Writes a string to a file.</para>
|
|
<para role="continues"><literal>greater(NUMBER, NUMBER...</literal>: Checks if the first number is
|
|
greater than the rest and returns true or false.</para>
|
|
<para role="continues"><literal>lesser(NUMBER, NUMBER...</literal>: Checks if the first number is
|
|
lesser than the rest and returns true or false.</para>
|
|
<para role="continues"><literal>equal(OBJECT, OBJECT...</literal>: Checks if the objects are equal and returns
|
|
true or false.</para>
|
|
<para role="continues"><literal>and(BOOLEAN...)</literal>: Checks if all booleans are true and returns true
|
|
or false.</para>
|
|
<para role="continues"><literal>or(BOOLEAN...)</literal>: Checks if at least one boolean is true and returns
|
|
true or false.</para>
|
|
<para role="continues"><literal>not(BOOLEAN...)</literal>: Converts values of true to values of false, and
|
|
vice-versa.</para>
|
|
<para role="continues"><literal>act(BOOLEAN, FUNCTION, [OBJECT]...)</literal>: Run the function with the
|
|
optional objects as arguments if the boolean is true.</para>
|
|
<para role="continues"><literal>system(STRING...)</literal>: Join the strings and run the result as a
|
|
system command.</para>
|
|
<para role="continues"><literal>add(NUMBER|STRING|CODE|LIST...)</literal>: Add objects together. Numbers, strings, code
|
|
strings and lists can be used, but only with similar types. The type
|
|
of the first object determines what types the rest must be. The result
|
|
is stored in the first object and also returned.</para>
|
|
<para role="continues"><literal>subtract(NUMBER...)</literal>: Subtract numbers from each other. The
|
|
first object receives the final number. It is also returned.</para>
|
|
<para role="continues"><literal>multiply(NUMBER...)</literal>: Multiply numbers with each other. The
|
|
first object receives the final number. It is also returned.</para>
|
|
<para role="continues"><literal>divide(NUMBER...)</literal>: Divide numbers with each other. The
|
|
first object receives the final number. It is also returned.</para>
|
|
<para role="continues"><literal>mod(NUMBER, NUMBER)</literal>: Finds the remainder of the first number
|
|
divided with the second number and returns it as a new variable.</para>
|
|
<para role="continues"><literal>pow(NUMBER, NUMBER)</literal>: Returns first number^second number.</para>
|
|
<para role="continues"><literal>log(NUMBER, [NUMBER])</literal>: Returns the logarithm of the first
|
|
number. If the second number is not specified, the natural logarith is
|
|
used.</para>
|
|
<para role="continues"><literal>random()</literal>: Returns a random number between 0 and 1.</para>
|
|
<para role="continues"><literal>abs(NUMBER...)</literal>: Sets and returns absolute values of numbers.</para>
|
|
<para role="continues"><literal>round(NUMBER, NUMBER)</literal>: Rounds the first number with x decimals,
|
|
where x is the second number.</para>
|
|
<para role="continues"><literal>floor(NUMBER, NUMBER)</literal>: Floors the first number with x decimals,
|
|
where x is the second number.</para>
|
|
<para role="continues"><literal>ceil(NUMBER, NUMBER)</literal>: "Ceils" the first number with x decimals,
|
|
where x is the second number.</para>
|
|
<para role="continues"><literal>sin(NUMBER...)</literal>: Sets and returns sine values.</para>
|
|
<para role="continues"><literal>cos(NUMBER...)</literal>: Sets and returns cosine values.</para>
|
|
<para role="continues"><literal>tan(NUMBER...)</literal>: Sets and returns tangent values.</para>
|
|
<para role="continues"><literal>asin(NUMBER...)</literal>: Sets and returns arcsine values.</para>
|
|
<para role="continues"><literal>acos(NUMBER...)</literal>: Sets and returns arccosine values.</para>
|
|
<para role="continues"><literal>atan(NUMBER...)</literal>: Sets and returns arctangent values.</para>
|
|
<para role="continues"><literal>sinh(NUMBER...)</literal>: Sets and returns hyperbolic sine values.</para>
|
|
<para role="continues"><literal>cosh(NUMBER...)</literal>: Sets and returns hyperbolic cosine values.</para>
|
|
<para role="continues"><literal>tanh(NUMBER...)</literal>: Sets and returns hyperbolic tangent values.</para>
|
|
</sect1>
|
|
</chapter>
|
|
|
|
<appendix id="Copying-This-Manual">
|
|
<title>GNU Free Documentation License</title>
|
|
<!-- The GNU Free Documentation License. -->
|
|
<para>Version 1.3, 3 November 2008
|
|
<!-- This file is intended to be included within another document, -->
|
|
<!-- hence no sectioning command or @node. --><literallayout>
|
|
Copyright © 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
|
|
<ulink url="http://fsf.org/">http://fsf.org/</ulink>
|
|
|
|
Everyone is permitted to copy and distribute verbatim copies
|
|
of this license document, but changing it is not allowed.
|
|
</literallayout></para>
|
|
<orderedlist numeration="arabic" role="0">
|
|
<listitem>
|
|
<para>PREAMBLE</para>
|
|
<para>The purpose of this License is to make a manual, textbook, or other
|
|
functional and useful document <firstterm>free</firstterm> in the sense of freedom: to
|
|
assure everyone the effective freedom to copy and redistribute it,
|
|
with or without modifying it, either commercially or noncommercially.
|
|
Secondarily, this License preserves for the author and publisher a way
|
|
to get credit for their work, while not being considered responsible
|
|
for modifications made by others.</para>
|
|
<para>This License is a kind of “copyleft”, which means that derivative
|
|
works of the document must themselves be free in the same sense. It
|
|
complements the GNU General Public License, which is a copyleft
|
|
license designed for free software.</para>
|
|
<para>We have designed this License in order to use it for manuals for free
|
|
software, because free software needs free documentation: a free
|
|
program should come with manuals providing the same freedoms that the
|
|
software does. But this License is not limited to software manuals;
|
|
it can be used for any textual work, regardless of subject matter or
|
|
whether it is published as a printed book. We recommend this License
|
|
principally for works whose purpose is instruction or reference.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>APPLICABILITY AND DEFINITIONS</para>
|
|
<para>This License applies to any manual or other work, in any medium, that
|
|
contains a notice placed by the copyright holder saying it can be
|
|
distributed under the terms of this License. Such a notice grants a
|
|
world-wide, royalty-free license, unlimited in duration, to use that
|
|
work under the conditions stated herein. The “Document”, below,
|
|
refers to any such manual or work. Any member of the public is a
|
|
licensee, and is addressed as “you”. You accept the license if you
|
|
copy, modify or distribute the work in a way requiring permission
|
|
under copyright law.</para>
|
|
<para>A “Modified Version” of the Document means any work containing the
|
|
Document or a portion of it, either copied verbatim, or with
|
|
modifications and/or translated into another language.</para>
|
|
<para>A “Secondary Section” is a named appendix or a front-matter section
|
|
of the Document that deals exclusively with the relationship of the
|
|
publishers or authors of the Document to the Document's overall
|
|
subject (or to related matters) and contains nothing that could fall
|
|
directly within that overall subject. (Thus, if the Document is in
|
|
part a textbook of mathematics, a Secondary Section may not explain
|
|
any mathematics.) The relationship could be a matter of historical
|
|
connection with the subject or with related matters, or of legal,
|
|
commercial, philosophical, ethical or political position regarding
|
|
them.</para>
|
|
<para>The “Invariant Sections” are certain Secondary Sections whose titles
|
|
are designated, as being those of Invariant Sections, in the notice
|
|
that says that the Document is released under this License. If a
|
|
section does not fit the above definition of Secondary then it is not
|
|
allowed to be designated as Invariant. The Document may contain zero
|
|
Invariant Sections. If the Document does not identify any Invariant
|
|
Sections then there are none.</para>
|
|
<para>The “Cover Texts” are certain short passages of text that are listed,
|
|
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
|
|
the Document is released under this License. A Front-Cover Text may
|
|
be at most 5 words, and a Back-Cover Text may be at most 25 words.</para>
|
|
<para>A “Transparent” copy of the Document means a machine-readable copy,
|
|
represented in a format whose specification is available to the
|
|
general public, that is suitable for revising the document
|
|
straightforwardly with generic text editors or (for images composed of
|
|
pixels) generic paint programs or (for drawings) some widely available
|
|
drawing editor, and that is suitable for input to text formatters or
|
|
for automatic translation to a variety of formats suitable for input
|
|
to text formatters. A copy made in an otherwise Transparent file
|
|
format whose markup, or absence of markup, has been arranged to thwart
|
|
or discourage subsequent modification by readers is not Transparent.
|
|
An image format is not Transparent if used for any substantial amount
|
|
of text. A copy that is not “Transparent” is called “Opaque”.</para>
|
|
<para>Examples of suitable formats for Transparent copies include plain
|
|
ascii without markup, Texinfo input format, La&tex; input
|
|
format, <acronym>SGML</acronym> or <acronym>XML</acronym> using a publicly available
|
|
<acronym>DTD</acronym>, and standard-conforming simple <acronym>HTML</acronym>,
|
|
PostScript or <acronym>PDF</acronym> designed for human modification. Examples
|
|
of transparent image formats include <acronym>PNG</acronym>, <acronym>XCF</acronym> and
|
|
<acronym>JPG</acronym>. Opaque formats include proprietary formats that can be
|
|
read and edited only by proprietary word processors, <acronym>SGML</acronym> or
|
|
<acronym>XML</acronym> for which the <acronym>DTD</acronym> and/or processing tools are
|
|
not generally available, and the machine-generated <acronym>HTML</acronym>,
|
|
PostScript or <acronym>PDF</acronym> produced by some word processors for
|
|
output purposes only.</para>
|
|
<para>The “Title Page” means, for a printed book, the title page itself,
|
|
plus such following pages as are needed to hold, legibly, the material
|
|
this License requires to appear in the title page. For works in
|
|
formats which do not have any title page as such, “Title Page” means
|
|
the text near the most prominent appearance of the work's title,
|
|
preceding the beginning of the body of the text.</para>
|
|
<para>The “publisher” means any person or entity that distributes copies
|
|
of the Document to the public.</para>
|
|
<para>A section “Entitled XYZ” means a named subunit of the Document whose
|
|
title either is precisely XYZ or contains XYZ in parentheses following
|
|
text that translates XYZ in another language. (Here XYZ stands for a
|
|
specific section name mentioned below, such as “Acknowledgements”,
|
|
“Dedications”, “Endorsements”, or “History”.) To “Preserve the Title”
|
|
of such a section when you modify the Document means that it remains a
|
|
section “Entitled XYZ” according to this definition.</para>
|
|
<para>The Document may include Warranty Disclaimers next to the notice which
|
|
states that this License applies to the Document. These Warranty
|
|
Disclaimers are considered to be included by reference in this
|
|
License, but only as regards disclaiming warranties: any other
|
|
implication that these Warranty Disclaimers may have is void and has
|
|
no effect on the meaning of this License.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>VERBATIM COPYING</para>
|
|
<para>You may copy and distribute the Document in any medium, either
|
|
commercially or noncommercially, provided that this License, the
|
|
copyright notices, and the license notice saying this License applies
|
|
to the Document are reproduced in all copies, and that you add no other
|
|
conditions whatsoever to those of this License. You may not use
|
|
technical measures to obstruct or control the reading or further
|
|
copying of the copies you make or distribute. However, you may accept
|
|
compensation in exchange for copies. If you distribute a large enough
|
|
number of copies you must also follow the conditions in section 3.</para>
|
|
<para>You may also lend copies, under the same conditions stated above, and
|
|
you may publicly display copies.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>COPYING IN QUANTITY</para>
|
|
<para>If you publish printed copies (or copies in media that commonly have
|
|
printed covers) of the Document, numbering more than 100, and the
|
|
Document's license notice requires Cover Texts, you must enclose the
|
|
copies in covers that carry, clearly and legibly, all these Cover
|
|
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
|
|
the back cover. Both covers must also clearly and legibly identify
|
|
you as the publisher of these copies. The front cover must present
|
|
the full title with all words of the title equally prominent and
|
|
visible. You may add other material on the covers in addition.
|
|
Copying with changes limited to the covers, as long as they preserve
|
|
the title of the Document and satisfy these conditions, can be treated
|
|
as verbatim copying in other respects.</para>
|
|
<para>If the required texts for either cover are too voluminous to fit
|
|
legibly, you should put the first ones listed (as many as fit
|
|
reasonably) on the actual cover, and continue the rest onto adjacent
|
|
pages.</para>
|
|
<para>If you publish or distribute Opaque copies of the Document numbering
|
|
more than 100, you must either include a machine-readable Transparent
|
|
copy along with each Opaque copy, or state in or with each Opaque copy
|
|
a computer-network location from which the general network-using
|
|
public has access to download using public-standard network protocols
|
|
a complete Transparent copy of the Document, free of added material.
|
|
If you use the latter option, you must take reasonably prudent steps,
|
|
when you begin distribution of Opaque copies in quantity, to ensure
|
|
that this Transparent copy will remain thus accessible at the stated
|
|
location until at least one year after the last time you distribute an
|
|
Opaque copy (directly or through your agents or retailers) of that
|
|
edition to the public.</para>
|
|
<para>It is requested, but not required, that you contact the authors of the
|
|
Document well before redistributing any large number of copies, to give
|
|
them a chance to provide you with an updated version of the Document.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>MODIFICATIONS</para>
|
|
<para>You may copy and distribute a Modified Version of the Document under
|
|
the conditions of sections 2 and 3 above, provided that you release
|
|
the Modified Version under precisely this License, with the Modified
|
|
Version filling the role of the Document, thus licensing distribution
|
|
and modification of the Modified Version to whoever possesses a copy
|
|
of it. In addition, you must do these things in the Modified Version:</para>
|
|
<orderedlist numeration="upperalpha">
|
|
<listitem>
|
|
<para>Use in the Title Page (and on the covers, if any) a title distinct
|
|
from that of the Document, and from those of previous versions
|
|
(which should, if there were any, be listed in the History section
|
|
of the Document). You may use the same title as a previous version
|
|
if the original publisher of that version gives permission.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>List on the Title Page, as authors, one or more persons or entities
|
|
responsible for authorship of the modifications in the Modified
|
|
Version, together with at least five of the principal authors of the
|
|
Document (all of its principal authors, if it has fewer than five),
|
|
unless they release you from this requirement.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>State on the Title page the name of the publisher of the
|
|
Modified Version, as the publisher.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Preserve all the copyright notices of the Document.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Add an appropriate copyright notice for your modifications
|
|
adjacent to the other copyright notices.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Include, immediately after the copyright notices, a license notice
|
|
giving the public permission to use the Modified Version under the
|
|
terms of this License, in the form shown in the Addendum below.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Preserve in that license notice the full lists of Invariant Sections
|
|
and required Cover Texts given in the Document's license notice.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Include an unaltered copy of this License.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Preserve the section Entitled “History”, Preserve its Title, and add
|
|
to it an item stating at least the title, year, new authors, and
|
|
publisher of the Modified Version as given on the Title Page. If
|
|
there is no section Entitled “History” in the Document, create one
|
|
stating the title, year, authors, and publisher of the Document as
|
|
given on its Title Page, then add an item describing the Modified
|
|
Version as stated in the previous sentence.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Preserve the network location, if any, given in the Document for
|
|
public access to a Transparent copy of the Document, and likewise
|
|
the network locations given in the Document for previous versions
|
|
it was based on. These may be placed in the “History” section.
|
|
You may omit a network location for a work that was published at
|
|
least four years before the Document itself, or if the original
|
|
publisher of the version it refers to gives permission.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>For any section Entitled “Acknowledgements” or “Dedications”, Preserve
|
|
the Title of the section, and preserve in the section all the
|
|
substance and tone of each of the contributor acknowledgements and/or
|
|
dedications given therein.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Preserve all the Invariant Sections of the Document,
|
|
unaltered in their text and in their titles. Section numbers
|
|
or the equivalent are not considered part of the section titles.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Delete any section Entitled “Endorsements”. Such a section
|
|
may not be included in the Modified Version.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Do not retitle any existing section to be Entitled “Endorsements” or
|
|
to conflict in title with any Invariant Section.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>Preserve any Warranty Disclaimers.</para>
|
|
</listitem>
|
|
</orderedlist>
|
|
<para>If the Modified Version includes new front-matter sections or
|
|
appendices that qualify as Secondary Sections and contain no material
|
|
copied from the Document, you may at your option designate some or all
|
|
of these sections as invariant. To do this, add their titles to the
|
|
list of Invariant Sections in the Modified Version's license notice.
|
|
These titles must be distinct from any other section titles.</para>
|
|
<para>You may add a section Entitled “Endorsements”, provided it contains
|
|
nothing but endorsements of your Modified Version by various
|
|
parties—for example, statements of peer review or that the text has
|
|
been approved by an organization as the authoritative definition of a
|
|
standard.</para>
|
|
<para>You may add a passage of up to five words as a Front-Cover Text, and a
|
|
passage of up to 25 words as a Back-Cover Text, to the end of the list
|
|
of Cover Texts in the Modified Version. Only one passage of
|
|
Front-Cover Text and one of Back-Cover Text may be added by (or
|
|
through arrangements made by) any one entity. If the Document already
|
|
includes a cover text for the same cover, previously added by you or
|
|
by arrangement made by the same entity you are acting on behalf of,
|
|
you may not add another; but you may replace the old one, on explicit
|
|
permission from the previous publisher that added the old one.</para>
|
|
<para>The author(s) and publisher(s) of the Document do not by this License
|
|
give permission to use their names for publicity for or to assert or
|
|
imply endorsement of any Modified Version.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>COMBINING DOCUMENTS</para>
|
|
<para>You may combine the Document with other documents released under this
|
|
License, under the terms defined in section 4 above for modified
|
|
versions, provided that you include in the combination all of the
|
|
Invariant Sections of all of the original documents, unmodified, and
|
|
list them all as Invariant Sections of your combined work in its
|
|
license notice, and that you preserve all their Warranty Disclaimers.</para>
|
|
<para>The combined work need only contain one copy of this License, and
|
|
multiple identical Invariant Sections may be replaced with a single
|
|
copy. If there are multiple Invariant Sections with the same name but
|
|
different contents, make the title of each such section unique by
|
|
adding at the end of it, in parentheses, the name of the original
|
|
author or publisher of that section if known, or else a unique number.
|
|
Make the same adjustment to the section titles in the list of
|
|
Invariant Sections in the license notice of the combined work.</para>
|
|
<para>In the combination, you must combine any sections Entitled “History”
|
|
in the various original documents, forming one section Entitled
|
|
“History”; likewise combine any sections Entitled “Acknowledgements”,
|
|
and any sections Entitled “Dedications”. You must delete all
|
|
sections Entitled “Endorsements.”</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>COLLECTIONS OF DOCUMENTS</para>
|
|
<para>You may make a collection consisting of the Document and other documents
|
|
released under this License, and replace the individual copies of this
|
|
License in the various documents with a single copy that is included in
|
|
the collection, provided that you follow the rules of this License for
|
|
verbatim copying of each of the documents in all other respects.</para>
|
|
<para>You may extract a single document from such a collection, and distribute
|
|
it individually under this License, provided you insert a copy of this
|
|
License into the extracted document, and follow this License in all
|
|
other respects regarding verbatim copying of that document.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>AGGREGATION WITH INDEPENDENT WORKS</para>
|
|
<para>A compilation of the Document or its derivatives with other separate
|
|
and independent documents or works, in or on a volume of a storage or
|
|
distribution medium, is called an “aggregate” if the copyright
|
|
resulting from the compilation is not used to limit the legal rights
|
|
of the compilation's users beyond what the individual works permit.
|
|
When the Document is included in an aggregate, this License does not
|
|
apply to the other works in the aggregate which are not themselves
|
|
derivative works of the Document.</para>
|
|
<para>If the Cover Text requirement of section 3 is applicable to these
|
|
copies of the Document, then if the Document is less than one half of
|
|
the entire aggregate, the Document's Cover Texts may be placed on
|
|
covers that bracket the Document within the aggregate, or the
|
|
electronic equivalent of covers if the Document is in electronic form.
|
|
Otherwise they must appear on printed covers that bracket the whole
|
|
aggregate.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>TRANSLATION</para>
|
|
<para>Translation is considered a kind of modification, so you may
|
|
distribute translations of the Document under the terms of section 4.
|
|
Replacing Invariant Sections with translations requires special
|
|
permission from their copyright holders, but you may include
|
|
translations of some or all Invariant Sections in addition to the
|
|
original versions of these Invariant Sections. You may include a
|
|
translation of this License, and all the license notices in the
|
|
Document, and any Warranty Disclaimers, provided that you also include
|
|
the original English version of this License and the original versions
|
|
of those notices and disclaimers. In case of a disagreement between
|
|
the translation and the original version of this License or a notice
|
|
or disclaimer, the original version will prevail.</para>
|
|
<para>If a section in the Document is Entitled “Acknowledgements”,
|
|
“Dedications”, or “History”, the requirement (section 4) to Preserve
|
|
its Title (section 1) will typically require changing the actual
|
|
title.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>TERMINATION</para>
|
|
<para>You may not copy, modify, sublicense, or distribute the Document
|
|
except as expressly provided under this License. Any attempt
|
|
otherwise to copy, modify, sublicense, or distribute it is void, and
|
|
will automatically terminate your rights under this License.</para>
|
|
<para>However, if you cease all violation of this License, then your license
|
|
from a particular copyright holder is reinstated (a) provisionally,
|
|
unless and until the copyright holder explicitly and finally
|
|
terminates your license, and (b) permanently, if the copyright holder
|
|
fails to notify you of the violation by some reasonable means prior to
|
|
60 days after the cessation.</para>
|
|
<para>Moreover, your license from a particular copyright holder is
|
|
reinstated permanently if the copyright holder notifies you of the
|
|
violation by some reasonable means, this is the first time you have
|
|
received notice of violation of this License (for any work) from that
|
|
copyright holder, and you cure the violation prior to 30 days after
|
|
your receipt of the notice.</para>
|
|
<para>Termination of your rights under this section does not terminate the
|
|
licenses of parties who have received copies or rights from you under
|
|
this License. If your rights have been terminated and not permanently
|
|
reinstated, receipt of a copy of some or all of the same material does
|
|
not give you any rights to use it.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>FUTURE REVISIONS OF THIS LICENSE</para>
|
|
<para>The Free Software Foundation may publish new, revised versions
|
|
of the GNU Free Documentation License from time to time. Such new
|
|
versions will be similar in spirit to the present version, but may
|
|
differ in detail to address new problems or concerns. See
|
|
<ulink url="http://www.gnu.org/copyleft/">http://www.gnu.org/copyleft/</ulink>.</para>
|
|
<para>Each version of the License is given a distinguishing version number.
|
|
If the Document specifies that a particular numbered version of this
|
|
License “or any later version” applies to it, you have the option of
|
|
following the terms and conditions either of that specified version or
|
|
of any later version that has been published (not as a draft) by the
|
|
Free Software Foundation. If the Document does not specify a version
|
|
number of this License, you may choose any version ever published (not
|
|
as a draft) by the Free Software Foundation. If the Document
|
|
specifies that a proxy can decide which future versions of this
|
|
License can be used, that proxy's public statement of acceptance of a
|
|
version permanently authorizes you to choose that version for the
|
|
Document.</para>
|
|
</listitem>
|
|
<listitem>
|
|
<para>RELICENSING</para>
|
|
<para>“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any
|
|
World Wide Web server that publishes copyrightable works and also
|
|
provides prominent facilities for anybody to edit those works. A
|
|
public wiki that anybody can edit is an example of such a server. A
|
|
“Massive Multiauthor Collaboration” (or “MMC”) contained in the
|
|
site means any set of copyrightable works thus published on the MMC
|
|
site.</para>
|
|
<para>“CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0
|
|
license published by Creative Commons Corporation, a not-for-profit
|
|
corporation with a principal place of business in San Francisco,
|
|
California, as well as future copyleft versions of that license
|
|
published by that same organization.</para>
|
|
<para>“Incorporate” means to publish or republish a Document, in whole or
|
|
in part, as part of another Document.</para>
|
|
<para>An MMC is “eligible for relicensing” if it is licensed under this
|
|
License, and if all works that were first published under this License
|
|
somewhere other than this MMC, and subsequently incorporated in whole
|
|
or in part into the MMC, (1) had no cover texts or invariant sections,
|
|
and (2) were thus incorporated prior to November 1, 2008.</para>
|
|
<para>The operator of an MMC Site may republish an MMC contained in the site
|
|
under CC-BY-SA on the same site at any time before August 1, 2009,
|
|
provided the MMC is eligible for relicensing.</para>
|
|
</listitem>
|
|
</orderedlist>
|
|
<bridgehead renderas="sect1">ADDENDUM: How to use this License for your documents</bridgehead>
|
|
<para>To use this License in a document you have written, include a copy of
|
|
the License in the document and put the following copyright and
|
|
license notices just after the title page:</para>
|
|
<screen>
|
|
Copyright (C) <replaceable>year</replaceable> <replaceable>your name</replaceable>.
|
|
Permission is granted to copy, distribute and/or modify this document
|
|
under the terms of the GNU Free Documentation License, Version 1.3
|
|
or any later version published by the Free Software Foundation;
|
|
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
|
|
Texts. A copy of the license is included in the section entitled ``GNU
|
|
Free Documentation License''.
|
|
</screen>
|
|
<para>If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
|
|
replace the “with…Texts.” line with this:</para>
|
|
<screen>
|
|
with the Invariant Sections being <replaceable>list their titles</replaceable>, with
|
|
the Front-Cover Texts being <replaceable>list</replaceable>, and with the Back-Cover Texts
|
|
being <replaceable>list</replaceable>.
|
|
</screen>
|
|
<para>If you have Invariant Sections without Cover Texts, or some other
|
|
combination of the three, merge those two alternatives to suit the
|
|
situation.</para>
|
|
<para>If your document contains nontrivial examples of program code, we
|
|
recommend releasing these examples in parallel under your choice of
|
|
free software license, such as the GNU General Public License,
|
|
to permit their use in free software.</para>
|
|
<!-- Local Variables: -->
|
|
<!-- ispell-local-pdict: "ispell-dict" -->
|
|
<!-- End: -->
|
|
</appendix>
|
|
|
|
<chapter label="" xreflabel="Index" id="Index">
|
|
<title>Index</title>
|
|
<index></index>
|
|
</chapter>
|
|
</book><!-- Keep this comment at the end of the file
|
|
Local variables:
|
|
mode: sgml
|
|
sgml-indent-step:1
|
|
sgml-indent-data:nil
|
|
End:
|
|
-->
|