array progress

24 files changed, 1065 insertions, 718 deletions

diff --git a/Makefile b/Makefile
index 5624b2e..719200c 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@ SRCS!=find ./src -name '*.c'
 OBJS=$(SRCS:.c=.o)
 CC?=cc
 #CC=mingw32-gcc
-#DEBUG=-g3 -ggdb3
+DEBUG=-g3 -ggdb3
 CFLAGS+=-c -Wall -std=c99 -pedantic $(DEBUG)
 LDADD+=
 HEADER?=docs/header.txt
diff --git a/README b/README
index 66a9695..b6f6969 100644
--- a/README
+++ b/README
@@ -75,42 +75,6 @@ GETTING STARTED
     See the ./examples subdir of the Fype source distribution for examples!
     See also fype -h for a list of all options.
 
-DATA TYPES
-    Fype uses auto type conversion. However, if you want to know what's
-    going on you may take a look at the provided basic datatypes.
-
-  The basic data types
-    *integer*
-        Specifies an integer number
-
-    *double*
-        Specifies a double number
-
-    *string*
-        Specifies a string
-
-    *number*
-        May be an integer or a double number
-
-    *any*
-        May be of any type above
-
-    *void*
-        No type
-
-    *identifier*
-        It's a variable name or a procedure name or a function name
-
-  Explicit type conversions
-    (*integer*) integer *any*
-        Converts any type to an integer
-
-    (*double*) double *any*
-        Converts any type to a double
-
-    (*string*) string *any*
-        Converts any type to a string
-
 SYNTAX
   Comments
     Text from a # character until the end of the current line is considered
@@ -126,8 +90,8 @@ SYNTAX
             say foo;
             exit foo - bar;
 
-  Paranthesis
-    All paranthesis of function calls are optional. They help to make the
+  Parenthesis
+    All parenthesis of function calls are optional. They help to make the
     code better readable. They also help to force precedences of
     expressions.
 
@@ -175,216 +139,270 @@ SYNTAX
         Runs the statements as long as the the expression evaluates to a
         false value.
 
+DATA TYPES
+    Fype uses auto type conversion. However, if you want to know what's
+    going on you may take a look at the provided basic datatypes.
+
+  The basic data types
+    *integer*
+        (Internal name TT_INTEGER)
+
+    *double*
+        (Internal name TT_DOUBLE)
+
+    *string*
+        (Internal name TT_STRING)
+
+    *array*
+        (Internal name TT_ARRAY)
+
+    *number*
+        May be an integer or a double number
+
+    *any*
+        May be of any type above
+
+    *void*
+        No type
+
+    *identifier*
+        It's a variable name or a procedure name or a function name
+
+  Explicit type conversions
+    The data types inside the brackets are only showing the return types of
+    each function.
+
+    (*integer*) integer *any*
+        Converts any type to an integer.
+
+    (*double*) double *any*
+        Converts any type to a double.
+
+    (*string*) string *any*
+        Converts any type to a string.
+
+    (*array*) array *any*
+        Converts any type to an array. This function is not yet implemented.
+
+  More functions for data types
+    (*string*) type *any*
+        Returns the name of the current type. Examples:
+
+                my foo = 1;
+                put type foo; # Prints "TT_INTEGER"
+                put type 1.2; # Prints "TT_DOUBLE"
+
 VARIABLES
-    Variables can be defined with the my keyword. If you don't assign a
-    value during declaration, then it's using the default integer value 0.
-    Variables may be changed during program runtime. Variables may be
-    deleted using the undef keyword! Example of defining variables:
+        Variables can be defined with the my keyword. If you don't assign a
+        value during declaration, then it's using the default integer value
+        0. Variables may be changed during program runtime. Variables may be
+        deleted using the undef keyword! Example of defining variables:
 
-            my foo = 1 + 2;
-            say foo; 
+                my foo = 1 + 2;
+                say foo; 
 
-            my bar = 12, baz = foo;
-            say 1 + bar;
-            say bar;
+                my bar = 12, baz = foo;
+                say 1 + bar;
+                say bar;
 
