autodoc.git/
autodoc.xml
Branch:
Tag:
Non-build tags
All tags
No tags
1996-02-26
1996-02-26 21:30:03 by Fredrik Hübinette (Hubbe) <hubbe@hubbe.net>
516e68cb1b1db22bcb84e6c735c94c7e92c79a84 (
604
lines) (+
585
/-
19
)
[
Show
|
Annotate
]
Branch:
ulpc
htmlify_docs.lpc added
Rev: bin/htmlify_docs.lpc:1.1
23:
#line<br/> #pragma<br/> #undef<br/>
-
</text></group></dl>
-
</p>
-
<
p><br
/>
-
</
p>
-
</tt></
text>
+
</text></group></dl></p>
+
</
tt
>
+
lpc
</text>
</doc> <docgroup homogen-name='#!' homogen-type='directive'>
250:
</doc> </docgroup>
+
<docgroup homogen-name='`!' homogen-type='method'>
+
<method name='`!'/><doc placeholder='true'>
+
<text>
+
<p><tt>`!</tt> - is not true</p>
+
+
<tt><p>! a<br/>
+
or<br/>
+
int `!(mixed a)<br/>
+
</p>
+
</tt>
+
<p>Returns 1 if a is zero, 0 otherwise.</p>
+
+
operators</text>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`!=' homogen-type='method'>
+
<method name='`!='/><doc placeholder='true'>
+
<text>
+
<p><tt>`!=</tt> - check if not equal</p>
+
+
<tt><p>a != b<br/>
+
or<br/>
+
int `!=(mixed a, mixed b)<br/>
+
</p>
+
</tt>
+
<p>This operator compares two values and returns 0 if they are the same,
+
1 otherwise. Note that pointer equivialenec is required for arrays,
+
objects, programs, mappings and lists. (Thus it is not enough that
+
two arrays LOOK alike, it must be the same array.)</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`<' to='`<'>`<</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref>, <ref resolved='predef::`>=' to='`>='>`>=</ref> and <ref to='efuns/equal'>efuns/equal</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`%' homogen-type='method'>
+
<method name='`%'/><doc placeholder='true'>
+
<text>
+
<p><tt>`%</tt> - modulo</p>
+
+
<tt><p>a % b<br/>
+
or<br/>
+
int `%(int a, int b)<br/>
+
or<br/>
+
float `%(int|float a,int|float b)<br/>
+
</p>
+
</tt>
+
<p>This operator computes the rest of a division. For integers, this
+
is the same as same as computing a-(a/b)*a. For floats, modulo is
+
interpreted as a-floor(a/b)*a
+
</p>
+
</text>
+
+
<group><example/><text>
+
<tt><p><matrix>
+
<r><c> 9%3 </c><c> returns 0 </c></r>
+
<r><c> 10%3 </c><c> returns 1 </c></r>
+
<r><c> 2%0.3 </c><c> returns 0.2 </c></r>
+
</matrix>
+
</p>
+
</tt>
+
operators</text></group>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`/' to='`/'>`/</ref> and <ref resolved='predef::`*' to='`*'>`*</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`&' homogen-type='method'>
+
<method name='`&'/><doc placeholder='true'>
+
<text>
+
<p><tt>`&</tt> - intersection</p>
+
+
<tt><p>a & b<br/>
+
or<br/>
+
mixed `&(mixed ... args)<br/>
+
</p>
+
</tt>
+
<p>This operator does logical intersections. For ints this means
+
bitwise and.
+
</p>
+
<p>Arrays and lists are treated as sets, so intersecting two arrays
+
will result in an array with containing all values present in all
+
arguments.
+
</p>
+
<p>For mappings, the intersection will be done on the indexes solely,
+
however, the values will be taken from the rightmost mapping.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`|' to='`|'>`|</ref> and <ref resolved='predef::`^' to='`^'>`^</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`*' homogen-type='method'>
+
<method name='`*'/><doc placeholder='true'>
+
<text>
+
<p><tt>`*</tt> - multiplication</p>
+
+
<tt><p>a * b<br/>
+
or<br/>
+
int `*(int ... args)<br/>
+
or<br/>
+
float `*(int|float ... args)<br/>
+
or<br/>
+
string `*(string *strings, string delimeter)<br/>
+
</p>
+
</tt>
+
<p>For ints and floats, this operator simply multiplies its arguments.
+
If the first argument is an array, and the second a string, all
+
strings in the arrays will be concatenated, with the delimiter in
+
between each string and the result will be returned.</p>
+
</text>
+
+
<group><example/><text>
+
<tt><p><matrix>
+
<r><c> 2*2 </c><c> returns 4 </c></r>
+
<r><c> 2.0*2.0 </c><c> returns 4.0 </c></r>
+
<r><c> 2.0*2 </c><c> returns 4.0 </c></r>
+
<r><c> ({"f","",""})*"o") </c><c> Returns "foo" </c></r>
+
<r><c> `*(2,2,2) </c><c> returns 8 </c></r>
+
</matrix>
+
</p>
+
</tt>
+
operators</text></group>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`/' to='`/'>`/</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`+' homogen-type='method'>
+
<method name='`+'/><doc placeholder='true'>
+
<text>
+
<p><tt>`+</tt> - add things together</p>
+
+
<tt><p>a + b<br/>
+
or<br/>
+
mixed `+(mixed ... args)<br/>
+
</p>
+
</tt>
+
<p>For ints and floats this operator simply adds the two operators
+
together. For strings and arrays, concatenation is done. For lists
+
and mapping this creates a new list with all indices and data as
+
in a and b. Note that this can cause a list or mapping to contain
+
several equal indices. Also, when adding a string to an int or float
+
the number is converted to a printable string first.</p>
+
</text>
+
+
<group><example/><text>
+
<tt><p><matrix>
+
<r><c> "a"+10 </c><c> returns "a10" </c></r>
+
<r><c> 10+20 </c><c> returns 30 </c></r>
+
<r><c> ({1})+({2}) </c><c> returns ({1,2}) </c></r>
+
<r><c> (<1>)+(<1>) </c><c> returns (<1,1>) </c></r>
+
<r><c> `+(2,2,2) </c><c> returns 6 </c></r>
+
</matrix>
+
</p>
+
</tt>
+
operators</text></group>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`-' to='`-'>`-</ref> and <ref resolved='predef::`*' to='`*'>`*</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`-' homogen-type='method'>
+
<method name='`-'/><doc placeholder='true'>
+
<text>
+
<p><tt>`-</tt> - subtract/negate</p>
+
+
<tt><p>- a<br/>
+
or<br/>
+
`-(mixed <i>a</i>);<br/>
+
or<br/>
+
a - b<br/>
+
or<br/>
+
mixed `-(mixed a, mixed b)<br/>
+
</p>
+
</tt>
+
<p>This is the negation and subtraction operator, for ints and floats
+
the operation should be obvious.
+
</p>
+
<p>For arrays, an array containing all elements present in a and not in
+
b is returne. The order of the remaining values from a will be kept.
+
</p>
+
<p>For lists, the same operation is done as for arrays, except order is
+
of course not considered.
+
</p>
+
<p><matrix>
+
<r><c> For mappings, a mapping is returned with every key-index pair from </c></r>
+
<r><c> a whos index is not present as an index in b. </c></r>
+
<r><c> EXAMPLES </c></r>
+
<r><c> 5-10 </c><c> returns -5 </c></r>
+
<r><c> 10-2.0 </c><c> returns 8.0 </c></r>
+
<r><c> ({1,2})-({2}) </c><c> returns ({1}) </c></r>
+
<r><c> ([1:2,2:1])-([1:0]) </c><c> returns ([2:1]) </c></r>
+
</matrix>
+
</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`+' to='`+'>`+</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`/' homogen-type='method'>
+
<method name='`/'/><doc placeholder='true'>
+
<text>
+
<p><tt>`/</tt> - division</p>
+
+
<tt><p>a / b<br/>
+
or<br/>
+
int `/(int a, int b)<br/>
+
or<br/>
+
float `/(int|float a,int|float b)<br/>
+
or<br/>
+
string* `/(string a,string b)<br/>
+
</p>
+
</tt>
+
<p>For ints and floats, this operator simply divide its arguments.
+
If the arguments are strings, the first string will be divided
+
at every occurance of the second string. The resulting pieces
+
are then returned in the form of an array.</p>
+
</text>
+
+
<group><example/><text>
+
<tt><p><matrix>
+
<r><c> 2/2 </c><c> returns 1 </c></r>
+
<r><c> 3/2 </c><c> returns 1 </c></r>
+
<r><c> 2.0/2.0 </c><c> returns 1.0 </c></r>
+
<r><c> 2.0/2 </c><c> returns 1.0 </c></r>
+
<r><c> "foo"/"o" </c><c> returns ({"f","",""}) </c></r>
+
<r><c> `/(2,2) </c><c> returns 1 </c></r>
+
</matrix>
+
</p>
+
</tt>
+
operators</text></group>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`*' to='`*'>`*</ref> and <ref resolved='predef::`%' to='`%'>`%</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`<' homogen-type='method'>
+
<method name='`<'/><doc placeholder='true'>
+
<text>
+
<p><tt>`<</tt> - is lesser than?</p>
+
+
<tt><p>a < b<br/>
+
or<br/>
+
int `<(int|float|string a,int|float|string b)<br/>
+
</p>
+
</tt>
+
<p>This operator compares two values and returns 1 if the first one
+
is lesser than the second one.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref> and <ref resolved='predef::`>=' to='`>='>`>=</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`<<' homogen-type='method'>
+
<method name='`<<'/><doc placeholder='true'>
+
<text>
+
<p><tt>`<<</tt> - shift left</p>
+
+
<tt><p>a << b<br/>
+
or<br/>
+
int `<<(int a, int b)<br/>
+
</p>
+
</tt>
+
<p>This operator shift the integer a b steps left. This is equal to
+
multiplying a by 2 b times.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`>>' to='`>>'>`>></ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`<=' homogen-type='method'>
+
<method name='`<='/><doc placeholder='true'>
+
<text>
+
<p><tt>`<=</tt> - is lesser or equal than?</p>
+
+
<tt><p>a <= b<br/>
+
or<br/>
+
int `<=(int|float|string a,int|float|string b)<br/>
+
</p>
+
</tt>
+
<p>This operator compares two values and returns 1 if the first one
+
is lesser than or equal to the second one.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<' to='`<'>`<</ref> and <ref resolved='predef::`>=' to='`>='>`>=</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`==' homogen-type='method'>
+
<method name='`=='/><doc placeholder='true'>
+
<text>
+
<p><tt>`==</tt> - compare values</p>
+
+
<tt><p>a == b<br/>
+
or<br/>
+
int `==(mixed a, mixed b)<br/>
+
</p>
+
</tt>
+
<p>This operator compares two values and returns 1 if they are the same,
+
0 otherwise. Note that pointer equivialenec is required for arrays,
+
objects, programs, mappings and lists. (Thus it is not enough that
+
two arrays LOOK alike, it must be the same array.)</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`<' to='`<'>`<</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref>, <ref resolved='predef::`>=' to='`>='>`>=</ref> and <ref to='efuns/equal'>efuns/equal</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`>' homogen-type='method'>
+
<method name='`>'/><doc placeholder='true'>
+
<text>
+
<p><tt>`></tt> - is lesser than?</p>
+
+
<tt><p>a > b<br/>
+
or<br/>
+
int `>(int|float|string a,int|float|string b)<br/>
+
</p>
+
</tt>
+
<p>This operator compares two values and returns 1 if the first one
+
is greater than the second one.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`<' to='`<'>`<</ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref> and <ref resolved='predef::`>=' to='`>='>`>=</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`>=' homogen-type='method'>
+
<method name='`>='/><doc placeholder='true'>
+
<text>
+
<p><tt>`>=</tt> - is greater than or equal to?</p>
+
+
<tt><p>a >= b<br/>
+
or<br/>
+
int `>=(int|float|string a,int|float|string b)<br/>
+
</p>
+
</tt>
+
<p>This operator compares two values and returns 1 if the first one
+
is greater than or equal to the second one.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<' to='`<'>`<</ref> and <ref resolved='predef::`<=' to='`<='>`<=</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`>>' homogen-type='method'>
+
<method name='`>>'/><doc placeholder='true'>
+
<text>
+
<p><tt>`>></tt> - shift right</p>
+
+
<tt><p>a >> b<br/>
+
or<br/>
+
int `>>(int a, int b)<br/>
+
</p>
+
</tt>
+
<p>This operator shift the integer a b steps right. This is equal to
+
dividing a by 2 b times.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`<<' to='`<<'>`<<</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`^' homogen-type='method'>
+
<method name='`^'/><doc placeholder='true'>
+
<text>
+
<p><tt>`^</tt> - exclusive or</p>
+
+
<tt><p>a ^ b<br/>
+
or<br/>
+
mixed `^(mixed ... args)<br/>
+
</p>
+
</tt>
+
<p>This operator does logical exclusive or operations For ints this means
+
bitwise xor.
+
</p>
+
<p>Arrays and lists are treated as sets, so xoring two arrays will
+
result in an array with containing all values present in either but
+
not both arrays.
+
</p>
+
<p>For mappings, the intersection will be done on the indexes solely,
+
however, the values will be taken from the rightmost mapping.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`|' to='`|'>`|</ref> and <ref resolved='predef::`&' to='`&'>`&</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`|' homogen-type='method'>
+
<method name='`|'/><doc placeholder='true'>
+
<text>
+
<p><tt>`|</tt> - union</p>
+
+
<tt><p>a | b<br/>
+
or<br/>
+
mixed `|(mixed ... args)<br/>
+
</p>
+
</tt>
+
<p>This operator does logical unions. For ints this means bitwise or.
+
</p>
+
<p>Arrays and lists are treated as sets, so doing a union on two arrays
+
will result in an array with containing all values present in either
+
array. Although values present in both ararys will only be present
+
once in the result.
+
</p>
+
<p>For mappings, the intersection will be done on the indexes solely,
+
however, the values will be taken from the rightmost mapping.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`&' to='`&'>`&</ref> and <ref resolved='predef::`^' to='`^'>`^</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
+
<docgroup homogen-name='`~' homogen-type='method'>
+
<method name='`~'/><doc placeholder='true'>
+
<text>
+
<p><tt>`~</tt> - bitwise complement</p>
+
+
<tt><p>~ a<br/>
+
or<br/>
+
int `~(int a)<br/>
+
</p>
+
</tt>
+
<p>This operator inverses all bits in an integer and returns the
+
new integer.</p>
+
+
operators</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::`&' to='`&'>`&</ref>, <ref resolved='predef::`|' to='`|'>`|</ref> and <ref resolved='predef::`^' to='`^'>`^</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
<docgroup homogen-name='acos' homogen-type='method'> <method name='acos'/><doc placeholder='true'> <text>
502:
</matrix> </p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::mapping' to='mapping'>mapping</ref>, <ref resolved='predef::list' to='list'>list</ref>, <ref resolved='predef::allocate' to='predef::allocate'>builtin/allocate</ref>, <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> and <ref resolved='predef::values' to='predef::values'>builtin/values</ref></p>
1426:
<p>floats and ints cannot be used together, they have to be cast to the same type first.</p>
-
type
</text></group>
+
types
</text></group>
<group><seealso/><text> <p><ref resolved='predef::sin' to='predef::sin'>math/sin</ref>, <ref resolved='predef::cos' to='predef::cos'>math/cos</ref>, <ref resolved='predef::tan' to='predef::tan'>math/tan</ref> and <ref resolved='predef::sqrt' to='predef::sqrt'>math/sqrt</ref></p>
1569:
become 0. If you try to call a functionpointer that has is 0 then 0 will be returned.</p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::object' to='object'>object</ref>, <ref resolved='predef::call_function' to='predef::call_function'>builtin/call_function</ref>, <ref resolved='predef::functionp' to='predef::functionp'>builtin/functionp</ref>, <ref resolved='predef::function_object' to='predef::function_object'>builtin/function_object</ref> and <ref resolved='predef::function_name' to='predef::function_name'>builtin/function_name</ref></p>
1719:
</doc> </docgroup>
+
<docgroup homogen-name='gc' homogen-type='method'>
+
<method name='gc'/><doc placeholder='true'>
+
<text>
+
<p><tt>gc</tt> - do garbage collection</p>
+
+
<tt><p>int gc();<br/>
+
</p>
+
</tt>
+
<p><matrix>
+
<r><c> This function checks all the memory for cyclic structures such </c></r>
+
<r><c> as arrays containing themselves and frees them if approperiate. </c></r>
+
<r><c> It also frees up destructed objects. It then returns how many </c></r>
+
<r><c> arrays/objects/programs/etc. it managed </c><c> to free by doing this. </c></r>
+
<r><c> Normally there is no need to call this function since uLPC will </c></r>
+
<r><c> call it by itself every now and then. (uLPC will try to predict </c></r>
+
<r><c> when 20% of all arrays/object/programs in memory is 'garbage' </c></r>
+
<r><c> and call this routine then.) </c></r>
+
</matrix>
+
+
</p>
+
<p/>
+
</text>
+
+
</doc>
+
</docgroup>
<docgroup homogen-name='get_dir' homogen-type='method'> <method name='get_dir'/><doc placeholder='true'> <text>
1921:
</p> </tt> <p>This function is the inverse of explode. It contatenates all the
-
strings in a with a delimeter in between each.
If no delimeter is
-
given, an empty string will be used.
</p>
+
strings in a with a delimeter in between each.</p>
</text> <group><example/><text> <tt><p>> implode( ({ "foo","bar","gazonk"}), "-" );<br/> Result: foo-bar-gazonk<br/>
-
> implode( ({ "f","o","o" }) );<br/>
-
Result: foo<br/>
+
> ({ "a","b","c" })*" and ";<br/> Result: a and b and c<br/> > <br/>
2064:
</matrix> </p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::float' to='float'>float</ref></p>
2242:
</matrix> </p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::mapping' to='mapping'>mapping</ref>, <ref resolved='predef::array' to='array'>array</ref>, <ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref> and <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref></p>
2446:
</matrix> </p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::array' to='array'>array</ref>, <ref resolved='predef::list' to='list'>list</ref>, <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref>, <ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref> and <ref resolved='predef::values' to='predef::values'>builtin/values</ref></p>
2640:
</matrix> </p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::program' to='program'>program</ref>, <ref resolved='predef::function' to='function'>function</ref>, <ref resolved='predef::clone' to='predef::clone'>builtin/clone</ref> and <ref resolved='predef::destruct' to='predef::destruct'>builtin/destruct</ref></p>
2764:
arguments to clone() and the only operators that applies to programs are == and !=.</p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::object' to='object'>object</ref>, <ref resolved='predef::function' to='function'>function</ref>, <ref resolved='predef::compile_file' to='predef::compile_file'>builtin/compile_file</ref>, <ref resolved='predef::compile_string' to='predef::compile_string'>builtin/compile_string</ref> and <ref resolved='predef::clone' to='predef::clone'>builtin/clone</ref></p>
3255:
<text> <p><tt>sizeof</tt> - return the size of an array, string, list or mapping</p>
-
<tt><p>int sizeof(string|list|mapping|array <i>a</i>);<br/>
+
<tt><p>int sizeof(string|list|mapping|array
|object
<i>a</i>);<br/>
</p> </tt> <p>This function returns the number of indexes available in the argument
3582:
</doc> </docgroup>
+
<docgroup homogen-name='sscanf' homogen-type='method'>
+
<method name='sscanf'/><doc placeholder='true'>
+
<text>
+
<p><tt>sscanf</tt> - scan a string using a format string</p>
+
+
<tt><p>int sscanf(string <i>str</i>, string <i>fmt</i>, mixed <i>var1</i>, mixed <i>var2</i> ...);<br/>
+
</p>
+
</tt>
+
<p>Parse a string str using the format fmt. fmt can contain strings
+
separated by "%d,%s,%c and %f. Every % corresponds to one of var1,
+
var2...
+
</p>
+
<p><matrix>
+
<r><c> %d </c><c> gives an integer </c></r>
+
<r><c> %o </c><c> gives an octal integer </c></r>
+
<r><c> %x </c><c> gives a hexadecimal integer </c></r>
+
<r><c> %D </c><c> gives an integer that is either octal (leading zero), hexadecimal (leading 0x) or decimal. </c></r>
+
<r><c> %f </c><c> gives a float </c></r>
+
<r><c> %c </c><c> matches one char and returns it as an integer </c></r>
+
<r><c> %s </c><c> gives a string </c></r>
+
<r><c> %[set] </c><c> matches a string containing a given set of characters. (thos given inside the brackets) %[^set] means any character ecept those inside brackets. %[0-9H] means any number or 'H'. </c></r>
+
</matrix>
+
+
</p>
+
<p>If a * is put between the percent and the operator, the operator
+
will not only match it's argument, not assign any variables.
+
</p>
+
<p>Number of matched arguments is returned.</p>
+
+
string</text>
+
+
<group><seealso/><text>
+
<p><ref resolved='predef::explode' to='explode'>explode</ref> and <ref resolved='predef::sprintf' to='sprintf'>sprintf</ref></p>
+
</text></group>
+
+
</doc>
+
</docgroup>
<docgroup homogen-name='string' homogen-type='method'> <method name='string'/><doc placeholder='true'> <text>
3622:
</matrix> </p>
-
type
</text>
+
types
</text>
<group><seealso/><text> <p><ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref>, <ref resolved='predef::values' to='predef::values'>builtin/values</ref>, <ref resolved='predef::sscanf' to='predef::sscanf'>builtin/sscanf</ref>, <ref resolved='predef::sprintf' to='predef::sprintf'>builtin/sprintf</ref> and <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref></p>
3711:
</doc> </docgroup>
+
<docgroup homogen-name='sum' homogen-type='method'>
+
<method name='sum'/><doc placeholder='true'>
+
<text>
+
<p><tt>sum</tt> - add values together</p>
+
+
<tt><p>int sum(int ... <i>i</i>);<br/>
+
or<br/>
+
float sum(float ... <i>f</i>);<br/>
+
or<br/>
+
string sum(string|float|int ... <i>p</i>);<br/>
+
or<br/>
+
array sum(array ... <i>a</i>);<br/>
+
or<br/>
+
mapping sum(mapping ... <i>m</i>);<br/>
+
or<br/>
+
list sum(list ... <i>l</i>);<br/>
+
</p>
+
</tt>
+
<p>This function does exactly the same thing as adding all the arguments
+
together with +. It's just here so you can get a function-pointer to
+
the summation operator.</p>
+
+
int, float, string, array, mapping and list</text>
+
+
</doc>
+
</docgroup>
<docgroup homogen-name='sum_arrays' homogen-type='method'> <method name='sum_arrays'/><doc placeholder='true'> <text>