diff options
| author | Paul Buetow <paul@buetow.org> | 2008-05-15 23:28:07 +0000 |
|---|---|---|
| committer | Paul Buetow <paul@buetow.org> | 2008-05-15 23:28:07 +0000 |
| commit | be839900419c7a74c4a46efd279d0ca16b35dc1f (patch) | |
| tree | 1355c8f238d1c58ffd5cb8803bcc2adf987e79aa /docs | |
| parent | 33c945e58f86267b0d3bdca4c3421155e11eb0d9 (diff) | |
Moved stuff into trunk.
Diffstat (limited to 'docs')
| -rw-r--r-- | docs/header.txt | 31 | ||||
| -rw-r--r-- | docs/help.txt | 8 | ||||
| -rw-r--r-- | docs/pod/Makefile | 19 | ||||
| -rw-r--r-- | docs/pod/fype.1.gz | bin | 0 -> 6086 bytes | |||
| -rw-r--r-- | docs/pod/fype.html | 582 | ||||
| -rw-r--r-- | docs/pod/fype.man | 555 | ||||
| -rw-r--r-- | docs/pod/fype.pod | 446 | ||||
| -rw-r--r-- | docs/pod/fype.tex | 503 | ||||
| -rw-r--r-- | docs/pod/fype.txt | 381 | ||||
| -rw-r--r-- | docs/stats.txt | 4 | ||||
| -rw-r--r-- | docs/synopses.txt | 4 | ||||
| -rw-r--r-- | docs/version.txt | 1 |
12 files changed, 2534 insertions, 0 deletions
diff --git a/docs/header.txt b/docs/header.txt new file mode 100644 index 0000000..80e026d --- /dev/null +++ b/docs/header.txt @@ -0,0 +1,31 @@ +File: ${FILE} +A simple interpreter + +WWW : http://fype.buetow.org +E-Mail : fype@dev.buetow.org + +Copyright (c) 2005 2006 2007 2008, Paul Buetow (http://www.pblabs.net) +All rights reserved. + +Redistribution and use in source and binary forms, with or without modi- +fication, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of P. B. Labs nor the names of its contributors may + be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY Paul Buetow ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL Paul Buetow BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING +IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/docs/help.txt b/docs/help.txt new file mode 100644 index 0000000..4d952af --- /dev/null +++ b/docs/help.txt @@ -0,0 +1,8 @@ +Fype v0.0-devel Build 8865 +Copyright by Paul C. Buetow (2005 - 2008) <fype@dev.buetow.org> + -e Executes given code string (see synopses) + -h Prints this help + -s Prints the synopsis + -v Prints the current version + -T Prints token list after scanning + -V Verbose mode: Print all possible output diff --git a/docs/pod/Makefile b/docs/pod/Makefile new file mode 100644 index 0000000..d6f56fe --- /dev/null +++ b/docs/pod/Makefile @@ -0,0 +1,19 @@ + +all: man html latex txt +html: + pod2html fype.pod > fype.html +latex: + pod2latex fype.pod > fype.tex +man: + pod2man --release "`cat ../version.txt`" --center "The Fype Users Manual Page" fype.pod > fype.man + cp fype.man fype.1 + if [ -f fype.1.gz ]; then rm fype.1.gz; fi + gzip fype.1 +txt: + pod2text fype.pod | tee ../../README > fype.txt +pdf: + pod2pdf --footer-text="This document describes `cat ../version.txt`" fype.pod > fype.pdf +clean: + for i in html tex man 1.gz pdf; do \ + if [ -f $$i ]; then rm $$i; fi \ + done diff --git a/docs/pod/fype.1.gz b/docs/pod/fype.1.gz Binary files differnew file mode 100644 index 0000000..c270197 --- /dev/null +++ b/docs/pod/fype.1.gz diff --git a/docs/pod/fype.html b/docs/pod/fype.html new file mode 100644 index 0000000..b47abe9 --- /dev/null +++ b/docs/pod/fype.html @@ -0,0 +1,582 @@ +<?xml version="1.0" ?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml"> +<head> +<title>NAME</title> +<meta http-equiv="content-type" content="text/html; charset=utf-8" /> +<link rev="made" href="mailto:root@chuck.buetow.org" /> +</head> + +<body style="background-color: white"> + +<p><a name="__index__"></a></p> +<!-- INDEX BEGIN --> + +<ul> + + <li><a href="#name">NAME</a></li> + <li><a href="#synopses">SYNOPSES</a></li> + <li><a href="#about">ABOUT</a></li> + <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="#scopeing">Scopeing</a></li> + <li><a href="#control_statements">Control statements</a></li> + </ul> + + <li><a href="#variables">VARIABLES</a></li> + <li><a href="#built_in_functions">BUILT IN FUNCTIONS</a></li> + <ul> + + <li><a href="#math">Math</a></li> + <li><a href="#conditional">Conditional</a></li> + <li><a href="#definedness">Definedness</a></li> + <li><a href="#bitwise">Bitwise</a></li> + <li><a href="#numeric">Numeric</a></li> + <li><a href="#system">System</a></li> + <li><a href="#i_o">I/O</a></li> + </ul> + + <li><a href="#self_defining_procedures_and_functions">SELF DEFINING PROCEDURES AND FUNCTIONS</a></li> + <ul> + + <li><a href="#procedures">Procedures</a></li> + <li><a href="#nested_procedures">Nested procedures</a></li> + <li><a href="#functions">Functions</a></li> + <li><a href="#nested_functions">Nested functions</a></li> + </ul> + + <li><a href="#author">AUTHOR</a></li> + <li><a href="#website">WEBSITE</a></li> + <li><a href="#see_also">SEE ALSO</a></li> +</ul> +<!-- INDEX END --> + +<hr /> +<p> +</p> +<h1><a name="name">NAME</a></h1> +<p><strong>Fype</strong> is <strong>f</strong>or <strong>y</strong>our <strong>p</strong>rogram <strong>e</strong>xecution</p> +<p><strong>Fype</strong> is <strong>f</strong>ree <strong>y</strong>ack <strong>p</strong>rogramed for <strong>E</strong>LF</p> +<p>It's not a hype - it's Fype!</p> +<p> +</p> +<hr /> +<h1><a name="synopses">SYNOPSES</a></h1> +<dl> +<dt><strong><a name="item_fype__5b_2d_5bhsvtv_5d_5d_file_2efy"><strong>fype</strong> [-[hsvTV]] file.fy</a></strong> + +<dt><strong><a name="item_fype__2de__22fype_code_string_3b_22"><strong>fype</strong> -e ``fype code string;''</a></strong> + +</dl> +<p> +</p> +<hr /> +<h1><a name="about">ABOUT</a></h1> +<p>Fype is not yet released! Lots of basic stuff is still missing! See the +TODO file of the source distribution of Fype!</p> +<p>Fype is a 32 bit scripting language created for fun. You can use it and comment on it if you like. You could also write patches and mail them to fype at dev dot buetow dot org! Or go visit the IRC channel #coding at irc.german-elite.net and ask rantanplan.</p> +<p>Fype is developed under the BSD license. See the COPYING file which is included in the source tree.</p> +<p>Fype should be ``at least as good as AWK''. This does not mean it will be a replacement for AWK but it should support functions, loops and arrays like AWK does but with a different syntax. It should also get extension support like AWK has. I am not talking about GNU AWK but about New AWK, which is included in the *BSD distributions! Fype already has a few features which are not available in AWK. However, AWK has still many features which are not available in Fype as well ;)</p> +<p>Fancy stuff like OOP or unicode or threading is not yet planed. But fancy stuff like function pointers and closures may be considered for one of the first releases of Fype :)</p> +<p> +</p> +<hr /> +<h1><a name="parsing___code_generation">PARSING / CODE GENERATION</a></h1> +<p>The Fype syntax is very simple and is using a maximum look ahead of 1 and a very easy top down parsing. Fype is parsing and interpreting its code simultaneous. This means, that syntax errors are only detected during program runtime.</p> +<p> +</p> +<hr /> +<h1><a name="requirements">REQUIREMENTS</a></h1> +<p>Fype only has been tested on FreeBSD 7.0. Linux may work too. Windows support is not planned. But may work using Cygwin or SFU.</p> +<p>You will also need:</p> +<pre> + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) (it's included in any *BSD)</pre> +<p> +</p> +<hr /> +<h1><a name="getting_started">GETTING STARTED</a></h1> +<p>Extract, compile and install Fype:</p> +<pre> + tar xvjf fype.tar.bz2 + cd fype + make + sudo make install + make clean</pre> +<p>Run a .fy file:</p> +<pre> + fype test.fy</pre> +<p>See the ./examples subdir of the Fype source distribution for examples! See also fype -h for a list of all options.</p> +<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> +</p> +<h2><a name="the_basic_data_types">The basic data types</a></h2> +<dl> +<dt><strong><a name="item_integer"><em>integer</em></a></strong> + +<dd> +<p>Specifies an integer number</p> +</dd> +</li> +<dt><strong><a name="item_double"><em>double</em></a></strong> + +<dd> +<p>Specifies a double number</p> +</dd> +</li> +<dt><strong><a name="item_string"><em>string</em></a></strong> + +<dd> +<p>Specifies a string</p> +</dd> +</li> +<dt><strong><a name="item_number"><em>number</em></a></strong> + +<dd> +<p>May be an integer or a double number</p> +</dd> +</li> +<dt><strong><a name="item_any"><em>any</em></a></strong> + +<dd> +<p>May be of any type above</p> +</dd> +</li> +<dt><strong><a name="item_void"><em>void</em></a></strong> + +<dd> +<p>No type</p> +</dd> +</li> +<dt><strong><a name="item_identifier"><em>identifier</em></a></strong> + +<dd> +<p>It's a variable name or a procedure name or a function name</p> +</dd> +</li> +</dl> +<p> +</p> +<h2><a name="explicit_type_conversions">Explicit type conversions</a></h2> +<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> +</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> +</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> +</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><expression</em>> { <em><statements</em>> }</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><expression</em>> { <em><statements</em>> }</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><expression</em>> { <em><statements</em>> }</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><expression</em>> { <em><statements</em>> }</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="variables">VARIABLES</a></h1> +<p>Variables can be defined with the <strong>my</strong> 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 <strong>undef</strong> keyword! Example of defining variables:</p> +<pre> + my foo = 1 + 2; + say foo;</pre> +<pre> + my bar = 12, baz = foo; + say 1 + bar; + say bar;</pre> +<pre> + my baz; + say baz; # Will print out 0</pre> +<p>You may use the <strong>defined</strong> keyword to check if an identifier has been defined or +not.</p> +<pre> + ifnot defined foo { + say "No foo yet defined"; + }</pre> +<pre> + my foo = 1;</pre> +<pre> + if defined foo { + put "foo is defined and has the value "; + say foo; + }</pre> +<p> +</p> +<hr /> +<h1><a name="built_in_functions">BUILT IN FUNCTIONS</a></h1> +<p>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.</p> +<p> +</p> +<h2><a name="math">Math</a></h2> +<dl> +<dt><strong><a name="item__28any_29_any__2b_any">(<em>any</em>) <em>any</em> <strong>+</strong> <em>any</em></a></strong> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +</li> +<dt><strong><a name="item__28any_29_any__2d_any">(<em>any</em>) <em>any</em> <strong>-</strong> <em>any</em></a></strong> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +</li> +<dt><strong><a name="item__28any_29_any__2a_any">(<em>any</em>) <em>any</em> <strong>*</strong> <em>any</em></a></strong> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +</li> +<dt><strong><a name="item__28any_29_any__2f_any">(<em>any</em>) <em>any</em> <strong>/</strong> <em>any</em></a></strong> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +</li> +</dl> +<p> +</p> +<h2><a name="conditional">Conditional</a></h2> +<dl> +<dt><strong><a name="item__28integer_29_any__3d_3d_any">(<em>integer</em>) <em>any</em> <strong>==</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28integer_29_any__21_3d_any">(<em>integer</em>) <em>any</em> <strong>!=</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28integer_29_any__3c_3d_any">(<em>integer</em>) <em>any</em> <strong><=</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28integer_29_any__3e_3d_any">(<em>integer</em>) <em>any</em> <strong>>=</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28integer_29_any__3c_any">(<em>integer</em>) <em>any</em> <strong><</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28integer_29_any__3e_any">(<em>integer</em>) <em>any</em> <strong>></strong> <em>any</em></a></strong> + +</dl> +<p> +</p> +<h2><a name="definedness">Definedness</a></h2> +<dl> +<dt><strong><a name="item__28integer_29_defined_identifier">(<em>integer</em>) <strong>defined</strong> <em>identifier</em></a></strong> + +<dd> +<p>Returns 1 if <em>identifier</em> has been defined. Returns 0 else.</p> +</dd> +</li> +<dt><strong><a name="item__28integer_29_undef_identifier">(<em>integer</em>) <strong>undef</strong> <em>identifier</em></a></strong> + +<dd> +<p>Tries to undefine/delete the <em>identifier</em>. Returns 1 if success, otherwise 0 is returned.</p> +</dd> +</li> +</dl> +<p> +</p> +<h2><a name="bitwise">Bitwise</a></h2> +<p>Bitwise operators do not work ATM. The fix is on its way!</p> +<dl> +<dt><strong><a name="item__28any_29_any__3c_3c_any">(<em>any</em>) <em>any</em> <strong><<</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28any_29_any__3e_3e_any">(<em>any</em>) <em>any</em> <strong>>></strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28any_29_any_and_any">(<em>any</em>) <em>any</em> <strong>and</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28any_29_any_or_any">(<em>any</em>) <em>any</em> <strong>or</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28any_29_any_xor_any">(<em>any</em>) <em>any</em> <strong>xor</strong> <em>any</em></a></strong> + +<dt><strong><a name="item__28any_29_not_any">(<em>any</em>) <strong>not</strong> <em>any</em></a></strong> + +</dl> +<p> +</p> +<h2><a name="numeric">Numeric</a></h2> +<dl> +<dt><strong><a name="item__28number_29_neg_number">(<em>number</em>) <strong>neg</strong> <em>number</em></a></strong> + +<dd> +<p>This function returns the negative value of <em>any</em></p> +</dd> +</li> +<dt><strong><a name="item__28integer_29_no__5binteger_5d">(<em>integer</em>) <strong>no</strong> [<em>integer</em>]</a></strong> + +<dd> +<p>This function returns 1 if the argument is 0, otherwise it will return 0! If no +argument is given, then 0 is returned!</p> +</dd> +</li> +<dt><strong><a name="item__28integer_29_yes__5binteger_5d">(<em>integer</em>) <strong>yes</strong> [<em>integer</em>]</a></strong> + +<dd> +<p>This function always returns 1. The parameter is optional. +</p> +</dd> +<dd> +<pre> + + # Prints out 1, because foo is not defined + if yes { say no defined foo; }</pre> +</dd> +</li> +</dl> +<p> +</p> +<h2><a name="system">System</a></h2> +<dl> +<dt><strong><a name="item__28void_29_end">(<em>void</em>) <strong>end</strong></a></strong> + +<dd> +<p>Exits the program with the exit status of 0</p> +</dd> +</li> +<dt><strong><a name="item__28void_29_exit_integer">(<em>void</em>) <strong>exit</strong> <em>integer</em></a></strong> + +<dd> +<p>Exits the program with the specified exit status</p> +</dd> +</li> +<dt><strong><a name="item__28integer_29_fork">(<em>integer</em>) <strong>fork</strong></a></strong> + +<dd> +<p>Fork forks a subprocess. It returns 0 for the child process and the pid of the +child process otherwise! Example:</p> +</dd> +<dd> +<pre> + my pid = fork;</pre> +</dd> +<dd> +<pre> + if pid { + put "I am the parent process; child has the pid "; + say pid;</pre> +</dd> +<dd> +<pre> + } ifnot pid { + say "I am the child process"; + }</pre> +</dd> +</li> +<dt><strong><a name="item__28integer_29_gc">(<em>integer</em>) <strong>gc</strong></a></strong> + +<dd> +<p>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!</p> +</dd> +</li> +</dl> +<p> +</p> +<h2><a name="i_o">I/O</a></h2> +<dl> +<dt><strong><a name="item__28any_29_put_any">(<em>any</em>) <strong>put</strong> <em>any</em></a></strong> + +<dd> +<p>Prints out the argument</p> +</dd> +</li> +<dt><strong><a name="item__28any_29_say_any">(<em>any</em>) <strong>say</strong> <em>any</em></a></strong> + +<dd> +<p>Same as put, but also includes an ending newline</p> +</dd> +</li> +<dt><strong><a name="item__28void_29_ln">(<em>void</em>) <strong>ln</strong></a></strong> + +<dd> +<p>Just prints a newline</p> +</dd> +</li> +</dl> +<p> +</p> +<hr /> +<h1><a name="self_defining_procedures_and_functions">SELF DEFINING PROCEDURES AND FUNCTIONS</a></h1> +<p> +</p> +<h2><a name="procedures">Procedures</a></h2> +<p>A procedure can be defined with the <strong>proc</strong> keyword and deleted with the <strong>undef</strong> 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.</p> +<pre> + proc foo { + say 1 + a * 3 + b; + my c = 6; + }</pre> +<pre> + my a = 2, b = 4;</pre> +<pre> + foo; # Run the procedure. Print out "11\n" + say c; # Print out "6\n";</pre> +<p> +</p> +<h2><a name="nested_procedures">Nested procedures</a></h2> +<p>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 <strong>defined</strong> +keyword in order to check if a procedure has been defined or not.</p> +<pre> + proc foo { + say "I am foo";</pre> +<pre> + undef bar; + proc bar { + say "I am bar"; + } + }</pre> +<pre> + # Here bar would produce an error because + # the proc is not yet defined! + # bar;</pre> +<pre> + 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!</pre> +<p> +</p> +<h2><a name="functions">Functions</a></h2> +<p>A function should be defined with the <strong>func</strong> keyword and deleted with the <strong>undef</strong> 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).</p> +<pre> + func foo { + say 1 + a * 3 + b; + my c = 6; + }</pre> +<pre> + my a = 2, b = 4;</pre> +<pre> + foo; # Run the procedure. Print out "11\n" + say c; # Will produce an error, because c is out of scoped!</pre> +<p> +</p> +<h2><a name="nested_functions">Nested functions</a></h2> +<p>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!</p> +<pre> + func foo { + func bar { + say "Hello i am nested"; + }</pre> +<pre> + bar; # Calling nested + }</pre> +<pre> + foo; + bar; # Will produce an error, because bar is out of scope!</pre> +<p> +</p> +<hr /> +<h1><a name="author">AUTHOR</a></h1> +<p>Paul C. Buetow (http://paul.buetow.org)</p> +<p> +</p> +<hr /> +<h1><a name="website">WEBSITE</a></h1> +<p>The Fype Language (http://fype.buetow.org)</p> +<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> + +</body> + +</html> diff --git a/docs/pod/fype.man b/docs/pod/fype.man new file mode 100644 index 0000000..0a04c66 --- /dev/null +++ b/docs/pod/fype.man @@ -0,0 +1,555 @@ +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.32 +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sh \" Subsection heading +.br +.if t .Sp +.ne 5 +.PP +\fB\\$1\fR +.PP +.. +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" Set up some character translations and predefined strings. \*(-- will +.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left +.\" double quote, and \*(R" will give a right double quote. | will give a +.\" real vertical bar. \*(C+ will give a nicer C++. Capital omega is used to +.\" do unbreakable dashes and therefore won't be available. \*(C` and \*(C' +.\" expand to `' in nroff, nothing in troff, for use with C<>. +.tr \(*W-|\(bv\*(Tr +.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' +.ie n \{\ +. ds -- \(*W- +. ds PI pi +. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch +. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch +. ds L" "" +. ds R" "" +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds -- \|\(em\| +. ds PI \(*p +. ds L" `` +. ds R" '' +'br\} +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.if \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.\" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.hy 0 +.if n .na +.\" +.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). +.\" Fear. Run. Save yourself. No user-serviceable parts. +. \" fudge factors for nroff and troff +.if n \{\ +. ds #H 0 +. ds #V .8m +. ds #F .3m +. ds #[ \f1 +. ds #] \fP +.\} +.if t \{\ +. ds #H ((1u-(\\\\n(.fu%2u))*.13m) +. ds #V .6m +. ds #F 0 +. ds #[ \& +. ds #] \& +.\} +. \" simple accents for nroff and troff +.if n \{\ +. ds ' \& +. ds ` \& +. ds ^ \& +. ds , \& +. ds ~ ~ +. ds / +.\} +.if t \{\ +. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" +. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' +. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' +. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' +. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' +. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' +.\} +. \" troff and (daisy-wheel) nroff accents +.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' +.ds 8 \h'\*(#H'\(*b\h'-\*(#H' +.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] +.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' +.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' +.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] +.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] +.ds ae a\h'-(\w'a'u*4/10)'e +.ds Ae A\h'-(\w'A'u*4/10)'E +. \" corrections for vroff +.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' +.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' +. \" for low resolution devices (crt and lpr) +.if \n(.H>23 .if \n(.V>19 \ +\{\ +. ds : e +. ds 8 ss +. ds o a +. ds d- d\h'-1'\(ga +. ds D- D\h'-1'\(hy +. ds th \o'bp' +. ds Th \o'LP' +. ds ae ae +. ds Ae AE +.\} +.rm #[ #] #H #V #F C +.\" ======================================================================== +.\" +.IX Title "FYPE 1" +.TH FYPE 1 "2008-04-25" "Fype v0.0-devel Build 8860" "The Fype Users Manual Page" +.SH "NAME" +\&\fBFype\fR is \fBf\fRor \fBy\fRour \fBp\fRrogram \fBe\fRxecution +.PP +\&\fBFype\fR is \fBf\fRree \fBy\fRack \fBp\fRrogramed for \fBE\fRLF +.PP +It's not a hype \- it's Fype! +.SH "SYNOPSES" +.IX Header "SYNOPSES" +.IP "\fBfype\fR [\-[hsvTV]] file.fy" 4 +.IX Item "fype [-[hsvTV]] file.fy" +.PD 0 +.ie n .IP "\fBfype\fR \-e ""fype code string;""" 4 +.el .IP "\fBfype\fR \-e ``fype code string;''" 4 +.IX Item "fype -e fype code string;" +.PD +.SH "ABOUT" +.IX Header "ABOUT" +Fype is not yet released! Lots of basic stuff is still missing! See the +\&\s-1TODO\s0 file of the source distribution of Fype! +.PP +Fype is a 32 bit scripting language created for fun. You can use it and comment on it if you like. You could also write patches and mail them to fype at dev dot buetow dot org! Or go visit the \s-1IRC\s0 channel #coding at irc.german\-elite.net and ask rantanplan. +.PP +Fype is developed under the \s-1BSD\s0 license. See the \s-1COPYING\s0 file which is included in the source tree. +.PP +Fype should be \*(L"at least as good as \s-1AWK\s0\*(R". This does not mean it will be a replacement for \s-1AWK\s0 but it should support functions, loops and arrays like \s-1AWK\s0 does but with a different syntax. It should also get extension support like \s-1AWK\s0 has. I am not talking about \s-1GNU\s0 \s-1AWK\s0 but about New \s-1AWK\s0, which is included in the *BSD distributions! Fype already has a few features which are not available in \s-1AWK\s0. However, \s-1AWK\s0 has still many features which are not available in Fype as well ;) +.PP +Fancy stuff like \s-1OOP\s0 or unicode or threading is not yet planed. But fancy stuff like function pointers and closures may be considered for one of the first releases of Fype :) +.SH "PARSING / CODE GENERATION" +.IX Header "PARSING / CODE GENERATION" +The Fype syntax is very simple and is using a maximum look ahead of 1 and a very easy top down parsing. Fype is parsing and interpreting its code simultaneous. This means, that syntax errors are only detected during program runtime. +.SH "REQUIREMENTS" +.IX Header "REQUIREMENTS" +Fype only has been tested on FreeBSD 7.0. Linux may work too. Windows support is not planned. But may work using Cygwin or \s-1SFU\s0. +.PP +You will also need: +.PP +.Vb 2 +\& GNU GCC C Compiler (gcc.gnu.org) +\& NetBSD Make aka pmake (GNU Make will not work) (it's included in any *BSD) +.Ve +.SH "GETTING STARTED" +.IX Header "GETTING STARTED" +Extract, compile and install Fype: +.PP +.Vb 5 +\& tar xvjf fype.tar.bz2 +\& cd fype +\& make +\& sudo make install +\& make clean +.Ve +.PP +Run a .fy file: +.PP +.Vb 1 +\& fype test.fy +.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" +Converts any type to an integer +.IP "(\fIdouble\fR) \fBdouble\fR \fIany\fR" 4 +.IX Item "(double) double any" +Converts any type to a double +.IP "(\fIstring\fR) \fBstring\fR \fIany\fR" 4 +.IX Item "(string) string any" +Converts any type to a string +.SH "SYNTAX" +.IX Header "SYNTAX" +.Sh "Comments" +.IX Subsection "Comments" +Text from a \fB#\fR character until the end of the current line is considered being a comment. Multi line comments may start with an \fB#*\fR and and with an \fB*#\fR anywhere. Exceptions are if those signs are inside of strings. +.Sh "Statements" +.IX Subsection "Statements" +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: +.PP +.Vb 3 +\& my bar = 3, foo = 1 + 2; +\& say foo; +\& exit foo - bar; +.Ve +.Sh "Paranthesis" +.IX Subsection "Paranthesis" +All paranthesis of function calls are optional. They help to make the code better readable. They also help to force precedences of expressions. +.Sh "Scopeing" +.IX Subsection "Scopeing" +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: +.PP +.Vb 1 +\& my foo = 1; +.Ve +.PP +.Vb 5 +\& { +\& # Prints out 1 +\& put defined foo; +\& { +\& my bar = 2; +.Ve +.PP +.Vb 3 +\& # Prints out 1 +\& put defined bar; +\& } +.Ve +.PP +.Vb 2 +\& # Prints out 0 +\& put defined bar; +.Ve +.PP +.Vb 2 +\& my baz = 3; +\& } +.Ve +.PP +.Vb 2 +\& # Prints out 0 +\& say defined bar; +.Ve +.Sh "Control statements" +.IX Subsection "Control statements" +Fype knows the following control statements: +.IP "if \fI<expression\fR> { \fI<statements\fR> }" 4 +.IX Item "if <expression> { <statements> }" +Runs the statements if the expression evaluates to a true value. +.IP "ifnot \fI<expression\fR> { \fI<statements\fR> }" 4 +.IX Item "ifnot <expression> { <statements> }" +Runs the statements if the expression evaluates to a false value. +.IP "while \fI<expression\fR> { \fI<statements\fR> }" 4 +.IX Item "while <expression> { <statements> }" +Runs the statements as long as the the expression evaluates to a true value. +.IP "until \fI<expression\fR> { \fI<statements\fR> }" 4 +.IX Item "until <expression> { <statements> }" +Runs the statements as long as the the expression evaluates to a false value. +.SH "VARIABLES" +.IX Header "VARIABLES" +Variables can be defined with the \fBmy\fR 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 \fBundef\fR keyword! Example of defining variables: +.PP +.Vb 2 +\& my foo = 1 + 2; +\& say foo; +.Ve +.PP +.Vb 3 +\& my bar = 12, baz = foo; +\& say 1 + bar; +\& say bar; +.Ve +.PP +.Vb 2 +\& my baz; +\& say baz; # Will print out 0 +.Ve +.PP +You may use the \fBdefined\fR keyword to check if an identifier has been defined or +not. +.PP +.Vb 3 +\& ifnot defined foo { +\& say "No foo yet defined"; +\& } +.Ve +.PP +.Vb 1 +\& my foo = 1; +.Ve +.PP +.Vb 4 +\& if defined foo { +\& put "foo is defined and has the value "; +\& say foo; +\& } +.Ve +.SH "BUILT IN FUNCTIONS" +.IX Header "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. +.Sh "Math" +.IX Subsection "Math" +.IP "(\fIany\fR) \fIany\fR \fB+\fR \fIany\fR" 4 +.IX Item "(any) any + any" +Special string behavior: A string will get auto convertet into an \fIinteger\fR. +.IP "(\fIany\fR) \fIany\fR \fB\-\fR \fIany\fR" 4 +.IX Item "(any) any - any" +Special string behavior: A string will get auto convertet into an \fIinteger\fR. +.IP "(\fIany\fR) \fIany\fR \fB*\fR \fIany\fR" 4 +.IX Item "(any) any * any" +Special string behavior: A string will get auto convertet into an \fIinteger\fR. +.IP "(\fIany\fR) \fIany\fR \fB/\fR \fIany\fR" 4 +.IX Item "(any) any / any" +Special string behavior: A string will get auto convertet into an \fIinteger\fR. +.Sh "Conditional" +.IX Subsection "Conditional" +.IP "(\fIinteger\fR) \fIany\fR \fB==\fR \fIany\fR" 4 +.IX Item "(integer) any == any" +.PD 0 +.IP "(\fIinteger\fR) \fIany\fR \fB!=\fR \fIany\fR" 4 +.IX Item "(integer) any != any" +.IP "(\fIinteger\fR) \fIany\fR \fB<=\fR \fIany\fR" 4 +.IX Item "(integer) any <= any" +.IP "(\fIinteger\fR) \fIany\fR \fB>=\fR \fIany\fR" 4 +.IX Item "(integer) any >= any" +.IP "(\fIinteger\fR) \fIany\fR \fB<\fR \fIany\fR" 4 +.IX Item "(integer) any < any" +.IP "(\fIinteger\fR) \fIany\fR \fB>\fR \fIany\fR" 4 +.IX Item "(integer) any > any" +.PD +.Sh "Definedness" +.IX Subsection "Definedness" +.IP "(\fIinteger\fR) \fBdefined\fR \fIidentifier\fR" 4 +.IX Item "(integer) defined identifier" +Returns 1 if \fIidentifier\fR has been defined. Returns 0 else. +.IP "(\fIinteger\fR) \fBundef\fR \fIidentifier\fR" 4 +.IX Item "(integer) undef identifier" +Tries to undefine/delete the \fIidentifier\fR. Returns 1 if success, otherwise 0 is returned. +.Sh "Bitwise" +.IX Subsection "Bitwise" +Bitwise operators do not work \s-1ATM\s0. The fix is on its way! +.IP "(\fIany\fR) \fIany\fR \fB<<\fR \fIany\fR" 4 +.IX Item "(any) any << any" +.PD 0 +.IP "(\fIany\fR) \fIany\fR \fB>>\fR \fIany\fR" 4 +.IX Item "(any) any >> any" +.IP "(\fIany\fR) \fIany\fR \fBand\fR \fIany\fR" 4 +.IX Item "(any) any and any" +.IP "(\fIany\fR) \fIany\fR \fBor\fR \fIany\fR" 4 +.IX Item "(any) any or any" +.IP "(\fIany\fR) \fIany\fR \fBxor\fR \fIany\fR" 4 +.IX Item "(any) any xor any" +.IP "(\fIany\fR) \fBnot\fR \fIany\fR" 4 +.IX Item "(any) not any" +.PD +.Sh "Numeric" +.IX Subsection "Numeric" +.IP "(\fInumber\fR) \fBneg\fR \fInumber\fR" 4 +.IX Item "(number) neg number" +This function returns the negative value of \fIany\fR +.IP "(\fIinteger\fR) \fBno\fR [\fIinteger\fR]" 4 +.IX Item "(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! +.IP "(\fIinteger\fR) \fByes\fR [\fIinteger\fR]" 4 +.IX Item "(integer) yes [integer]" +This function always returns 1. The parameter is optional. +.Sp +.Vb 2 +\& # Prints out 1, because foo is not defined +\& if yes { say no defined foo; } +.Ve +.Sh "System" +.IX Subsection "System" +.IP "(\fIvoid\fR) \fBend\fR" 4 +.IX Item "(void) end" +Exits the program with the exit status of 0 +.IP "(\fIvoid\fR) \fBexit\fR \fIinteger\fR" 4 +.IX Item "(void) exit integer" +Exits the program with the specified exit status +.IP "(\fIinteger\fR) \fBfork\fR" 4 +.IX Item "(integer) fork" +Fork forks a subprocess. It returns 0 for the child process and the pid of the +child process otherwise! Example: +.Sp +.Vb 1 +\& my pid = fork; +.Ve +.Sp +.Vb 3 +\& if pid { +\& put "I am the parent process; child has the pid "; +\& say pid; +.Ve +.Sp +.Vb 3 +\& } ifnot pid { +\& say "I am the child process"; +\& } +.Ve +.IP "(\fIinteger\fR) \fBgc\fR" 4 +.IX Item "(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! +.Sh "I/O" +.IX Subsection "I/O" +.IP "(\fIany\fR) \fBput\fR \fIany\fR" 4 +.IX Item "(any) put any" +Prints out the argument +.IP "(\fIany\fR) \fBsay\fR \fIany\fR" 4 +.IX Item "(any) say any" +Same as put, but also includes an ending newline +.IP "(\fIvoid\fR) \fBln\fR" 4 +.IX Item "(void) ln" +Just prints a newline +.SH "SELF DEFINING PROCEDURES AND FUNCTIONS" +.IX Header "SELF DEFINING PROCEDURES AND FUNCTIONS" +.Sh "Procedures" +.IX Subsection "Procedures" +A procedure can be defined with the \fBproc\fR keyword and deleted with the \fBundef\fR 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. +.PP +.Vb 4 +\& proc foo { +\& say 1 + a * 3 + b; +\& my c = 6; +\& } +.Ve +.PP +.Vb 1 +\& my a = 2, b = 4; +.Ve +.PP +.Vb 2 +\& foo; # Run the procedure. Print out "11\en" +\& say c; # Print out "6\en"; +.Ve +.Sh "Nested procedures" +.IX Subsection "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 \fBdefined\fR +keyword in order to check if a procedure has been defined or not. +.PP +.Vb 2 +\& proc foo { +\& say "I am foo"; +.Ve +.PP +.Vb 5 +\& undef bar; +\& proc bar { +\& say "I am bar"; +\& } +\& } +.Ve +.PP +.Vb 3 +\& # Here bar would produce an error because +\& # the proc is not yet defined! +\& # bar; +.Ve +.PP +.Vb 3 +\& 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! +.Ve +.Sh "Functions" +.IX Subsection "Functions" +A function should be defined with the \fBfunc\fR keyword and deleted with the \fBundef\fR 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). +.PP +.Vb 4 +\& func foo { +\& say 1 + a * 3 + b; +\& my c = 6; +\& } +.Ve +.PP +.Vb 1 +\& my a = 2, b = 4; +.Ve +.PP +.Vb 2 +\& foo; # Run the procedure. Print out "11\en" +\& say c; # Will produce an error, because c is out of scoped! +.Ve +.Sh "Nested functions" +.IX Subsection "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! +.PP +.Vb 4 +\& func foo { +\& func bar { +\& say "Hello i am nested"; +\& } +.Ve +.PP +.Vb 2 +\& bar; # Calling nested +\& } +.Ve +.PP +.Vb 2 +\& foo; +\& bar; # Will produce an error, because bar is out of scope! +.Ve +.SH "AUTHOR" +.IX Header "AUTHOR" +Paul C. Buetow (http://paul.buetow.org) +.SH "WEBSITE" +.IX Header "WEBSITE" +The Fype Language (http://fype.buetow.org) +.SH "SEE ALSO" +.IX Header "SEE ALSO" +\&\fIawk\fR\|(1) \fIcc\fR\|(1) \fImake\fR\|(1) diff --git a/docs/pod/fype.pod b/docs/pod/fype.pod new file mode 100644 index 0000000..6628322 --- /dev/null +++ b/docs/pod/fype.pod @@ -0,0 +1,446 @@ +=head1 NAME + +B<Fype> is B<f>or B<y>our B<p>rogram B<e>xecution + +B<Fype> is B<f>ree B<y>ack B<p>rogramed for B<E>LF + +It's not a hype - it's Fype! + +=head1 SYNOPSES + +=over + +=item B<fype> [-[hsvTV]] file.fy + +=item B<fype> -e "fype code string;" + +=back + +=head1 ABOUT + +Fype is not yet released! Lots of basic stuff is still missing! See the +TODO file of the source distribution of Fype! + +Fype is a 32 bit scripting language created for fun. You can use it and comment on it if you like. You could also write patches and mail them to fype at dev dot buetow dot org! Or go visit the IRC channel #coding at irc.german-elite.net and ask rantanplan. + +Fype is developed under the BSD license. See the COPYING file which is included in the source tree. + +Fype should be "at least as good as AWK". This does not mean it will be a replacement for AWK but it should support functions, loops and arrays like AWK does but with a different syntax. It should also get extension support like AWK has. I am not talking about GNU AWK but about New AWK, which is included in the *BSD distributions! Fype already has a few features which are not available in AWK. However, AWK has still many features which are not available in Fype as well ;) + +Fancy stuff like OOP or unicode or threading is not yet planed. But fancy stuff like function pointers and closures may be considered for one of the first releases of Fype :) + +=head1 PARSING / CODE GENERATION + +The Fype syntax is very simple and is using a maximum look ahead of 1 and a very easy top down parsing. Fype is parsing and interpreting its code simultaneous. This means, that syntax errors are only detected during program runtime. + +=head1 REQUIREMENTS + +Fype only has been tested on FreeBSD 7.0. Linux may work too. Windows support is not planned. But may work using Cygwin or SFU. + +You will also need: + + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) (it's included in any *BSD) + +=head1 GETTING STARTED + +Extract, compile and install Fype: + + tar xvjf fype.tar.bz2 + cd fype + make + sudo make install + make clean + +Run a .fy file: + + fype test.fy + +See the ./examples subdir of the Fype source distribution for examples! See also fype -h for a list of all options. + +=head1 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. + +=head2 The basic data types + +=over + +=item I<integer> + +Specifies an integer number + +=item I<double> + +Specifies a double number + +=item I<string> + +Specifies a string + +=item I<number> + +May be an integer or a double number + +=item I<any> + +May be of any type above + +=item I<void> + +No type + +=item I<identifier> + +It's a variable name or a procedure name or a function name + +=back + +=head2 Explicit type conversions + +=over + +=item (I<integer>) B<integer> I<any> + +Converts any type to an integer + +=item (I<double>) B<double> I<any> + +Converts any type to a double + +=item (I<string>) B<string> I<any> + +Converts any type to a string + +=back + +=head1 SYNTAX + +=head2 Comments + +Text from a B<#> character until the end of the current line is considered being a comment. Multi line comments may start with an B<#*> and and with an B<*#> anywhere. Exceptions are if those signs are inside of strings. + +=head2 Statements + +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: + + my bar = 3, foo = 1 + 2; + say foo; + exit foo - bar; + +=head2 Paranthesis + +All paranthesis of function calls are optional. They help to make the code better readable. They also help to force precedences of expressions. + +=head2 Scopeing + +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: + + my foo = 1; + + { + # Prints out 1 + put defined foo; + { + my bar = 2; + + # Prints out 1 + put defined bar; + } + + # Prints out 0 + put defined bar; + + my baz = 3; + } + + # Prints out 0 + say defined bar; + +=head2 Control statements + +Fype knows the following control statements: + +=over + +=item if I<<expression>> { I<<statements>> } + +Runs the statements if the expression evaluates to a true value. + +=item ifnot I<<expression>> { I<<statements>> } + +Runs the statements if the expression evaluates to a false value. + +=item while I<<expression>> { I<<statements>> } + +Runs the statements as long as the the expression evaluates to a true value. + +=item until I<<expression>> { I<<statements>> } + +Runs the statements as long as the the expression evaluates to a false value. + +=back + +=head1 VARIABLES + +Variables can be defined with the B<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 B<undef> keyword! Example of defining variables: + + my foo = 1 + 2; + say foo; + + my bar = 12, baz = foo; + say 1 + bar; + say bar; + + my baz; + say baz; # Will print out 0 + +You may use the B<defined> keyword to check if an identifier has been defined or +not. + + ifnot defined foo { + say "No foo yet defined"; + } + + my foo = 1; + + if defined foo { + put "foo is defined and has the value "; + say foo; + } + +=head1 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. + +=head2 Math + +=over + +=item (I<any>) I<any> B<+> I<any> + +Special string behavior: A string will get auto convertet into an I<integer>. + +=item (I<any>) I<any> B<-> I<any> + +Special string behavior: A string will get auto convertet into an I<integer>. + +=item (I<any>) I<any> B<*> I<any> + +Special string behavior: A string will get auto convertet into an I<integer>. + +=item (I<any>) I<any> B</> I<any> + +Special string behavior: A string will get auto convertet into an I<integer>. + +=back + +=head2 Conditional + +=over + +=item (I<integer>) I<any> B<==> I<any> + +=item (I<integer>) I<any> B<!=> I<any> + +=item (I<integer>) I<any> B<<=> I<any> + +=item (I<integer>) I<any> B<E<gt>=> I<any> + +=item (I<integer>) I<any> B<<> I<any> + +=item (I<integer>) I<any> B<E<gt>> I<any> + +=back + +=head2 Definedness + +=over + +=item (I<integer>) B<defined> I<identifier> + +Returns 1 if I<identifier> has been defined. Returns 0 else. + +=item (I<integer>) B<undef> I<identifier> + +Tries to undefine/delete the I<identifier>. Returns 1 if success, otherwise 0 is returned. + +=back + +=head2 Bitwise + +Bitwise operators do not work ATM. The fix is on its way! + +=over + +=item (I<any>) I<any> B<<<> I<any> + +=item (I<any>) I<any> B<E<gt>E<gt>> I<any> + +=item (I<any>) I<any> B<and> I<any> + +=item (I<any>) I<any> B<or> I<any> + +=item (I<any>) I<any> B<xor> I<any> + +=item (I<any>) B<not> I<any> + +=back + +=head2 Numeric + +=over + +=item (I<number>) B<neg> I<number> + +This function returns the negative value of I<any> + +=item (I<integer>) B<no> [I<integer>] + +This function returns 1 if the argument is 0, otherwise it will return 0! If no +argument is given, then 0 is returned! + +=item (I<integer>) B<yes> [I<integer>] + +This function always returns 1. The parameter is optional. + + # Prints out 1, because foo is not defined + if yes { say no defined foo; } + +=back + +=head2 System + +=over + +=item (I<void>) B<end> + +Exits the program with the exit status of 0 + +=item (I<void>) B<exit> I<integer> + +Exits the program with the specified exit status + +=item (I<integer>) B<fork> + +Fork forks a subprocess. It returns 0 for the child process and the pid of the +child process otherwise! Example: + + my pid = fork; + + if pid { + put "I am the parent process; child has the pid "; + say pid; + + } ifnot pid { + say "I am the child process"; + } + +=item (I<integer>) B<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! + +=back + +=head2 I/O + +=over + +=item (I<any>) B<put> I<any> + +Prints out the argument + +=item (I<any>) B<say> I<any> + +Same as put, but also includes an ending newline + +=item (I<void>) B<ln> + +Just prints a newline + +=back + +=head1 SELF DEFINING PROCEDURES AND FUNCTIONS + +=head2 Procedures + +A procedure can be defined with the B<proc> keyword and deleted with the B<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; + + foo; # Run the procedure. Print out "11\n" + say c; # Print out "6\n"; + +=head2 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 B<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; + + 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! + +=head2 Functions + +A function should be defined with the B<func> keyword and deleted with the B<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; + + foo; # Run the procedure. Print out "11\n" + say c; # Will produce an error, because c is out of scoped! + +=head2 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! + + func foo { + func bar { + say "Hello i am nested"; + } + + bar; # Calling nested + } + + foo; + bar; # Will produce an error, because bar is out of scope! + +=head1 AUTHOR + +Paul C. Buetow (http://paul.buetow.org) + +=head1 WEBSITE + +The Fype Language (http://fype.buetow.org) + +=head1 SEE ALSO + +awk(1) cc(1) make(1) + diff --git a/docs/pod/fype.tex b/docs/pod/fype.tex new file mode 100644 index 0000000..a14a509 --- /dev/null +++ b/docs/pod/fype.tex @@ -0,0 +1,503 @@ +\section{NAME\label{NAME}\index{NAME}} + + +\textbf{Fype} is \textbf{f}or \textbf{y}our \textbf{p}rogram \textbf{e}xecution + + + +\textbf{Fype} is \textbf{f}ree \textbf{y}ack \textbf{p}rogramed for \textbf{E}LF + + + +It's not a hype - it's Fype! + +\section{SYNOPSES\label{SYNOPSES}\index{SYNOPSES}} +\begin{description} + +\item[{\textbf{fype} [-[hsvTV]] file.fy}] \mbox{} +\item[{\textbf{fype} -e "fype code string;"}] \mbox{}\end{description} +\section{ABOUT\label{ABOUT}\index{ABOUT}} + + +Fype is not yet released! Lots of basic stuff is still missing! See the +TODO file of the source distribution of Fype! + + + +Fype is a 32 bit scripting language created for fun. You can use it and comment on it if you like. You could also write patches and mail them to fype at dev dot buetow dot org! Or go visit the IRC channel \#coding at irc.german-elite.net and ask rantanplan. + + + +Fype is developed under the BSD license. See the COPYING file which is included in the source tree. + + + +Fype should be "at least as good as AWK". This does not mean it will be a replacement for AWK but it should support functions, loops and arrays like AWK does but with a different syntax. It should also get extension support like AWK has. I am not talking about GNU AWK but about New AWK, which is included in the *BSD distributions! Fype already has a few features which are not available in AWK. However, AWK has still many features which are not available in Fype as well ;) + + + +Fancy stuff like OOP or unicode or threading is not yet planed. But fancy stuff like function pointers and closures may be considered for one of the first releases of Fype :) + +\section{PARSING / CODE GENERATION\label{PARSING_CODE_GENERATION}\index{PARSING / CODE GENERATION}} + + +The Fype syntax is very simple and is using a maximum look ahead of 1 and a very easy top down parsing. Fype is parsing and interpreting its code simultaneous. This means, that syntax errors are only detected during program runtime. + +\section{REQUIREMENTS\label{REQUIREMENTS}\index{REQUIREMENTS}} + + +Fype only has been tested on FreeBSD 7.0. Linux may work too. Windows support is not planned. But may work using Cygwin or SFU. + + + +You will also need: + +\begin{verbatim} + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) (it's included in any *BSD) +\end{verbatim} +\section{GETTING STARTED\label{GETTING_STARTED}\index{GETTING STARTED}} + + +Extract, compile and install Fype: + +\begin{verbatim} + tar xvjf fype.tar.bz2 + cd fype + make + sudo make install + make clean +\end{verbatim} + + +Run a .fy file: + +\begin{verbatim} + fype test.fy +\end{verbatim} + + +See the ./examples subdir of the Fype source distribution for examples! See also fype -h for a list of all options. + +\section{DATA TYPES\label{DATA_TYPES}\index{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. + +\subsection*{The basic data types\label{The_basic_data_types}\index{The basic data types}} +\begin{description} + +\item[{\textit{integer}}] \mbox{} + +Specifies an integer number + + +\item[{\textit{double}}] \mbox{} + +Specifies a double number + + +\item[{\textit{string}}] \mbox{} + +Specifies a string + + +\item[{\textit{number}}] \mbox{} + +May be an integer or a double number + + +\item[{\textit{any}}] \mbox{} + +May be of any type above + + +\item[{\textit{void}}] \mbox{} + +No type + + +\item[{\textit{identifier}}] \mbox{} + +It's a variable name or a procedure name or a function name + +\end{description} +\subsection*{Explicit type conversions\label{Explicit_type_conversions}\index{Explicit type conversions}} +\begin{description} + +\item[{(\textit{integer}) \textbf{integer} \textit{any}}] \mbox{} + +Converts any type to an integer + + +\item[{(\textit{double}) \textbf{double} \textit{any}}] \mbox{} + +Converts any type to a double + + +\item[{(\textit{string}) \textbf{string} \textit{any}}] \mbox{} + +Converts any type to a string + +\end{description} +\section{SYNTAX\label{SYNTAX}\index{SYNTAX}} +\subsection*{Comments\label{Comments}\index{Comments}} + + +Text from a \textbf{\#} character until the end of the current line is considered being a comment. Multi line comments may start with an \textbf{\#*} and and with an \textbf{*\#} anywhere. Exceptions are if those signs are inside of strings. + +\subsection*{Statements\label{Statements}\index{Statements}} + + +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: + +\begin{verbatim} + my bar = 3, foo = 1 + 2; + say foo; + exit foo - bar; +\end{verbatim} +\subsection*{Paranthesis\label{Paranthesis}\index{Paranthesis}} + + +All paranthesis of function calls are optional. They help to make the code better readable. They also help to force precedences of expressions. + +\subsection*{Scopeing\label{Scopeing}\index{Scopeing}} + + +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: + +\begin{verbatim} + my foo = 1; +\end{verbatim} +\begin{verbatim} + { + # Prints out 1 + put defined foo; + { + my bar = 2; +\end{verbatim} +\begin{verbatim} + # Prints out 1 + put defined bar; + } +\end{verbatim} +\begin{verbatim} + # Prints out 0 + put defined bar; +\end{verbatim} +\begin{verbatim} + my baz = 3; + } +\end{verbatim} +\begin{verbatim} + # Prints out 0 + say defined bar; +\end{verbatim} +\subsection*{Control statements\label{Control_statements}\index{Control statements}} + + +Fype knows the following control statements: + +\begin{description} + +\item[{if \textit{$<$expression}$>$ \{ \textit{$<$statements}$>$ \}}] \mbox{} + +Runs the statements if the expression evaluates to a true value. + + +\item[{ifnot \textit{$<$expression}$>$ \{ \textit{$<$statements}$>$ \}}] \mbox{} + +Runs the statements if the expression evaluates to a false value. + + +\item[{while \textit{$<$expression}$>$ \{ \textit{$<$statements}$>$ \}}] \mbox{} + +Runs the statements as long as the the expression evaluates to a true value. + + +\item[{until \textit{$<$expression}$>$ \{ \textit{$<$statements}$>$ \}}] \mbox{} + +Runs the statements as long as the the expression evaluates to a false value. + +\end{description} +\section{VARIABLES\label{VARIABLES}\index{VARIABLES}} + + +Variables can be defined with the \textbf{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 \textbf{undef} keyword! Example of defining variables: + +\begin{verbatim} + my foo = 1 + 2; + say foo; +\end{verbatim} +\begin{verbatim} + my bar = 12, baz = foo; + say 1 + bar; + say bar; +\end{verbatim} +\begin{verbatim} + my baz; + say baz; # Will print out 0 +\end{verbatim} + + +You may use the \textbf{defined} keyword to check if an identifier has been defined or +not. + +\begin{verbatim} + ifnot defined foo { + say "No foo yet defined"; + } +\end{verbatim} +\begin{verbatim} + my foo = 1; +\end{verbatim} +\begin{verbatim} + if defined foo { + put "foo is defined and has the value "; + say foo; + } +\end{verbatim} +\section{BUILT IN FUNCTIONS\label{BUILT_IN_FUNCTIONS}\index{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. + +\subsection*{Math\label{Math}\index{Math}} +\begin{description} + +\item[{(\textit{any}) \textit{any} \textbf{+} \textit{any}}] \mbox{} + +Special string behavior: A string will get auto convertet into an \textit{integer}. + + +\item[{(\textit{any}) \textit{any} \textbf{-} \textit{any}}] \mbox{} + +Special string behavior: A string will get auto convertet into an \textit{integer}. + + +\item[{(\textit{any}) \textit{any} \textbf{*} \textit{any}}] \mbox{} + +Special string behavior: A string will get auto convertet into an \textit{integer}. + + +\item[{(\textit{any}) \textit{any} \textbf{/} \textit{any}}] \mbox{} + +Special string behavior: A string will get auto convertet into an \textit{integer}. + +\end{description} +\subsection*{Conditional\label{Conditional}\index{Conditional}} +\begin{description} + +\item[{(\textit{integer}) \textit{any} \textbf{==}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{!=}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{$<$=}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{$>$=}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{$<$}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{$>$}}] \textbf{\textit{any}}\end{description} +\subsection*{Definedness\label{Definedness}\index{Definedness}} +\begin{description} + +\item[{(\textit{integer}) \textbf{defined} \textit{identifier}}] \mbox{} + +Returns 1 if \textit{identifier} has been defined. Returns 0 else. + + +\item[{(\textit{integer}) \textbf{undef} \textit{identifier}}] \mbox{} + +Tries to undefine/delete the \textit{identifier}. Returns 1 if success, otherwise 0 is returned. + +\end{description} +\subsection*{Bitwise\label{Bitwise}\index{Bitwise}} + + +Bitwise operators do not work ATM. The fix is on its way! + +\begin{description} + +\item[{(\textit{any}) \textit{any} \textbf{$<$$<$}}] \textbf{\textit{any}} +\item[{(\textit{any}) \textit{any} \textbf{$>$$>$}}] \textbf{\textit{any}} +\item[{(\textit{any}) \textit{any} \textbf{and}}] \textbf{\textit{any}} +\item[{(\textit{any}) \textit{any} \textbf{or}}] \textbf{\textit{any}} +\item[{(\textit{any}) \textit{any} \textbf{xor}}] \textbf{\textit{any}} +\item[{(\textit{any}) \textbf{not} \textit{any}}] \mbox{}\end{description} +\subsection*{Numeric\label{Numeric}\index{Numeric}} +\begin{description} + +\item[{(\textit{number}) \textbf{neg} \textit{number}}] \mbox{} + +This function returns the negative value of \textit{any} + + +\item[{(\textit{integer}) \textbf{no} [\textit{integer}]}] \mbox{} + +This function returns 1 if the argument is 0, otherwise it will return 0! If no +argument is given, then 0 is returned! + + +\item[{(\textit{integer}) \textbf{yes} [\textit{integer}]}] \mbox{} + +This function always returns 1. The parameter is optional. + +\begin{verbatim} + # Prints out 1, because foo is not defined + if yes { say no defined foo; } +\end{verbatim} +\end{description} +\subsection*{System\label{System}\index{System}} +\begin{description} + +\item[{(\textit{void}) \textbf{end}}] \mbox{} + +Exits the program with the exit status of 0 + + +\item[{(\textit{void}) \textbf{exit} \textit{integer}}] \mbox{} + +Exits the program with the specified exit status + + +\item[{(\textit{integer}) \textbf{fork}}] \mbox{} + +Fork forks a subprocess. It returns 0 for the child process and the pid of the +child process otherwise! Example: + +\begin{verbatim} + my pid = fork; +\end{verbatim} +\begin{verbatim} + if pid { + put "I am the parent process; child has the pid "; + say pid; +\end{verbatim} +\begin{verbatim} + } ifnot pid { + say "I am the child process"; + } +\end{verbatim} + +\item[{(\textit{integer}) \textbf{gc}}] \mbox{} + +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! + +\end{description} +\subsection*{I/O\label{I_O}\index{I/O}} +\begin{description} + +\item[{(\textit{any}) \textbf{put} \textit{any}}] \mbox{} + +Prints out the argument + + +\item[{(\textit{any}) \textbf{say} \textit{any}}] \mbox{} + +Same as put, but also includes an ending newline + + +\item[{(\textit{void}) \textbf{ln}}] \mbox{} + +Just prints a newline + +\end{description} +\section{SELF DEFINING PROCEDURES AND FUNCTIONS\label{SELF_DEFINING_PROCEDURES_AND_FUNCTIONS}\index{SELF DEFINING PROCEDURES AND FUNCTIONS}} +\subsection*{Procedures\label{Procedures}\index{Procedures}} + + +A procedure can be defined with the \textbf{proc} keyword and deleted with the \textbf{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. + +\begin{verbatim} + proc foo { + say 1 + a * 3 + b; + my c = 6; + } +\end{verbatim} +\begin{verbatim} + my a = 2, b = 4; +\end{verbatim} +\begin{verbatim} + foo; # Run the procedure. Print out "11\n" + say c; # Print out "6\n"; +\end{verbatim} +\subsection*{Nested procedures\label{Nested_procedures}\index{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 \textbf{defined} +keyword in order to check if a procedure has been defined or not. + +\begin{verbatim} + proc foo { + say "I am foo"; +\end{verbatim} +\begin{verbatim} + undef bar; + proc bar { + say "I am bar"; + } + } +\end{verbatim} +\begin{verbatim} + # Here bar would produce an error because + # the proc is not yet defined! + # bar; +\end{verbatim} +\begin{verbatim} + 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! +\end{verbatim} +\subsection*{Functions\label{Functions}\index{Functions}} + + +A function should be defined with the \textbf{func} keyword and deleted with the \textbf{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). + +\begin{verbatim} + func foo { + say 1 + a * 3 + b; + my c = 6; + } +\end{verbatim} +\begin{verbatim} + my a = 2, b = 4; +\end{verbatim} +\begin{verbatim} + foo; # Run the procedure. Print out "11\n" + say c; # Will produce an error, because c is out of scoped! +\end{verbatim} +\subsection*{Nested functions\label{Nested_functions}\index{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! + +\begin{verbatim} + func foo { + func bar { + say "Hello i am nested"; + } +\end{verbatim} +\begin{verbatim} + bar; # Calling nested + } +\end{verbatim} +\begin{verbatim} + foo; + bar; # Will produce an error, because bar is out of scope! +\end{verbatim} +\section{AUTHOR\label{AUTHOR}\index{AUTHOR}} + + +Paul C. Buetow (http://paul.buetow.org) + +\section{WEBSITE\label{WEBSITE}\index{WEBSITE}} + + +The Fype Language (http://fype.buetow.org) + +\section{SEE ALSO\label{SEE_ALSO}\index{SEE ALSO}} + + +awk(1) cc(1) make(1) + diff --git a/docs/pod/fype.txt b/docs/pod/fype.txt new file mode 100644 index 0000000..3f61d8b --- /dev/null +++ b/docs/pod/fype.txt @@ -0,0 +1,381 @@ +NAME + Fype is for your program execution + + Fype is free yack programed for ELF + + It's not a hype - it's Fype! + +SYNOPSES + fype [-[hsvTV]] file.fy + fype -e "fype code string;" + +ABOUT + Fype is not yet released! Lots of basic stuff is still missing! See the + TODO file of the source distribution of Fype! + + Fype is a 32 bit scripting language created for fun. You can use it and + comment on it if you like. You could also write patches and mail them to + fype at dev dot buetow dot org! Or go visit the IRC channel #coding at + irc.german-elite.net and ask rantanplan. + + Fype is developed under the BSD license. See the COPYING file which is + included in the source tree. + + Fype should be "at least as good as AWK". This does not mean it will be + a replacement for AWK but it should support functions, loops and arrays + like AWK does but with a different syntax. It should also get extension + support like AWK has. I am not talking about GNU AWK but about New AWK, + which is included in the *BSD distributions! Fype already has a few + features which are not available in AWK. However, AWK has still many + features which are not available in Fype as well ;) + + Fancy stuff like OOP or unicode or threading is not yet planed. But + fancy stuff like function pointers and closures may be considered for + one of the first releases of Fype :) + +PARSING / CODE GENERATION + The Fype syntax is very simple and is using a maximum look ahead of 1 + and a very easy top down parsing. Fype is parsing and interpreting its + code simultaneous. This means, that syntax errors are only detected + during program runtime. + +REQUIREMENTS + Fype only has been tested on FreeBSD 7.0. Linux may work too. Windows + support is not planned. But may work using Cygwin or SFU. + + You will also need: + + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) (it's included in any *BSD) + +GETTING STARTED + Extract, compile and install Fype: + + tar xvjf fype.tar.bz2 + cd fype + make + sudo make install + make clean + + Run a .fy file: + + fype test.fy + + 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 + being a comment. Multi line comments may start with an #* and and with + an *# anywhere. Exceptions are if those signs are inside of strings. + + Statements + 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: + + my bar = 3, foo = 1 + 2; + say foo; + exit foo - bar; + + Paranthesis + All paranthesis of function calls are optional. They help to make the + code better readable. They also help to force precedences of + expressions. + + Scopeing + 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: + + my foo = 1; + + { + # Prints out 1 + put defined foo; + { + my bar = 2; + + # Prints out 1 + put defined bar; + } + + # Prints out 0 + put defined bar; + + my baz = 3; + } + + # Prints out 0 + say defined bar; + + Control statements + Fype knows the following control statements: + + if *<expression*> { *<statements*> } + Runs the statements if the expression evaluates to a true value. + + ifnot *<expression*> { *<statements*> } + Runs the statements if the expression evaluates to a false value. + + while *<expression*> { *<statements*> } + Runs the statements as long as the the expression evaluates to a + true value. + + until *<expression*> { *<statements*> } + Runs the statements as long as the the expression evaluates to a + false value. + +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 bar = 12, baz = foo; + say 1 + bar; + say bar; + + my baz; + say baz; # Will print out 0 + + You may use the defined keyword to check if an identifier has been + defined or not. + + ifnot defined foo { + say "No foo yet defined"; + } + + my foo = 1; + + 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. + + 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*. + + Conditional + (*integer*) *any* == *any* + (*integer*) *any* != *any* + (*integer*) *any* <= *any* + (*integer*) *any* >= *any* + (*integer*) *any* < *any* + (*integer*) *any* > *any* + + Definedness + (*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. + + Bitwise + Bitwise operators do not work ATM. The fix is on its way! + + (*any*) *any* << *any* + (*any*) *any* >> *any* + (*any*) *any* and *any* + (*any*) *any* or *any* + (*any*) *any* xor *any* + (*any*) not *any* + + Numeric + (*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*) 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; } + + System + (*void*) end + Exits the program with the exit status of 0 + + (*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: + + my pid = fork; + + if pid { + put "I am the parent process; child has the pid "; + say pid; + + } 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! + + I/O + (*any*) put *any* + Prints out the argument + + (*any*) say *any* + Same as put, but also includes an ending 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; + } + + my a = 2, b = 4; + + 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"; + } + } + + # 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! + + 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; + } + + 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! + + 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! + + func foo { + func bar { + say "Hello i am nested"; + } + + bar; # Calling nested + } + + foo; + bar; # Will produce an error, because bar is out of scope! + +AUTHOR + Paul C. Buetow (http://paul.buetow.org) + +WEBSITE + The Fype Language (http://fype.buetow.org) + +SEE ALSO + awk(1) cc(1) make(1) + diff --git a/docs/stats.txt b/docs/stats.txt new file mode 100644 index 0000000..f9acef3 --- /dev/null +++ b/docs/stats.txt @@ -0,0 +1,4 @@ +===> Num of C source files : 42 +===> Num of C source lines : 7213 +===> Num of Fype source examples : 13 +===> Num of Fype source lines : 320 diff --git a/docs/synopses.txt b/docs/synopses.txt new file mode 100644 index 0000000..c0842aa --- /dev/null +++ b/docs/synopses.txt @@ -0,0 +1,4 @@ +Synopsis: +./fype [-[hsvTV]] file.fy +./fype -e "code string;" + (Hint: Try -h for details) diff --git a/docs/version.txt b/docs/version.txt new file mode 100644 index 0000000..7376a66 --- /dev/null +++ b/docs/version.txt @@ -0,0 +1 @@ +Fype v0.0-devel Build 8865 |