-            my baz;
-            say baz; # Will print out 0
+                my baz;
+                say baz; # Will print out 0
 
-    You may use the defined keyword to check if an identifier has been
-    defined or not.
+        You may use the defined keyword to check if an identifier has been
+        defined or not.
 
-            ifnot defined foo {
-                    say "No foo yet defined";
-            }
+                ifnot defined foo {
+                        say "No foo yet defined";
+                }
 
-            my foo = 1;
+                my foo = 1;
 
-            if defined foo {
-                    put "foo is defined and has the value ";
-                    say foo;
-            }
+                if defined foo {
+                        put "foo is defined and has the value ";
+                        say foo;
+                }
 
 BUILT IN FUNCTIONS
-    In Fype, operators are built in functions as well. The difference is,
-    that they may be written in infix notation instead in front of the
-    arguments. The types inside the () specify the return types.
+        In Fype, operators are built in functions as well. The difference
+        is, that they may be written in infix notation instead in front of
+        the arguments. The types inside the () specify the return types.
 
   Math
-    (*any*) *any* + *any*
-        Special string behavior: A string will get auto convertet into an
-        *integer*.
+        (*any*) *any* + *any*
+            Special string behavior: A string will get auto convertet into
+            an *integer*.
 
-    (*any*) *any* - *any*
-        Special string behavior: A string will get auto convertet into an
-        *integer*.
+        (*any*) *any* - *any*
+            Special string behavior: A string will get auto convertet into
+            an *integer*.
 
-    (*any*) *any* * *any*
-        Special string behavior: A string will get auto convertet into an
-        *integer*.
+        (*any*) *any* * *any*
+            Special string behavior: A string will get auto convertet into
+            an *integer*.
 
-    (*any*) *any* / *any*
-        Special string behavior: A string will get auto convertet into an
-        *integer*.
+        (*any*) *any* / *any*
+            Special string behavior: A string will get auto convertet into
+            an *integer*.
 
   Conditional
-    (*integer*) *any* == *any*
-    (*integer*) *any* != *any*
-    (*integer*) *any* <= *any*
-    (*integer*) *any* >= *any*
-    (*integer*) *any* < *any*
-    (*integer*) *any* > *any*
-    (*integer*) not *any*
+        (*integer*) *any* == *any*
+        (*integer*) *any* != *any*
+        (*integer*) *any* <= *any*
+        (*integer*) *any* >= *any*
+        (*integer*) *any* < *any*
+        (*integer*) *any* > *any*
+        (*integer*) not *any*
 
   Definedness
-    (*integer*) defined *identifier*
-        Returns 1 if *identifier* has been defined. Returns 0 else.
+        (*integer*) defined *identifier*
+            Returns 1 if *identifier* has been defined. Returns 0 else.
 
-    (*integer*) undef *identifier*
-        Tries to undefine/delete the *identifier*. Returns 1 if success,
-        otherwise 0 is returned.
+        (*integer*) undef *identifier*
+            Tries to undefine/delete the *identifier*. Returns 1 if success,
+            otherwise 0 is returned.
 
   Bitwise
-    (*integer*) *any* :< *any*
-    (*integer*) *any* :> *any*
-    (*integer*) *any* and *any*
-    (*integer*) *any* or *any*
-    (*integer*) *any* xor *any*
+        (*integer*) *any* :< *any*
+        (*integer*) *any* :> *any*
+        (*integer*) *any* and *any*
+        (*integer*) *any* or *any*
+        (*integer*) *any* xor *any*
 
   Numeric
-    (*number*) neg *number*
-        This function returns the negative value of *any*
+        (*number*) neg *number*
+            This function returns the negative value of *any*
 
-    (*integer*) no [*integer*]
-        This function returns 1 if the argument is 0, otherwise it will
-        return 0! If no argument is given, then 0 is returned!
+        (*integer*) no [*integer*]
+            This function returns 1 if the argument is 0, otherwise it will
+            return 0! If no argument is given, then 0 is returned!
 
-    (*integer*) yes [*integer*]
-        This function always returns 1. The parameter is optional.
+        (*integer*) yes [*integer*]
+            This function always returns 1. The parameter is optional.
 
