From 3d88a409bc312a15b74379a6e37764cb0b331f75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fredrik=20H=C3=BCbinette=20=28Hubbe=29?= <hubbe@hubbe.net>
Date: Sat, 6 Sep 1997 03:04:51 -0700
Subject: [PATCH] lots of stuff fixed
Rev: tutorial/Wmml.pmod:1.3
Rev: tutorial/html.pike:1.4
Rev: tutorial/tutorial.wmml:1.23
---
tutorial/Wmml.pmod | 9 +
tutorial/html.pike | 117 +++
tutorial/tutorial.wmml | 1979 ++++++++++++++++++----------------------
3 files changed, 1002 insertions(+), 1103 deletions(-)
diff --git a/tutorial/Wmml.pmod b/tutorial/Wmml.pmod
index 92770d966e..e416a8754a 100644
--- a/tutorial/Wmml.pmod
+++ b/tutorial/Wmml.pmod
@@ -53,6 +53,15 @@ static private int verify_any(SGML data, string in)
case "strong":
case "link":
+ case "man_nb":
+ case "class":
+ case "method":
+ case "man_description":
+ case "man_see":
+ case "man_syntax":
+ case "man_bugs":
+ case "man_example":
+
case "ex_identifier":
case "ex_keyword":
case "ex_string":
diff --git a/tutorial/html.pike b/tutorial/html.pike
index 562d09081c..a1eb73e614 100644
--- a/tutorial/html.pike
+++ b/tutorial/html.pike
@@ -223,8 +223,15 @@ SGML index_to_wmml(INDEX data)
});
}
+string name_to_link(string x)
+{
+ return replace(x,"->",".");
+}
+
int cpos;
+string classbase;
+
SGML wmml_to_html(SGML data);
/* Partially destructive! */
@@ -247,7 +254,117 @@ SGML convert(SGML data)
data->params->noshade=1;
data->params->size="1";
break;
+
+ case "class":
+ {
+ string tmp=classbase;
+ if(!classbase || classbase=="")
+ {
+ classbase=data->params->name;
+ }else{
+ classbase+="."+data->params->name;
+ }
+ ret+=convert(data->data);
+ classbase=tmp;
+ continue;
+ }
+
+ case "man_title":
+ ret+=convert(({
+ Sgml.Tag("p"),
+ "\n",
+ Sgml.Tag("dt"),
+ Sgml.Tag("encaps",([]),data->pos, data->data),
+ Sgml.Tag("dd"),
+ "\n"
+ }));
+ continue;
+
+ case "method":
+ {
+ string fullname=classbase+"->"+data->params->name;
+ ret+=convert(({
+ Sgml.Tag("anchor",(["name":name_to_link(fullname)]),data->pos,
+ ({
+ Sgml.Tag("dl",([]),data->pos,
+ ({
+ Sgml.Tag("man_title",([]),data->pos,({"METHOD"})),
+ Sgml.Tag("tt",([]),data->pos,({fullname})),
+ " - ",
+ data->params->title,
+ "\n",
+ })
+ +
+ data->data
+ )
+ })),
+ "\n",
+ Sgml.Tag("hr"),
+ }));
+ continue;
+ }
+ case "man_syntax":
+ ret+=convert(
+ ({
+ Sgml.Tag("man_title",([]),data->pos,({"SYNTAX"})),
+ Sgml.Tag("tt",([]),data->pos,data->data)
+ }));
+ continue;
+
+ case "man_example":
+ ret+=convert(
+ ({
+ Sgml.Tag("man_title",([]),data->pos,({"EXAMPLE"})),
+ Sgml.Tag("tt",([]),data->pos,data->data)
+ }));
+ continue;
+
+ case "man_nb":
+ ret+=convert(
+ ({
+ Sgml.Tag("man_title",([]),data->pos,({"NOTA BENE"})),
+ })+data->data);
+ continue;
+
+ case "man_bugs":
+ ret+=convert(
+ ({
+ Sgml.Tag("man_title",([]),data->pos,({"BUGS"})),
+ })+data->data);
+ continue;
+ case "man_description":
+ ret+=convert(
+ ({
+ Sgml.Tag("man_title",([]),data->pos,({"DESCRIPTION"})),
+ })+data->data);
+ continue;
+
+ case "man_see":
+ {
+ ret+=convert( ({
+ Sgml.Tag("man_title",([]),data->pos,({"SEE ALSO"}))
+ }));
+
+ SGML tmp=({});
+ foreach(replace(data->data[0],({" ","\n"}),({"",""}))/",",string name)
+ {
+ tmp+=({
+ Sgml.Tag("link",(["to":name_to_link(name)]),data->pos,
+ ({
+ Sgml.Tag("tt",([]),data->pos,({name})),
+ })),
+ ", "
+ });
+ }
+
+ tmp[-1]="";
+ if(sizeof(tmp)>3) tmp[-3]=" and ";
+
+ ret+=convert(tmp);
+ continue;
+ }
+
case "link":
{
data->tag="a";
diff --git a/tutorial/tutorial.wmml b/tutorial/tutorial.wmml
index df34698abe..8a13855a70 100644
--- a/tutorial/tutorial.wmml
+++ b/tutorial/tutorial.wmml
@@ -1,10 +1,10 @@
<head>
<title>Pike tutorial</title>
</head>
+
<!-- Allmänt: Sök på "'" och byt ut nästan alla 'foo' mot <i>foo</i>
Ändra alla kommandon under SEE ALSO till <tt>foo</tt>
- Det står "return" på miljoner ställen där det ska stå "returns">
-
+ Det står "return" på miljoner ställen där det ska stå "returns" -->
<firstpage>
<p>
@@ -28,7 +28,7 @@ This book was written with the intention to make anybody with a little
programming experience able to use Pike. It should also be possible to
gain a deep understanding of how Pike works and to some extent why it works
the way does from this book. It will teach you how to write your own
-extentions to Pike. I have been trying for years to get someone else to
+extensions to Pike. I have been trying for years to get someone else to
write this book, but since it seems impossible without paying a fortune for
it I will have to do it myself.
A big thanks goes to
@@ -54,25 +54,25 @@ learn Pike fast. Since Pike is a simple language to learn, especially
if you have some prior programming experience, this should benefit most people.
<p>
Chapter one is devoted to background information about Pike and this book.
-It is not really nesesary to read this chapter to learn how to use and
+It is not really necessary to read this chapter to learn how to use and
program Pike, but it might help explain why some things work th way they do.
It might be more interesting to re-read the chapter after you have
learned the basics of Pike programming.
Chapter two is where the action starts. It is a crash course in Pike with
examples and explanations about some of the basics. It explains the
-fundamenals of the Pike data types and control structures
+fundamentals of the Pike data types and control structures
The systematic documentation of all Pike capabilities starts in chapter three
with a description of all control structures in Pike. It then continues with
all the data types in chapter four and operators in chapter five. Chapter
six deals with object orientation in Pike, which is slightly different than
what you might be used to.
-<!-- FIXME (finish this overview) -->
+<!-- FIX ME (finish this overview) -->
</section>
<anchor name=uLPC>
<section title="The history of Pike">
In the beginning, there was Zork. Then a bunch of people decided to make
-multiplayer adventure games. One of those people was Lars Pensjö at the
+multi-player adventure games. One of those people was Lars Pensjö at the
Chalmers university in Gothenburg, Sweden. For his game he needed a simple,
memory-efficient language, and thus LPC (Lars Pensjö C) was born. About a
year later I started playing one of these games and found that the language
@@ -88,7 +88,7 @@ is a company dedicated to supporting GNU and GPL software and they wanted
to create more GPL software.
<p>
When µLPC became usable, InformationsVävarna AB started using it for
-their webserver. Before then, Roxen (then called Spinner) was non-commercial
+their web-server. Before then, Roxen (then called Spinner) was non-commercial
and written in LPC4. Then in 1996 I started working for InformationsVävarna
developing µLPC for them. We also changed the name of µLPC to Pike to
get a more commercially viable name.
@@ -108,7 +108,7 @@ get a more commercially viable name.
<dd> Pike's syntax is almost the same as for C++. A huge difference is that
Pike is interpreted. This makes the code slower, but reduces compile times
to almost nothing. For those few applications which require the speed of
- C or C++, it is often easier to write a Pike extention than to write the
+ C or C++, it is often easier to write a Pike extension than to write the
whole thing in C or C++.
<dt> Lisp and Scheme
@@ -123,7 +123,7 @@ get a more commercially viable name.
<dd> Pike is similar to Tcl/Tk in intent and they both have good string
handling. Pike has better data types and is much faster however.
On the other hand Tcl/Tk has X windows system support.
-<!-- The idea from the begining was similar but the implementation is very different.-->
+<!-- The idea from the beginning was similar but the implementation is very different.-->
</dl>
</section>
@@ -163,8 +163,8 @@ things:
<dt><b>bold</b>
<dd>Bold is just used to emphasize that this word is not merely what it sounds
like. It is actually a <b>term</b>.
-<dt><tt>fixedsize</tt>
-<dd>Fixedsize is used to for examples and text directly from the computer.
+<dt><tt>fixed size</tt>
+<dd>Fixed size is used to for examples and text directly from the computer.
</dl>
Also, please beware that the word <b>program</b> is also a builtin Pike
data type.
@@ -205,7 +205,7 @@ Pretty simple, Let's see what everything means:
This begins the function <tt>main</tt>. Before the function name the type of value
it returns is declared, in this case <tt>int</tt> which is the name of the
integer number type in Pike. The empty space between the
-parethesis indicates that this function takes no arguments.
+parenthesis indicates that this function takes no arguments.
A Pike program has to contain at least one function, the <tt>main</tt> function. This function is where program execution starts and thus the function from which every other function is called, directly or indirectly. We can say that this function is called by the operating system.
Pike is, as many other programming languages, built upon the concept of functions, i.e. what the program does is separated into small portions, or functions, each performing one (perhaps very complex) task. A function declaration consists of certain essential components; the type of the value it will return, the <i>name</i> of the function, the <i>parameters</i>, if any, it takes and the body of the function. A function is also a part of something greater; an object. You can program in Pike without caring about objects, but the programs you write will in fact be objects themselves anyway.
Now let's examine the body of <tt>main</tt>;
@@ -243,8 +243,7 @@ Typing <tt>pike hello_world.pike</tt> to run our program may seem a bit
unpractical. Fortunately, Unix provides us with a way of automating this
somewhat. If we modify hello_world.pike to look like this:
<p>
-<example language=pike>
- #!/usr/local/bin/pike
+<example language=pike/local/bin/pike
int main()
{
@@ -274,7 +273,7 @@ But of course we don't want to make our program "incompatible" with the old
version. Someone might need the program to work like it used to.
Therefore we'll add a <i>command line option</i> that will make it type the old
<tt>hello world</tt>. We also have to give the program the ability to choose
-what it should output based on the command line optino.
+what it should output based on the command line option.
This is what it could look like:
<p>
<example language=pike>
@@ -305,7 +304,7 @@ What is new in this version, then?
<example language=pike>
int main(int argc, string *argv)
</example>
-In this version the space between the parentesis has been filled.
+In this version the space between the parenthesis has been filled.
What it means is that <tt>main</tt> now takes two arguments.
One is called <tt>argc</tt>, and is of the type <tt>int</tt>.
The other is called <tt>argv</tt> and is a an array of strings.
@@ -338,7 +337,7 @@ be executed. Let's look at that expression:
Loosely translated, this means: argc is greater than one, and the second
element in the array argv is equal to the string <tt>--traditional</tt>. Since
argc is the number of words on the command line the first part is true only
-if there was anything after the program invocaton.
+if there was anything after the program invocation.
<p>
Also note the comments:
<p>
@@ -357,7 +356,7 @@ Comments are also allowed to look like C-style comments, ie. <tt>/* ... */</tt>,
The first thing to understand about Pike is that just like any other
programming language it executes one piece of code at a time. Most of
the time it simply executes code line by line working its way downwards.
-Just excuting a long list of instructions is not enough to make an interesting
+Just executing a long list of instructions is not enough to make an interesting
program however. Therefore we have <b>control structures</b> to make Pike
execute pieces of code in more interesting orders than from top to bottom.
<p>
@@ -368,10 +367,10 @@ We have already seen an example of the <tt>if</tt> statement:
else
<i>statement2 </i> ;
</pre>
-<!-- FIXME: should if have a capital letter or not? -->
+<!-- FIX ME: should if have a capital letter or not? -->
<tt>if</tt> simply evaluates the expression and if the result is true it
executes <i>statement1</i>, otherwise it executes <i>statement2</i>. If you have no need for
-statement2 you can leave out the whole else<!-- FIXME: tt/italics --> part like this:
+statement2 you can leave out the whole else<!-- FIX ME: tt/italics --> part like this:
<pre>
if( <i>expression </i> )
<i>statement1 </i> ;
@@ -400,7 +399,7 @@ Another control structure we have already seen is the function.
A function is simply a block of Pike code that can be executed with different arguments from different places in the program.
A function is declared like this:
<pre>
- <i>modifers type name </i> ( <i>type name1 </i>, <i>type name2 </i>, <i>... </i> )
+ <i>modifiers type name </i> ( <i>type name1 </i>, <i>type name2 </i>, <i>... </i> )
{
<i> statements </i>
}
@@ -411,7 +410,7 @@ For example, the word <tt>int</tt> would signify that the function returns
an integer number. The <i>name </i> is used to identify the function when
calling it. The names between the parenthesis are the arguments to the
function. They will be defined as local variables inside the function. Each
-variable will be declared to contain values of the preceeding type.
+variable will be declared to contain values of the preceding type.
The three dots signifies that you can have anything from zero to 256 arguments
to a function. The <i> statements </i> between the brackets are the function
body. Those statements will be executed whenever the function is called.
@@ -421,7 +420,7 @@ body. Those statements will be executed whenever the function is called.
int sqr(int x) { return x*x; }
</example>
This line defines a function called <tt>sqr</tt> to take one argument of the
-type <tt>int</tt> and also Returns an <tt>int</tt>. The code itself returns
+type <tt>int</tt> and also returns an <tt>int</tt>. The code itself returns
the argument multiplied by itself. To call this function from somewhere in the code
you could simply put: <tt>sqr(17)</tt> and that would return the integer value
289.
@@ -484,7 +483,7 @@ We can also declare several array variables on the same line:
<example language=pike>
string i, j;
</example>
-If we want to specify that the variable should hold an array of strigngs,
+If we want to specify that the variable should hold an array of strings,
we would write:
<example language=pike>
array (string) i;
@@ -497,7 +496,7 @@ Any 8-bit character is allowed.
String is a basic type in Pike, it is not an array of char like it is in C.
This means that you cannot assign new values to individual characters in a string.
Also, all strings are "shared", i.e. if the same string is used in several places, it will be stored in memory only once.
-When writing a string in a program, you enclose it in doublequotes. To write special characters you need to use the following syntax:
+When writing a string in a program, you enclose it in double quotes. To write special characters you need to use the following syntax:
<table>
<tr><td><li>\n</td><td>newline</td></tr>
<tr><td><li>\r</td><td>carriage return</td></tr>
@@ -507,7 +506,7 @@ When writing a string in a program, you enclose it in doublequotes. To write spe
<tr><td><li>\\</td><td>\ (literal backslash)</td></tr>
</table>
<dt>Mapping
-<dd>A mapping is basically an array that can be indexed on any type, not just integers. It can also be seen as a way of linking data (usually strings) together. It consists of a lot of index-data pairs which are linked togeter in such a way that map[index1] returns data1.
+<dd>A mapping is basically an array that can be indexed on any type, not just integers. It can also be seen as a way of linking data (usually strings) together. It consists of a lot of index-data pairs which are linked together in such a way that map[index1] returns data1.
A mapping can be created in a way similar to arrays:
<example language=pike>
map=([five:good, ten:excellent]);
@@ -522,7 +521,7 @@ If you try to set an index in a mapping that isn't already present in the mappin
</chapter>
<chapter title="A more elaborate example">
-<!-- FIXME: explain things AFTER showing the code? -->
+<!-- FIX ME: explain things AFTER showing the code? -->
To illustrate several of the fundamental points of Pike we will now
introduce an example program, that will be extended as we go.
We will build a database program that keeps track of a record
@@ -541,7 +540,7 @@ of one record.
"Main Title",
"Princess Leia's Theme",
"Here They Come",
- "The Asteriod Field",
+ "The Asteroid Field",
"Yoda's Theme",
"The Imperial March",
"Parade of the Ewoks",
@@ -555,7 +554,7 @@ of one record.
]);
</example>
We want to be able to get a simple list of the records in our database. The function <tt>list_records</tt> just goes through the mapping <tt>records</tt> and puts the indices, i.e. the record names, in an array of strings, record_names. By using the builtin function <tt>sort</tt> we put the record names into the array in alphabetical order which might be a nice touch.
-For the printout we just print a header, "Records:", followed by a newline. Then we use the loop control structure for to traverse the array and print every item in it, including the number of the record, by counting up from zero to the last item of the array. The builtin function sizeof gives the number of items in an array. The printout is formatted through the use of <tt>sprintf</tt> which works more or less like the C function of the same name.
+For the printout we just print a header, "Records:", followed by a newline. Then we use the loop control structure for to traverse the array and print every item in it, including the number of the record, by counting up from zero to the last item of the array. The builtin function <tt>sizeof</tt> gives the number of items in an array. The printout is formatted through the use of <tt>sprintf</tt> which works more or less like the C function of the same name.
<example language=pike>
void list_records()
{
@@ -691,13 +690,13 @@ To open a file for reading or writing we will use one of the programs which is b
To Pike, a program is a data type which contains code, functions and variables.
A program can be <i>cloned</i> which means that Pike creates a data area
in memory for the program, place a reference to the program in the data area, and initialize it to act on the data file in question. The methods (ie. functions in the object) and variables in the object Stdio.File enables us to perform actions on the associated data file.
-The methods we need to use are open, read, write and close. <!-- See <ref to=io>
-for more details. (Den här eländeslänken krashar wmml->html) >
+The methods we need to use are open, read, write and close. See <ref to=io>
+for more details. <!-- Does this link work? -->
<p>
<section title="save()">
First we clone a <tt>Stdio.File</tt> program to the object <tt>o</tt>.
-Then we use it to open the file whose<!-- FIXME: which instead of whose? --> name is given in the string file_name for writing.
+Then we use it to open the file whose<!-- FIX ME: which instead of whose? --> name is given in the string file_name for writing.
We use the fact that if there is an error during opening, open() will return a false value which we can detect and act upon by exiting.
The arrow operator (->) is what you use to access methods and variables in an object.
If there is no error we use yet another control structure, <tt>foreach</tt>, to go through the mapping <tt>records</tt> one record at a time.
@@ -734,8 +733,8 @@ Finally, remember to close the file.
The <tt>load</tt> function begins much the same, except we open the file named <tt>file</tt> for reading instead.
When receiving data from the file we put it in the string <tt>file_contents</tt>.
-The abscense of arguments to the method o->read means that the reading should not end until the end of the file.
-After having closed the file we initialise our database, i.e. the mapping records. Then we have to put <tt>file_contents</tt> into the mapping and we do this by splitting the string on newlines (cf. the split operator in Perl) using the division operator. Yes, that's right: by dividing one string with another we can obtain an array consisting of parts from the first. And by using a <tt>foreach</tt> statement we can take the string <tt>file_contents</tt> apart piece by piece, putting each piece back in its proper place in the mapping records.
+The absence of arguments to the method o->read means that the reading should not end until the end of the file.
+After having closed the file we initialize our database, i.e. the mapping records. Then we have to put <tt>file_contents</tt> into the mapping and we do this by splitting the string on newlines (cf. the split operator in Perl) using the division operator. Yes, that's right: by dividing one string with another we can obtain an array consisting of parts from the first. And by using a <tt>foreach</tt> statement we can take the string <tt>file_contents</tt> apart piece by piece, putting each piece back in its proper place in the mapping records.
<example language=pike>
void load(string file_name)
{
@@ -813,7 +812,7 @@ Then we find the name of the record of the number <tt>num</tt> and use the built
</section>
<section title="search()">
-Searching for songs is quite easy too. To count the number of <tt>hits</tt> we declare the variable hits. Note that it's not necessary to initialise variables, that is done automatically when the variable is declared if you do not do it explicitly. To be able to use the builtin function <tt>search()</tt>, which searches for the presence of a given string inside another, we put the search string in lowercase and compare it with the lowercase version of every song. The use of <tt>search()</tt> enables us to search for partial song titles as well.
+Searching for songs is quite easy too. To count the number of <tt>hits</tt> we declare the variable hits. Note that it's not necessary to initialize variables, that is done automatically when the variable is declared if you do not do it explicitly. To be able to use the builtin function <tt>search()</tt>, which searches for the presence of a given string inside another, we put the search string in lowercase and compare it with the lowercase version of every song. The use of <tt>search()</tt> enables us to search for partial song titles as well.
When a match is found it is immediately written to standard output with the record name followed by the name of the song where the search string was found and a newline.
If there were no hits at all, the function prints out a message saying just that.
<example language=pike>
@@ -1028,7 +1027,7 @@ This would call show_record with the values 1, 2, 3 and 4.
<section title="for">
-<tt>For</tt> is simply an extention of <tt>while</tt>. It provides an
+<tt>For</tt> is simply an extension of <tt>while</tt>. It provides an
even shorter and more compact way of writing loops. The syntax looks
like this:
<pre>
@@ -1069,7 +1068,7 @@ As usual, the <i>statement</i> can also be a block of statements, and then
you do not need a semicolon after it. To clarify, this statement executes
<i>statement</i> first, and then evaluates the <i>expression</i>. If the
expression is <b>true</b> it executes the loop again. For instance, if you
-want to make a program that lets your modem dial your internet provider,
+want to make a program that lets your modem dial your Internet provider,
it could look something like this:
<!-- Can someone come up with a better example? -->
<example language=pike>
@@ -1124,7 +1123,7 @@ that is still missing is the ability to exit a loop in the middle of it.
There are three ways to do this:
<section title="break">
-<tt>Break</tt><!-- FIXME: liten bokstav? --> exits a loop or switch statement immediately and continues
+<tt>Break</tt><!-- FIX ME: liten bokstav? --> exits a loop or switch statement immediately and continues
executing after the loop. <tt>Break</tt> can not be used outside of a loop or
switch. It is quite useful in conjunction with <tt>while(1)</tt> to
construct command parsing loops for instance:
@@ -1167,7 +1166,7 @@ two returned anything in particular however. To do that you just put the return
value right after <tt>return</tt>. Of course the type of the return value
must match the type in the function declaration. If your function declaration
is <tt>int main()</tt> the value after <tt>return</tt> must be an <b>int</b>.
-For instace, if we wanted to make a program that always returns an error
+For instance, if we wanted to make a program that always returns an error
code to the system, just like the UNIX command <tt>false</tt> this is how
it would be done:
<example language=pike>
@@ -1261,7 +1260,7 @@ Also note these functions:
</section>
<section title="float">
-<!-- FIXME: Du borde skriva något om att float och int inte är kompatibla och ingen
+<!-- FIX ME: Du borde skriva något om att float och int inte är kompatibla och ingen
implicit casting sker som i C++ -->
Although most programs only use integers, they are unpractical when doing
trigonometric calculations, transformations or anything else where you
@@ -1276,7 +1275,7 @@ form:
1.0e-9 // A billionth
</pre>
Of course you do not need this many decimals, but it doesn't hurt either.
-Usually digits after the nineth digit are ignored, but on some architechtures
+Usually digits after the ninth digit are ignored, but on some architectures
<tt>float</tt> might have higher accuracy than that. In the exponential form,
<tt>e</tt> means "times 10 to the power of", so <tt>1.0e9</tt> is equal to
"1.0 times 10 to the power of 9".
@@ -1331,7 +1330,7 @@ string:
"\r" // A carriage return character
"\b" // A backspace character
"\0" // A null character
- "\"" // A doublequote character
+ "\"" // A double quote character
"\\" // A singe backslash
"hello world\116\t\n\r\b\0\"\\" // All of the above
</pre>
@@ -1339,7 +1338,7 @@ As you can see, any sequence of characters within double quotes is a string.
The backslash character is used to escape characters that are not allowed or
impossible to type. As you can see, <tt>\t</tt> is the sequence to produce
a tab character, <tt>\\</tt> is used when you want one backslash and
-<tt>\"</tt> is used when you want a doublequote to be a part of the string
+<tt>\"</tt> is used when you want a double quote to be a part of the string
instead of ending it. Also, <tt>\<i>XXX</i></tt> where <i>XXX</i> is an
octal number from 000 to 377 lets you write any character you want in the
string, even null characters. If you write two constant strings after each
@@ -1358,7 +1357,7 @@ All the comparison operators plus the operators listed here can be used on strin
<dd> Adding strings together will simply concatenate them.
<tt>"foo"+"bar"</tt> becomes <tt>"foobar"</tt>.
<dt> Subtraction
-<dd> Subtracting one string from another will remove all occurances
+<dd> Subtracting one string from another will remove all occurrences
of the second string from the first one. So
<tt>"foobarfoogazonk" - "foo"</tt> results in <tt>"bargazonk"</tt>.
<dt> Indexing
@@ -1368,11 +1367,11 @@ All the comparison operators plus the operators listed here can be used on strin
<dd> The range operator will let you copy any part of the string into a
new string. Example: <tt>"foobar"[2..4]</tt> will return <tt>"oba"</tt>.
<dt> Division
-<dd> Divison will let you divide a string at every occurance of a word or
+<dd> Division will let you divide a string at every occurrence of a word or
character. For instance if you do <tt>"foobargazonk" / "o"</tt> the
result would be <tt>({"f","","bargaz","nk"})</tt>.
<dt> Multiplication
-<dd> The reverse of the division operator can be accoplished by multiplying
+<dd> The reverse of the division operator can be accomplished by multiplying
an array with a string. So if you evaluate
<tt>({"f","","bargaz","nk"}) * "o"</tt> the result would be
<tt>"foobargazonk"</tt>.
@@ -1387,14 +1386,14 @@ Also, these functions operates on strings:
<dd>Returns <i>s</i> with all the upper case characters converted to lower case.
<dt><tt>string replace(string <i>s</i>, string <i>from</i>, string <i>to</i>)</tt>
-<dd>This function replaces all occurances of the string <i>from</i> in <i>s</i> with <i>to</i> and returns the new string.
+<dd>This function replaces all occurrences of the string <i>from</i> in <i>s</i> with <i>to</i> and returns the new string.
<dt><tt>string reverse(string <i>s</i>)</tt>
<dd>This function returns a copy of <i>s</i> with the last byte from <i>s</i>
first, the second last in second place and so on.
<dt><tt>string search(string <i>haystack</i>, string <i>needle</i>)</tt>
-<dd>This function finds the first occurance of <i>needle</i> in <i>haystack</i>.
+<dd>This function finds the first occurrence of <i>needle</i> in <i>haystack</i>.
<dt><tt>string sizeof(string <i>s</i>)</tt>
<dd>Same as <tt>strlen(<i>s</i>)</tt>, returns the length of the string.
@@ -1454,7 +1453,7 @@ fig 4.1
Operators and functions usable with arrays:
<dl>
<dt> indexing ( <tt><i>arr</i> [ <i>c</i> ]</tt> )
-<dd> Indexing an array retreives or sets a given element in the array.
+<dd> Indexing an array retrieves or sets a given element in the array.
The index <i>c</i> has to be an integer. To set an index, simply put
the whole thing on the left side of an assignment, like this:
<tt><i>arr</i> [ <i>c</i> ] = <i>new_value</i></tt>
@@ -1541,7 +1540,7 @@ For example: <tt>rows( ({"a","b","c"}), ({ 2,1,2,0}) ) </tt> will return
<tt>({"c","b","c","a"})</tt>.
<dt><tt>int search(array <i>haystack</i>, mixed <i>needle</i>)</tt>
-<dd>This function returns the index of the first occurance of an element
+<dd>This function returns the index of the first occurrence of an element
equal (tested with <tt>==</tt>) to <i>needle</i> in the array
<i>haystack</i>.
@@ -1601,7 +1600,7 @@ mappings.
The following operators and functions are important to use mappings:
<dl>
<dt> indexing ( <tt><i>m</i> [ <i>ind</i> ]</tt> )
-<dd> As discussed above, indexing is used to retreive, store and add values
+<dd> As discussed above, indexing is used to retrieve, store and add values
to the mapping.
<dt> addition, subtraction, union, intersection and xor
<dd> All these operators works exactly as on arrays, with the difference that
@@ -1753,7 +1752,6 @@ in much the same way. It can also be used to create <b>structs</b>
foreach(rec->songs, string song)
write(" "+song+"\n");
}
-
</example>
This could be a small part of a better record register program. It is not
a complete executable program in itself. In this example we create a
@@ -1761,7 +1759,8 @@ a complete executable program in itself. In this example we create a
In <tt>add_empty_record</tt> a new object is created
by calling <tt>record</tt>. This is called <b>cloning</b> and it
allocates space to store the variables defined in the <tt>class record</tt>.
-<tt>Show_record</tt> takes one of the records created in <tt>add_empty_record</tt> and shows the contents of it. As you can see, the arrow operator
+<tt>Show_record</tt> takes one of the records created in
+<tt>add_empty_record</tt> and shows the contents of it. As you can see, the arrow operator
is used to access the data allocated in <tt>add_empty_record</tt>.
If you do not understand this section I suggest you go on and read the
next section about <tt>objects</tt> and then come back and read this
@@ -1875,7 +1874,7 @@ Functions and operators relevant to objects:
<li> Use the functions <tt>new</tt> or <tt>clone</tt>. (They are the same function.)
</ol>
Whenever you clone an object, all the global variables will be
- initailized. After that the function <tt>create</tt> will be called
+ initialized. After that the function <tt>create</tt> will be called
with any arguments you call the program with.
<dt> <tt>void destruct(object <i>o</i>)</tt>
<dd> This function invalidates all references to the object <i>o</i> and
@@ -1915,7 +1914,7 @@ fig 4.6
When the function pointer is called, the interpreter sets
<tt>this_object()</tt> to the object in which the function is located and
-procedes to execute the function it points to. Also note that function pointers
+proceeds to execute the function it points to. Also note that function pointers
can be passed around just like any other data type:
<example language=pike>
int foo() { return 1; }
@@ -1931,7 +1930,7 @@ is an expression returning a function pointer that is then called. To
further illustrate this, <tt>foo</tt> has been replaced by <tt>bar()</tt>
in the function <tt>teleledningsanka</tt>.
<p>
-For convenince, there is also a simple way to write a function inside another
+For convenience, there is also a simple way to write a function inside another
function. To do this you use the <tt>lambda</tt> keyword. The
syntax is the same as for a normal function, except you write
<tt>lambda</tt> instead of the function name:
@@ -2069,7 +2068,7 @@ Here is a list of what is possible:
</section>
-<!-- FIXME: insert some things for the reader to do here -->
+<!-- FIX ME: insert some things for the reader to do here -->
</chapter>
@@ -2085,7 +2084,7 @@ the scope of the category they are in.
<section title="Arithmetic operators">
The arithmetic operators are the simplest ones, since they work just like
-you remember from maths in school. The arithmetic operators are:
+you remember from math in school. The arithmetic operators are:
<center>
<p>
<table border=1>
@@ -2107,7 +2106,7 @@ of this chapter.
When applied to integers or floats these operators do exactly what they
are supposed to do. The only operator in the list not known from basic
math is the <b>modulo</b> operator. The modulo operator returns the
-rest of an integer division. It is the same as caluclating
+rest of an integer division. It is the same as calculating
<tt>a - floor(a / b) * b</tt>. <tt>floor</tt> rounds the value down to
closest lower integer value. Note that the call to <tt>floor</tt> isn't
needed when operating on integers, since dividing two integers will return
@@ -2156,7 +2155,7 @@ the complete list of combinations of types you can use with these operators:
</tr>
<tr>
-<td><tt><i>multiset</i> + <i>multiset</i></tt></td><td>multiset</td><td>A multiset with all the indices from both builtisets is returned.</td>
+<td><tt><i>multiset</i> + <i>multiset</i></tt></td><td>multiset</td><td>A multiset with all the indices from both muiltisets is returned.</td>
</tr>
<tr>
@@ -2170,7 +2169,7 @@ the complete list of combinations of types you can use with these operators:
</tr>
<tr>
-<td><tt><i>string</i> - <i>string</i></tt></td><td>string</td><td>A copy of the left string with all occurances of the right string removed.</td>
+<td><tt><i>string</i> - <i>string</i></tt></td><td>string</td><td>A copy of the left string with all occurrences of the right string removed.</td>
</tr>
<tr>
@@ -2214,11 +2213,11 @@ the complete list of combinations of types you can use with these operators:
<tr>
<td><tt><i>float</i> / <i>int</i><br>
<i>int</i> / <i>float</i><br>
- <i>float</i> / <i>float</i></tt></td><td>float</td><td>The right value diveded by the left value.</td>
+ <i>float</i> / <i>float</i></tt></td><td>float</td><td>The right value divided by the left value.</td>
</tr>
<tr>
-<td><tt><i>string</i> / <i>string</i></tt></td><td>array(string)</td><td>In symmetry with the multiplication operator, the division operator can split a string into pieces. The right string will be split at every occurance of the right string and an array containing the results will be returned. Example:
+<td><tt><i>string</i> / <i>string</i></tt></td><td>array(string)</td><td>In symmetry with the multiplication operator, the division operator can split a string into pieces. The right string will be split at every occurrence of the right string and an array containing the results will be returned. Example:
<tt>"foo-bar"/"-"</tt> will return <tt>({"foo","bar"})</tt></td>
</tr>
@@ -2331,7 +2330,7 @@ Example: <tt>([1:2]) | ([1:3])</tt> will return <tt>([1:3])</tt>.
</section>
<section title="Indexing">
-The index and range operators are used to retreive information from a
+The index and range operators are used to retrieve information from a
complex data type.
<center>
@@ -2339,11 +2338,11 @@ complex data type.
<table border=1>
<tr><th>Function</th> <th>Syntax</th> <th>Identifier</th> <th>Returns</th></tr>
<tr><td>Index</td> <td>a [ b ]</td><td>`[]</td> <td>Returns the index b from a.</td></tr>
-<tr><td>Lookup</td> <td>a -><i>identifier</i></td> <td>`-></td> <td>Looks up the identifier. Same as a["<i>identifeir</i>"].</td></tr>
+<tr><td>Lookup</td> <td>a -><i>identifier</i></td> <td>`-></td> <td>Looks up the identifier. Same as a["<i>identifier</i>"].</td></tr>
<tr><td>Assign index</td> <td>a [ b ] = c</td><td>`[]=;</td><td>Sets the index b in a to c.</td></tr>
<tr><td>Assign index</td> <td>a -><i>identifier</i> = c</td><td>`->=</td><td>Sets the index "<i>identifier</i>" in a to c.</td></tr>
<tr><td>Range</td> <td>a [ b .. c]</td> <td>`[..]</td> <td>Returns a slice of a starting at the index b and ending at c.</td></tr>
-<tr><td>Range</td> <td>a [ .. c]</td> <td>`[..]</td> <td>Returns a slice of a starting at the beginning av a and ending at c.</td></tr>
+<tr><td>Range</td> <td>a [ .. c]</td> <td>`[..]</td> <td>Returns a slice of a starting at the beginning of a and ending at c.</td></tr>
<tr><td>Range</td> <td>a [ b .. ]</td> <td>`[..]</td> <td>Returns a slice of a from the index b to the end of a.</td></tr>
</table>
<p>
@@ -2397,7 +2396,7 @@ can only be indexed on certain things as shown in this list:
<td><tt>
<i>mapping</i>[<i>mixed</i>]<br>
<i>mapping</i>-><i>identifier</i>
- </tt></td><td>Returns the value ascociated with the index, 0 if it is not found.</td>
+ </tt></td><td>Returns the value associated with the index, 0 if it is not found.</td>
</tr>
@@ -2436,7 +2435,7 @@ can only be indexed on certain things as shown in this list:
When indexing an <tt>array</tt> or <tt>string</tt> it is sometimes convenient
to access index from the end instead of from the beginning. This function
can be performed by using a negative index. Thus <tt> arr[-i] </tt> is the
-same as <tt>arr[sizeof(arr)-i]</tt>. Note however that this behaviour does
+same as <tt>arr[sizeof(arr)-i]</tt>. Note however that this behavior does
not apply to the range operator. Instead the range operator clamps it's
arguments to a suitable range. This means that
<tt><i>a</i>[<i>b</i>..<i>c</i>]</tt> will be treated as follows:
@@ -2456,7 +2455,7 @@ arguments to a suitable range. This means that
</center>
</section>
-<!-- FIXME: tell more about indexing and ranges -->
+<!-- FIX ME: tell more about indexing and ranges -->
<section title="The assignment operators">
There is really only one assignment operator, but it can be combined with
@@ -2528,7 +2527,7 @@ not fit in any particular categories.
</center>
The most important of these operators is the calling operator. It is used
-to call functions. The operator itself is just a set of parethesis placed
+to call functions. The operator itself is just a set of parenthesis placed
after the expression that returns the function. Any arguments to the function
should be placed between the parenthesis, separated by commas. We have
already seen many examples of this operator, although you might not have
@@ -2536,7 +2535,7 @@ realized it was an operator at the time. The function call operator can
do more than just calling functions though; if the 'function' is in fact
an array, the operator will loop over the array and call each element in
the array and returns an array with the results.
-<!-- In fact, <tt>({ foo, bar, gaznonk }) (1, 2, 3)</tt> is the same as <tt>map(({ foo, bar, gaznonk }), call_function, 1, 2, 3)</tt>. -->
+<!-- In fact, <tt>({ foo, bar, gazonk }) (1, 2, 3)</tt> is the same as <tt>map(({ foo, bar, gazonk }), call_function, 1, 2, 3)</tt>. -->
If on the other hand, the 'function' is a program, the operator will
clone an object from the program and call create() in the new object
with the arguments given. In fact, the function <tt>clone</tt> is
@@ -2553,7 +2552,7 @@ in the array as a separate argument to the function call. The splice operator
can only be used in an argument list for a function call.
<p>
Then there are the increment and decrement operators. The increment and
-decrement operators are somwhat limited: they can only be used on
+decrement operators are somewhat limited: they can only be used on
integers. They provide a short and fast way to add or subtract one
to an integer. If the operator is written before the variable
(<tt>++<i>a</i></tt>) the returned value will be what the variable
@@ -2649,7 +2648,7 @@ look at some examples:
<dt> <tt>`+(0, @arr)</tt>
<dd> This will add all the integers in the array <tt>arr</tt> together.
<dt> <tt>int abs(int a) { return ( a>0 ? `+ : `-)(a); }</tt>
-<dd> This is a rather absurd but working function wich will return the
+<dd> This is a rather absurd but working function which will return the
absolute value of a.
</dl>
@@ -2684,10 +2683,10 @@ Think of the data type program as an executable file. Then we clone this
program and create an object. The object is then a running program. The
object has its own data and its own functions, however, it can work
together with other programs by calling functions in those objects.
-The functions can be thought of as message carriers, tcp sockets or
+The functions can be thought of as message carriers, TCP sockets or
just a way for programs to communicate.
-<!-- FIXME: do something about the following sentence? -->
+<!-- FIX ME: do something about the following sentence? -->
Now we have a running system with
many running programs, each performing only the task it was designed for.
<p>
@@ -2695,12 +2694,12 @@ This analogy has one major flaw, when running programs in UNIX they actually
run simultaneously. UNIX is <i>multitasking</i>, Pike is not. When one
object is executing code, all the other objects has to wait until they
are called. An exception is if you are using <b>threads</b> as will be
-descussed in a later chapter.
+discussed in a later chapter.
</section>
<section title="How does this help?">
Ok, why is it a good idea to use object oriented programming? Well
-if you beleive what you hear, the biggest advantage is that you can re-use
+if you believe what you hear, the biggest advantage is that you can re-use
your code in several projects. In my experience this is not the case.
<p>
In my experience, the advantages of object oriented programming are:
@@ -2711,9 +2710,9 @@ In my experience, the advantages of object oriented programming are:
<dt>Local data scope
<dd>This is a very nifty with object oriented programs. If your program
- uses several files, windows, stacks, tcp connections or whatever, you
+ uses several files, windows, stacks, TCP connections or whatever, you
simply write a <tt>program</tt> that handles one such file, window,
- stack or tcp connection. If correctly written, you can then just create
+ stack or TCP connection. If correctly written, you can then just create
many clones of that program.
<dt>Using the same interface to different objects
@@ -2773,7 +2772,7 @@ same file can be used. Example:
</example>
This works because <tt>x</tt> is a <b>constant</b>. If x had been a variable
or function it would not have worked. In future versions of Pike it may be
-possible to do this with variables as well. To make it easier to progam,
+possible to do this with variables as well. To make it easier to program,
defining a class is also to define a
constant with that name. Essentially, these two lines of code do the same
thing:
@@ -2795,7 +2794,7 @@ inside classes you define later, like this:
};
</example>
-<!-- FIXME: tell more -->
+<!-- FIX ME: tell more -->
</section>
<section title="Inherit">
@@ -2825,12 +2824,12 @@ in front of the function name. The argument to inherit can be one of the followi
<dd> Any constant from this program, module or inherited program that contains a
program can be inherited.
<dt> A class name
-<dd> A class defined with the <tt>class</tt> keyword is in fact added as a contant,
+<dd> A class defined with the <tt>class</tt> keyword is in fact added as a constant,
so the same rule as above applies.
</dl>
<p>
-Let's look at an example. We'll split up an eariler example into three parts
+Let's look at an example. We'll split up an earlier example into three parts
and let each inherit the previous part. It would look something like this:
<center>
<image xfig=inherit><br>
@@ -2838,7 +2837,7 @@ and let each inherit the previous part. It would look something like this:
Note that the actual code is not copied, only the list of references.
Also note that the list of inherits is copied when you inherit a program
this does not mean you can access those copied inherit with the <tt>::</tt>
-operator, it is merely an implemention detail. Although this example does
+operator, it is merely an implementation detail. Although this example does
not show an example of a re-defined function, it should be easy to see how
that works by just changing what an identifier is pointing at.
@@ -2934,7 +2933,7 @@ These modifiers are available:
<dt><tt>protected</tt>
<dd>Reserved for future use.
</dl>
-When modifiers are used in conjunction with inherit, all the variabels,
+When modifiers are used in conjunction with inherit, all the variables,
functions and classes copied from the inherited class will be modified
with the keywords used. For instance, <tt>private inherit</tt> means that
the identifiers from this inherit will not be available to program inheriting
@@ -2953,7 +2952,7 @@ will not be subject to change.
<p>
The following table assumes that a and b are objects and shows what will be
evaluated if you use that particular operation on an object. Note that some
-of these operators, notably <tt>==</tt> and <tt>!</tt> have default behaviour
+of these operators, notably <tt>==</tt> and <tt>!</tt> have default behavior
which will be used if the corresponding method is not defined in the object.
Other operators will simply fail if called with objects. Refer to
<ref to=operators> for information on which operators can operate on objects
@@ -2988,7 +2987,7 @@ without operator overloading.
<tr><td>a->foo</td><td>a->`->("foo")</td></tr>
<tr><td>a->foo=b</td><td>a->`->=("foo",b)</td></tr>
<tr><td>sizeof(a)</td><td>a->_sizeof()</td></tr>
-<tr><td>indies(a)</td><td>a->_indices()</td></tr>
+<tr><td>indices(a)</td><td>a->_indices()</td></tr>
<tr><td>values(a)</td><td>a->_values()</td></tr>
<tr><td>a(b)</td><td>a->`()(b)</td></tr>
</table>
@@ -3023,7 +3022,7 @@ expect, in which case you are better off not using operator overloading.
<li> Make a program that clones 10 hello world and then runs main() in
each one of them.
<li> Modify the register program to use an object for each record.
-<li> Modify the register program to use the following search funtion:
+<li> Modify the register program to use the following search function:
<example language=pike>
void find_song(string title)
{
@@ -3047,7 +3046,7 @@ expect, in which case you are better off not using operator overloading.
</ul>
</box>
-<!-- FIXME add more examples above -->
+<!-- FIX ME add more examples above -->
</section>
</chapter>
@@ -3088,7 +3087,7 @@ to the following table:
<tr valign=top><td> %s </td><td> reads a string. If followed by %d, %s will
read any non-numerical characters. If followed by a %[], %s will read any
characters not present in the set. If followed by normal text, %s will match
- all characters up to but not including the first occurance of that text. </td></tr>
+ all characters up to but not including the first occurrence of that text. </td></tr>
<tr valign=top><td> %5s </td><td> gives a string of 5 characters (5 can be any number) </td></tr>
<tr valign=top><td> %[set] </td><td> matches a string containing a given set of characters (those given inside the brackets). %[^set] means any character except those inside brackets. Example: %[0-9H] means any number or 'H'. </td></tr>
</table>
@@ -3160,13 +3159,13 @@ The syntax for gauge is the same as the syntax for catch:
However, gauge simply returns how many milliseconds the code took to execute.
This can be used to find out how fast your code actually is.. :)
Only CPU time used by the Pike process is measured. This means that if it takes
-two seconds to execute but only uses 50% cpu, this function will return 1000.
+two seconds to execute but only uses 50% CPU, this function will return 1000.
</section>
</anchor>
<anchor name=typeof>
<section title="typeof">
-This function retuns the type of an expression as a string. It does not
+This function returns the type of an expression as a string. It does not
evaluate the expression at all, which might be somewhat confusing. Example:
<example language=pike>
typeof( exit(1) )
@@ -3187,8 +3186,8 @@ environment. They provide you with simple interfaces to system routines
and they also constitute a neat way to use your own C/C++ code from
within Pike. Pike comes with a number of modules that are ready to use.
In this chapter I will explain the basics of modules and how to use them.
-
-<!-- Vad sägs om "Here is a list of XXX modules:" >
+<p>
+here is a list of the basic Pike modules:
<dl>
<dt>Stdio
<dd>This module contains file I/O routines.
@@ -3231,7 +3230,7 @@ In this chapter I will explain the basics of modules and how to use them.
</dl>
<p>
* These modules might not be available depending on how Pike was compiled
- and wether support for these functions exist on your system.<br>
+ and whether support for these functions exist on your system.<br>
<p>
<section title="How to use modules">
@@ -3267,13 +3266,13 @@ For each of these directories, Pike will do the following:
<li> If there is a file called Stdio.pmod.so, Pike will load this
with load_module(), clone it and use that as a module.
<li> If there is a directory called Stdio.pmod, Pike will create a module
- containing all the modules in that dir <!-- "directory"?>
- as identifiers. If there is
+ containing all the modules in that directory as identifiers. If there is
a module called <tt>module</tt> in that directory, all identifiers
from that module will overload any modules actually present in the
directory.
</ol>
+
As you can see, quite a lot of work goes into finding the modules, this
makes it possible to choose the most convenient way to build your own Pike
modules.
@@ -3325,12 +3324,10 @@ or like this:
have written so far in it. Make a program that runs one of those
programs. Make sure the program can be modified to run another of
your examples by changing what module it loads.
-<li> Copy hello_world.pike.pmod to programs/module.pike.pmod, now <!-- dåligt!>
- write
- a program that runs hello_world without actually using the identifier
- <tt>hello_world</tt>.
-<li> Try putting <tt>Programs.pmod</tt> in another directory, now <!-- dåligt!>
- try to
+<li> Copy the file hello_world.pike.pmod to programs/module.pike.pmod and
+ then write a program that runs hello_world without actually using the
+ identifier <tt>hello_world</tt>.
+<li> Try putting <tt>Programs.pmod</tt> in another directory and then try to
run the programs from the last two examples.
</ul>
</box>
@@ -3338,6 +3335,8 @@ or like this:
</chapter>
+
+
<anchor name=Stdio>
<chapter title="File I/O" name=io>
Programming without reading and writing data from files, sockets, keyboard
@@ -3353,23 +3352,16 @@ reading, that is done in the FILE object. <tt>Stdio.File</tt> is completely
written in C. What follows is a description of all the functions in
<tt>Stdio.File</tt>.
-<hr noshade size=1>
-<anchor name=Stdio.File.create>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->create</tt> - init file struct
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>object Stdio.File();<br>
-or<br>
-object Stdio.File(string <I>fd</I>);<br>
-or<br>
+<class name=Stdio.File>
+<method name=create title="init file struct">
+<man_syntax>
+object(Stdio.File) Stdio.File();<br>
+object(Stdio.File) Stdio.File(string <I>fd</I>);<br>
object(Stdio.File) Stdio.File(string <i>file</i>, string <i>mode</i>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-When cloning a File you can choose between <!-- "among"?> three different ways. The
-first is to clone it without any arguments, in which case the you
+</man_syntax>
+<man_description>
+There are three different ways to clone a File.
+The first is to clone it without any arguments, in which case the you
have to call open(), connect() or some other method which connects
the File object with a stream.
<p>
@@ -3380,24 +3372,15 @@ cloning and then calling open, except shorter and faster.
Alternatively, you can clone a File with "stdin", "stdout" or
"stderr" as argument. This will open the specified standard
stream.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=clone>clone</link> and <link to=Stdio.File.open>Stdio.File->open</link>
-<p>
-</dl>
-</anchor>
-
-<hr noshade size=1>
-<anchor name=Stdio.File.open>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->open</tt> - open a file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int open(string <I>filename</I>, string <I>how</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_description>
+<man_see>clone, Stdio.File->open</man_see>
+</method>
+
+<method name=open title="open a file">
+<man_syntax>
+int open(string <I>filename</I>, string <I>how</I>);<br>
+</man_syntax>
+<man_description>
Open a file for read, write or append. The variable <i>how</i> should
contain one or more of the following letters:
<p><table border=0 cellpadding=0 cellspacing=0>
@@ -3411,53 +3394,34 @@ contain one or more of the following letters:
<p>How should _always_ contain at least one of 'r' or 'w'.
<p>Returns 1 on success, 0 otherwise.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.close>Stdio.File->close</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->close</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.close>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->close</tt> - close file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int close(string <I>how</I>);<br>
-or<br>
+
+<method name=close title="close a file">
+<man_syntax>
+int close(string <I>how</I>);<br>
int close();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_syntax>
+<man_description>
Close the file. Optionally, specify "r", "w" or "rw" to close just
the read, just the write or both read and write part of the file
-respectively. Note that this funciton will not call the
+respectively. Note that this function will not call the
close_callback.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.open>Stdio.File->open</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->open</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.read>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->read</tt> - read data from a file or stream
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>string read(int <I>nbytes</I>);<br>
-or<br>
+
+<method name=read title="read data from a file or stream">
+<man_syntax>
+string read(int <I>nbytes</I>);<br>
string read(int <I>nbytes</I>, int <I>notall</I>);<br>
-or<br>
string read();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-Read tries to read <I>nbytes</i> bytes from the file, and return it as a
+</man_syntax>
+<man_description>
+Read tries to read <i>nbytes</i> bytes from the file, and return it as a
string. If something goes wrong, zero is returned.
<p>If a one is given as second argument to read(), read will not try
its best to read as many bytes as you asked it to read, it will
@@ -3466,434 +3430,272 @@ return. This mainly useful with stream devices which can return
exactly one row or packet at a time.
<p>
If no arguments are given, read will read to the end of the file/stream.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.write>Stdio.File->write</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->write</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.write>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->write</tt> - write data to a file or stream
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int write(string <I>data</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=write title="write data to a file or stream">
+<man_syntax>
+int write(string <I>data</I>);<br>
+</man_syntax>
+<man_description>
Write data to file or stream and return how many bytes that was
actually written. -1 is returned if something went wrong and no
bytes had been written.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.read>Stdio.File->read</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->read</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.seek>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->seek</tt> - seek to a position in a file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int seek(int <I>pos</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=seek title="seek to a position in a file">
+<man_syntax>
+int seek(int <I>pos</I>);<br>
+</man_syntax>
+<man_description>
Seek to a position in a file, if pos is less than zero, seek to
-position pos relative end of file. Returns -1 for failiure, or
+position pos relative end of file. Returns -1 for failure, or
the old position in the file when successful.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.tell>Stdio.File->tell</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->tell</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.tell>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->tell</tt> - tell where we are in a file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int tell();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=tell title="tell where we are in a file">
+<man_syntax>
+int tell();<br>
+</man_syntax>
+<man_description>
Returns the current position in the file.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.seek>Stdio.File->seek</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->seek</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.stat>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->stat</tt> - do file_stat on an open file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int *stat();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=stat title="do file_stat on an open file">
+<man_syntax>
+int *stat();<br>
+</man_syntax>
+<man_description>
This function returns the same information as the function file_stat,
but for the file it is called in. If file is not an open file,
zero will be returned. Zero is also returned if file is a pipe or
socket.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=file_stat>file_stat</link>
-<p>
-</dl>
-
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.errno>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->errno</tt> - what was last error?
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int errno();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_description>
+<man_see>file_stat</man_see>
+</method>
+
+<method name=errno title="what was last error?">
+<man_syntax>
+int errno();<br>
+</man_syntax>
+<man_description>
Returns the error code for the last command on this file.
Error code is normally cleared when a command is successful.
-<p>
-<p>
-</dl>
+</man_description>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_buffer>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_buffer</tt> - set internal socket buffer
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_buffer(int <I>bufsize</I>, string <I>mode</I>);<br>
-or<br>
+
+<method name=set_buffer title="set internal socket buffer">
+<man_syntax>
+void set_buffer(int <I>bufsize</I>, string <I>mode</I>);<br>
void set_buffer(int <I>bufsize</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_syntax>
+<man_description>
This function sets the internal buffer size of a socket or stream.
The second argument allows you to set the read or write buffer by
specifying "r" or "w". It is not guaranteed that this function
actually does anything, but it certainly helps to increase data
transfer speed when it does.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.open_socket>Stdio.File->open_socket</link> and <link to=Stdio.Port.accept>Stdio.Port->accept</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->open_socket, Stdio.Port->accept</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_nonblocking>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_nonblocking</tt> - make stream nonblocking
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_nonblocking(function read_callback,<br>
+
+<method name=set_nonblocking title="make stream nonblocking">
+<man_syntax>
+void set_nonblocking(function read_callback,<br>
<dl><dt><dd>function write_callback,<br>
function close_callback);<br>
-</dl>or<br>
+</dl>
+or<br>
void set_nonblocking();<br>
-<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_syntax>
+<man_description>
This function sets a stream to nonblocking mode. When data arrives on
the stream, read_callback will be called with some or all of this data.
When the stream has buffer space over for writing, write_callback is
called so you can write more data to it. If the stream is closed at
the other end, close_callback is called. All callbacks will have the
id of file as first argument when called.
-<p>If no arguments are given, the callbacks are not changed. The
-stream is just set to nonblocking mode.
<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_blocking>Stdio.File->set_blocking</link>
-<p>
-</dl>
-
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_read_callback>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_read_callback</tt> - set the read callback
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_read_callback(function read_callback)<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+If no arguments are given, the callbacks are not changed. The
+stream is just set to nonblocking mode.
+</man_description>
+<man_see>Stdio.File->set_blocking</man_see>
+</method>
+
+<method name=set_read_callback title="set the read callback">
+<man_syntax>
+void set_read_callback(function read_callback)<br>
+</man_syntax>
+<man_description>
This function sets the read callback for the file. The read callback
is called whenever there is data to read from the file. Note that
this function does not set the file nonblocking.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->set_nonblocking</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_write_callback>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_write_callback</tt> - set the write callback
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_write_callback(function write_callback)<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=set_write_callback title="set the write callback">
+<man_syntax>
+void set_write_callback(function write_callback)<br>
+</man_syntax>
+<man_description>
This function sets the write callback for the file. The write callback
is called whenever there is buffer space available to write to for
the file. Note that this function does not set the file nonblocking.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->set_nonblocking</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_close_callback>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_close_callback</tt> - set the close callback
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_close_callback(function close_callback)<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=set_close_callback title="set the close callback">
+<man_syntax>
+void set_close_callback(function close_callback)<br>
+</man_syntax>
+<man_description>
This function sets the close callback for the file. The close callback
is called when the remote end of a socket or pipe is closed. Note that
this function does not set the file nonblocking.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->set_nonblocking</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_blocking>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_blocking</tt> - make stream blocking
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_blocking();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=set_blocking title="make stream blocking">
+<man_syntax>
+void set_blocking();<br>
+</man_syntax>
+<man_description>
This function sets a stream to blocking mode. ie. all reads and writes
will wait until data has been written before returning.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->set_nonblocking</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_id>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_id</tt> - set id of this file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_id(mixed <I>id</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=set_id title="set id of this file">
+<man_syntax>
+void set_id(mixed <I>id</I>);<br>
+</man_syntax>
+<man_description>
This function sets the id of this file. The id is mainly used as an
identifier that is sent as the first arguments to all callbacks. The
default id is 0. Another possible use of the id is to hold all data
related to this file in a mapping or array.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.query_id>Stdio.File->query_id</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->query_id</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.query_id>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->query_id</tt> - get id of this file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>mixed query_id();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=query_id title="get id of this file">
+<man_syntax>
+mixed query_id();<br>
+</man_syntax>
+<man_description>
This function returns the id of this file.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_id>Stdio.File->set_id</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->set_id</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.query_read_callback>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->query_read_callback</tt> - return the read callback function
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>function query_read_callback();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns the read_callback, which is set with
-set_nonblocking.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.query_write_callback>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->query_write_callback</tt> - return the write callback function
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>function query_write_callback();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns the write_callback, which is set with
-set_nonblocking.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
-
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.query_close_callback>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File.query_close_callback</tt> - return the close callback function
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>function query_close_callback();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns the close_callback, which is set with
-set_nonblocking.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.set_nonblocking>Stdio.File->set_nonblocking</link>
-<p>
-</dl>
+<method name=query_read_callback title="return the read callback function">
+<man_syntax>
+function query_read_callback();<br>
+</man_syntax>
+<man_description>
+This function returns the read_callback, which is set with
+set_nonblocking or set_read_callback.
+</man_description>
+<man_see>Stdio.File->set_nonblocking, Stdio.File->set_read_callback</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.dup>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->dup</tt> - duplicate a file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>object(Stdio.File) dup();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=query_write_callback title="return the write callback function">
+<man_syntax>
+function query_write_callback();<br>
+</man_syntax>
+<man_description>
+This function returns the write_callback, which is set with
+set_nonblocking or set_write_callback.
+</man_description>
+<man_see>Stdio.File->set_nonblocking, Stdio.File->set_write_callback</man_see>
+</method>
+
+
+<method name=query_close_callback title="return the close callback function">
+<man_syntax>
+function query_close_callback();<br>
+</man_syntax>
+<man_description>
+This function returns the close_callback, which is set with
+set_nonblocking or set_close_callback.
+</man_description>
+<man_see>Stdio.File->set_nonblocking, Stdio.File->set_close_callback</man_see>
+</method>
+
+<method name=dup title="duplicate a file">
+<man_syntax>
+object(Stdio.File) dup();<br>
+</man_syntax>
+<man_description>
This function returns a clone of Stdio.File with all variables
copied from this file. Note that all variables, even id, is copied.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.assign>Stdio.File->assign</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->assign</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.dup2>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->dup2</tt> - duplicate a file over another
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int dup2(object(Stdio.File) <I>to</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=dup2 title="duplicate a file over another">
+<man_syntax>
+int dup2(object(Stdio.File) <I>to</I>);<br>
+</man_syntax>
+<man_description>
This function works similarly to Stdio.File->assign, but instead of making
the argument a reference to the same file, it creates a new file
with the same properties and places it in the argument.
-<p>
-<dt><encaps>EXAMPLE</encaps><dd>
-<tt>/* Redirect stdin to come from the file 'foo' */<br>
-object o=Stdio.File();<br>
-o->open("foo","r");<br>
-o->dup2(Stdio.File("stdin"));<br>
-</tt>
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.assign>Stdio.File->assign</link> and <link to=Stdio.File.dup>Stdio.File->dup</link>
-<p>
-</dl>
-
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.assign>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->assign</tt> - assign a file
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void assign(object <I>f</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_description>
+<man_example>
+<example language=pike>
+ /* Redirect stdin to come from the file 'foo' */
+ object o=Stdio.File();
+ o->open("foo","r");
+ o->dup2(Stdio.File("stdin"));
+</example>
+</man_example>
+<man_see>Stdio.File->assign, Stdio.File->dup</man_see>
+</method>
+
+<method name=assign title="assign a file">
+<man_syntax>
+void assign(object <I>f</I>);<br>
+</man_syntax>
+<man_description>
This function takes a clone of Stdio.File and assigns all
variables of this file from it. It can be used together with file->dup
to move files around.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.dup>Stdio.File->dup</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->dup</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.open_socket>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->open_socket</tt> - open a socket
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int open_socket(int|void port, int|void address);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=open_socket title="open a socket">
+<man_syntax>
+int open_socket(int|void port, int|void address);<br>
+</man_syntax>
+<man_description>
This makes this file into a socket ready for connection. The reason
for this function is so that you can set the socket to nonblocking
or blocking (default is blocking) before you call Stdio.File->connect()
@@ -3901,109 +3703,73 @@ This function returns 1 for success, 0 otherwise.
<p>
If you give a port number to this function, the socket will be bound to
this port locally before connecting anywhere. This is only useful for
-some silly protocols like FTP. You may also specify an adress to bind to
-if your machine has many ip numbers.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.connect>Stdio.File->connect</link> and <link to=Stdio.File.set_nonblocking>Stdio.Fileile->set_nonblocking</link>
-<p>
-</dl>
-
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.connect>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->connect</tt> - connect a socket to something.
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>int connect(string <I>ip</I>,int <I>port</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-This funcion connects a socket previously created with
-Stdio.File->open_socket to a remote socket. The argument is the ip name
-or number for the remote machine.
+some silly protocols like FTP. You may also specify an address to bind to
+if your machine has many IP numbers.
+</man_description>
+<man_see>Stdio.File->connect, Stdio.File->set_nonblocking</man_see>
+</method>
+
+<method name=connect title="connect a socket to something">
+<man_syntax>
+int connect(string <I>IP</I>,int <I>port</I>);<br>
+</man_syntax>
+<man_description>
+This function connects a socket previously created with
+Stdio.File->open_socket to a remote socket. The argument is the IP name
+or number for he remote machine.
<p>This function returns 1 for success, 0 otherwise. Note that if the
socket is in nonblocking mode, you have to wait for a write or close
callback before you know if the connection failed or not.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.query_address>Stio.File->query_address</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->query_address</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.query_address>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->query_address</tt> - get adresses
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>string query_address();<br>
-or<br>
+
+<method name=query_address title="get addresses">
+<man_syntax>
+string query_address();<br>
string query_address(1);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+</man_syntax>
+<man_description>
This function returns the remote or local address of a socket on the
form "x.x.x.x port". Without argument, the remote address is returned,
with argument the local address is returned. If this file is not a
socket, not connected or some other error occurs, zero is returned.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=Stdio.File.connect>Stdio.File->connect</link>
-<p>
-</dl>
+</man_description>
+<man_see>Stdio.File->connect</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.pipe>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->pipe</tt> - create a two-way pipe
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>object pipe();<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=pipe title="create a two-way pipe">
+<man_syntax>
+object pipe();<br>
+</man_syntax>
+<man_description>
This function creates a pipe between the object it was called in
and an object that is returned. The two ends of the pipe are
-indistinguishable. If the object is this function is called in <!-- Obegripligt!>
+indistinguishable. If the File object this function is called in
was open to begin with, it is closed before the pipe is created.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=fork>fork</link>
-<p>
-</dl>
+</man_description>
+<man_see>fork</man_see>
+</method>
-</anchor>
-<hr noshade size=1>
-<anchor name=Stdio.File.set_close_on_exec>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Stdio.File->set_close_on_exec</tt> - set / clear the close on exec flag
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>void set_close_on_exec(int <I>onoff</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
+
+<method name=set_close_on_exec title="set / clear the close on exec flag">
+<man_syntax>
+void set_close_on_exec(int <I>onoff</I>);<br>
+</man_syntax>
+<man_description>
This function determines whether this file will be closed when
calling exece. Default is that the file WILL be closed on exec
except for stdin, stdout and stderr.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<link to=exece>exece</link>
-<p>
-</dl>
+</man_description>
+<man_see>exece</man_see>
+</method>
+
+</class>
-</anchor>
-<hr noshade size=1>
-<!-- FIXME might be good to have a plain and simple example of Stdio.File here -->
+<!-- FIX ME might be good to have a plain and simple example of Stdio.File here -->
<p>
Here is an example of how to use the TCP functions in Stdio.File in blocking
@@ -4042,16 +3808,16 @@ necessary.
}
</example>
-<!--
+
</section>
</anchor>
->
+
<anchor name=Stdio.FILE>
<section title="Stdio.FILE">
Stdio.FILE is a buffered version of Stdio.File, it inherits Stdio.File and
-has most of the functionalty of Stdio.File. However, it has an input buffer
-that allows line-by-line input. Note that the output part of Stio.FILE is
+has most of the functionality of Stdio.File. However, it has an input buffer
+that allows line-by-line input. Note that the output part of Stdio.FILE is
not buffered at this moment. The added functionality of Stdio.FILE is
described here:
@@ -4084,7 +3850,7 @@ no more lines are available.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function does aproximately the same as:
+This function does approximately the same as:
write(sprintf(format,@data))
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -4129,11 +3895,19 @@ a string containing one character.
</dl>
</anchor>
-<!-- FIXME, example of how to use Stdio.FILE here -->
-<!--
+<!-- FIX ME, example of how to use Stdio.FILE here -->
+
+
+
+
+
+
+
+
+
</section>
</anchor>
->
+
<anchor name=Stdio.stdin>
<anchor name=Stdio.stdout>
@@ -4159,7 +3933,7 @@ Example:
This example will read lines from standard input for as long as there
are more lines to read. Each line will then be written to stdout together
with the line number. We could use <tt>Stdio.stdout.write</tt> instead
-of just <tt>write</tt> <!-- Punkt eller because?> they are the same function.
+of just <tt>write</tt> because they are the same function.
</section>
</anchor>
</anchor>
@@ -4259,7 +4033,7 @@ and return those lines as a string. If <i>start</i> and <i>len</i> are omitted
the whole file is read.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Stdio.read_bytes>Stdio.read_bytes</link></tt> and <tt><link to=Stdio.write_file.html>Stdio.write_file</link></tt>
+<link to=Stdio.read_bytes>Stdio.read_bytes</link> and <link to=Stdio.write_file.html>Stdio.write_file</link>
<p>
</dl>
@@ -4280,7 +4054,7 @@ the whole file is read.
This function writes the string <i>prompt</i> and then waits until the
user has entered a line from the keyboard. If the readline library
was available when Pike was compiled the user will have history and
-line edithing at his/her disposal when entering the line.
+line editing at his/her disposal when entering the line.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=Stdio.File>Stdio.File</link>
@@ -4346,17 +4120,17 @@ These are the methods available in <tt>Stdio.Port</tt>:
or<br>
int bind(int <I>port</I>,function <I>accept_callback</I>);<br>
or<br>
-int bind(int <I>port</I>,function <I>accept_callback</I>, string <I>ip</I>);<br>
+int bind(int <I>port</I>,function <I>accept_callback</I>, string <I>IP</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Bind opens a sockets and binds it to port number on the local machine.
If the second argument is present, the socket is set to nonblocking
-and the callback funcition is called whenever something connects to
+and the callback function is called whenever something connects to
the socket. The callback will receive the id for this port as argument.
-Bind returns 1 on success, and zero on failiure.
-<p>If the optional argument 'ip' is given, bind will try to bind to
-this ip name (or number).
+Bind returns 1 on success, and zero on failure.
+<p>If the optional argument 'IP' is given, bind will try to bind to
+this IP name (or number).
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=Stdio.Port.accept>Stdio.Port->accept</link>
@@ -4379,7 +4153,7 @@ int listen_fd(int <I>fd</I>,function <I>accept_callback</I>);<br>
<dt><encaps>DESCRIPTION</encaps><dd>
This function does the same as Stdio.Port->bind, except that instead
of creating a new socket and bind it to a port, it expects that
-the filedescriptor 'fd' is an already open port.
+the file descriptor 'fd' is an already open port.
<p>
<dt><encaps>NOTA BENE</encaps><dd>
This function is only for the advanced user, and is generally used
@@ -4399,32 +4173,28 @@ when sockets are passed to Pike at exec time.
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>object(Stdio.Port) Stdio.Port("stdin")<br>
-or<br>
-object(Stdio.Port) Stdio.Port("stdin",function accept_callback)<br>
-or<br>
-object(Stdio.Port) Stdio.Port("stdin",function accept_callback)<br>
-or<br>
-object(Stdio.Port) Stdio.Port(int port)<br>
-or<br>
-object(Stdio.Port) Stdio.Port(int port,function accept_callback)<br>
-or<br>
-object(Stdio.Port) Stdio.Port(int port,function accept_callback, string ip)<br>
+object(Stdio.Port) Stdio.Port("stdin",function <i>accept_callback</i>)<br>
+object(Stdio.Port) Stdio.Port("stdin",function <i>accept_callback</i>)<br>
+object(Stdio.Port) Stdio.Port(int <i>port</i>)<br>
+object(Stdio.Port) Stdio.Port(int <i>port</i>,function <i>accept_callback</i>)<br>
+object(Stdio.Port) Stdio.Port(int <i>port</i>,function <i>accept_callback</i>, string <i>ip</i>)<br>
</tt>
-<p> <!-- Det saknas <i> överallt här. Lägger till det>
+<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-When create is called with 'stdin'
-<!-- är det inte bättre att skriva "... with the string "stdin" as ..." >
-as argument, a socket is created
+When create is called with <tt>"stdin"</tt> as argument, a socket is created
out of the file descriptor 0. This is only useful if that actually
-IS <!-- bold?> a socket to begin with. When create is called with an int as first
+is a socket to begin with. When create is called with an int as first
argument, it does the same as bind() would do with the same arguments.
+The second and third argument has the same function as in the bind()
+call.
<p>
-<!-- Här verkar det saknas info>
<dt><encaps>SEE ALSO</encaps><dd>
-<link to=clone>clone</link>
+<link to=clone>clone</link> and <link to=Stdio.Port.bind>Stdio.Port->bind</link>
<p>
</dl>
+
+
</anchor>
<hr noshade size=1>
<anchor name=Stdio.Port.set_id>
@@ -4478,7 +4248,7 @@ first argument to accept_callback.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
If the last call done on this port failed, errno will return an
-integer describing what went wrong. Refer to your unix manual for
+integer describing what went wrong. Refer to your Unix manual for
further information.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -4512,16 +4282,20 @@ Stdio.File. The new file is by default set to blocking.
</anchor>
<hr noshade size=1>
-<section title="A more complex example - a simple www server">
-For you who are not familiar with WWW (World Wide Web), it works by using
-<!-- Så www funkar bara om man inte är bekant med det? Skriv om det bättre!>
+
+
+
+
+<section title="A more complex example - a simple WWW server">
+
+As most of you know, WWW WWW (World Wide Web), works by using a
client program which will fetch files from remote servers when asked.
-Usually by clicking a pitcure or text. This example is a program for the
+Usually by clicking a picture or text. This example is a program for the
server which will send files to any computer that requests them. The
-protocol used to send the file is called HTTP. (HyperText Transfer Protocol)
+protocol used to send the file is called HTTP. (Hyper-Text Transfer Protocol)
<p>
-Usually WWW involves HTML. HTML (HyperText Markup Language) is a way to
+Usually WWW involves HTML. HTML (Hyper-Text Markup Language) is a way to
write documents with embedded pictures and links to other pages. These
links are normally displayed underlined and if you click them your WWW-
browser will load whatever document that link leads to.
@@ -4542,7 +4316,7 @@ to and from different programs on the same computer.
Next are some constants that will affect how uHTTPD will operate. This uses
the preprocessor directive #define. The preprocessor is the first stage in
the compiling process and can make textual processing of the code before
-it is compiled. As an example, after the first define below, all occurances
+it is compiled. As an example, after the first define below, all occurrences
of 'BLOCK' will be replaced with 16060.
<example language=pike>
@@ -4619,7 +4393,7 @@ read only that many bytes will be returned.
if(strlen(data))
{
</example>
- If we managed to read someting...
+ If we managed to read something...
<p>
<example language=pike>
written=socket::write(data);
@@ -4668,13 +4442,13 @@ read only that many bytes will be returned.
input+=data;
</example>
Append data to the string input. Then we check if we have received a
-a complete line yet. If so we parse this and start ouputting the file.
+a complete line yet. If so we parse this and start outputting the file.
<p>
<example language=pike>
if(sscanf(input,"%s %s%*[\012\015 \t]",cmd,input)>2)
{
</example>
-This sscanf is pretty complicated, but in essense it means: put the
+This sscanf is pretty complicated, but in essence it means: put the
first word in 'input' in 'cmd' and the second in 'input' and return 2
if successful, 0 otherwise.
<p>
@@ -4848,7 +4622,7 @@ Write an encouraging message to stderr.
</example>
Bind PORT and set it up to call accept_callback as soon as someone connects
to it. If the bind() fails we write an error message and return the 17 to
-indicate failiure.
+indicate failure.
<example language=pike>
return - 17; /* Keep going */
@@ -4942,7 +4716,7 @@ makes it very simple to write threaded programs. Let's look at an example:
while(string line=o->gets())
{
if(search(line, lookfor) >=0)
- write(sprintf("%s:%d: %s\n",file, lineno<!-- Den här hittar jag inte tidigare>, line));
+ write(sprintf("%s:%d: %s\n",file, linenum, line));
linenum++;
}
@@ -4972,7 +4746,7 @@ this example again.
<dt> Deadlocks
<dd> Deadlocks arise when two threads are waiting for each other to do something.
- This bug can often arise when several threads needs<!-- need ska det nog vara> access to a number of
+ This bug can often arise when several threads need access to a number of
resources such as files or other I/O devices. What may happen is that one
thread has locked device #1 and is trying to lock device #2 while another
thread has locked device #2 and is trying to lock device #1. This type
@@ -5040,10 +4814,10 @@ This function returns the object that identifies this thread.
<tt>Thread.Mutex</tt> - mutex locks
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Thread.Mutex is a precompiled Pike program that implements
+Thread.Mutex is a pre-compiled Pike program that implements
mutual exclusion locks. Mutex locks are used to prevent multiple
-threads from simultaneously execute sections of code which accesses
-or changes <!-- access or change ska det vara>shared data. The basic operations for a mutex are locking
+threads from simultaneously execute sections of code which access
+or change shared data. The basic operations for a mutex is locking
and unlocking, if a thread attempts to lock an already locked mutex
the thread will sleep until the mutex is unlocked.
<p>
@@ -5097,10 +4871,10 @@ mixed read()
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function attempts to lock the mutex, if the mutex is already
-locked current thread will sleep until the lock is unlocked by some
-other thread. The value returned is the 'key' to the lock, which the
-key is destructed <!-- Skriv om! Helt obegripligt>or has no more references the lock will automatically
-be unlocked.
+locked the current thread will sleep until the lock is unlocked by some
+other thread. The value returned is the 'key' to the lock. When the
+key is destructed or has no more references the lock will automatically
+be unlocked. The key will also be destructed if the lock is destructed.
<p>
</dl>
@@ -5129,7 +4903,7 @@ lock is unlocked.
<tt>Thread.Condition</tt> - condition variables
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Thread.Condition is a precompiled Pike program that implements
+Thread.Condition is a pre-compiled Pike program that implements
condition variables. Condition variables are used by threaded programs
to wait for events happening in other threads.
<p>
@@ -5198,7 +4972,7 @@ void wait(object <I>mutex_key</I>);<br>
This function makes the current thread sleep until the condition
variable is signalled. The optional argument should be the 'key'
to a mutex lock. If present the mutex lock will be unlocked before
-waiting for the condition in one atomical operation. After waiting
+waiting for the condition in one atomic operation. After waiting
for the condition the mutex referenced by mutex_key will be re-locked.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -5315,7 +5089,7 @@ available.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function retreives a value from the fifo. Values will be
+This function retrieves a value from the fifo. Values will be
returned in the order they were written. If there are no values
present in the fifo the current thread will sleep until some other
thread writes a value to the fifo.
@@ -5334,7 +5108,7 @@ thread writes a value to the fifo.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns how many values are currently in the fifo<!-- Låter fel, lite osäker dock>.
+This function returns how many values are currently in the fifo. <!-- L}ter fel /hedda -->
<p>
</dl>
@@ -5392,7 +5166,7 @@ room for it.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function retreives a value from the queue. Values will be
+This function retrieves a value from the queue. Values will be
returned in the order they were written. If there are no values
present in the queue the current thread will sleep until some other
thread writes a value to the queue.
@@ -5516,7 +5290,7 @@ int main(int argc, array(string) argv)
</example>
<p>
As stated in the beginning of this chapter; Pike threads are only available
-on some UNIX systems. The above example does not work if your systems <!-- "system"?>does
+on some UNIX systems. The above example does not work if your system does
not have threads.
</section>
</chapter>
@@ -5539,7 +5313,7 @@ complement to those written in C.
<anchor name=String.implode_nicely>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>String.implode_nicely</tt> - make an english comma separated list
+<tt>String.implode_nicely</tt> - make an English comma separated list
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>string implode_nicely(array(string) words, string|void separator)<br>
@@ -5598,7 +5372,7 @@ new string.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function multplies 's' by 'num'. The return value is the same
+This function multiplies 's' by 'num'. The return value is the same
as appending 's' to an empty string 'num' times.
<p>
</dl>
@@ -5608,7 +5382,7 @@ as appending 's' to an empty string 'num' times.
<section title="Array">
As with <tt>String</tt> these functions are Pike functions written to
-suppliment those written in C.
+supplement those written in C.
<hr noshade size=1>
<anchor name=Array.map>
@@ -5617,16 +5391,16 @@ suppliment those written in C.
<tt>Array.map</tt> - map an array or mapping over a function
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>mixed *map(mixed <!-- "*"/Array() här?><I>arr</I>,function <I>fun</I>,mixed ... <I>args</I>);<br>
-or<br>
-mixed *map(object *<I>arr</I>,string <I>fun</I>,mixed ... <I>args</I>);<br>
-or<br>
-mixed *map(function *<I>arr</I>,-<I>1</I>,mixed ... <I>arg</I>);<br>
+<tt>array map(array <I>arr</I>,function <I>fun</I>,mixed ... <I>args</I>);<br>
+array map(array(object) <I>arr</I>,string <I>fun</I>,mixed ... <I>args</I>);<br>
+array map(array(function) <I>arr</I>,-<I>1</I>,mixed ... <I>arg</I>);<br>
</tt>
<p>
+
+
<dt><encaps>DESCRIPTION</encaps><dd>
First syntax:
-Map array returns an array holding the items of arr mapped thrugh
+Map array returns an array holding the items of arr mapped through
the function fun. ie. arr[x]=fun(arr[x], @args) for all x.
<p>Second syntax:
Map array calls function fun in all objects in the array arr.
@@ -5648,13 +5422,13 @@ arr[x]=arr[x]->fun(@ args);
<tt>Array.filter</tt> - filter an array or mapping through a function
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>mixed *filter(mixed<!-- "*"/Array() här?> <I>arr</I>,function <I>fun</I>,mixed ... <I>args</I>);<br>
-or<br>
-mixed *filter(object *<I>arr</I>,string <I>fun</I>,mixed ... <I>args</I>);<br>
+<tt>array filter(array <I>arr</I>,function <I>fun</I>,mixed ... <I>args</I>);<br>
+array filter(array(object) <I>arr</I>,string <I>fun</I>,mixed ... <I>args</I>);<br>
or<br>
-mixed *filter(function *<I>arr</I>,-<I>1</I>,mixed ... <I>args</I>);<br>
+array filter(array(function) <I>arr</I>,-<I>1</I>,mixed ... <I>args</I>);<br>
</tt>
<p>
+
<dt><encaps>DESCRIPTION</encaps><dd>
First syntax:
Filter array returns an array holding the items of arr for which
@@ -5740,7 +5514,7 @@ return res;<br>
<dt><encaps>DESCRIPTION</encaps><dd>
This function sorts an array after a compare-function <i>fun</i>
which takes two arguments and should return 1 if the first argument
-is larger than the second. The rest of the arguments <i>args</i> will be
+is larger then the second. The rest of the arguments <i>args</i> will be
sent as 3rd, 4th etc. argument to <i>fun</i>. If <i>fun</i> is omitted, `< is used
instead.
<p>
@@ -5760,7 +5534,7 @@ instead.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns a copy of the array <i>a</i> with all duplicate
+This function returns an copy of the array <i>a</i> with all duplicate
values removed. The order of the values in the result is undefined.
<p>
</dl>
@@ -5957,9 +5731,9 @@ int getpgrp(int <I>pid</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-With no argguments or with <i>pid</i> equal to zero, returns the process
+With no arguments or with <i>pid</i> equal to zero, returns the process
group ID of this process.
-<p>If <i>pid'</i> is specified, returns the process group ID of that process.
+<p>If <i>pid</i> is specified, returns the process group ID of that process.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=getpid>getpid</link> and <link to=getppid>getppid</link>
@@ -6076,9 +5850,9 @@ list.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Initializes the connection to syslogd.
-<p>The <i>ident</i> argument specifies an identifier to tag all logentries
+<p>The <i>ident</i> argument specifies an identifier to tag all log entries
with.
-<p><i>options</i> is a bitfield specifying the behaviour of the message
+<p><i>options</i> is a bit field specifying the behavior of the message
logging. Valid options are:
<p><dl><dt><dd><table border=0 cellpadding=0 cellspacing=0>
<tr valign=top><td> LOG_PID </td><td> Log the process ID with each message. </td></tr>
@@ -6277,7 +6051,7 @@ The Process module contains functions to start and control other programs from P
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function runs the command <i>cmd</i> as in a shell and returns the
-output. See your unix/C manual for details on popen.
+output. See your Unix/C manual for details on popen.
<p>
</dl>
@@ -6379,7 +6153,7 @@ exece("/bin/sh", ({"-c", "echo $HOME"}), (["HOME":"/not/home"]));<br>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function destroys the Pike parser and runs the program
-'file' instead with the arguments. If there is no '/' in
+<i>file</i> instead with the arguments. If no there are no '/' in
the filename, the variable PATH will be consulted when looking
for the program. This function does not return except when
the exec fails for some reason.
@@ -6413,8 +6187,8 @@ but some characters have special meaning.
<tr><td> [a-z] </td><td> any character a to z inclusive </td></tr>
<tr><td> [^ac] </td><td> any character except a and c </td></tr>
<tr><td> (x) </td><td> x (x might be any regexp) If used with split, this also puts the string matching x into the result array. </td></tr>
-<tr><td> x* </td><td> zero or more occurances of 'x' (x may be any regexp) </td></tr>
-<tr><td> x+ </td><td> one or more occurances of 'x' (x may be any regexp) </td></tr>
+<tr><td> x* </td><td> zero or more occurrences of 'x' (x may be any regexp) </td></tr>
+<tr><td> x+ </td><td> one or more occurrences of 'x' (x may be any regexp) </td></tr>
<tr><td> x|y </td><td> x or y. (x or y may be any regexp) </td></tr>
<tr><td> xy </td><td> xy (x and y may be any regexp) </td></tr>
<tr><td> ^ </td><td> beginning of string (but no characters) </td></tr>
@@ -6441,7 +6215,7 @@ they can then be used over and over again without needing to be recompiled.
To give the user full control over the compilations and use of regexp an
object oriented interface is provided.
<p>
-You might wonder what you use regexp for<!-- Skriv "... what regesp can be used to" eller nåt>, hopefully it should be more clear
+You might wonder what regexps are good for, hopefully it should be more clear
when you read about the following functions:
<hr noshade size=1>
@@ -6464,7 +6238,7 @@ object(Regexp) Regexp(string <I>regexp</I>);<br>
When create is called, the current regexp bound to this object is
cleared. If a string is sent to create(), this string will be compiled
to an internal representation of the regexp and bound to this object
-for laters calls to match or split. Calling create() without an
+for later calls to match or split. Calling create() without an
argument can be used to free up a little memory after the regexp has
been used.
<p>
@@ -6485,7 +6259,7 @@ been used.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>s</i> matches the regexp bound to the object regexp,
+Return 1 if <i>s</i> matches the regexp bound to the object regexp,
zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -6506,31 +6280,31 @@ zero otherwise.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Works as regexp->match, but returns an array of the strings that
-matched the subregexps. Subregexps are those contained in ( ) in
-the regexp. Subregexps that were not matched will contain zero.
+matched the sub-regexps. Sub-regexps are those contained in ( ) in
+the regexp. Sub-regexps that were not matched will contain zero.
If the total regexp didn't match, zero is returned.
<p>
<dt><encaps>BUGS</encaps><dd>
-You can only have 40 subregexps.
+You can only have 40 sub-regexps.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Regexp.create>Regexp->create</link></tt> and <tt><link to=Regexp.match>Regexp->match</link></tt>
+<link to=Regexp.create>Regexp->create</link> and <link to=Regexp.match>Regexp->match</link>
<p>
</dl>
</anchor>
<hr noshade size=1>
-<!-- FIXME: write and document Regexp->explode -->
+<!-- FIX ME: write and document Regexp->explode -->
</section>
</anchor>
<anchor name=Gmp>
-<section title="Gmp"><!-- Jag har ändrat alla "Name Gmp.mpz.foo" till "Gmp.mpz->foo". Dock inte i Anchor förståss.>
-Gmp is short for GNU MultiPrecision library. It is a set of routines that
+<section title="Gmp">
+Gmp is short for GNU Multi-Precision library. It is a set of routines that
can manipulate very large numbers. Although much slower than regular integers
-they are very useful when you need to handle extremly large numbers.
+they are very useful when you need to handle extremely large numbers.
Billions and billions as Mr Attenborough would have said..
<p>
The Gmp library can handle large integers, floats and rational numbers, but
@@ -6580,10 +6354,9 @@ give the number in the string in another base by specifying the
base as a second argument. Valid bases are 2-36 and 256.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=clone>clone</link></tt>
+<link to=clone>clone</link>
<p>
</dl>
-
</anchor>
<hr noshade size=1>
<anchor name=Gmp.mpz.powm>
@@ -6596,9 +6369,10 @@ base as a second argument. Valid bases are 2-36 and 256.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns ( mpz ** a ) % b <!-- Fattar inte! Förklara!>
+This function returns ( mpz ** <i>a</i> ) % <i>b</i>.
+For example, <tt> Mpz(2)->powm(10,42); </tt> would return <tt>16</tt>
+since 2 to the power of 10 is 1024 and 1024 modulo 42 is 16.
</dl>
-
</anchor>
<hr noshade size=1>
<anchor name=Gmp.mpz.sqrt>
@@ -6611,7 +6385,7 @@ This function returns ( mpz ** a ) % b <!-- Fattar inte! F
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns the the truncated integer part of the square
+This function returns the truncated integer part of the square
root of the value of mpz.
</dl>
@@ -6693,7 +6467,7 @@ number will be represented in that base. Valid bases are 2-36 and
256. The default base is 10.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Gmp.mpz.cast>Gmp.mpz->cast</link></tt>
+<link to=Gmp.mpz.cast>Gmp.mpz->cast</link>
<p>
</dl>
@@ -6715,7 +6489,7 @@ This function returns how long the mpz would be represented in the
specified base. The default base is 2.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Gmp.mpz.digits>Gmp.mpz->digits</link></tt>
+<link to=Gmp.mpz.digits>Gmp.mpz->digits</link>
<p>
</dl>
@@ -6732,7 +6506,7 @@ but the data is located on disk, not in memory. Each gdbm database
is one file which contains a key-pair values, both keys and values
have to be strings. All keys are always unique, just as with a mapping.
<p>
-<!-- FIXME, implement `[], `[]=, _sizeof, _indices and _values -->
+<!-- FIX ME, implement `[], `[]=, _sizeof, _indices and _values -->
This is the an interface to the gdbm library. This module might or
might not be available in your Pike depending on whether the gdbm library
@@ -6772,7 +6546,7 @@ flags in a string:
<tr valign=top><td> f </td><td> fast mode </td></tr>
</table>
-<p>The fast mode prevents the database from syncronizing each change
+<p>The fast mode prevents the database from synchronizing each change
in the database immediately. This is dangerous because the database
can be left in an unusable state if Pike is terminated abnormally.
<p>The default mode is "rwc".
@@ -6819,7 +6593,7 @@ the database was not open for writing.
<anchor name=Gdbm.fetch>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>Gdbm.fetch</tt> - fetch a value from the databse
+<tt>Gdbm.fetch</tt> - fetch a value from the database
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>string fetch(string <I>key</I>);<br>
@@ -6930,11 +6704,11 @@ on the disk.
</section>
</anchor>
<hr noshade size=1>
-<!-- Alla funktioner i denna modul ska ha en "int|void throw_errors">
+
<anchor name=Getopt>
<section title="Getopt">
Getopt is a group of function which can be used to find command line options.
-Command line options come in two flavours: long and short. The short ones
+Command line options come in two flavors: long and short. The short ones
consists of a dash followed by a character (<tt>-t</tt>), the long ones
consist of two dashes followed by a string of text (<tt>--test</tt>).
The short options can also be combined, which means that you can write
@@ -6951,9 +6725,10 @@ with an argument you write <tt>-t <i>argument</i></tt> or <tt>-t<i>argument</i><
<dt><encaps>SYNTAX</encaps><dd>
<tt><p>mixed find_option(array(string) <i>argv</i>,<br>
<dl><dt><dd>string <i>shortform</i>,<br>
-string <i>longform</i>,<br><!-- Det ska väl vara void| på dessa???>
-string <i>envvar</i>,<br>
-mixed <i>def</i>);<br>
+void|string <i>longform</i>,<br>
+void|string <i>envvar</i>,<br>
+void|mixed <i>def</i>,<br>
+void|int <i>throw_errors</i>);<br>
</dl></tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
@@ -6981,18 +6756,22 @@ This function reads options even if they are written after the first
non-option on the line.
<p>
<dt><encaps>EXAMPLE</encaps><dd>
-<tt>int main(int argc, array(string) argv)<br>
-{<br>
-<dl><dt><dd>if(find_option(argv,"f","foo"))<br>
-<dl><dt><dd>werror("The FOO option was given.\n");<br>
-</dl></dl>
-<p><dl><dt><dd>werror("The BAR option got the "+<br>
-find_option(argv,"b","bar","BAR_OPTION","default")+<br>
-" argument.\n");<br>
-</dl>}<br>
-</tt>
+This program tests two different options. One is called <tt>-f</tt> or
+<tt>-foo</tt> and the other is called <tt>-b</tt> or <tt>--bar</tt> and
+can also be given by using the <tt>BAR_OPTION</tt> environment variable.
+
+<example language=pike>
+int main(int argc, array(string) argv)<br>
+{
+ if(find_option(argv,"f","foo"))
+ werror("The FOO option was given.\n");
+
+ werror("The BAR option got the "+
+ find_option(argv,"b","bar","BAR_OPTION","default")+
+ " argument.\n");
+}
+</example>
<p>
-<!-- Förklara kort vad programmet ovan gör>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=Getopt.get_args>Getopt.get_args</link>
<p>
@@ -7005,11 +6784,11 @@ find_option(argv,"b","bar","BAR_OPTION","default")+<br>
<tt>Getopt.find_all_options</tt> - find command line options
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt><p>mixed * find_all_options(array(string) <i>argv</i>, mixed *<i>option</i>, int|void <i>posix_me_harder</i>);<br>
+<tt><p>array find_all_options(array(string) <i>argv</i>, array <i>option</i>, int|void <i>posix_me_harder</i>, int|void <i>throw_errors</i>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function does the job of serveral calls to <tt>find_option</tt>.
+This function does the job of several calls to <tt>find_option</tt>.
The main advantage of this is that it allows it to handle the
POSIX_ME_HARDER environment variable better. When the either
the argument <i>posix_me_harder</i> or the environment variable
@@ -7040,7 +6819,7 @@ Only the first three elements has to be included.
argument, such as <tt>--version</tt>. MAY_HAVE_ARG should be used
for options that may or may not need an argument.
<dt> <i>aliases</i>
-<dd> This is a string or a list of string <!-- Ska väl vara an array of strings> of options that will be looked for.
+<dd> This is a string or an array of string of options that will be looked for.
Short and long options can be mixed, and short options can be
combined into one string. Note that you must include the dashes
in <i>aliases</i> so find_all_options can distinguish between
@@ -7070,7 +6849,7 @@ value given to it from the argument, environment variable or <i>default</i>.
If no default is given, <i>value</i> will be 1.
<p>
<dt><encaps>NOTA BENE</encaps><dd>
-find_option modifies argv.<br> <!-- Vad gäller find_all_options???>
+find_all_options modifies argv.<br>
<p>
<dt><encaps>EXAMPLE</encaps><dd>
First let's take a look at input and output:
@@ -7110,7 +6889,7 @@ int main(int argc, array(string) argv
</example>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Getopt.get_args>Getopt.get_args</link></tt>
+<link to=Getopt.get_args>Getopt.get_args</link>
<p>
</dl>
</anchor>
@@ -7121,7 +6900,7 @@ int main(int argc, array(string) argv
<tt>Getopt.get_args</tt> - get the non-option arguments
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>array(string) get_args(array(string) <I>argv</I>);<br>
+<tt>array(string) get_args(array(string) <I>argv</I>,void|int <i>throw_errors</i>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
@@ -7144,7 +6923,7 @@ werror("The arguments are: "+(argv*" ")+".\n");<br>
</tt>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Getopt.find_option>Getopt.find_option</link></tt>
+<link to=Getopt.find_option>Getopt.find_option</link>
<p>
</dl>
@@ -7179,7 +6958,7 @@ This program is only available if libz was available and found when
Pike was compiled.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Gz.inflate>Gz.inflate</link></tt>
+<link to=Gz.inflate>Gz.inflate</link>
<p>
</dl>
@@ -7197,9 +6976,9 @@ object(Gz.deflate) Gz.deflate(int X)<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This functionion is called when a new Gz.deflate is created.
+This function is called when a new Gz.deflate is created.
If given, X should be a number from 0 to 9 indicating the packing /
-cpu ratio. Zero means no packing, 2-3 is considered 'fast', 6 is
+CPU ratio. Zero means no packing, 2-3 is considered 'fast', 6 is
default and higher is considered 'slow' but gives better packing.
<p>This function can also be used to re-initialize a Gz.deflate object
so it can be re-used.
@@ -7219,7 +6998,7 @@ so it can be re-used.
<dt><encaps>DESCRIPTION</encaps><dd>
This function performs gzip style compression on a string and
returns the packed data. Streaming can be done by calling this
-functon several times and concatenating the returned data.
+function several times and concatenating the returned data.
The optional 'flush' argument should be one f the following:
<p>
<table border=0 cellpadding=0 cellspacing=0>
@@ -7234,7 +7013,7 @@ used until the end of the data when FINISH should be used. For
interactive data PARTIAL_FLUSH should be used.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Gz.inflate.inflate>Gz.inflate->inflate</link></tt>
+<link to=Gz.inflate.inflate>Gz.inflate->inflate</link>
<p>
</dl>
@@ -7254,7 +7033,7 @@ This program is only available if libz was available and found when
Pike was compiled.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Gz.deflate>Gz.deflate</link></tt>
+<link to=Gz.deflate>Gz.deflate</link>
<p>
</dl>
@@ -7272,7 +7051,7 @@ object(Gz.inflate) Gz.inflate()<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This functionion is called when a new Gz.inflate is created.
+This function is called when a new Gz.inflate is created.
It can also be called after the object has been used to re-initialize
it.
<p>
@@ -7305,7 +7084,7 @@ while(string s=stdin->read(8192))<br>
</dl></tt>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Gz.deflate.deflate>Gz.deflate->deflate</link></tt>
+<link to=Gz.deflate.deflate>Gz.deflate->deflate</link>
<p>
</dl>
@@ -7351,7 +7130,7 @@ Returns the default yp-domain.
This creates a new YpDomain object.
<p>
If there is no YP server available for the domain, this
-functioncall will block until there is one. If no server apperars
+function call will block until there is one. If no server appears
in about ten minutes or so, an error will be returned. The timeout
is not configurable from the C interface to Yp either.
<p>
@@ -7402,9 +7181,7 @@ write(dom->match("passwd.byname", "root"));
</example>
</dl>
</anchor>
-
<hr noshade size=1>
-
<anchor name=Yp.YpDomain.all>
<dl>
<dt><encaps>NAME</encaps><dd>
@@ -7433,14 +7210,13 @@ write(dom->match("passwd.byname", "root"));
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
For each entry in 'map', call the function(s) specified by 'over'.
- Over will get two arguments, the first beeing the key, and the
+ Over will get two arguments, the first being the key, and the
second the value. <i>map</i> is the YP-map to search in.
This must be the full map name, as an
example, passwd.byname instead of just passwd.
<p>
</dl>
</anchor>
-
<hr noshade size=1>
<anchor name=Yp.YpDomain.server>
<dl>
@@ -7451,24 +7227,23 @@ write(dom->match("passwd.byname", "root"));
<tt>string server(string <i>map</i>)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
- Returns the hostname of the server serving the map 'map'. <i>map</i>
+ Returns the hostname of the server serving the map <i>map</i>. <i>map</i>
is the YP-map to search in. This must be the full map name, as an
example, passwd.byname instead of just passwd.
<p>
</dl>
</anchor>
<hr noshade size=1>
-
<anchor name=Yp.YpDomain.order>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>Yp.YpDomain->order</tt> - get the'order' for specified map
+<tt>Yp.YpDomain->order</tt> - get the 'order' for specified map
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>int order(string <i>map</i>)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
- Returns the 'order' number for the map map. This is usually a
+ Returns the 'order' number for the map <i>map</i>. This is usually a
time_t (see the global function time()). When the map is changed, this number
will change as well. <i>map</i> is
the YP-map to search in. This must be the full map name, as an
@@ -7488,18 +7263,17 @@ write(dom->match("passwd.byname", "root"));
This creates a new YpMap object.
<p>
If there is no YP server available for the domain, this
- functioncall will block until there is one. If no server appears
+ function call will block until there is one. If no server appears
in about ten minutes or so, an error will be returned. The timeout
is not configurable from the C-yp interface either. <i>map</i> is
the YP-map to bind to. This must be the full map name, as an
example, passwd.byname instead of just passwd.
If no domain is specified, the
- default domain will be used. This is usualy best.
+ default domain will be used. This is usually best.
<p>
</dl>
</anchor>
<hr noshade size=1>
-
<anchor name=Yp.YpMap.match>
<dl>
<dt><encaps>NAME</encaps><dd>
@@ -7513,10 +7287,9 @@ or<br>
<dt><encaps>DESCRIPTION</encaps><dd>
Search for the key <i>key</i>. If there is no <i>key</i> in the map, 0
will be returned, otherwise the string matching the key will
- be returned.
+ be returned.
<i>key</i> must match exactly, no pattern
matching of any kind is done.
-<!-- Jag skrev om stycket ovan lite. Checka!>
</dl>
</anchor>
<hr noshade size=1>
@@ -7553,6 +7326,7 @@ or<br>
</anchor>
<hr noshade size=1>
+
<anchor name=Yp.YpMap.server>
<dl>
<dt><encaps>NAME</encaps><dd>
@@ -7619,7 +7393,7 @@ array(string) values(<i>Yp.Ypmap</i>)
<p>
<hr noshade size=1>
Here is an example program using the Yp module, it lists users and
-their GCOS field from the Yp map "passwd.byname" if your system uses
+their GECOS field from the Yp map "passwd.byname" if your system uses
Yp.
<example language=pike>
@@ -7682,23 +7456,23 @@ allow transport over non 8bit clean channels
</ul>
</dl>
-The MIME module can extract and analyze these two entitites from a stream
+The MIME module can extract and analyze these two entities from a stream
of bytes. It can also recreate such a stream from these entities.
To encapsulate the headers and body entities, the class MIME.Message is
used. An object of this class holds all the headers as a mapping from
string to string, and it is possible to obtain the body data in either
raw or encoded form as a string. Common attributes such as message type and
-text charset are also extracted into separate variables for easy access.
+text char set are also extracted into separate variables for easy access.
<p>
The Message class does not make any interpretation of the body data, unless
the content type is <tt>multipart</tt>. A multipart message contains several
individual messages separated by boundary strings. The <tt>create</tt>
method of the Message class will divide a multipart body on these boundaries,
-and then create individial Message objects for each part. These objects
-will be collecte in the array <tt>body_parts</tt> within the original
+and then create individual Message objects for each part. These objects
+will be collected in the array <tt>body_parts</tt> within the original
Message object. If any of the new Message objects have a body of type
-multpart, the process is of course repeated recursively. The following
+multipart, the process is of course repeated recursively. The following
figure illustrates a multipart message containing three parts, one of
which contains plain text, one containing a graphical image, and the third
containing raw uninterpreted data:
@@ -7732,7 +7506,7 @@ The encoding can be any of
The encoding string is not case sensitive.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.encode>MIME.encode</link></tt>
+<link to=MIME.encode>MIME.encode</link>
<p>
</dl>
</anchor>
@@ -7751,7 +7525,7 @@ The encoding string is not case sensitive.
This function decodes data encoded using the <tt>base64</tt> transfer encoding.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.encode_base64>MIME.encode_base64</link></tt>
+<link to=MIME.encode_base64>MIME.encode_base64</link>
<p>
</dl>
</anchor>
@@ -7771,7 +7545,7 @@ This function decodes data encoded using the <tt>quoted-printable</tt>
(a.k.a. quoted-unreadable) transfer encoding.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.encode_qp>MIME.encode_qp</link></tt>
+<link to=MIME.encode_qp>MIME.encode_qp</link>
<p>
</dl>
</anchor>
@@ -7791,7 +7565,7 @@ This function decodes data encoded using the <tt>x-uue</tt> transfer encoding.
It can also be used to decode generic UUEncoded files.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.encode_uue>MIME.encode_uue</link></tt>
+<link to=MIME.encode_uue>MIME.encode_uue</link>
<p>
</dl>
</anchor>
@@ -7800,7 +7574,7 @@ It can also be used to decode generic UUEncoded files.
<anchor name=MIME.decode_word>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>MIME.decode_word</tt> - Descramble RFC1522 encoding
+<tt>MIME.decode_word</tt> - De-scramble RFC1522 encoding
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>array(string) decode_word(string <i>word</i>);<br>
@@ -7811,7 +7585,7 @@ Extracts the textual content and character set from an <i>encoded word</i>
as specified by RFC1522. The result is an array where the first element
is the raw text, and the second element the name of the character set.
If the input string is not an encoded word, the result is still an array,
-but the charset element will be set to 0. Note that this function can only
+but the char set element will be set to 0. Note that this function can only
be applied to individual encoded words.
<p>
<dt><encaps>EXAMPLES</encaps><dd>
@@ -7835,7 +7609,7 @@ Result: ({ /* 3 elements */
</pre>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.encode_word>MIME.encode_word</link></tt>
+<link to=MIME.encode_word>MIME.encode_word</link>
<p>
</dl>
</anchor>
@@ -7869,7 +7643,7 @@ as <i>no_linebreaks</i>, the result string will not contain any linebreaks
(base64 and quoted-printable only).
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.decode>MIME.decode</link></tt>
+<link to=MIME.decode>MIME.decode</link>
<p>
</dl>
</anchor>
@@ -7890,7 +7664,7 @@ If a nonzero value is passed as <i>no_linebreaks</i>, the result string
will not contain any linebreaks.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.decode_base64>MIME.decode_base64</link></tt>
+<link to=MIME.decode_base64>MIME.decode_base64</link>
<p>
</dl>
</anchor>
@@ -7912,7 +7686,7 @@ This function encodes data using the <tt>quoted-printable</tt>
excuse for using it.</strong>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.decode_qp>MIME.decode_qp</link></tt>
+<link to=MIME.decode_qp>MIME.decode_qp</link>
<p>
</dl>
</anchor>
@@ -7935,7 +7709,7 @@ in the encoded data, for extraction purposes.
This function can also be used to produce generic UUEncoded files.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.decode_uue>MIME.decode_uue</link></tt>
+<link to=MIME.decode_uue>MIME.decode_uue</link>
<p>
</dl>
</anchor>
@@ -7952,10 +7726,10 @@ This function can also be used to produce generic UUEncoded files.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Create an <i>encoded word</i> as specified in RFC1522 from an array containing
-a raw text string and a charset name. The text will be transfer encoded
+a raw text string and a char set name. The text will be transfer encoded
according to the encoding argument, which can be either <tt>"base64"</tt> or
<tt>"quoted-printable"</tt> (or either <tt>"b"</tt> or <tt>"q"</tt> for
-short). If either the second element of the array (the charset name), or
+short). If either the second element of the array (the char set name), or
the encoding argument is 0, the raw text is returned as is.
<p>
<dt><encaps>EXAMPLES</encaps><dd>
@@ -7967,7 +7741,7 @@ Result: Foo
</pre>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.decode_word>MIME.decode_word</link></tt>
+<link to=MIME.decode_word>MIME.decode_word</link>
<p>
</dl>
</anchor>
@@ -8043,11 +7817,11 @@ Result: attachment;filename="/usr/dict/words"
</pre>
<p>
<dt><encaps>NOTA BENE</encaps><dd>
-There is no way to constuct a domain-literal using this function.
+There is no way to construct a domain-literal using this function.
Neither can it be used to produce comments.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.tokenize>MIME.tokenize</link></tt>
+<link to=MIME.tokenize>MIME.tokenize</link>
<p>
</dl>
</anchor>
@@ -8085,7 +7859,7 @@ many, -1 is returned.
</ul>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.is_partial>MIME.Message->is_partial</link></tt>
+<link to=MIME.Message.is_partial>MIME.Message->is_partial</link>
<p>
</dl>
</anchor>
@@ -8141,7 +7915,7 @@ The set of special-characters is the one specified in RFC1521 (i.e. <tt>"<",
specified in RFC822.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.quote>MIME.quote</link></tt>
+<link to=MIME.quote>MIME.quote</link>
<p>
</dl>
</anchor>
@@ -8158,7 +7932,7 @@ This class is used to hold a decoded MIME message.
<anchor name=MIME.Message.body_parts>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>MIME.Message->body_parts</tt> - Multipart submessages
+<tt>MIME.Message->body_parts</tt> - Multipart sub-messages
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>array(object) msg->body_parts;<br>
@@ -8170,8 +7944,8 @@ Message object for each part of the message. If the message is not a
multipart, this field is <tt>0</tt>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.type>MIME.Message->type</link></tt>,
-<tt><link to=MIME.Message.boundary>MIME.Message->boundary</link></tt>
+<link to=MIME.Message.type>MIME.Message->type</link>,
+<link to=MIME.Message.boundary>MIME.Message->boundary</link>
<p>
</dl>
</anchor>
@@ -8180,7 +7954,7 @@ multipart, this field is <tt>0</tt>.
<anchor name=MIME.Message.boundary>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>MIME.mesage->boundary</tt> - Boundary string for multipart messages
+<tt>MIME.message->boundary</tt> - Boundary string for multipart messages
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>string msg->boundary;<br>
@@ -8193,7 +7967,7 @@ are handled internally by the module, you should not need to access this
field.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setboundary>MIME.Message->setboundary</link></tt>
+<link to=MIME.Message.setboundary>MIME.Message->setboundary</link>
<p>
</dl>
</anchor>
@@ -8215,7 +7989,7 @@ type text. If there is no <tt>Content-Type</tt> header, the value of this
field is <tt>"us-ascii"</tt>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.type>MIME.Message->type</link></tt>
+<link to=MIME.Message.type>MIME.Message->type</link>
<p>
</dl>
</anchor>
@@ -8246,7 +8020,7 @@ field is <tt>0</tt>.
<tt>MIME.Message->disp_params</tt> - Content-Disposition parameters
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>array(string:string) <!-- mapping ska det väl vara?>msg->disp_params;<br>
+<tt>mapping(string:string) msg->disp_params;<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
@@ -8254,8 +8028,8 @@ A mapping containing all the additional parameters to the
<tt>Content-Disposition</tt> header.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setdisp_param>MIME.Message->setdisp_param</link></tt>,
-<tt><link to=MIME.Message.get_filename>MIME.Message->get_filename</link></tt>
+<link to=MIME.Message.setdisp_param>MIME.Message->setdisp_param</link>,
+<link to=MIME.Message.get_filename>MIME.Message->get_filename</link>
<p>
</dl>
</anchor>
@@ -8286,19 +8060,19 @@ The contents of these fields can be accessed and/or modified through a set
of variables and methods available for this purpose.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.type>MIME.Message->type</link></tt>,
-<tt><link to=MIME.Message.subtype>MIME.Message->subtype</link></tt>,
-<tt><link to=MIME.Message.charset>MIME.Message->charset</link></tt>,
-<tt><link to=MIME.Message.boundary>MIME.Message->boundary</link></tt>,
-<tt><link to=MIME.Message.transfer_encoding>MIME.Message->transfer_encoding</link></tt>,
-<tt><link to=MIME.Message.params>MIME.Message->params</link></tt>,
-<tt><link to=MIME.Message.disposition>MIME.Message->disposition</link></tt>,
-<tt><link to=MIME.Message.disp_params>MIME.Message->disp_params</link></tt>,
-<tt><link to=MIME.Message.setencoding>MIME.Message->setencoding</link></tt>,
-<tt><link to=MIME.Message.setparam>MIME.Message->setparam</link></tt>,
-<tt><link to=MIME.Message.setdisp_param>MIME.Message->setdisp_param</link></tt>,
-<tt><link to=MIME.Message.setcharset>MIME.Message->setcharset</link></tt>,
-<tt><link to=MIME.Message.setboundary>MIME.Message->setboundary</link></tt>
+<link to=MIME.Message.type>MIME.Message->type</link>,
+<link to=MIME.Message.subtype>MIME.Message->subtype</link>,
+<link to=MIME.Message.charset>MIME.Message->charset</link>,
+<link to=MIME.Message.boundary>MIME.Message->boundary</link>,
+<link to=MIME.Message.transfer_encoding>MIME.Message->transfer_encoding</link>,
+<link to=MIME.Message.params>MIME.Message->params</link>,
+<link to=MIME.Message.disposition>MIME.Message->disposition</link>,
+<link to=MIME.Message.disp_params>MIME.Message->disp_params</link>,
+<link to=MIME.Message.setencoding>MIME.Message->setencoding</link>,
+<link to=MIME.Message.setparam>MIME.Message->setparam</link>,
+<link to=MIME.Message.setdisp_param>MIME.Message->setdisp_param</link>,
+<link to=MIME.Message.setcharset>MIME.Message->setcharset</link>,
+<link to=MIME.Message.setboundary>MIME.Message->setboundary</link>
<p>
</dl>
</anchor>
@@ -8319,9 +8093,9 @@ A mapping containing all the additional parameters to the
own, which should be accessed instead of this mapping wherever applicable.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.charset>MIME.Message->charset</link></tt>,
-<tt><link to=MIME.Message.boundary>MIME.Message->boundary</link></tt>,
-<tt><link to=MIME.Message.setparam>MIME.Message->setparam</link></tt>
+<link to=MIME.Message.charset>MIME.Message->charset</link>,
+<link to=MIME.Message.boundary>MIME.Message->boundary</link>,
+<link to=MIME.Message.setparam>MIME.Message->setparam</link>
<p>
</dl>
</anchor>
@@ -8343,8 +8117,8 @@ header. If there is no <tt>Content-Type</tt> header, the value of this field
is <tt>"plain"</tt>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.type>MIME.Message->type</link></tt>,
-<tt><link to=MIME.Message.params>MIME.Message->params</link></tt>
+<link to=MIME.Message.type>MIME.Message->type</link>,
+<link to=MIME.Message.params>MIME.Message->params</link>
<p>
</dl>
</anchor>
@@ -8362,12 +8136,12 @@ is <tt>"plain"</tt>.
<dt><encaps>DESCRIPTION</encaps><dd>
The contents of the <tt>Content-Transfer-Encoding</tt> header. If no
<tt>Content-Transfer-Encoding</tt> header is given, this field is <tt>0</tt>.
-Transfer encoding and decoding is done transparantly by the module, so this
-field should be intrerresting only to applications wishing to do autoconversion
+Transfer encoding and decoding is done transparently by the module, so this
+field should be interesting only to applications wishing to do auto conversion
of certain transfer encodings.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setencoding>MIME.Message->setencoding</link></tt>
+<link to=MIME.Message.setencoding>MIME.Message->setencoding</link>
<p>
</dl>
</anchor>
@@ -8389,8 +8163,8 @@ header. If there is no <tt>Content-Type</tt> header, the value of this field
is <tt>"text"</tt>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.subtype>MIME.Message->subtype</link></tt>,
-<tt><link to=MIME.Message.params>MIME.Message->params</link></tt>
+<link to=MIME.Message.subtype>MIME.Message->subtype</link>,
+<link to=MIME.Message.params>MIME.Message->params</link>
<p>
</dl>
</anchor>
@@ -8435,7 +8209,7 @@ SGVsbG8sIHdvcmxkIQ==
</pre>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.create>MIME.Message->create</link></tt>
+<link to=MIME.Message.create>MIME.Message->create</link>
<p>
</dl>
</anchor>
@@ -8482,7 +8256,7 @@ Result: iso-8859-1
</pre>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Messag.cast>MIME.Message->cast</link></tt>
+<link to=MIME.Message.cast>MIME.Message->cast</link>
<p>
</dl>
</anchor>
@@ -8503,7 +8277,7 @@ This method returns the raw data of the message body entity. The
indicate how this data should be interpreted.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.getencoded>MIME.Message->getencoded</link></tt>
+<link to=MIME.Message.getencoded>MIME.Message->getencoded</link>
<p>
</dl>
</anchor>
@@ -8523,7 +8297,7 @@ This method returns the data of the message body entity, encoded using the
current transfer encoding. You should never have to call this function.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.getdata>MIME.Message->getdata</link></tt>
+<link to=MIME.Message.getdata>MIME.Message->getdata</link>
<p>
</dl>
</anchor>
@@ -8539,7 +8313,7 @@ current transfer encoding. You should never have to call this function.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This method tries to find a suitable filename should <!-- Parse error! Skriv om!>you want to save the
+This method tries to find a suitable filename should you want to save the
body data to disk. It will examine the <tt>filename</tt> attribute of the
<tt>Content-Disposition</tt> header, and failing that the <tt>name</tt>
attribute of the <tt>Content-Type</tt> header. If neither attribute is set,
@@ -8575,7 +8349,7 @@ was not available. If this method is called in a message that is not
a part of a fragmented message, it will return 0.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.reconstruct_partial>MIME.reconstruct_partial</link></tt>
+<link to=MIME.reconstruct_partial>MIME.reconstruct_partial</link>
<p>
</dl>
</anchor>
@@ -8596,7 +8370,7 @@ This is equivalent of calling
<tt>msg->setparam("boundary", <i>boundary</i>)</tt>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setparam>MIME.Message->setparam</link></tt>
+<link to=MIME.Message.setparam>MIME.Message->setparam</link>
<p>
</dl>
</anchor>
@@ -8617,7 +8391,7 @@ This is equivalent of calling
<tt>msg->setparam("charset", <i>charset</i>)</tt>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setparam>MIME.Message->setparam</link></tt>
+<link to=MIME.Message.setparam>MIME.Message->setparam</link>
<p>
</dl>
</anchor>
@@ -8639,7 +8413,7 @@ The new data should comply to the format indicated by the
Do not use this method unless you know what you are doing.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.getdata>MIME.Message->getdata</link></tt>
+<link to=MIME.Message.getdata>MIME.Message->getdata</link>
<p>
</dl>
</anchor>
@@ -8661,8 +8435,8 @@ the <tt>Content-Disposition</tt> header directly, please use this
function instead.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setparam>MIME.Message->setparam</link></tt>,
-<tt><link to=MIME.Message.get_filename>MIME.Message->get_filename</link></tt>
+<link to=MIME.Message.setparam>MIME.Message->setparam</link>,
+<link to=MIME.Message.get_filename>MIME.Message->get_filename</link>
<p>
</dl>
</anchor>
@@ -8679,13 +8453,13 @@ function instead.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Select a new transfer encoding for this message. The
-<tt>Content-Transfer-Encoding</tt> header will be modified accordningly,
+<tt>Content-Transfer-Encoding</tt> header will be modified accordingly,
and subsequent calls to <tt>getencoded</tt> will produce data encoded using
the new encoding. See <link to=MIME.Message.encode>encode</link> for a list of valid
encodings.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.getencoded>MIME.Message->getencoded</link></tt>
+<link to=MIME.Message.getencoded>MIME.Message->getencoded</link>
<p>
</dl>
</anchor>
@@ -8707,9 +8481,9 @@ Common parameters include <tt>charset</tt> for text messages, and
the <tt>Content-Type</tt> header directly, please use this function instead.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=MIME.Message.setcharset>MIME.Message->setcharset</link></tt>,
-<tt><link to=MIME.Message.setboundary>MIME.Message->setboundary</link></tt>,
-<tt><link to=MIME.Message.setdisp_param>MIME.Message->setdisp_param</link></tt>
+<link to=MIME.Message.setcharset>MIME.Message->setcharset</link>,
+<link to=MIME.Message.setboundary>MIME.Message->setboundary</link>,
+<link to=MIME.Message.setdisp_param>MIME.Message->setdisp_param</link>
<p>
</dl>
</anchor>
@@ -8721,7 +8495,7 @@ the <tt>Content-Type</tt> header directly, please use this function instead.
<anchor name=Simulate>
<section title="Simulate">
-This module is used to achive better compatibility with older versions of
+This module is used to achieve better compatibility with older versions of
Pike. It can also be used for convenience, but I would advice against it
since some functions defined here are much slower than using similar
functions in other modules. The purpose of this section in the manual is
@@ -8737,14 +8511,14 @@ modules. In addition, these functions are available:
<anchor name=Simulate.member_array>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>Simulate.member_array</tt> - find the index to the <!-- Här la jag in index osv> first occurance of a value in an array
+<tt>Simulate.member_array</tt> - find first occurrence of a value in an array
<p>
<dt><encaps>SYNTAX</encaps><dd>
<tt>int member_array(mixed <I>item</I>, mixed *<I>arr</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the index of the first occurence of item in array arr.
+Returns the index of the first occurrence of item in array arr.
If not found, then -1 is returned. This is the same as
<tt>search(<i>arr</i>, <i>item</i>)</tt>.
<p>
@@ -8767,7 +8541,7 @@ Returns an object pointer to the object that called current function,
if any.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=backtrace>backtrace</link></tt>
+<link to=backtrace>backtrace</link>
<p>
</dl>
@@ -8789,7 +8563,7 @@ Returns a function pointer to the current function, useful for
making recursive lambda-functions.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=backtrace>backtrace</link></tt>
+<link to=backtrace>backtrace</link>
<p>
</dl>
@@ -8863,7 +8637,7 @@ constant Pi.
This function is the same as all_constants.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=all_constants>all_constants</link></tt>
+<link to=all_constants>all_constants</link>
<p>
</dl>
@@ -8889,33 +8663,7 @@ mixed *filter_array(function *<I>arr</I>,-<I>1</I>,mixed ... <I>args</I>);<br>
Filter array is the same function as Array.filter.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Array.filter>Array.filter</link></tt>
-<p>
-</dl>
-
-</anchor>
-
-<!-- Jag la in "<hr newpage>" här, men varför står .map_array här och inte på M? >
-<hr newpage>
-
-<anchor name=Simulate.map_array>
-<dl>
-<dt><encaps>NAME</encaps><dd>
-<tt>Simulate.map_array</tt> - map an array over a function
-<p>
-<dt><encaps>SYNTAX</encaps><dd>
-<tt>mixed *map_array(mixed *<I>arr</I>,function <I>fun</I>,mixed ... <I>args</I>);<br>
-or<br>
-mixed *map_array(object *<I>arr</I>,string <I>fun</I>,mixed ... <I>args</I>);<br>
-or<br>
-mixed *map_array(function *<I>arr</I>,-<I>1</I>,mixed ... <I>arg</I>);<br>
-</tt>
-<p>
-<dt><encaps>DESCRIPTION</encaps><dd>
-This function is the same as Array.map.
-<p>
-<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Array.map>Array.map</link></tt>
+<link to=Array.filter>Array.filter</link>
<p>
</dl>
@@ -8928,12 +8676,12 @@ This function is the same as Array.map.
<tt>Simulate.implode</tt> - implode an array of strings
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>string implode(array(string) <I>a</I>, string <I>delimeter</I>);<br>
+<tt>string implode(array(string) <I>a</I>, string <I>delimiter</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function is the inverse of explode. It contatenates all the
-strings in a with a delimeter in between each.
+This function is the inverse of explode. It concatenates all the
+strings in a with a delimiter in between each.
<p>This function is the same as multiplication.
<p>
<dt><encaps>EXAMPLES</encaps><dd>
@@ -8945,7 +8693,7 @@ Result: a and b and c<br>
</tt>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=Simulate.simulated_explode.html>Simulate.explode</link></tt>
+<link to=Simulate.explode>Simulate.explode</link>
<p>
</dl>
@@ -8985,7 +8733,7 @@ This function is equal to indices.
This function is equal to sizeof.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sizeof>sizeof</link></tt>
+<link to=sizeof>sizeof</link>
<p>
</dl>
@@ -9005,13 +8753,39 @@ This function is equal to sizeof.
This function is equal to values.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=values>values</link></tt>
+<link to=values>values</link>
<p>
</dl>
</anchor>
+<hr newpage>
+
+<anchor name=Simulate.map_array>
+<dl>
+<dt><encaps>NAME</encaps><dd>
+<tt>Simulate.map_array</tt> - map an array over a function
+<p>
+<dt><encaps>SYNTAX</encaps><dd>
+<tt>mixed *map_array(mixed *<I>arr</I>,function <I>fun</I>,mixed ... <I>args</I>);<br>
+or<br>
+mixed *map_array(object *<I>arr</I>,string <I>fun</I>,mixed ... <I>args</I>);<br>
+or<br>
+mixed *map_array(function *<I>arr</I>,-<I>1</I>,mixed ... <I>arg</I>);<br>
+</tt>
+<p>
+<dt><encaps>DESCRIPTION</encaps><dd>
+This function is the same as Array.map.
+<p>
+<dt><encaps>SEE ALSO</encaps><dd>
+<link to=Array.map>Array.map</link>
+<p>
+</dl>
+</anchor>
<hr newpage>
+
+
+
<anchor name=Simulate.strstr>
<dl>
<dt><encaps>NAME</encaps><dd>
@@ -9022,12 +8796,11 @@ This function is equal to values.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the position of str2 in str1, if str2 can't be found in str1
+Returns the position of <i>str2</i> in <i>str1</i>, if <i>str2</i> can't be found in <i>str1</i>
-1 is returned.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sscanf>sscanf</link> and <link to=Simulate.explode>Simulate.explode</link></tt>
-<!-- Här ska det vara en länk till <tt>search</tt>!>
+<link to=sscanf>sscanf</link>, <link to=Simulate.explode>Simulate.explode</link>, <link to=search>search</link>
<p>
</dl>
@@ -9079,7 +8852,7 @@ void add_efun(string func_name)<br>
This function is the same as add_constant.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=add_constant>Simulate.add_constant</link></tt>
+<link to=add_constant>Simulate.add_constant</link>
<p>
</dl>
</anchor>
@@ -9098,7 +8871,7 @@ This function is the same as add_constant.
This function is equal to sizeof.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sizeof>sizeof</link></tt>
+<link to=sizeof>sizeof</link>
<p>
</dl>
@@ -9117,7 +8890,7 @@ This function is equal to sizeof.
This function is the same as multisetp.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=multisetp>Simulate.multisetp</link></tt>
+<link to=multisetp>Simulate.multisetp</link>
<p>
</dl>
@@ -9146,27 +8919,27 @@ Result: (< /* 3 elements */<br>
</tt>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=aggregage_multiset>aggregate_multiset</link></tt>
+<link to=aggregate_multiset>aggregate_multiset</link>
<p>
</dl>
</anchor>
<hr newpage>
-<anchor name=Simulate.aggregage_list>
+<anchor name=Simulate.aggregate_list>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>Simulate.aggregage_list</tt> - aggregate a multiset
+<tt>Simulate.aggregate_list</tt> - aggregate a multiset
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>multiset aggregage_list(mixed ... <I>args</I>);<br>
+<tt>multiset aggregate_list(mixed ... <I>args</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function is exactly the same as aggregate_multiset.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=aggregage_multiset>aggregate_multiset</link></tt>
+<link to=aggregate_multiset>aggregate_multiset</link>
<p>
</dl>
@@ -9189,15 +8962,14 @@ prints.
<p>
</dl>
-<!-- explode saknas!>
-
</anchor>
</section>
+<!-- Simulate.explode saknas -->
</anchor>
<hr newpage>
-<!-- FIXME priority_queue and heap should be placed inside Structs
+<!-- FIX ME priority_queue and heap should be placed inside Structs
<h2>Structs</h2>
<h2>Msql</h2>
@@ -9209,10 +8981,10 @@ prints.
</chapter>
+<!-- This chapter should be updated from http://www.mirar.org/ -->
+<!-- Until then we might have to remove it -->
<anchor name=Image>
<chapter title="The Image module">
-
-<!-- Hela Image-skiten ska uppdateras från http://www.mirar.org/ >
The Image module is used to manipulate bit-mapped color images.
It can read PPM images and do various manipulations, or it can be
used to create completely new images. The created images can be
@@ -9225,7 +8997,7 @@ and use up all the memory by giving the wrong argument to one
of the scaling functions.
<p>
Most functions in this module work by creating a new Image and then
-returning that instead of chaning the Image you are working with.
+returning that instead of changing the Image you are working with.
This makes it possible to share the same image between many variables
without having to worry that it will be changed by accident. This
can reduce the amount of memory used.
@@ -9248,7 +9020,7 @@ Let's look at an example of how this can be used:
write(image->togif());
}
</example>
-This very simple example can be used as a cgi script to produce a gif image
+This very simple example can be used as a CGI script to produce a gif image
which says what time it is in white text on a black background.
<p>
@@ -9286,7 +9058,7 @@ The main object of the <link to=Image>Image</link> module, this object
<link to=Image.image.paste_alpha_color>Image.image->paste_alpha_color</link>,
<link to=Image.image.paste_mask>Image.image->paste_mask</link>
-<p> getting subimages, scaling, rotating: <link to=Image.image.autocrop>Image.image->autocrop</link>,
+<p> getting sub-images, scaling, rotating: <link to=Image.image.autocrop>Image.image->autocrop</link>,
<link to=Image.image.ccw>Image.image->ccw</link>,
<link to=Image.image.cw>Image.image->cw</link>,
<link to=Image.image.clone>Image.image->clone</link>,
@@ -9312,7 +9084,7 @@ The main object of the <link to=Image>Image</link> module, this object
<link to=Image.image.modify_by_intensity>Image.image->modify_by_intensity</link>,
<link to=Image.image.select_from>Image.image->select_from</link>
-<p> converting to other datatypes: <link to=Image.image.cast>Image.image->cast</link>,
+<p> converting to other data types: <link to=Image.image.cast>Image.image->cast</link>,
<link to=Image.image.fromgif>Image.image->fromgif</link>,
<link to=Image.image.frompnm>Image.image->frompnm</link>/<link to=Image.image.fromppm>Image.image->fromppm</link>,
<link to=Image.image.gif_add>Image.image->gif_add</link>,
@@ -9384,7 +9156,7 @@ object `*(int value)</tt>
Multiplies pixel values and creates a new image.
<p> This can be useful to lower the values of an image,
- making it greyer, for instance:
+ making it grayer, for instance:
<p> <pre>image=image*128+64;</pre>
@@ -9600,7 +9372,7 @@ Applies a pixel-transform matrix, or filter, to the image.
({1, 1,1})})
</pre>
-<p> horisontal edge detect (get the idea):
+<p> horizontal edge detect (get the idea):
<pre>
({({0, 0,0})
({1,-8,1}),
@@ -9639,7 +9411,7 @@ the new image object
<anchor name=Image.image.autocrop>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>autocrop</tt> - Removes "unneccesary" borders around the image<p><dt><encaps>SYNTAX</encaps><dd>
+<tt>autocrop</tt> - Removes "unnecessary" borders around the image<p><dt><encaps>SYNTAX</encaps><dd>
<tt>object autocrop()<br>
object autocrop(int border)<br>
object autocrop(int border, int r, int g, int b)<br>
@@ -9647,10 +9419,10 @@ object autocrop(int border, int left, int right, int top, in
object autocrop(int border, int left, int right, int top, int bottom, int r, int g, int b)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Removes "unneccesary" borders around the image, adds one of
+Removes "unnecessary" borders around the image, adds one of
its own if wanted to, in selected directions.
-<p> "Unneccesary" is all pixels that are equal -- ie if all the same pixels
+<p> "Unnecessary" is all pixels that are equal -- ie if all the same pixels
to the left are the same color, that column of pixels are removed.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
@@ -9665,7 +9437,7 @@ Removes "unneccesary" borders around the image, adds one of
<dt><tt>int top</tt>
<dt><tt>int bottom</tt>
<dd>which borders to scan and cut the image;
- a typical example is removing the top and bottom unneccesary
+ a typical example is removing the top and bottom unnecessary
pixels:
<pre>img=img->autocrop(0, 0,0,1,1);</pre>
@@ -9758,8 +9530,8 @@ the new image object
object change_color(int fromr, int fromg, int fromb, int tor, int tog, int tob)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Changes one color (exakt match) to another.
- If non-exakt-match is preferred, check <link to=Image.image.distancesq>Image.image->distancesq</link>
+Changes one color (exact match) to another.
+ If non-exact-match is preferred, check <link to=Image.image.distancesq>Image.image->distancesq</link>
and <link to=Image.image.paste_alpha_color>Image.image->paste_alpha_color</link>.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
@@ -9790,7 +9562,7 @@ object circle(int x, int y, int rx, int ry, int r, int&
object circle(int x, int y, int rx, int ry, int r, int g, int b, int alpha)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Draws a line on the image. The line is <i>not</i> antialiased.
+Draws a line on the image. The line is <i>not</i> anti-aliased.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
<dt><tt>int x</tt>
@@ -10055,7 +9827,8 @@ Do NOT use this function if you don't know what
<anchor name=Image.image.distancesq>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>distancesq</tt> - Makes a grey-scale image for alpha-channel use<p><dt><encaps>SYNTAX</encaps><dd>
+<tt>distancesq</tt> - Makes a grey-scale image for alpha-channel use
+<p><dt><encaps>SYNTAX</encaps><dd>
<tt>object distancesq()<br>
object distancesq(int r, int g, int b)</tt>
<p>
@@ -10065,7 +9838,7 @@ Makes a grey-scale image, for alpha-channel use.
The given value (or current color) are used for coordinates
in the color cube. Each resulting pixel is the
distance from this point to the source pixel color,
- in the color cube, squared, rightshifted 8 steps:
+ in the color cube, squared, right-shifted 8 steps:
<p> <pre>
p = pixel color
@@ -10218,7 +9991,7 @@ string gif_add_fs_nomap(int x, int y, array(array(int)) colors, f
Makes a GIF (sub)image data chunk, to be placed
at the given position.
-<p> The "fs" versions uses floyd-steinberg dithering, and the "nomap"
+<p> The "fs" versions uses Floyd-Steinberg dithering, and the "nomap"
versions have no local colormap.
<p> Example:
@@ -10237,7 +10010,7 @@ Makes a GIF (sub)image data chunk, to be placed
<dt><encaps>ARGUMENTS</encaps><dd><dl>
<dt><tt>int x</tt>
<dt><tt>int y</tt>
- <dd>the location of this subimage
+ <dd>the location of this sub-image
<dt><tt>int delay_cs</tt>
<dd>frame delay in centiseconds
<dt><tt>float delay_s</tt>
@@ -10254,7 +10027,7 @@ the GIF data chunk as a string
<dt><encaps>NOTE</encaps>
<dd>
I (Mirar) recommend reading about the GIF file format before
- experementing with these.
+ experimenting with these.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=Image.image.gif_add>Image.image->gif_add</link>, <link to=Image.image.gif_end>Image.image->gif_end</link>, <link to=Image.image.gif_netscape_loop>Image.image->gif_netscape_loop</link> and <link to=Image.image.togif */>Image.image->togif */</link>
@@ -10395,7 +10168,7 @@ object line(int x1, int y1, int x2, int y2, int r, int&
object line(int x1, int y1, int x2, int y2, int r, int g, int b, int alpha)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Draws a line on the image. The line is <i>not</i> antialiased.
+Draws a line on the image. The line is <i>not</i> anti-aliased.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
<dt><tt>int x1</tt>
@@ -10517,7 +10290,7 @@ Maps all pixel colors to the colors given.
over the colors given, selecting the nearest in the
color cube. Slow...
-<p> Floyd-steinberg error correction is added to create
+<p> Floyd-Steinberg error correction is added to create
a better-looking image, in many cases, anyway.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
@@ -10575,12 +10348,12 @@ mirrors an image:
<anchor name=Image.image.modify_by_intensity>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>modify_by_intensity</tt> - Recolor an image from intensity values
+<tt>modify_by_intensity</tt> - Re-color an image from intensity values
<p><dt><encaps>SYNTAX</encaps><dd>
<tt>object modify_by_intensity(int r, int g, int b, int|array(int) v1, ..., int|array(int) vn)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Recolor an image from intensity values.
+Re-color an image from intensity values.
<p> For each color an intensity is calculated, from r, g and b factors
(see <link to=Image.image.grey>Image.image->grey</link>), this gives a value between 0 and max.
@@ -10773,7 +10546,7 @@ fills an area with the current color
</dl><p>
<dt><encaps>NOTE</encaps><dd>
-This function is new (april-97) and rather untested.
+This function is new (April-97) and rather untested.
<p>
<dt><encaps>RETURNS</encaps><dd>
@@ -10892,11 +10665,11 @@ object select_from(int x, int y, int edge_value)</tt>
<dt><encaps>DESCRIPTION</encaps><dd>
Makes a grey-scale image, for alpha-channel use.
- This is very close to a floodfill.
+ This is very close to a flood fill.
The image is scanned from the given pixel,
filled with 255 if the color is the same,
- or 255 minus distance in the colorcube, squared, rightshifted
+ or 255 minus distance in the colorcube, squared, right-shifted
8 steps (see <link to=Image.image.distancesq>Image.image->distancesq</link>).
<p> When the edge distance is reached, the scan is stopped.
@@ -11078,7 +10851,7 @@ string to8bit_closest(array(array(int)) colors)</tt>
Maps the image to the given colors and returns
the 8 bit data.
-<p> to8bit_fs uses floyd-steinberg dithering
+<p> to8bit_fs uses Floyd-Steinberg dithering
</p>
<dt><encaps>RETURNS</encaps><dd>
the calculated string
@@ -11109,7 +10882,7 @@ string to8bit_rgbcube_rdither(int red, int green, int blue, strin
Maps the image into a colorcube with the given
dimensions. Red is least significant, blue is most.
-<p> The "rdither" type of method uses a random dither algoritm.
+<p> The "rdither" type of method uses a random dither algorithm.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
<dt><tt>int red</tt>
@@ -11181,8 +10954,8 @@ string togif_fs(int num_colors, int trans_r, int trans_g, int&nbs
string togif_fs(array(array(int)) colors, int trans_r, int trans_g, int trans_b)</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Makes GIF data. The togif_fs variant uses floyd-steinberg
- dithereing.
+Makes GIF data. The togif_fs variant uses Floyd-Steinberg
+ dithering.
</p>
<dt><encaps>ARGUMENTS</encaps><dd><dl>
<dt><tt>int num_colors</tt>
@@ -11209,7 +10982,7 @@ the GIF data
<anchor name=Image.image.toppm>
<dl>
<dt><encaps>NAME</encaps><dd>
-<tt>toppm</tt> - Returns PPM (P6, binary pixmap) data from the Image
+<tt>toppm</tt> - Return PPM (P6, binary pixmap) data from the Image
<p><dt><encaps>SYNTAX</encaps><dd>
<tt>string toppm()</tt>
<p>
@@ -11290,7 +11063,7 @@ Draws a filled rectangle with colors (and alpha values) tuned
<pre>
({x1y1,x2y1,x1y2,x2y2})
</pre>
- each of these is an array of integeres:
+ each of these is an array of integers:
<pre>
({r,g,b}) or ({r,g,b,alpha})
</pre>
@@ -11525,7 +11298,7 @@ what it can do:
<dt><encaps>DESCRIPTION</encaps><dd>
This directive is in effect a comment statement, since the
preprocessor will ignore everything to the end of the line.
-This is used to write unix type scripts in Pike by starting
+This is used to write Unix type scripts in Pike by starting
the script with
<p>#!/usr/local/bin/pike
@@ -11543,12 +11316,12 @@ the script with
The simplest way to use define is to write
<p><dl><dt><dd>#define <identifier> <replacement string><br>
</dl>
-<p>which will cause all subsequent occurances of 'identifier' to be
+<p>which will cause all subsequent occurrences of 'identifier' to be
replaced with the replacement string.
<p>Define also has the capability to use arguments, thus a line like
<p><dl><dt><dd>#define <identifier>(arg1, arg2) <replacement string><br>
</dl>
-<p>would cause identifier to be a macro. All occurances of
+<p>would cause identifier to be a macro. All occurrences of
'identifier(something1,something2d)' would be replaced with
the replacement string. And in the replacement string, arg1 and arg2
will be replaced with something1 and something2.
@@ -11583,7 +11356,7 @@ int main()
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This removes the effect of a #define, all subsequent occurances of
+This removes the effect of a #define, all subsequent occurrences of
the undefined identifier will not be replaced by anything. Note that
when undefining a macro, you just give the identifier, not the
arguments.
@@ -11619,17 +11392,18 @@ the expression after the #if directive. That is, if the expression
is true, the code up to the next #else, #elif, #elseif or #endif is
compiled. If the expression is false, that code will be skipped.
If the skip leads up to a #else, the code after the else will be
-compiled. #elif and #elseif are equivialent and causes the code that
+compiled. #elif and #elseif are equivalent and causes the code that
follow them to be compiled if the previous #if or #elif evaluated
false and the expression after the #elif evaluates true.
<p>Expressions given to #if, #elif or #endif are special, all identifiers
evaluate to zero unless they are defined to something else. Integers,
strings and floats are the only types that can be used, but all pike
operators can be used on these types.
-<p>Also, two special functions can be used, defined() <!-- Ska detta skrivas med <tt> eller något annat?> and constant().
-defined(<identifier>) expands to '1' if the identifier is defined,
-'0' otherwise. constant(<identifier>) expands to '1' if identifier is
-an predefined constant (with add_constant) and '0' otherwise.
+<p>
+Also, two special functions can be used, <tt>defined()</tt> and <tt>constant()</tt>.
+<tt>defined(<i>identifier</i>)</tt> expands to 1 if <i>identifier</i> is defined and
+0 otherwise. <tt>constant(<i>identifier</i>)</tt> expands to 1 if <i>identifier</i> is
+an predefined constant (with add_constant), 0 otherwise.
<p>
<dt><encaps>EXAMPLES</encaps><dd>
<tt>#if 1<br>
@@ -11762,15 +11536,14 @@ They are listed in alphabetical order.
This function is mostly intended for debugging. It delivers a mapping
with information about how many arrays/mappings/strings etc. there
are currently allocated and how much memory they use. Try evaluating
-the function in hilfe to see precisly what it returns.
+the function in hilfe to see precisely what it returns.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=_verify_internals>_verify_internals</link></tt>
+<link to=_verify_internals>_verify_internals</link>
<p>
</dl>
</anchor>
-
<HR NEWPAGE>
<anchor name=_next>
<dl>
@@ -11782,12 +11555,13 @@ the function in hilfe to see precisly what it returns.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns the 'next' object/array/mapping/string/etc
-in the linked list<!-- Vilken länkad lista. Jag fattade det inte när jag läste detta första gången.>. It is mainly meant for debugging Pike but
+All objects, arrays, mappings, multisets, programs and strings are stored in linked lists
+inside Pike. This function returns the next object/array/mapping/string/etc
+in the linked list. It is mainly meant for debugging Pike but
can also be used to control memory usage.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=next_object>next_object</link> and <link to=_prev>_prev</link></tt>
+<link to=next_object>next_object</link> and <link to=_prev>_prev</link>
<p>
</dl>
</anchor>
@@ -11809,7 +11583,7 @@ can also be used to control memory usage. Note that this function
does not work on strings.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=_next>_next</link></tt>
+<link to=_next>_next</link>
<p>
</dl>
</anchor>
@@ -11832,7 +11606,7 @@ _refs() is mainly meant for debugging Pike but
can also be used to control memory usage.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=_next>_next</link></tt> and <tt><link to=_prev>_prev</link></tt>
+<link to=_next>_next</link> and <link to=_prev>_prev</link>
<p>
</dl>
</anchor>
@@ -11866,14 +11640,17 @@ It is only used for debugging.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the arcus cosinus value for <i>f</i>. <!-- Borde man inte skriva att <i>f</i> ska anges i radianer?>
+Return the arcus cosine value for <i>f</i>.
+The result will be in radians.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=cos>cos</link></tt> and <tt><link to=asin>asin</link></tt>
+<link to=cos>cos</link> and <link to=asin>asin</link>
<p>
</dl>
</anchor>
+
+
<HR NEWPAGE>
<anchor name=add_constant>
<dl>
@@ -11892,14 +11669,10 @@ add builtin functions. All programs compiled after add_constant
function is called can access 'value' by the name given by 'name'.
If there is a constant called 'name' already, it will be replaced by
by the new definition. This will not affect already compiled programs.
-<p>Calling add_constant without a value will remove that name from the list<br>
-<dl><dt><dd><table border=0 cellpadding=0 cellspacing=0>
-<tr valign=top><td> </td><td> of of
-<!-- Fel layout, ett extra "of" och det ska väl vara "constants"> constant. As with replacing, this will not affect already compiled </td></tr>
-<tr valign=top><td> </td></tr>
-</table>
-</dl>programs.<br>
-
+<p>
+Calling add_constant without a value will remove that name from the list
+of constants. As with replacing, this will not affect already compiled
+programs.
<p>
<dt><encaps>EXAMPLES</encaps><dd>
<tt>add_constant("true",1);<br>
@@ -11910,11 +11683,12 @@ add_constant("add_constant");<br>
</tt>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=all_constants>all_constants</link></tt>
+<link to=all_constants>all_constants</link>
<p>
</dl>
</anchor>
+
<HR NEWPAGE>
<anchor name=add_include_path>
<dl>
@@ -11932,7 +11706,7 @@ the added directory will only be searched when using < > to
quote the included file.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=remove_include_path>remove_include_path</link></tt> and <tt><link to=include>#include</link></tt>
+<link to=remove_include_path>remove_include_path</link> and <link to=include>#include</link>
<p>
</dl>
</anchor>
@@ -11953,7 +11727,7 @@ This is the same as the command line option <tt>-M</tt>. For more
information about modules, see <ref to=modules>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=remove_module_path>remove_module_path</link></tt>
+<link to=remove_module_path>remove_module_path</link>
<p>
</dl>
</anchor>
@@ -11974,7 +11748,7 @@ This is the same as the command line option <tt>-P</tt>. For more
information about programs, see <ref to=programs>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=remove_program_path>remove_program_path</link></tt>
+<link to=remove_program_path>remove_program_path</link>
<p>
</dl>
</anchor>
@@ -12002,7 +11776,7 @@ like int a[10]=allocate(10); (and it isn't possible either) like
in C, just int *a=allocate(10); will do.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sizeof>sizeof</link>, <link to=arrayp>arrayp</link> and <link to=allocate>allocate</link></tt>
+<link to=sizeof>sizeof</link>, <link to=arrayp>arrayp</link> and <link to=allocate>allocate</link>
<p>
</dl>
</anchor>
@@ -12025,7 +11799,7 @@ creates a mapping of those pairs. The second syntax is always
preferable.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sizeof>sizeof</link></tt>, <tt><link to=mappingp>mappingp</link></tt> and <tt><link to=mkmapping>mkmapping</link></tt>
+<link to=sizeof>sizeof</link>, <link to=mappingp>mappingp</link> and <link to=mkmapping>mkmapping</link>
<p>
</dl>
</anchor>
@@ -12047,10 +11821,10 @@ Construct a multiset with the arguments as indexes. This function
could be written in Pike as:
<p>multiset aggregate(mixed ... elems) { return mkmultiset(elems); }
<p>The only problem is that mkmultiset is implemented using
-aggregage_multiset...
+aggregate_multiset...
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sizeof>sizeof</link></tt>, <tt><link to=multisetp>multisetp</link></tt> and <tt><link to=Simulate.mkmultiset>Simulate.mkmultiset</link></tt>
+<link to=sizeof>sizeof</link>, <link to=multisetp>multisetp</link> and <link to=Simulate.mkmultiset>Simulate.mkmultiset</link>
<p>
</dl>
</anchor>
@@ -12067,17 +11841,19 @@ aggregage_multiset...
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
<tt>alarm</tt> arranges for a SIGALRM signal to be delivered to the
-process<!-- Menar du process eller thread? Lite mer förklaring, tack.> in <i>seconds</i> seconds.
-<p>If <i>seconds</i> is zero, no new alarm is scheduled.
-<p>In any event any previously set alarm is cancelled.
+process <!-- hedda: Menar du process eller thread? Lite mer förklaring, tack. hubbe: det st}r process, vad tror du jag menar??? -->in <i>seconds</i> seconds.
+<p>
+If <i>seconds</i> is zero, no new alarm is scheduled.
+<p>
+In any event any previously set alarm is canceled.
<p>
<dt><encaps>RETURN VALUE</encaps><dd>
-<tt>alarm</tt> returns the number of seconds remaining until any
+<tt>alarm</tt> returns the number of seconds remaining until any
previously scheduled alarm was due to be delivered, or
zero if there was no previously scheduled alarm.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=signal>signal</link></tt>
+<link to=signal>signal</link>
<p>
</dl>
</anchor>
@@ -12097,7 +11873,7 @@ Returns a mapping containing all constants, indexed on the names of the
constant, and with the value of the efun as argument.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=add_constant>add_constant</link></tt>
+<link to=add_constant>add_constant</link>
<p>
</dl>
</anchor>
@@ -12121,11 +11897,11 @@ Allocate an array of size elements and initialize them to zero.
<p>
<dt><encaps>NOTA BENE</encaps><dd>
Arrays are dynamically allocated there is no need to declare them
-like <tt>int a[10]=allocate(10);</tt> (and it isn't possible either) like
-in C, just <tt>int *a=allocate(10);</tt> will do.
+like <tt>int a[10]=allocate(10);</tt> (and it is not possible either) like
+in C, just <tt>array(int) a=allocate(10);</tt> will do.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sizeof>sizeof</link></tt>, <tt><link to=aggregate>aggregate</link></tt> and <tt><link to=arrayp>arrayp</link></tt>
+<link to=sizeof>sizeof</link>, <link to=aggregate>aggregate</link> and <link to=arrayp>arrayp</link>
<p>
</dl>
</anchor>
@@ -12141,10 +11917,10 @@ in C, just <tt>int *a=allocate(10);</tt> will do.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is an array and zero otherwise.
+Returns 1 if <i>arg</i> is an array, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=allocate>allocate</link></tt>, <tt><link to=intp>intp</link></tt>, <tt><link to=programp>programp</link></tt>, <tt><link to=floatp>floatp</link></tt>, <tt><link to=stringp>stringp</link></tt>, <tt><link to=objectp>objectp</link></tt>, <tt><link to=mappingp>mappingp</link></tt>, <tt><link to=multisetp>multisetp</link></tt> and <tt><link to=functionp>functionp</link></tt>
+<link to=allocate>allocate</link>, <link to=intp>intp</link>, <link to=programp>programp</link>, <link to=floatp>floatp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=multisetp>multisetp</link> and <link to=functionp>functionp</link>
<p>
</dl>
</anchor>
@@ -12160,10 +11936,10 @@ Returns 1 if <i>arg</i> is an array and zero otherwise.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the arcus sinus value for f.
+Returns the arcus sinus value for <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=sin>sin</link></tt> and <tt><link to=acos>acos</link></tt>
+<link to=sin>sin</link> and <link to=acos>acos</link>
<p>
</dl>
</anchor>
@@ -12179,10 +11955,10 @@ Returns the arcus sinus value for f.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the arcus tangent value for f.
+Returns the arcus tangent value for <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=tan>tan</link></tt>, <tt><link to=asin>asin</link></tt> and <tt><link to=acos>acos</link></tt>
+<link to=tan>tan</link>, <link to=asin>asin</link> and <link to=acos>acos</link>
<p>
</dl>
</anchor>
@@ -12194,7 +11970,7 @@ Returns the arcus tangent value for f.
<tt>backtrace</tt> - get a description of the call stack
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>mixed <!-- Ett "*" till här?>*backtrace();<br>
+<tt>array(array) backtrace();<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
@@ -12214,11 +11990,10 @@ in the stack. Each entry has this format:
that the last but one and so on.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=catch>catch</link></tt> and <tt><link to=throw>throw</link></tt>
+<link to=catch>catch</link> and <link to=throw>throw</link>
<p>
</dl>
</anchor>
-
<HR NEWPAGE>
<anchor name=call_function>
<dl>
@@ -12238,7 +12013,7 @@ you will never have to write call_function(), because you will use the
second syntax instead.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=backtrace>backtrace</link></tt> and <tt><link to=Simulate.get_function>Simulate.get_function</link></tt>
+<link to=backtrace>backtrace</link> and <link to=Simulate.get_function>Simulate.get_function</link>
<p>
</dl>
</anchor>
@@ -12260,7 +12035,7 @@ identifies this call out. The return value can be sent to
find_call_out or remove_call_out to remove the call out again.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=remove_call_out>remove_call_out</link></tt>, <tt><link to=find_call_out>find_call_out</link></tt> and <tt><link to=call_out_info>call_out_info</link></tt>
+<link to=remove_call_out>remove_call_out</link>, <link to=find_call_out>find_call_out</link> and <link to=call_out_info>call_out_info</link>
<p>
</dl>
</anchor>
@@ -12292,7 +12067,7 @@ contains an array that looks like this:
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=call_out>call_out</link></tt>, <tt><link to=find_call_out>find_call_out</link></tt> and <tt><link to=remove_call_out>remove_call_out</link></tt>
+<link to=call_out>call_out</link>, <link to=find_call_out>find_call_out</link> and <link to=remove_call_out>remove_call_out</link>
<p>
</dl>
</anchor>
@@ -12315,7 +12090,7 @@ contains an array that looks like this:
<tt>time(1)</tt> to the current time.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=call_out>call_out</link></tt>, <tt><link to=find_call_out>find_call_out</link></tt> and <tt><link to=remove_call_out>remove_call_out</link></tt>
+<link to=call_out>call_out</link>, <link to=find_call_out>find_call_out</link> and <link to=remove_call_out>remove_call_out</link>
<p>
</dl>
</anchor>
@@ -12338,7 +12113,7 @@ returns the argument given to throw. For a run time error, this value
is ({ "error message", backtrace })
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<tt><link to=throw>throw</link></tt>
+<link to=throw>throw</link>
<p>
</dl>
</anchor>
@@ -12374,8 +12149,8 @@ Change the current directory for the whole Pike process, return
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the closest integer <!-- Det heter inte integral number! Då vill inte jag vara med i alla fall!> value higher or equal to <i>f</i>.
-Note that <tt>ceil()</tt> does _not_ return an int! It returns an integer value stored in a float. <!-- Jag skrev om den sista meningen>
+Return the closest integer value higher or equal to <i>f</i>.
+Note that <tt>ceil()</tt> does <strong>not</strong> return an int, merely an integer value stored in a float.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=floor>floor</link>
@@ -12419,13 +12194,19 @@ with <i>args</i> as arguments.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function is exactly equivialent to:
-<p>map_array(index,lambda(mixed x,mixed y) { return x[y]; },data)
-<p>Except of course it is a lot shorter and faster.
+This function is exactly equivalent to:
+<example language=pike>
+map_array(index,lambda(mixed x,mixed y) { return x[y]; },data)
+</example>
+Except of course it is a lot shorter and faster.
That is, it indexes every index in the array data on the value of
the argument index and returns an array with the results.
<p>
-<!-- Vore fint med ett exempel här.>
+<dt><encaps>EXAMPLE</encaps><dd>
+<pre>
+ > column( ({ ({1,2}), ({3,4}), ({5,6}) }), 1)
+ Result: ({2, 4, 6})
+</pre>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=rows>rows</link>
<p>
@@ -12473,15 +12254,14 @@ Result: /foo/bar/sune.c<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function will compile the file with the filename <i>filename</i> to a Pike program that can
-later be used for cloning. <!-- Jag skrev om förgående mening. Kolla den!>
+This function will compile the file <i>filename</i> to a Pike program that can
+later be used for cloning.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=clone>clone</link> and <link to=compile_string>compile_string</link>
<p>
</dl>
</anchor>
-
<HR NEWPAGE>
<anchor name=compile_string>
<dl>
@@ -12493,11 +12273,11 @@ later be used for cloning. <!-- Jag skrev om f
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Compile_string takes a complete Pike program <!-- Nej, det gör den inte! Den tar en sträng med Pike-kod som beskriver ett helt program. Var försiktig med termen "program" annars blir det förvirrande!>
-as an argument in the
-string prog and compiles it to clonable program. The second argument
-will be used as the file name of the program and will be used for
-error messages and such.
+<tt>compile_string()</tt> takes a piece of Pike code as a string and
+compiles it into a clonable program. Note that <i>prog</i> must contain
+the complete source for a program. You can not compile a single expression
+or statement.The second argument will be used as the file name of the
+program and will be used for error messages and such.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=compile_string>compile_string</link> and <link to=clone>clone</link>
@@ -12539,7 +12319,7 @@ they may not the the same value. (tested with ==)
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the cosinus value for f.
+Returns the cosine value for <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=acos>acos</link> and <link to=sin>sin</link>
@@ -12589,7 +12369,7 @@ matched, 0 otherwise.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Convert the output from a previous call to time() into a readable
-string containing the currnent year, month, day and time.
+string containing the current year, month, day and time.
<p>
<dt><encaps>EXAMPLE</encaps><dd>
<tt>> ctime(time());<br>
@@ -12609,11 +12389,11 @@ Result: Wed Jan 14 03:36:08 1970<br>
<tt>decode_value</tt> - code a value into a string
<p>
<dt><encaps>SYNTAX</encaps><dd>
-<tt>mixed denode_value(mixed<!-- Det ska väl vara string? Och kanske ett annat namn på "value"? (coded_value?)> <I>value</I>);<br>
+<tt>mixed decode_value(string <I>coded_value</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function takes a string created with <tt>encode_value()</tt> and converts
+This function takes a string created with encode_value() and converts
it back to the value that was coded.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -12810,9 +12590,7 @@ more information about return codes.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the natural exponent of <i>f</i>.
-<!-- Ingen matteskola här inte! Och vad menar du med "doesn't overflow an int."?
-log( exp( x ) ) == x as long as exp(x) doesn't overflow an int.>
+Return the natural exponent of <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=pow>pow</link> and <link to=log>log</link>
@@ -12897,7 +12675,7 @@ zero_type(find_call_out(f)) will return 1.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is a float and zero otherwise.
+Returns 1 if <i>arg</i> is a float, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=programp>programp</link>, <link to=arrayp>arrayp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=multisetp>multisetp</link> and <link to=functionp>functionp</link>
@@ -12916,8 +12694,8 @@ Returns 1 if <i>arg</i> is a float and zero otherwise.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the closest integer <!-- Det heter inte integral number! Då vill inte jag vara med i alla fall!> value lower or equal to <i>f</i>.
-Note that <tt>floor()</tt> does _not_ return an int! It returns an integer value stored in a float. <!-- Jag skrev om den sista meningen>
+Return the closest integer value lower or equal to <i>f</i>.
+Note that floor() does <strong>not</strong> return an int, merely an integer value stored in a float.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=ceil>ceil</link>
@@ -12937,7 +12715,7 @@ Note that <tt>floor()</tt> does _not_ return an int! It returns an integer value
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
Fork splits the process in two, and for the parent it returns the
-pid of the child. Refer to your unix manual for further details.
+pid of the child. Refer to your Unix manual for further details.
<p>
<dt><encaps>NOTA BENE</encaps><dd>
This function cause endless bugs if used without proper care.
@@ -13000,7 +12778,7 @@ returned.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is a function and zero otherwise.
+Returns 1 if <i>arg</i> is a function, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=programp>programp</link>, <link to=arrayp>arrayp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=multisetp>multisetp</link> and <link to=floatp>floatp</link>
@@ -13020,7 +12798,7 @@ Returns 1 if <i>arg</i> is a function and zero otherwise.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function checks all the memory for cyclic structures such
-as arrays containing themselves and frees them if approperiate.
+as arrays containing themselves and frees them if appropriate.
It also frees up destructed objects. It then returns how many
arrays/objects/programs/etc. it managed to free by doing this.
Normally there is no need to call this function since Pike will
@@ -13085,7 +12863,7 @@ Returns the value of the environment variable with the name <i>varname</i>,
if no such environment variable exists, zero is returned.
<p>
<dt><encaps>NOTA BENE</encaps><dd>
-This function is provided by master.c
+This function is provided by master.pike
<p>
</dl>
</anchor>
@@ -13123,7 +12901,7 @@ array(string) glob(string <I>glob</I>, array(string) <I>arr</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function matches "globs". A the the <!-- Jag begriper inte vad det ska stå. Skriv om!> glob string a question sign
+This function matches "globs". In a glob string a question sign
matches any character and an asterisk matches any string. When
given two strings as argument a true/false value is returned
which reflects if the <i>str</i> matches <i>glob</i>. When given an array as
@@ -13188,7 +12966,7 @@ kind of value. For objects, the result is an array of strings.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is an int and zero otherwise.
+Returns 1 if <i>arg</i> is an int, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=arrayp>arrayp</link>, <link to=programp>programp</link>, <link to=floatp>floatp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=multisetp>multisetp</link> and <link to=functionp>functionp</link>
@@ -13211,7 +12989,7 @@ Kill sends a signal to another process. If something goes wrong
-1 is returned, 0 otherwise.
<p>Some signals and their supposed purpose:
<p><table border=0 cellpadding=0 cellspacing=0>
-<tr valign=top><td> SIGHUP </td><td> Hangup, sent to process when user logs out </td></tr>
+<tr valign=top><td> SIGHUP </td><td> Hang-up, sent to process when user logs out </td></tr>
<tr valign=top><td> SIGINT </td><td> Interrupt, normally sent by ctrl-c </td></tr>
<tr valign=top><td> SIGQUIT </td><td> Quit, sent by ctrl-\ </td></tr>
<tr valign=top><td> SIGILL </td><td> Illegal instruction </td></tr>
@@ -13232,7 +13010,7 @@ Kill sends a signal to another process. If something goes wrong
<tr valign=top><td> SIGSTP </td><td> Suspend process </td></tr>
<tr valign=top><td> SIGTTIN </td><td> tty input for background process </td></tr>
<tr valign=top><td> SIGTTOU </td><td> tty output for background process </td></tr>
-<tr valign=top><td> SIGXCPU </td><td> Out of cpu </td></tr>
+<tr valign=top><td> SIGXCPU </td><td> Out of CPU </td></tr>
<tr valign=top><td> SIGXFSZ </td><td> File size limit exceeded </td></tr>
<tr valign=top><td> SIGPROF </td><td> Profile trap </td></tr>
<tr valign=top><td> SIGWINCH </td><td> Window change signal </td></tr>
@@ -13298,11 +13076,10 @@ components:
<tr valign=top><td> mday </td><td> day of the month </td><td> 1 - 31 </td></tr>
<tr valign=top><td> mon </td><td> what month </td><td> 0 - 11 </td></tr>
<tr valign=top><td> year </td><td> years since 1900 </td><td> 0 - </td></tr>
-<tr valign=top><td> wday </td><td> day of week (0=sunday) </td><td> 0 - 6 </td></tr>
+<tr valign=top><td> wday </td><td> day of week (0=Sunday) </td><td> 0 - 6 </td></tr>
<tr valign=top><td> yday </td><td> day of year </td><td> 0 - 365 </td></tr>
<tr valign=top><td> isdst </td><td> is daylight saving time </td><td> 0/1 </td></tr>
-<tr valign=top><td> timezone </td><td> difference between </td></tr>
-<tr valign=top><td> </td><td><!-- Layout-fel! ("fel" är substantiv här :-)> </td><td> local time and UTC </td></tr>
+<tr valign=top><td> timezone </td><td> difference between local time and UTC </td></tr>
</table>
<p>
@@ -13326,10 +13103,7 @@ The 'timezone' might not be available on all platforms.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the natural logarithm of <i>f</i>.
-<!--
-exp( log(x) ) == x for x > 0.
-Onödig info som förvirrar>
+Return the natural logarithm of <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=pow>pow</link> and <link to=exp>exp</link>
@@ -13367,9 +13141,9 @@ Returns a string with all capital letters converted to lower case.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Remove the entry with index 'index' from mapping 'map' destructively.
+Removes the entry with index <i>index</i> from mapping <i>map</i> destructively.
Returns the changed mapping. If the mapping does not have an
-entry with index 'index', nothing is done.
+entry with index <i>index</i>, nothing is done.
Note that m_delete changes map destructively and only returns
the mapping for compatibility reasons.
<p>
@@ -13390,7 +13164,7 @@ the mapping for compatibility reasons.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is a mapping and zero otherwise.
+Returns 1 if <i>arg</i> is a mapping, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=programp>programp</link>, <link to=arrayp>arrayp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=multisetp>multisetp</link>, <link to=floatp>floatp</link> and <link to=functionp>functionp</link>
@@ -13478,7 +13252,7 @@ Result: (< /* 3 elements */<br>
</tt>
<p>
<dt><encaps>SEE ALSO</encaps><dd>
-<link to=aggregage_multiset>aggregate_multiset</link>
+<link to=aggregate_multiset>aggregate_multiset</link>
<p>
</dl>
</anchor>
@@ -13532,7 +13306,7 @@ Or you can just send them all on one line as the second syntax suggests.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is a multiset and zero otherwise.
+Returns 1 if <i>arg</i> is a multiset, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=programp>programp</link>, <link to=arrayp>arrayp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=floatp>floatp</link> and <link to=functionp>functionp</link>
@@ -13603,7 +13377,7 @@ for(o=next_object();o;o=next_object(o))<br>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function returns the program from which <i>o</i> was cloned.
-If <i>o</i> is not an object, or <i>o</i> have been destructed, zero is returned. <!-- Skrev om den meningen lite>
+If <i>o</i> is not an object or has been destructed <i>o</i> zero is returned.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=clone>clone</link>
@@ -13622,7 +13396,7 @@ If <i>o</i> is not an object, or <i>o</i> have been destructed, zero is returned
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is an object and zero otherwise.
+Returns 1 if <i>arg</i> is an object, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=programp>programp</link>, <link to=floatp>floatp</link>, <link to=stringp>stringp</link>, <link to=arrayp>arrayp</link>, <link to=mappingp>mappingp</link>, <link to=multisetp>multisetp</link> and <link to=functionp>functionp</link>
@@ -13642,7 +13416,7 @@ Returns 1 if <i>arg</i> is an object and zero otherwise.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns <i>n</i> raised to the power of <i>x</i>.
+Return <i>n</i> raised to the power of <i>x</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=exp>exp</link> and <link to=log>log</link>
@@ -13661,7 +13435,7 @@ Returns <i>n</i> raised to the power of <i>x</i>.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is a program and zero otherwise.
+Returns 1 if <i>arg</i> is a program, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=multisetp>multisetp</link>, <link to=arrayp>arrayp</link>, <link to=stringp>stringp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=floatp>floatp</link> and <link to=functionp>functionp</link>
@@ -13700,7 +13474,7 @@ This function sets the environment variable <i>varname</i> to <i>value</i>.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function returns the name of the machine the interpreter is
-running on. This is the same thing that the command <i>hostname</i>
+running on. This is the same thing that the command <tt>hostname</tt>
prints.
<p>
@@ -13718,7 +13492,7 @@ prints.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-query_num_arg returns the number of arguments given when this
+<tt>query_num_arg</tt> returns the number of arguments given when this
function was called. This is only useful for varargs functions.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -13760,7 +13534,7 @@ This function returns a random number in the range 0 - max-1.
This function sets the initial value for the random generator.
<p>
<dt><encaps>EXAMPLE</encaps><dd>
-<tt>Pike v1.0E-13 Running Hilfe v1.2 (Hubbe's Incremental Pike FrontEnd)<br>
+<tt>Pike v1.0E-13 Running Hilfe v1.2 (Hubbe's Incremental Pike Front-End)<br>
> random_seed(17);<br>
Result: 0<br>
> random(1000);<br>
@@ -13894,11 +13668,11 @@ This function can do several kinds replacement operations, the
different syntaxes do different things as follow:
<p>string replace(string s, string from, string to);
<p><dl><dt><dd>When given strings as second and third argument, a copy of<br>
-s with every occurance of 'from' replaced with 'to' is returned.<br>
+s with every occurrence of 'from' replaced with 'to' is returned.<br>
</dl>
<p>string replace(string s, array(string) from, array(string) to);
<p><dl><dt><dd>When given arrays of strings as second and third argument,<br>
-every occurance of from[0] in s is replaced by to[0],<br>
+every occurrence of from[0] in s is replaced by to[0],<br>
from[1] is replaced by to[1] and so on...<br>
</dl>
<p><table border=0 cellpadding=0 cellspacing=0>
@@ -13930,7 +13704,7 @@ This will let you control many aspects of how Pike works, but beware that
master.pike may be required to fill certain functions, so it is probably
a good idea to have your master inherit the original master and only
re-define certain functions.
-<!-- FIXME, tell how to inherit the master -->
+<!-- FIX ME, tell how to inherit the master -->
</dl>
</anchor>
@@ -13943,13 +13717,13 @@ re-define certain functions.
<dt><encaps>SYNTAX</encaps><dd>
<tt>string reverse(string <I>s</I>);<br>
or<br>
-array reverse(arary <I>a</I>);<br>
+array reverse(array <I>a</I>);<br>
or<br>
int reverse(int <I>i</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function reverseses a string, char by char, an array, value
+This function reverses a string, char by char, an array, value
by value or an int, bit by bit and returns the result. Reversing
strings can be particularly useful for parsing difficult syntaxes
which require scanning backwards.
@@ -13991,7 +13765,7 @@ Remove a file or directory, return 0 if it fails. Nonzero otherwise.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function is exactly equivialent to:
+This function is exactly equivalent to:
<p>map_array(index,lambda(mixed x,mixed y) { return y[x]; },data)
<p>Except of course it is a lot shorter and faster.
That is, it indexes data on every index in the array index and
@@ -14015,7 +13789,7 @@ returns an array with the results.
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
This function returns an array of ints describing how much resources
-the intepreter process has used so far. This array will have at least
+the interpreter process has used so far. This array will have at least
29 elements, of which those values not available on this system will
be zero. The elements are as follows:
<p>0: user time
@@ -14024,8 +13798,8 @@ be zero. The elements are as follows:
3: idrss
4: isrss
5: minflt
-6: minor pagefaults
-7: major pagefaults
+6: minor page faults
+7: major page faults
8: swaps
9: block input op.
10: block output op.
@@ -14071,19 +13845,17 @@ mixed search(mapping <I>haystack</I>, mixed <I>needle</I>, [ mixed <I>start</I>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Search for needle in haystack. Returns the position of needle in
-haystack or -1 if not found. If the optional argument start is present
-search is started at this position. Note that when haystack is a string
-needle must be a string, and the first occurance of this string is
-returned. However, when haystack is an array, needle is compared only
-to one value at a time in haystack.
-<p>When the haystack is a mapping, search tries to find the index
-connected to the data needle. That is, it tries to lookup the mapping
-backwards. If needle isn't present in the mapping, zero is returned,
-and zero_type() will return 1 for this zero.
+Search for <i>needle</i> in <i>haystack</i>. Return the position of <i>needle</i> in
+<i>haystack</i> or -1 if not found. If the optional argument <i>start</i> is present
+search is started at this position. Note that when <i>haystack</i> is a string
+<i>needle</i> must be a string, and the first occurrence of this string is
+returned. However, when <i>haystack</i> is an array, <i>needle</i> is compared only
+to one value at a time in <i>haystack</i>.
<p>
-<dt><encaps>NOTA BENE</encaps><dd>
-This function replaces strstr and member_array from Pike4.
+When the <i>haystack</i> is a mapping, <tt>search</tt> tries to find the index
+connected to the data <i>needle</i>. That is, it tries to lookup the mapping
+backwards. If <i>needle</i> isn't present in the mapping, zero is returned,
+and zero_type() will return 1 for this zero.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=indices>indices</link>, <link to=values>values</link> and <link to=zero_type>zero_type</link>
@@ -14108,7 +13880,7 @@ This function allows you to trap a signal and have a function called
when the process receives a signal. Although it IS possible to trap
SIGBUS, SIGSEGV etc. I advice you not to. Pike should not receive any
such signals and if it does it is because of bugs in the Pike
-interperter. And all bugs should be reported, no matter how trifle.
+interpreter. And all bugs should be reported, no matter how trifle.
<p>The callback will receive the signal number as the only argument.
See the document for the function 'kill' for a list of signals.
<p>If no second argument is given, the signal handler for that signal
@@ -14180,7 +13952,7 @@ Result: 9<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the sinus value for f.
+Returns the sinus value for <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=asin>asin</link> and <link to=cos>cos</link>
@@ -14278,7 +14050,7 @@ generally speaking have one %<modifiers><operator> (examples:
<tr valign=top><td> - </td><td> left adjusted within field size (default is right) </td></tr>
<tr valign=top><td> | </td><td> centered within field size </td></tr>
<tr valign=top><td> = </td><td> column mode if strings are greater than field size </td></tr>
-<tr valign=top><td> / </td><td> Rough linebreak (break at exactly fieldsize instead of between words) </td></tr>
+<tr valign=top><td> / </td><td> Rough line break (break at exactly field size instead of between words) </td></tr>
<tr valign=top><td> # </td><td> table mode, print a list of '\n' separated word (top-to-bottom order) </td></tr>
<tr valign=top><td> $ </td><td> Inverse table mode (left-to-right order) </td></tr>
<tr valign=top><td> n </td><td> (where n is a number or *) a number specifies field size </td></tr>
@@ -14305,7 +14077,7 @@ generally speaking have one %<modifiers><operator> (examples:
<tr valign=top><td> %X </td><td> uppercase unsigned hexadecimal int </td></tr>
<tr valign=top><td> %c </td><td> char (or short with %2c, %3c gives 3 bytes etc.) </td></tr>
<tr valign=top><td> %f </td><td> float </td></tr>
-<tr valign=top><td> %g </td><td> heruistically chosen representation of float </td></tr>
+<tr valign=top><td> %g </td><td> heuristically chosen representation of float </td></tr>
<tr valign=top><td> %e </td><td> exponential notation float </td></tr>
<tr valign=top><td> %s </td><td> string </td></tr>
<tr valign=top><td> %O </td><td> any type (debug style) </td></tr>
@@ -14316,7 +14088,7 @@ generally speaking have one %<modifiers><operator> (examples:
<p>
<dt><encaps>EXAMPLES</encaps><dd>
-<tt>Pike v0.1 Running Hilfe v1.2 (Incremental Pike Frontend)<br>
+<tt>Pike v0.1 Running Hilfe v1.2 (Incremental Pike Front end)<br>
> int screen_width=70;<br>
Result: 70<br>
> mixed sample;<br>
@@ -14366,37 +14138,37 @@ slosh-n's will of course force a new-line when needed. <br>
Result: 0<br>
> write(sprintf("%-=*s %-=*s\n", screen_width/2,<br>
<dl><dt><dd>"Two columns next to each other (any number of columns will "+<br>
-"of course work) independantly word-wrapped, can be useful.",<br>
+"of course work) independently word-wrapped, can be useful.",<br>
screen_width/2-1,<br>
-"The - is to specify justification, this is in addherence "+<br>
+"The - is to specify justification, this is in adherence "+<br>
"to std sprintf which defaults to right-justification, "+<br>
-"this version also supports centre and right justification."));<br>
+"this version also supports center and right justification."));<br>
</dl>Two columns next to each other (any The - is to specify justification,<br>
-number of columns will of course this is in addherence to std <br>
-work) independantly word-wrapped, sprintf which defaults to <br>
+number of columns will of course this is in adherence to std <br>
+work) independently word-wrapped, sprintf which defaults to <br>
can be useful. right-justification, this version <br>
-<dl><dt><dd>also supports centre and right <br>
+<dl><dt><dd>also supports center and right <br>
justification. <br>
</dl>Result: 0<br>
> write(sprintf("%-$*s\n", screen_width,<br>
<dl><dt><dd>"Given a\nlist of\nslosh-n\nseparated\n'words',\nthis option\n"+<br>
"creates a\ntable out\nof them\nthe number of\ncolumns\n"+<br>
-"be forced\nby specifying a\npresision.\nThe most obvious\n"+<br>
+"be forced\nby specifying a\nprecision.\nThe most obvious\n"+<br>
"use is for\nformatted\nls output."));<br>
</dl>Given a list of slosh-n <br>
separated 'words', this option <br>
creates a table out of them <br>
the number of columns be forced <br>
-by specifying a presision. The most obvious <br>
+by specifying a precision. The most obvious <br>
use is for formatted ls output. <br>
Result: 0<br>
> write(sprintf("%-#*s\n", screen_width,<br>
<dl><dt><dd>"Given a\nlist of\nslosh-n\nseparated\n'words',\nthis option\n"+<br>
"creates a\ntable out\nof them\nthe number of\ncolumns\n"+<br>
-"be forced\nby specifying a\npresision.\nThe most obvious\n"+<br>
+"be forced\nby specifying a\nprecision.\nThe most obvious\n"+<br>
"use is for\nformatted\nls output."));<br>
</dl>Given a creates a by specifying a <br>
-list of table out presision. <br>
+list of table out precision. <br>
slosh-n of them The most obvious <br>
separated the number of use is for <br>
'words', columns formatted <br>
@@ -14455,7 +14227,7 @@ int sqrt(int <I>i</I>);<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the square root of f, or in the second case, the square root
+Returns the square root of <i>f</i>, or in the second case, the square root
truncated to the closest lower integer.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -14495,7 +14267,7 @@ This function may not be available on all platforms.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns 1 if <i>arg</i> is a string and zero otherwise.
+Returns 1 if <i>arg</i> is a string, zero otherwise.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=intp>intp</link>, <link to=multisetp>multisetp</link>, <link to=arrayp>arrayp</link>, <link to=programp>programp</link>, <link to=objectp>objectp</link>, <link to=mappingp>mappingp</link>, <link to=floatp>floatp</link> and <link to=functionp>functionp</link>
@@ -14534,7 +14306,7 @@ This function is equal to sizeof.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns the tangent value for f.
+Returns the tangent value for <i>f</i>.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
<link to=atan>atan</link>, <link to=sin>sin</link> and <link to=cos>cos</link>
@@ -14553,7 +14325,7 @@ Returns the tangent value for f.
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-This function returns the object we are curently evaluating in.
+This function returns the object we are currently evaluating in.
<p>
</dl>
</anchor>
@@ -14620,7 +14392,7 @@ but is only updated in the backed. (when Pike code isn't running)
This function affects the debug trace level. (also set by the -t
command line option) The old level is returned. Trace level 1 or
higher means that calls to Pike functions are printed to stderr,
-level 2 or higer means calls to builtin functions are printed, 3
+level 2 or higher means calls to builtin functions are printed, 3
means every opcode interpreted is printed, 4 means arguments to
these opcodes are printed as well. See the command lines options
for more information
@@ -14669,7 +14441,7 @@ Result: int<br>
ualarm arranges for a SIGALRM signal to be delivered to the
process in useconds micro seconds.
<p>If useconds is zero, no new alarm is scheduled.
-<p>In any event any previously set alarm is cancelled.
+<p>In any event any previously set alarm is canceled.
<p>
<dt><encaps>RETURN VALUE</encaps><dd>
ualarm returns the number of microseconds seconds remaining<br>
@@ -14694,7 +14466,7 @@ ualarm returns the number of microseconds seconds remaining<br>
</tt>
<p>
<dt><encaps>DESCRIPTION</encaps><dd>
-Returns a copy of the string s with all lower case character converted
+Returns a copy of the string <i>s</i> with all lower case character converted
to upper case character.
<p>
<dt><encaps>SEE ALSO</encaps><dd>
@@ -14802,7 +14574,7 @@ returned. Otherwise zero_type will return zero.
<H1>XXX. Things to describe somewhere</H1>
<ul>
<li>garbage collection
- <li>int ... ars
+ <li>int ... args
<li>data storage (local vs. global variables)
<li>trace
<li>Pike command line
@@ -14833,7 +14605,7 @@ object to take care of these things. Here is a list of the methods needed
in the <b>master object</b>:
<dl>
<dt> <tt>program cast_to_program(string <i>program_name</i>, string <i>current_file</i>)</tt>
-<dd> This function is called whenever somoene performs a cast from a string
+<dd> This function is called whenever someone performs a cast from a string
to a program.
<dt> <tt>program handle_inherit(string <i>program_name</i>, string <i>current_file</i>)</tt>
<dd> This is called whenever a Pike program which uses inherit with a string
@@ -14844,7 +14616,7 @@ in the <b>master object</b>:
<tt>({"<i>error_description</i>", backtrace() })</tt>. If any error
occurs in this routine Pike will dump core.
<dt> <tt>program cast_to_program(string <i>program_name</i>, string <i>current_file</i>)</tt>
-<dd> This function is called whenever someone performas a cast from a string
+<dd> This function is called whenever someone performs a cast from a string
to an object.
<dt> <tt>mixed resolv(string <i>identifier</i>, string <i>current_file</i>)</tt>
<dd> This function is called whenever the compiler finds an unknown identifier
@@ -14862,7 +14634,7 @@ in the <b>master object</b>:
<dt> <tt>string handle_include(string <i>file</i>, string <i>current_file</i>, int <i>local_include</i>)</tt>
<dd> This function is used to locate include files. <i>file</i> is the file
name the user wants to include, and <i>local_include</i> is 1 if
- the user used doublequotes rather than lesser-than, greather-than to
+ the user used double quotes rather than lesser-than, greater-than to
quote the file name. Otherwise it is zero.
</dl>
<p>
@@ -14887,7 +14659,7 @@ scripts. The current master add the following global functions:
getenv and putenv.
</dl>
<p>
-There are at least two ways to change the behaviour of the master object.
+There are at least two ways to change the behavior of the master object.
(Except for editing it directly, which would cause other Pike scripts not
to run in most cases.) You can either copy the master object, modify it
and use the command line option <tt>-m</tt> to load your file instead of
@@ -14923,7 +14695,7 @@ Let's look an example:
void handle_error(mixed *trace)
{
- Stdio.write_file("errorlog",describe_backtrace(trace));
+ Stdio.write_file("error log",describe_backtrace(trace));
}
};
@@ -14973,11 +14745,11 @@ instead of writing them to stderr.
<appendix title="Terms and jargon">
<dl>
- <dt> HTTP <dd> HyperText Transfer Protocol, the protocol used by WWW to transfer HTML from the server to the client. Based on TCP.
+ <dt> HTTP <dd> Hyper-Text Transfer Protocol, the protocol used by WWW to transfer HTML from the server to the client. Based on TCP.
<dt> WWW <dd> World Wide Web, popularly known as 'the Internet' :)
- <dt> TCP <dd> Transmission Control Protocol, the internet standard for computer communication
- <dt> ASCII <dd> American Standard Code for Information Interchange. Standard set by the American Standards Authority for encoding English letters, numbers , some symbols and control characters in 7 bits. There are also some "semi-standard" systems which add other characters by using 8 bits, which are also loosly called ASCII.
- <dt> UNIX <dd> A group of operating systems. Some noteworthy unixes are: Solaris, Linux, HP-UX, Digital Unix, SunOs, BSD and Unixware.
+ <dt> TCP <dd> Transmission Control Protocol, the Internet standard for computer communication
+ <dt> ASCII <dd> American Standard Code for Information Interchange. Standard set by the American Standards Authority for encoding English letters, numbers , some symbols and control characters in 7 bits. There are also some "semi-standard" systems which add other characters by using 8 bits, which are also loosely called ASCII.
+ <dt> UNIX <dd> A group of operating systems. Some noteworthy Unixes are: Solaris, Linux, HP-UX, Digital Unix, SunOs, BSD and Unixware.
<dt> clone <dd> To create an object from a program. Or to use C++ jargon: to instantiate a class.
<dt> command line <dd> The line you write to execute a program
<dt> command line option <dd> The words after the program name on the <i>command line</i>.
@@ -15001,13 +14773,13 @@ chapter 2.
<example language=pike>
#!/usr/local/bin/pike
-mapping records(string:aray(string)) = ([
+mapping records(string:array(string)) = ([
"Star Wars Trilogy" : ({
"Fox Fanfare",
"Main Title",
- "Princess leia's Theme",
+ "Princess Leia's Theme",
"Here They Come",
- "The Asteriod Field",
+ "The Asteroid Field",
"Yoda's Theme",
"The Imperial March",
"Parade of th Ewoks",
@@ -15243,7 +15015,7 @@ This is the BNF for Pike:
<tr valign=top><td>expression3</td><td>::=</td><td>expression4 '?' expression3 ":" expression3 </td></tr>
<tr valign=top><td>expression4</td><td>::=</td><td>{ expression5 ( "||" | "&&" | "|" | "^" | "&" | "==" | "!=" | ">" | "<" | ">=" | "<=" | "<<" | ">>" | "+" | "*" | "/" | "%" ) } expression5</td></tr>
<tr valign=top><td>expression5</td><td>::=</td><td>expression6 | "(" type ")" expression5 | "--" expression6 | "++" expression6 | expression6 "--" | expression6 "++" | "~" expression5 | "-" expression5 </td></tr>
-<tr valign=top><td>expression6</td><td>::=</td><td>string | number | float | catch | guage | typeof | sscanf | lambda | class | constant_identifier | call | index | mapping | multiset | array | parenthesis | arrow </td></tr>
+<tr valign=top><td>expression6</td><td>::=</td><td>string | number | float | catch | gauge | typeof | sscanf | lambda | class | constant_identifier | call | index | mapping | multiset | array | parenthesis | arrow </td></tr>
<tr valign=top><td>number</td><td>::=</td><td>digit { digit } | "0x" { digits } | "'" character "'" </td></tr>
<tr valign=top><td>float</td><td>::=</td><td>digit { digit } "." { digit }</td></tr>
<tr valign=top><td>catch</td><td>::=</td><td><b>catch</b> ( "(" expression ")" | block )</td></tr>
@@ -15284,7 +15056,7 @@ Pike should compile and install nicely on almost any UNIX platform. It has
been tested on the following:
<ul>
<li> Solaris 2.4, 2.5, 2.5.1
-<li> Sunos 4.1.1, 4.1.3
+<li> SunOs 4.1.1, 4.1.3
<li> Linux Red Hat 3, Red Hat 4, Slackware 3.0, Slackware 96
<li> HP-UX 9, 10
<li> AIX 4
@@ -15296,20 +15068,20 @@ been tested on the following:
After obtaining the Pike source you need to unpack it. To unpack Pike you
need gzip, which is available from any GNU mirror site. You also need tar,
-which is a part of UNIX. If you got Pike-v0.4.tar.gz, simply unpack it by
+which is a part of UNIX. If you got Pike-v0.5.tar.gz, simply unpack it by
typing:
<pre>
- $ gunzip -d Pike-v0.4.tar.gz
- $ tar xvf Pike-v0.4.tar
+ $ gunzip -d Pike-v0.5.tar.gz
+ $ tar xvf Pike-v0.5.tar
</pre>
-Now you have a directory called Pike-v0.4. Please read the README file
+Now you have a directory called Pike-v0.5. Please read the README file
in the new directory since newer versions can contain information not
available at the time this book was written.
<p>
Now, to compile Pike, the following three commands should be enough.
<pre>
- $ cd Pike-v0.4/src
+ $ cd Pike-v0.5/src
$ ./configure --prefix=/dir/to/install/pike
$ make
</pre>
@@ -15319,13 +15091,13 @@ makefiles. You will see a lot of output after you run configure. Do not
worry, that is normal. It is usually not a good idea to install Pike anywhere
but in /usr/local (the default) since Pike scripts written by other people
will usually assume that's where Pike is. However, if you do not have write
-acceess to /usr/local you will have to install Pike somewhere else on your
+access to /usr/local you will have to install Pike somewhere else on your
system.
<p>
After that <tt>make</tt> will actually compile the program. After compilation
it is a good idea to do <tt>make verify</tt> to make sure that Pike is
100% compatible with your system. Make verify will take a while to run
-and use a lot of cpu, but it is worth it to see that your compilation was
+and use a lot of CPU, but it is worth it to see that your compilation was
successful. After doing that you should run <tt>make install</tt> to install
the Pike binaries, libraries and include files in the directory you selected
earlier.
@@ -15334,3 +15106,4 @@ You are now ready to use Pike.
</appendix>
<index title=Index>
+
--
GitLab