-                # Prints out 1, because foo is not defined
-                if yes { say no defined foo; } 
+                    # Prints out 1, because foo is not defined
+                    if yes { say no defined foo; } 
 
   System
-    (*void*) end
-        Exits the program with the exit status of 0
+        (*void*) end
+            Exits the program with the exit status of 0
 
-    (*void*) exit *integer*
-        Exits the program with the specified exit status
+        (*void*) exit *integer*
+            Exits the program with the specified exit status
 
-    (*integer*) fork
-        Fork forks a subprocess. It returns 0 for the child process and the
-        pid of the child process otherwise! Example:
+        (*integer*) fork
+            Fork forks a subprocess. It returns 0 for the child process and
+            the pid of the child process otherwise! Example:
 
-                my pid = fork;
+                    my pid = fork;
 
-                if pid {
-                        put "I am the parent process; child has the pid ";
-                        say pid;
+                    if pid {
+                            put "I am the parent process; child has the pid ";
+                            say pid;
 
-                } ifnot pid {
-                        say "I am the child process";
-                }
+                    } ifnot pid {
+                            say "I am the child process";
+                    }
 
-    (*integer*) gc
-        Executes the garbage collector and returns the number of items
-        freed! You may wonder why most of the time it will return a value of
-        0! Fype tries to free not needed memory asap. This may change in
-        future versions in order to gain faster execution of scripts!
+        (*integer*) gc
+            Executes the garbage collector and returns the number of items
+            freed! You may wonder why most of the time it will return a
+            value of 0! Fype tries to free not needed memory asap. This may
+            change in future versions in order to gain faster execution of
+            scripts!
 
   I/O
-    (*any*) put *any*
-        Prints out the argument
+        (*any*) put *any*
+            Prints out the argument
 
-    (*any*) say *any*
-        Same as put, but also includes an ending newline
+        (*any*) say *any*
+            Same as put, but also includes an ending newline
 
-    (*void*) ln
-        Just prints a newline
+        (*void*) ln
+            Just prints a newline
 
 SELF DEFINING PROCEDURES AND FUNCTIONS
   Procedures
-    A procedure can be defined with the proc keyword and deleted with the
-    undef keyword. A procedure does not return any value and does not
-    support parameter passing. It's using already defined variables (e.g.
-    global variables). A procedure does not have its own namespace. It's
-    using the calling namespace. It is possible to define new variabes
-    inside of a procedure in the current namespace.
-
-            proc foo {
-                    say 1 + a * 3 + b;
-                    my c = 6;
-            }
+        A procedure can be defined with the proc keyword and deleted with
+        the undef keyword. A procedure does not return any value and does
+        not support parameter passing. It's using already defined variables
+        (e.g. global variables). A procedure does not have its own
+        namespace. It's using the calling namespace. It is possible to
+        define new variabes inside of a procedure in the current namespace.
+
+                proc foo {
+                        say 1 + a * 3 + b;
+                        my c = 6;
+                }
 
-            my a = 2, b = 4;
+                my a = 2, b = 4;
 
-            foo; # Run the procedure. Print out "11\n"
-            say c; # Print out "6\n";
+                foo; # Run the procedure. Print out "11\n"
+                say c; # Print out "6\n";
 
   Nested procedures
-    It's possible to define procedures inside of procedures. Since
-    procedures don't have its own scope, nested procedures will be available
-    to the current scope as soon as the main procedure has run the first
-    time. You may use the defined keyword in order to check if a procedure
-    has been defined or not.
-
-            proc foo {
-                    say "I am foo";
-
-                    undef bar;
-                    proc bar {
-                            say "I am bar";
-                    }
-            }
+        It's possible to define procedures inside of procedures. Since
+        procedures don't have its own scope, nested procedures will be
+        available to the current scope as soon as the main procedure has run
+        the first time. You may use the defined keyword in order to check if
+        a procedure has been defined or not.
+
+                proc foo {
+                        say "I am foo";
+
+                        undef bar;
+                        proc bar {
+                                say "I am bar";
+                        }
+                }
 
-            # Here bar would produce an error because 
-            # the proc is not yet defined!
-            # bar; 
+                # Here bar would produce an error because 
+                # the proc is not yet defined!
+                # bar; 
 
-            foo; # Here the procedure foo will define the procedure bar!
-            bar; # Now the procedure bar is defined!
-            foo; # Here the procedure foo will redefine bar again!
+                foo; # Here the procedure foo will define the procedure bar!
+                bar; # Now the procedure bar is defined!
+                foo; # Here the procedure foo will redefine bar again!
 
   Functions
-    A function should be defined with the func keyword and deleted with the
-    undef keyword. Function not yet return values (will be changed in future
-    versions) and supports not yet parameter passing (will be changed in
-    future versions). It's using local (lexical scoped) variables. If a
-    certain variable does not exist It's using already defined variables
-    (e.g. one scope above).
-
-            func foo {
-                    say 1 + a * 3 + b;
-                    my c = 6;
-            }
+        A function should be defined with the func keyword and deleted with
+        the undef keyword. Function not yet return values (will be changed
+        in future versions) and supports not yet parameter passing (will be
+        changed in future versions). It's using local (lexical scoped)
+        variables. If a certain variable does not exist It's using already
+        defined variables (e.g. one scope above).
+
+                func foo {
+                        say 1 + a * 3 + b;
+                        my c = 6;
+                }
 
-            my a = 2, b = 4;
+                my a = 2, b = 4;
 
-            foo; # Run the procedure. Print out "11\n"
-            say c; # Will produce an error, because c is out of scoped!
+                foo; # Run the procedure. Print out "11\n"
+                say c; # Will produce an error, because c is out of scoped!
 
   Nested functions
-    Nested functions work the same way the nested procedures work, with the
-    exception that nested functions will not be available any more after the
-    function has been left!
+        Nested functions work the same way the nested procedures work, with
+        the exception that nested functions will not be available any more
+        after the function has been left!
 
-            func foo {
-                    func bar {
-                            say "Hello i am nested";
-                    }
+                func foo {
+                        func bar {
+                                say "Hello i am nested";
+                        }
 
-                    bar; # Calling nested
-            }
+                        bar; # Calling nested
+                }
 
-            foo;
-            bar; # Will produce an error, because bar is out of scope!
+                foo;
+                bar; # Will produce an error, because bar is out of scope!
 
 AUTHOR
-    Paul C. Buetow (http://paul.buetow.org)
+        Paul C. Buetow (http://paul.buetow.org)
 
 WEBSITE
-    The Fype Language (http://fype.buetow.org)
+        The Fype Language (http://fype.buetow.org)
 
 SEE ALSO
-    awk(1) cc(1) make(1)
+        awk(1) cc(1)
 
diff --git a/docs/help.txt b/docs/help.txt
index d7163e6..25988ea 100644
--- a/docs/help.txt
+++ b/docs/help.txt
@@ -1,4 +1,4 @@
-Fype v0.1-devel Build 9208
+Fype v0.1-devel Build 9322
 Copyright by Paul C. Buetow (2005 - 2008) <fype@dev.buetow.org>
 	-e	Executes given code string (see synopses)
 	-h	Prints this help
diff --git a/docs/pod/fype.1.gz b/docs/pod/fype.1.gz
index e05d4c5..29ae39d 100644
--- a/docs/pod/fype.1.gz
+++ b/docs/pod/fype.1.gz
diff --git a/docs/pod/fype.html b/docs/pod/fype.html
index b88a1b4..47397a4 100644
--- a/docs/pod/fype.html
+++ b/docs/pod/fype.html
@@ -20,23 +20,24 @@
 	<li><a href="#parsing___code_generation">PARSING / CODE GENERATION</a></li>
 	<li><a href="#requirements">REQUIREMENTS</a></li>
 	<li><a href="#getting_started">GETTING STARTED</a></li>
-	<li><a href="#data_types">DATA TYPES</a></li>
-	<ul>
-
-		<li><a href="#the_basic_data_types">The basic data types</a></li>
-		<li><a href="#explicit_type_conversions">Explicit type conversions</a></li>
-	</ul>
-
 	<li><a href="#syntax">SYNTAX</a></li>
 	<ul>
 
 		<li><a href="#comments">Comments</a></li>
 		<li><a href="#statements">Statements</a></li>
-		<li><a href="#paranthesis">Paranthesis</a></li>
+		<li><a href="#parenthesis">Parenthesis</a></li>
 		<li><a href="#scopeing">Scopeing</a></li>
 		<li><a href="#control_statements">Control statements</a></li>
 	</ul>
 
+	<li><a href="#data_types">DATA TYPES</a></li>
+	<ul>
+
+		<li><a href="#the_basic_data_types">The basic data types</a></li>
+		<li><a href="#explicit_type_conversions">Explicit type conversions</a></li>
+		<li><a href="#more_functions_for_data_types">More functions for data types</a></li>
+	</ul>
+
 	<li><a href="#variables">VARIABLES</a></li>
 	<li><a href="#built_in_functions">BUILT IN FUNCTIONS</a></li>
 	<ul>
@@ -132,6 +133,81 @@ TODO file of the source distribution of Fype!</p>
 <p>
 </p>
 <hr />
+<h1><a name="syntax">SYNTAX</a></h1>
+<p>
+</p>
+<h2><a name="comments">Comments</a></h2>
+<p>Text from a <strong>#</strong> character until the end of the current line is considered being a comment. Multi line comments may start with an <strong>#*</strong> and and with an <strong>*#</strong> anywhere. Exceptions are if those signs are inside of strings.</p>
+<p>
+</p>
+<h2><a name="statements">Statements</a></h2>
+<p>A Fype program is a list of statements. Each keyword, expression or function call is part of a statement. Each statement is ended with a semicolon. Example:</p>
+<pre>
+        my bar = 3, foo = 1 + 2; 
+        say foo;
+        exit foo - bar;</pre>
+<p>
+</p>
+<h2><a name="parenthesis">Parenthesis</a></h2>
+<p>All parenthesis of function calls are optional. They help to make the code better readable. They also help to force precedences of expressions.</p>
+<p>
+</p>
+<h2><a name="scopeing">Scopeing</a></h2>
+<p>A new scope starts with an { and ends with an }. An exception is a procedure, which does not use its own scope (see later in this manual). Control statements and functions support scopeings. Here is a small example how to use scopes:</p>
+<pre>
+        my foo = 1;</pre>
+<pre>
+        {
+                # Prints out 1
+                put defined foo;
+                {
+                        my bar = 2;</pre>
+<pre>
+                        # Prints out 1
+                        put defined bar;
+                }</pre>
+<pre>
+                # Prints out 0
+                put defined bar;</pre>
+<pre>
+                my baz = 3;
+        }</pre>
+<pre>
+        # Prints out 0
+        say defined bar;</pre>
+<p>
+</p>
+<h2><a name="control_statements">Control statements</a></h2>
+<p>Fype knows the following control statements:</p>
+<dl>
+<dt><strong><a name="item_if__3cexpression_3e__7b__3cstatements_3e__7d">if <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
+
+<dd>
+<p>Runs the statements if the expression evaluates to a true value.</p>
+</dd>
+</li>
+<dt><strong><a name="item_ifnot__3cexpression_3e__7b__3cstatements_3e__7d">ifnot <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
+
+<dd>
+<p>Runs the statements if the expression evaluates to a false value.</p>
+</dd>
+</li>
+<dt><strong><a name="item_while__3cexpression_3e__7b__3cstatements_3e__7d">while <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
+
+<dd>
+<p>Runs the statements as long as the the expression evaluates to a true value.</p>
+</dd>
+</li>
+<dt><strong><a name="item_until__3cexpression_3e__7b__3cstatements_3e__7d">until <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
+
+<dd>
+<p>Runs the statements as long as the the expression evaluates to a false value.</p>
+</dd>
+</li>
+</dl>
+<p>
+</p>
+<hr />
 <h1><a name="data_types">DATA TYPES</a></h1>
 <p>Fype uses auto type conversion. However, if you want to know what's going on you may take a look at the provided basic datatypes.</p>
 <p>
@@ -141,19 +217,25 @@ TODO file of the source distribution of Fype!</p>
 <dt><strong><a name="item_integer"><em>integer</em></a></strong>
 
 <dd>
-<p>Specifies an integer number</p>
+<p>(Internal name TT_INTEGER)</p>
 </dd>
 </li>
 <dt><strong><a name="item_double"><em>double</em></a></strong>
 
 <dd>
-<p>Specifies a double number</p>
+<p>(Internal name TT_DOUBLE)</p>
 </dd>
 </li>
 <dt><strong><a name="item_string"><em>string</em></a></strong>
 
 <dd>
-<p>Specifies a string</p>
+<p>(Internal name TT_STRING)</p>
+</dd>
+</li>
+<dt><strong><a name="item_array"><em>array</em></a></strong>
+
+<dd>
+<p>(Internal name TT_ARRAY)</p>
 </dd>
 </li>
 <dt><strong><a name="item_number"><em>number</em></a></strong>
@@ -184,98 +266,47 @@ TODO file of the source distribution of Fype!</p>
 <p>
 </p>
 <h2><a name="explicit_type_conversions">Explicit type conversions</a></h2>
+<p>The data types inside the brackets are only showing the return types of each function.</p>
 <dl>
 <dt><strong><a name="item__28integer_29_integer_any">(<em>integer</em>) <strong>integer</strong> <em>any</em></a></strong>
 
 <dd>
-<p>Converts any type to an integer</p>
+<p>Converts any type to an integer.</p>
 </dd>
 </li>
 <dt><strong><a name="item__28double_29_double_any">(<em>double</em>) <strong>double</strong> <em>any</em></a></strong>
 
 <dd>
-<p>Converts any type to a double</p>
+<p>Converts any type to a double.</p>
 </dd>
 </li>
 <dt><strong><a name="item__28string_29_string_any">(<em>string</em>) <strong>string</strong> <em>any</em></a></strong>
 
 <dd>
-<p>Converts any type to a string</p>
+<p>Converts any type to a string.</p>
 </dd>
 </li>
-</dl>
-<p>
-</p>
-<hr />
-<h1><a name="syntax">SYNTAX</a></h1>
-<p>
-</p>
-<h2><a name="comments">Comments</a></h2>
-<p>Text from a <strong>#</strong> character until the end of the current line is considered being a comment. Multi line comments may start with an <strong>#*</strong> and and with an <strong>*#</strong> anywhere. Exceptions are if those signs are inside of strings.</p>
-<p>
-</p>
-<h2><a name="statements">Statements</a></h2>
-<p>A Fype program is a list of statements. Each keyword, expression or function call is part of a statement. Each statement is ended with a semicolon. Example:</p>
-<pre>
-        my bar = 3, foo = 1 + 2; 
-        say foo;
-        exit foo - bar;</pre>
-<p>
-</p>
-<h2><a name="paranthesis">Paranthesis</a></h2>
-<p>All paranthesis of function calls are optional. They help to make the code better readable. They also help to force precedences of expressions.</p>
-<p>
-</p>
-<h2><a name="scopeing">Scopeing</a></h2>
-<p>A new scope starts with an { and ends with an }. An exception is a procedure, which does not use its own scope (see later in this manual). Control statements and functions support scopeings. Here is a small example how to use scopes:</p>
-<pre>
-        my foo = 1;</pre>
-<pre>
-        {
-                # Prints out 1
-                put defined foo;
-                {
-                        my bar = 2;</pre>
-<pre>
-                        # Prints out 1
-                        put defined bar;
-                }</pre>
-<pre>
-                # Prints out 0
-                put defined bar;</pre>
-<pre>
-                my baz = 3;
-        }</pre>
-<pre>
-        # Prints out 0
-        say defined bar;</pre>
-<p>
-</p>
-<h2><a name="control_statements">Control statements</a></h2>
-<p>Fype knows the following control statements:</p>
-<dl>
-<dt><strong><a name="item_if__3cexpression_3e__7b__3cstatements_3e__7d">if <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
-
-<dd>
-<p>Runs the statements if the expression evaluates to a true value.</p>
-</dd>
-</li>
-<dt><strong><a name="item_ifnot__3cexpression_3e__7b__3cstatements_3e__7d">ifnot <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
+<dt><strong><a name="item__28array_29_array_any">(<em>array</em>) <strong>array</strong> <em>any</em></a></strong>
 
 <dd>
-<p>Runs the statements if the expression evaluates to a false value.</p>
+<p>Converts any type to an array. This function is not yet implemented.</p>
 </dd>
 </li>
-<dt><strong><a name="item_while__3cexpression_3e__7b__3cstatements_3e__7d">while <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
+</dl>
+<p>
+</p>
+<h2><a name="more_functions_for_data_types">More functions for data types</a></h2>
+<dl>
+<dt><strong><a name="item__28string_29_type_any">(<em>string</em>) <strong>type</strong> <em>any</em></a></strong>
 
 <dd>
-<p>Runs the statements as long as the the expression evaluates to a true value.</p>
+<p>Returns the name of the current type. Examples:</p>
 </dd>
-</li>
-<dt><strong><a name="item_until__3cexpression_3e__7b__3cstatements_3e__7d">until <em>&lt;expression</em>&gt; { <em>&lt;statements</em>&gt; }</a></strong>
-
 <dd>
-<p>Runs the statements as long as the the expression evaluates to a false value.</p>
+<pre>
+        my foo = 1;
+        put type foo; # Prints &quot;TT_INTEGER&quot;
+        put type 1.2; # Prints &quot;TT_DOUBLE&quot;</pre>
 </dd>
 </li>
 </dl>
@@ -580,7 +611,7 @@ keyword in order to check if a procedure has been defined or not.</p>
 </p>
 <hr />
 <h1><a name="see_also">SEE ALSO</a></h1>
-<p><code>awk(1)</code> <code>cc(1)</code> <code>make(1)</code>
+<p><code>awk(1)</code> <code>cc(1)</code> 
 
 </p>
 
diff --git a/docs/pod/fype.man b/docs/pod/fype.man
index b3d89bf..1be72ec 100644
--- a/docs/pod/fype.man
+++ b/docs/pod/fype.man
@@ -129,7 +129,7 @@
 .\" ========================================================================
 .\"
 .IX Title "FYPE 1"
-.TH FYPE 1 "2008-09-06" "Fype v0.1-devel Build 9208" "The Fype Users Manual Page"
+.TH FYPE 1 "2008-09-16" "Fype v0.1-devel Build 9269" "The Fype Users Manual Page"
 .SH "NAME"
 \&\fBFype\fR is \fBF\fRor \fBY\fRour \fBP\fRrogram \fBE\fRxecution
 .PP
@@ -201,43 +201,6 @@ Run a .fy file:
 .Ve
 .PP
 See the ./examples subdir of the Fype source distribution for examples! See also fype \-h for a list of all options.
-.SH "DATA TYPES"
-.IX Header "DATA TYPES"
-Fype uses auto type conversion. However, if you want to know what's going on you may take a look at the provided basic datatypes.
-.Sh "The basic data types"
-.IX Subsection "The basic data types"
-.IP "\fIinteger\fR" 4
-.IX Item "integer"
-Specifies an integer number
-.IP "\fIdouble\fR" 4
-.IX Item "double"
-Specifies a double number
-.IP "\fIstring\fR" 4
-.IX Item "string"
-Specifies a string
-.IP "\fInumber\fR" 4
-.IX Item "number"
-May be an integer or a double number
-.IP "\fIany\fR" 4
-.IX Item "any"
-May be of any type above
-.IP "\fIvoid\fR" 4
-.IX Item "void"
-No type
-.IP "\fIidentifier\fR" 4
-.IX Item "identifier"
-It's a variable name or a procedure name or a function name
-.Sh "Explicit type conversions"
-.IX Subsection "Explicit type conversions"
-.IP "(\fIinteger\fR) \fBinteger\fR \fIany\fR" 4
-.IX Item "(integer) integer any"