diff options
42 files changed, 6121 insertions, 0 deletions
@@ -0,0 +1,6 @@ +keywords: + refs + +functions: + ind + len diff --git a/README.pod b/README.pod new file mode 100644 index 0000000..5006345 --- /dev/null +++ b/README.pod @@ -0,0 +1,495 @@ +=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>ak B<P>rogramed for B<E>LF + +It's not a hype - it's B<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. Linux users have to install pmake before compiling Fype! + +You will need: + + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) + +NetBSD Make is included in any *BSD and can be run with just B<make>. + +=head1 GETTING STARTED + +On Linux: Extract, compile and install Fype: + + tar xvjf fype.tar.bz2 + cd fype + pmake + sudo pmake install + pmake clean + +On FreeBSD: 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. The B<scope> function will print out all available symbols at the current position. Here is a small example of how to use scopes: + + my foo = 1; + + { + # Prints out 1 + put defined foo; + { + my bar = 2; + + # Prints out 1 + put defined bar; + + # Prints out all available symbols at this + # point to stdout. Those are: bar and foo + scope; + } + + # 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 SYNONYMS + +Each variable can have as many synonyms as wished. A synonym is another name to access the content of a specific variable. Here is an example of how to use synomyms: + + my foo = "foo"; + my bar = \foo; + foo = "bar"; + + # The synonym variable should now also set to "bar" + assert "bar" == bar; + +Synonyms can be used for all kind of identifiers. It's not limited to normal variables but can be also used for function and procedure names etc. + + # Create a new procedure baz + proc baz { say "I am baz"; } + + # Make a synonym baz, and undefine baz + my bay = \baz; + + undef baz; + + # bay still has a reference of the original procedure baz + bay; # this prints aut "I am baz" + +The B<syms> keyword gives you the total number of synonyms pointing to a specific value: + + my foo = 1; + say syms foo; # Prints 1 + + my baz = \foo; + say syms foo; # Prints 2 + say syms baz; # Prints 2 + + undef baz; + say syms foo; # Prints 1 + + +=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> + +=item (I<integer>) B<not> 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 + +=over + +=item (I<integer>) I<any> B<:<> I<any> + +=item (I<integer>) I<any> B<:E<gt>> I<any> + +=item (I<integer>) I<any> B<and> I<any> + +=item (I<integer>) I<any> B<or> I<any> + +=item (I<integer>) I<any> B<xor> 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) + @@ -0,0 +1,11 @@ +Todo's (not in any specific order) + +Functions should be handled via hash and ptrs not if/else (in progress) +Arrays (in progress) +Closures +Function arguments and return values +Interactive shell +Labels +String operators/functions +loop, next, break, do + diff --git a/docs/pod/Makefile b/docs/pod/Makefile new file mode 100644 index 0000000..ddc6de4 --- /dev/null +++ b/docs/pod/Makefile @@ -0,0 +1,20 @@ +# THIS MAKEFILE MAY WORK ONLY WITH (NET)BSD MAKE AKA PMAKE! + +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..916f836 --- /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..121cbea --- /dev/null +++ b/docs/pod/fype.html @@ -0,0 +1,592 @@ +<?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@localhost" /> +</head> + +<body style="background-color: white"> + + +<!-- INDEX BEGIN --> +<div name="index"> +<p><a name="__index__"></a></p> + +<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="#synonyms">SYNONYMS</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> + +<hr name="index" /> +</div> +<!-- INDEX END --> + +<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>ak <strong>P</strong>rogramed for <strong>E</strong>LF</p> +<p>It's not a hype - it's <strong>Fype</strong>!</p> +<p> +</p> +<hr /> +<h1><a name="synopses">SYNOPSES</a></h1> +<dl> +<dt><strong><a name="fype_hsvtv_file_fy" class="item"><strong>fype</strong> [-[hsvTV]] file.fy</a></strong></dt> + +<dt><strong><a name="fype_e_fype_code_string" class="item"><strong>fype</strong> -e "fype code string;"</a></strong></dt> + +</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. Linux users have to install pmake before compiling Fype!</p> +<p>You will need:</p> +<pre> + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work)</pre> +<p>NetBSD Make is included in any *BSD and can be run with just <strong>make</strong>.</p> +<p> +</p> +<hr /> +<h1><a name="getting_started">GETTING STARTED</a></h1> +<p>On Linux: Extract, compile and install Fype:</p> +<pre> + tar xvjf fype.tar.bz2 + cd fype + pmake + sudo pmake install + pmake clean</pre> +<p>On FreeBSD: 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="integer" class="item"><em>integer</em></a></strong></dt> + +<dd> +<p>Specifies an integer number</p> +</dd> +<dt><strong><a name="double" class="item"><em>double</em></a></strong></dt> + +<dd> +<p>Specifies a double number</p> +</dd> +<dt><strong><a name="string" class="item"><em>string</em></a></strong></dt> + +<dd> +<p>Specifies a string</p> +</dd> +<dt><strong><a name="number" class="item"><em>number</em></a></strong></dt> + +<dd> +<p>May be an integer or a double number</p> +</dd> +<dt><strong><a name="any" class="item"><em>any</em></a></strong></dt> + +<dd> +<p>May be of any type above</p> +</dd> +<dt><strong><a name="void" class="item"><em>void</em></a></strong></dt> + +<dd> +<p>No type</p> +</dd> +<dt><strong><a name="identifier" class="item"><em>identifier</em></a></strong></dt> + +<dd> +<p>It's a variable name or a procedure name or a function name</p> +</dd> +</dl> +<p> +</p> +<h2><a name="explicit_type_conversions">Explicit type conversions</a></h2> +<dl> +<dt><strong><a name="integer_integer_any" class="item">(<em>integer</em>) <strong>integer</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Converts any type to an integer</p> +</dd> +<dt><strong><a name="double_double_any" class="item">(<em>double</em>) <strong>double</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Converts any type to a double</p> +</dd> +<dt><strong><a name="string_string_any" class="item">(<em>string</em>) <strong>string</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Converts any type to a string</p> +</dd> +</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. The <strong>scope</strong> function will print out all available symbols at the current position. Here is a small example of 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 all available symbols at this + # point to stdout. Those are: bar and foo + scope; + }</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="if_expression_statements" class="item">if <em><expression</em>> { <em><statements</em>> }</a></strong></dt> + +<dd> +<p>Runs the statements if the expression evaluates to a true value.</p> +</dd> +<dt><strong><a name="ifnot_expression_statements" class="item">ifnot <em><expression</em>> { <em><statements</em>> }</a></strong></dt> + +<dd> +<p>Runs the statements if the expression evaluates to a false value.</p> +</dd> +<dt><strong><a name="while_expression_statements" class="item">while <em><expression</em>> { <em><statements</em>> }</a></strong></dt> + +<dd> +<p>Runs the statements as long as the the expression evaluates to a true value.</p> +</dd> +<dt><strong><a name="until_expression_statements" class="item">until <em><expression</em>> { <em><statements</em>> }</a></strong></dt> + +<dd> +<p>Runs the statements as long as the the expression evaluates to a false value.</p> +</dd> +</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="synonyms">SYNONYMS</a></h1> +<p>Each variable can have as many synonyms as wished. A synonym is another name to access the content of a specific variable. Here is an example of how to use synomyms:</p> +<pre> + my foo = "foo"; + my bar = \foo; + foo = "bar";</pre> +<pre> + # The synonym variable should now also set to "bar" + assert "bar" == bar;</pre> +<p>Synonyms can be used for all kind of identifiers. It's not limited to normal variables but can be also used for function and procedure names etc.</p> +<pre> + # Create a new procedure baz + proc baz { say "I am baz"; }</pre> +<pre> + # Make a synonym baz, and undefine baz + my bay = \baz;</pre> +<pre> + undef baz;</pre> +<pre> + # bay still has a reference of the original procedure baz + bay; # this prints aut "I am baz"</pre> +<p>The <strong>syms</strong> keyword gives you the total number of synonyms pointing to a specific value:</p> +<pre> + my foo = 1; + say syms foo; # Prints 1</pre> +<pre> + my baz = \foo; + say syms foo; # Prints 2 + say syms baz; # Prints 2</pre> +<pre> + undef baz; + say syms foo; # Prints 1</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="any_any_any" class="item">(<em>any</em>) <em>any</em> <strong>+</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +<dt><strong><a name="any_any_any2" class="item">(<em>any</em>) <em>any</em> <strong>-</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +<dt><strong><a name="any_any_any3" class="item">(<em>any</em>) <em>any</em> <strong>*</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +<dt><strong><a name="any_any_any4" class="item">(<em>any</em>) <em>any</em> <strong>/</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Special string behavior: A string will get auto convertet into an <em>integer</em>.</p> +</dd> +</dl> +<p> +</p> +<h2><a name="conditional">Conditional</a></h2> +<dl> +<dt><strong><a name="integer_any_any" class="item">(<em>integer</em>) <em>any</em> <strong>==</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_any2" class="item">(<em>integer</em>) <em>any</em> <strong>!=</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_any3" class="item">(<em>integer</em>) <em>any</em> <strong><=</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_any4" class="item">(<em>integer</em>) <em>any</em> <strong>>=</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_any5" class="item">(<em>integer</em>) <em>any</em> <strong><</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_any6" class="item">(<em>integer</em>) <em>any</em> <strong>></strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_not_any" class="item">(<em>integer</em>) <strong>not</strong> <em>any</em></a></strong></dt> + +</dl> +<p> +</p> +<h2><a name="definedness">Definedness</a></h2> +<dl> +<dt><strong><a name="integer_defined_identifier" class="item">(<em>integer</em>) <strong>defined</strong> <em>identifier</em></a></strong></dt> + +<dd> +<p>Returns 1 if <em>identifier</em> has been defined. Returns 0 else.</p> +</dd> +<dt><strong><a name="integer_undef_identifier" class="item">(<em>integer</em>) <strong>undef</strong> <em>identifier</em></a></strong></dt> + +<dd> +<p>Tries to undefine/delete the <em>identifier</em>. Returns 1 if success, otherwise 0 is returned.</p> +</dd> +</dl> +<p> +</p> +<h2><a name="bitwise">Bitwise</a></h2> +<dl> +<dt><strong><a name="integer_any_any7" class="item">(<em>integer</em>) <em>any</em> <strong>:<</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_any8" class="item">(<em>integer</em>) <em>any</em> <strong>:></strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_and_any" class="item">(<em>integer</em>) <em>any</em> <strong>and</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_or_any" class="item">(<em>integer</em>) <em>any</em> <strong>or</strong> <em>any</em></a></strong></dt> + +<dt><strong><a name="integer_any_xor_any" class="item">(<em>integer</em>) <em>any</em> <strong>xor</strong> <em>any</em></a></strong></dt> + +</dl> +<p> +</p> +<h2><a name="numeric">Numeric</a></h2> +<dl> +<dt><strong><a name="number_neg_number" class="item">(<em>number</em>) <strong>neg</strong> <em>number</em></a></strong></dt> + +<dd> +<p>This function returns the negative value of <em>any</em></p> +</dd> +<dt><strong><a name="integer_no_integer" class="item">(<em>integer</em>) <strong>no</strong> [<em>integer</em>]</a></strong></dt> + +<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> +<dt><strong><a name="integer_yes_integer" class="item">(<em>integer</em>) <strong>yes</strong> [<em>integer</em>]</a></strong></dt> + +<dd> +<p>This function always returns 1. The parameter is optional.</p> +<pre> + + # Prints out 1, because foo is not defined + if yes { say no defined foo; }</pre> +</dd> +</dl> +<p> +</p> +<h2><a name="system">System</a></h2> +<dl> +<dt><strong><a name="void_end" class="item">(<em>void</em>) <strong>end</strong></a></strong></dt> + +<dd> +<p>Exits the program with the exit status of 0</p> +</dd> +<dt><strong><a name="void_exit_integer" class="item">(<em>void</em>) <strong>exit</strong> <em>integer</em></a></strong></dt> + +<dd> +<p>Exits the program with the specified exit status</p> +</dd> +<dt><strong><a name="integer_fork" class="item">(<em>integer</em>) <strong>fork</strong></a></strong></dt> + +<dd> +<p>Fork forks a subprocess. It returns 0 for the child process and the pid of the +child process otherwise! Example:</p> +<pre> + my pid = fork;</pre> +<pre> + if pid { + put "I am the parent process; child has the pid "; + say pid;</pre> +<pre> + } ifnot pid { + say "I am the child process"; + }</pre> +</dd> +<dt><strong><a name="integer_gc" class="item">(<em>integer</em>) <strong>gc</strong></a></strong></dt> + +<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> +</dl> +<p> +</p> +<h2><a name="i_o">I/O</a></h2> +<dl> +<dt><strong><a name="any_put_any" class="item">(<em>any</em>) <strong>put</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Prints out the argument</p> +</dd> +<dt><strong><a name="any_say_any" class="item">(<em>any</em>) <strong>say</strong> <em>any</em></a></strong></dt> + +<dd> +<p>Same as put, but also includes an ending newline</p> +</dd> +<dt><strong><a name="void_ln" class="item">(<em>void</em>) <strong>ln</strong></a></strong></dt> + +<dd> +<p>Just prints a newline</p> +</dd> +</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..ed963a7 --- /dev/null +++ b/docs/pod/fype.man @@ -0,0 +1,570 @@ +.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16) +.\" +.\" Standard preamble: +.\" ======================================================================== +.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. \*(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- +.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\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is turned on, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.ie \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. nr % 0 +. rr F +.\} +.el \{\ +. de IX +.. +.\} +.\" +.\" 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 "2014-06-22" "Fype Superalpha Build 9666" "The Fype Users Manual Page" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH "NAME" +Fype is For Your Program Execution +.PP +Fype is Free Yak Programed for ELF +.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. Linux users have to install pmake before compiling Fype! +.PP +You will need: +.PP +.Vb 2 +\& GNU GCC C Compiler (gcc.gnu.org) +\& NetBSD Make aka pmake (GNU Make will not work) +.Ve +.PP +NetBSD Make is included in any *BSD and can be run with just \fBmake\fR. +.SH "GETTING STARTED" +.IX Header "GETTING STARTED" +On Linux: Extract, compile and install Fype: +.PP +.Vb 5 +\& tar xvjf fype.tar.bz2 +\& cd fype +\& pmake +\& sudo pmake install +\& pmake clean +.Ve +.PP +On FreeBSD: 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. +.SS "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 +.SS "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" +.SS "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. +.SS "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 +.SS "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. +.SS "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. The \fBscope\fR function will print out all available symbols at the current position. Here is a small example of how to use scopes: +.PP +.Vb 1 +\& my foo = 1; +\& +\& { +\& # Prints out 1 +\& put defined foo; +\& { +\& my bar = 2; +\& +\& # Prints out 1 +\& put defined bar; +\& +\& # Prints out all available symbols at this +\& # point to stdout. Those are: bar and foo +\& scope; +\& } +\& +\& # Prints out 0 +\& put defined bar; +\& +\& my baz = 3; +\& } +\& +\& # Prints out 0 +\& say defined bar; +.Ve +.SS "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; +\& +\& my bar = 12, baz = foo; +\& say 1 + bar; +\& say bar; +\& +\& 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"; +\& } +\& +\& my foo = 1; +\& +\& if defined foo { +\& put "foo is defined and has the value "; +\& say foo; +\& } +.Ve +.SH "SYNONYMS" +.IX Header "SYNONYMS" +Each variable can have as many synonyms as wished. A synonym is another name to access the content of a specific variable. Here is an example of how to use synomyms: +.PP +.Vb 3 +\& my foo = "foo"; +\& my bar = \efoo; +\& foo = "bar"; +\& +\& # The synonym variable should now also set to "bar" +\& assert "bar" == bar; +.Ve +.PP +Synonyms can be used for all kind of identifiers. It's not limited to normal variables but can be also used for function and procedure names etc. +.PP +.Vb 2 +\& # Create a new procedure baz +\& proc baz { say "I am baz"; } +\& +\& # Make a synonym baz, and undefine baz +\& my bay = \ebaz; +\& +\& undef baz; +\& +\& # bay still has a reference of the original procedure baz +\& bay; # this prints aut "I am baz" +.Ve +.PP +The \fBsyms\fR keyword gives you the total number of synonyms pointing to a specific value: +.PP +.Vb 2 +\& my foo = 1; +\& say syms foo; # Prints 1 +\& +\& my baz = \efoo; +\& say syms foo; # Prints 2 +\& say syms baz; # Prints 2 +\& +\& undef baz; +\& say syms foo; # Prints 1 +.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. +.SS "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. +.SS "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" +.IP "(\fIinteger\fR) \fBnot\fR \fIany\fR" 4 +.IX Item "(integer) not any" +.PD +.SS "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. +.SS "Bitwise" +.IX Subsection "Bitwise" +.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 \fBand\fR \fIany\fR" 4 +.IX Item "(integer) any and any" +.IP "(\fIinteger\fR) \fIany\fR \fBor\fR \fIany\fR" 4 +.IX Item "(integer) any or any" +.IP "(\fIinteger\fR) \fIany\fR \fBxor\fR \fIany\fR" 4 +.IX Item "(integer) any xor any" +.PD +.SS "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 +.SS "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; +\& +\& if pid { +\& put "I am the parent process; child has the pid "; +\& say pid; +\& +\& } 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! +.SS "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" +.SS "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; +\& } +\& +\& my a = 2, b = 4; +\& +\& foo; # Run the procedure. Print out "11\en" +\& say c; # Print out "6\en"; +.Ve +.SS "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"; +\& +\& 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! +.Ve +.SS "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; +\& } +\& +\& my a = 2, b = 4; +\& +\& foo; # Run the procedure. Print out "11\en" +\& say c; # Will produce an error, because c is out of scoped! +.Ve +.SS "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"; +\& } +\& +\& bar; # Calling nested +\& } +\& +\& 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..5006345 --- /dev/null +++ b/docs/pod/fype.pod @@ -0,0 +1,495 @@ +=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>ak B<P>rogramed for B<E>LF + +It's not a hype - it's B<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. Linux users have to install pmake before compiling Fype! + +You will need: + + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) + +NetBSD Make is included in any *BSD and can be run with just B<make>. + +=head1 GETTING STARTED + +On Linux: Extract, compile and install Fype: + + tar xvjf fype.tar.bz2 + cd fype + pmake + sudo pmake install + pmake clean + +On FreeBSD: 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. The B<scope> function will print out all available symbols at the current position. Here is a small example of how to use scopes: + + my foo = 1; + + { + # Prints out 1 + put defined foo; + { + my bar = 2; + + # Prints out 1 + put defined bar; + + # Prints out all available symbols at this + # point to stdout. Those are: bar and foo + scope; + } + + # 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 SYNONYMS + +Each variable can have as many synonyms as wished. A synonym is another name to access the content of a specific variable. Here is an example of how to use synomyms: + + my foo = "foo"; + my bar = \foo; + foo = "bar"; + + # The synonym variable should now also set to "bar" + assert "bar" == bar; + +Synonyms can be used for all kind of identifiers. It's not limited to normal variables but can be also used for function and procedure names etc. + + # Create a new procedure baz + proc baz { say "I am baz"; } + + # Make a synonym baz, and undefine baz + my bay = \baz; + + undef baz; + + # bay still has a reference of the original procedure baz + bay; # this prints aut "I am baz" + +The B<syms> keyword gives you the total number of synonyms pointing to a specific value: + + my foo = 1; + say syms foo; # Prints 1 + + my baz = \foo; + say syms foo; # Prints 2 + say syms baz; # Prints 2 + + undef baz; + say syms foo; # Prints 1 + + +=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> + +=item (I<integer>) B<not> 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 + +=over + +=item (I<integer>) I<any> B<:<> I<any> + +=item (I<integer>) I<any> B<:E<gt>> I<any> + +=item (I<integer>) I<any> B<and> I<any> + +=item (I<integer>) I<any> B<or> I<any> + +=item (I<integer>) I<any> B<xor> 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..7609a00 --- /dev/null +++ b/docs/pod/fype.tex @@ -0,0 +1,569 @@ +\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}ak \textbf{P}rogramed for \textbf{E}LF + + + +It's not a hype - it's \textbf{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. Linux users have to install pmake before compiling Fype! + + + +You will need: + +\begin{verbatim} + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) +\end{verbatim} + + +NetBSD Make is included in any *BSD and can be run with just \textbf{make}. + +\section{GETTING STARTED\label{GETTING_STARTED}\index{GETTING STARTED}} + + +On Linux: Extract, compile and install Fype: + +\begin{verbatim} + tar xvjf fype.tar.bz2 + cd fype + pmake + sudo pmake install + pmake clean +\end{verbatim} + + +On FreeBSD: 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. The \textbf{scope} function will print out all available symbols at the current position. Here is a small example of 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 all available symbols at this + # point to stdout. Those are: bar and foo + scope; + } +\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{SYNONYMS\label{SYNONYMS}\index{SYNONYMS}} + + +Each variable can have as many synonyms as wished. A synonym is another name to access the content of a specific variable. Here is an example of how to use synomyms: + +\begin{verbatim} + my foo = "foo"; + my bar = \foo; + foo = "bar"; +\end{verbatim} +\begin{verbatim} + # The synonym variable should now also set to "bar" + assert "bar" == bar; +\end{verbatim} + + +Synonyms can be used for all kind of identifiers. It's not limited to normal variables but can be also used for function and procedure names etc. + +\begin{verbatim} + # Create a new procedure baz + proc baz { say "I am baz"; } +\end{verbatim} +\begin{verbatim} + # Make a synonym baz, and undefine baz + my bay = \baz; +\end{verbatim} +\begin{verbatim} + undef baz; +\end{verbatim} +\begin{verbatim} + # bay still has a reference of the original procedure baz + bay; # this prints aut "I am baz" +\end{verbatim} + + +The \textbf{syms} keyword gives you the total number of synonyms pointing to a specific value: + +\begin{verbatim} + my foo = 1; + say syms foo; # Prints 1 +\end{verbatim} +\begin{verbatim} + my baz = \foo; + say syms foo; # Prints 2 + say syms baz; # Prints 2 +\end{verbatim} +\begin{verbatim} + undef baz; + say syms foo; # Prints 1 +\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}} +\item[{(\textit{integer}) \textbf{not} \textit{any}}] \mbox{}\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}} +\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{and}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{or}}] \textbf{\textit{any}} +\item[{(\textit{integer}) \textit{any} \textbf{xor}}] \textbf{\textit{any}}\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..8513538 --- /dev/null +++ b/docs/pod/fype.txt @@ -0,0 +1,435 @@ +NAME + Fype is For Your Program Execution + + Fype is Free Yak 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. Linux users + have to install pmake before compiling Fype! + + You will need: + + GNU GCC C Compiler (gcc.gnu.org) + NetBSD Make aka pmake (GNU Make will not work) + + NetBSD Make is included in any *BSD and can be run with just make. + +GETTING STARTED + On Linux: Extract, compile and install Fype: + + tar xvjf fype.tar.bz2 + cd fype + pmake + sudo pmake install + pmake clean + + On FreeBSD: 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. The scope function + will print out all available symbols at the current position. Here is a + small example of how to use scopes: + + my foo = 1; + + { + # Prints out 1 + put defined foo; + { + my bar = 2; + + # Prints out 1 + put defined bar; + + # Prints out all available symbols at this + # point to stdout. Those are: bar and foo + scope; + } + + # 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; + } + +SYNONYMS + Each variable can have as many synonyms as wished. A synonym is another + name to access the content of a specific variable. Here is an example of + how to use synomyms: + + my foo = "foo"; + my bar = \foo; + foo = "bar"; + + # The synonym variable should now also set to "bar" + assert "bar" == bar; + + Synonyms can be used for all kind of identifiers. It's not limited to + normal variables but can be also used for function and procedure names + etc. + + # Create a new procedure baz + proc baz { say "I am baz"; } + + # Make a synonym baz, and undefine baz + my bay = \baz; + + undef baz; + + # bay still has a reference of the original procedure baz + bay; # this prints aut "I am baz" + + The syms keyword gives you the total number of synonyms pointing to a + specific value: + + my foo = 1; + say syms foo; # Prints 1 + + my baz = \foo; + say syms foo; # Prints 2 + say syms baz; # Prints 2 + + undef baz; + say syms foo; # Prints 1 + +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* + (*integer*) not *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 + (*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* + + (*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/examples/all-examples.txt b/examples/all-examples.txt new file mode 100644 index 0000000..f71e8a2 --- /dev/null +++ b/examples/all-examples.txt @@ -0,0 +1,377 @@ + +#* + * Examples of how to use bitwise operators + *# + +# Prints "01\n" +assert 0 == (put 1 and 0); +assert 1 == (say 1 and 1); + +# Prints "01\n" +assert 0 == (put 0 or 0); +assert 1 == (say 0 or 1); + +# Prints "01\n" +assert 0 == (put 1 xor 1); +assert 1 == (say 1 xor 0); + +# Prints "82\n" +assert 8 == (put 2 :< 2); +assert 2 == (say 8 :> 2); + +# A bit more complex, prints "9\n" +assert 9 == (say 1 :< 5 :> 5 or 2 and 5 xor 8); + +# Same result, but with parenthesis: +assert 9 == (say ((((1 :< 5) :> 5) or 2) and 5) xor 8); + +# Different parenthesis, different result: "1\n" +assert 1 == (say 1 :< 5 :> 5 or 2 and (5 xor 8)); + +# Prints "-1" +assert (neg 1) == (say neg not 0); + + +#* + * Simple examples how to write comments + *# + +# This is a single lined comment + +say 1 + 1; # This is a comment at the end of the line + +say 1 #* This is an embedded comment *# + 1; + +#* This is + a + multiline + comment *# + +#* + * This is + * a nicer looking + * multiline comment + *# + + +#* + * Simple conditional tests + *# + +# "0010\n" +assert 0 == (put 1 < 1); +assert 0 == (put 1 < 0); +assert 1 == (put 0 < 1); +assert 0 == (say 0 < 0); + +# "0100\n" +assert 0 == (put 1 > 1); +assert 1 == (put 1 > 0); +assert 0 == (put 0 > 1); +assert 0 == (say 0 > 0); + +# "1001\n" +assert 1 == (put 1 == 1); +assert 0 == (put 1 == 0); +assert 0 == (put 0 == 1); +assert 1 == (say 0 == 0); + +# "0110\n" +assert 0 == (put 1 != 1); +assert 1 == (put 1 != 0); +assert 1 == (put 0 != 1); +assert 0 == (say 0 != 0); + +# "1011\n" +assert 1 == (put 1 <= 1); +assert 0 == (put 1 <= 0); +assert 1 == (put 0 <= 1); +assert 1 == (say 0 <= 0); + +## "1101\n" +assert 1 == (put 1 >= 1); +assert 1 == (put 1 >= 0); +assert 0 == (put 0 >= 1); +assert 1 == (say 0 >= 0); + + + +#* + * Examples of how to use control statements + *# + +if 1 { + say "if 1"; +} + +ifnot 0 == 1 { + say "ifnot 0 == 1"; +} + +# Calculate 10! + +my n = 10, fac = 0; + +while n > 1 { + ifnot fac { + fac = 1; + } + say fac = (fac * n); + decr n; +} + +# Count up to 10 + +n = 0; + +until n == 10 { + say incr n; +} + + +#* + * Simple expression tests + *# + +# Result 10 +assert 10 == say (8 / 2) + 2 * 3; + +# Result 12 +assert 12 == say 2 * (4 + 2); + +# Result 4 +assert 4 == say 2 * (4 / 2); + +# Result 4 +assert 4 == say 2 * (4 / 2); + +# Result 4 +assert 4 == say 2 * (4 / 2); + +# Result 46 +assert 46 == say "12" + "34"; + +# Result 1231 +assert 1231 == say "1234" - "3"; + +# Result 24 +assert "24" == say "2ab" * "12"; + +# Result 5.0 +assert 5 == say "10 bla" / 2; + + +#* + * Examples of how to use fork + *# + +my pid = fork; + +if pid { + put "I am the parent process and the child has the pid "; + say pid; +} + +ifnot pid { + say "I am the child process"; +} + +#* + * Examples of how to use functions + *# + +func foo { + say 1 + a * 3 + b; + + func bar { + say "Hello i am nested"; + } + + bar; # Calling nested +} + +my a = 2, b = 4; # Create global variables +foo; +assert 0 == (defined bar); # bar is not available anymore + +func baz { + say "I am baz"; + undef baz; +} + +baz; # Baz deletes itself +assert 0 == (defined baz); # baz is not available anymore + +#* + * Simple builtin function tests + *# + +# Print "-20\n" +assert (neg 20) == (say neg 20); + +# Print "30\n" +assert 30 == (say 10 - neg 20); + +# Print "-30\n" +assert (neg 30) == (say neg neg neg 10 - neg 20); + +# Print "Hello\n" +put "Hello"; +ln; + +# Exit with exit code 0 +exit 10 + 10 - 5 - 15; + + +#* + * Simple I/O examples. Currently only output is supported. + *# + +# Print out 10 followed by a newline +say 10; + +# Print out 20 without a newline followed +put 20; + +# Print out a newline +ln; + + +#* + * Examples of how to use procedures + *# + +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"; + +proc bar { + say "I am bar"; + + undef baz; + + proc baz { + say "I am baz"; + } +} + +# Here bar would produce an error because the proc is not yet defined! +# bar; + +bar; # Here the procedure bar will define the procedure baz! +baz; # Now the procedure baz is defined! +bar; # Here the procedure bar will redefine baz again! + +#* + * Examples of how to use scopeing + *# + +my foo = 1; + +{ + # Prints out 1 + assert 1 == (put defined foo); + + { + my bar = 2; + + # Prints out 1 + assert 1 == (put defined bar); + + # Prints out all available symbols at + # the current program position. + scope; + } + + # Prints out 0 + assert 0 == (put defined bar); + + my baz = 3; +} + +# Prints out 0 +assert 0 == (say defined bar); + + + +#* + * Examples of how to use synonyms + *# + +# Create a variable foo, and bar is a synonym for foo +my foo = "foo"; +my bar = \foo; + +# Reset the value of foo +foo = "bar"; + +# The synonym variable should now also set to "bar" +assert "bar" == say bar; + +# Create a new procedure baz +proc baz { + say "I am baz"; +} + +# Make a synonym baz, and undefine baz +my bay = \baz; + +# Should be the num of syms for the same value +assert 2 == syms baz; +assert 2 == syms bay; +undef baz; +assert 1 == syms bay; + +# bay still has a reference of the original procedure baz +bay; # this prints aut "I am baz" + +assert 0 == defined baz; +assert 1 == defined bay; + +# This removes the procedure from memory +undef bay; + + +#* + * Examples how to convert types + *# + +assert 1 == say 1; # Integer output + +assert 1 == say double 1; # Double output + +assert 14 == say 1 + string 13; # Implicit type conversion to Integer + +assert 2 == say integer 2.8; # Rounds down to the Integer 2 + +assert say integer double string put say neg 12; # Nonsense but working :) + + +#* + * Examples of how to define variables + *# + +# Defines the variables +my foo = 1 + 1; +my bar = 4 - 1, baz = 100 + 1, bay; + +# bay has been initialized with the default value of 0 +say bay; + +# Prints out "5\n" +assert 5 == (say foo + bar); + +# Pritns out "51101\n" +assert 51 == (put baz - 50); +assert 101 == (say baz); + +# Change the value of the variable to 99 and print it out +assert 99 == (baz = 99); +say baz; + diff --git a/examples/assert.fy b/examples/assert.fy new file mode 100644 index 0000000..d9871f5 --- /dev/null +++ b/examples/assert.fy @@ -0,0 +1,14 @@ +#* + * Examples of how to use asserts + *# + +# The built in function assert checks if a condition evaluates to true +# and aborts the interpreter if it evaluates to false. + +# Evaluates to true +assert 0 == 0 +assert 6 == 2 * 3 + +# Evaluates to false +# assert 1 == 0 + diff --git a/examples/bitwise.fy b/examples/bitwise.fy new file mode 100644 index 0000000..03fda6c --- /dev/null +++ b/examples/bitwise.fy @@ -0,0 +1,32 @@ +#* + * Examples of how to use bitwise operators + *# + +# Prints "01\n" +assert 0 == (put 1 and 0); +assert 1 == (say 1 and 1); + +# Prints "01\n" +assert 0 == (put 0 or 0); +assert 1 == (say 0 or 1); + +# Prints "01\n" +assert 0 == (put 1 xor 1); +assert 1 == (say 1 xor 0); + +# Prints "82\n" +assert 8 == (put 2 :< 2); +assert 2 == (say 8 :> 2); + +# A bit more complex, prints "9\n" +assert 9 == (say 1 :< 5 :> 5 or 2 and 5 xor 8); + +# Same result, but with parenthesis: +assert 9 == (say ((((1 :< 5) :> 5) or 2) and 5) xor 8); + +# Different parenthesis, different result: "1\n" +assert 1 == (say 1 :< 5 :> 5 or 2 and (5 xor 8)); + +# Prints "-1" +assert (neg 1) == (say neg not 0); + diff --git a/examples/comments.fy b/examples/comments.fy new file mode 100644 index 0000000..216e41b --- /dev/null +++ b/examples/comments.fy @@ -0,0 +1,21 @@ +#* + * Simple examples how to write comments + *# + +# This is a single lined comment + +say 1 + 1; # This is a comment at the end of the line + +say 1 #* This is an embedded comment *# + 1; + +#* This is + a + multiline + comment *# + +#* + * This is + * a nicer looking + * multiline comment + *# + diff --git a/examples/conditionals.fy b/examples/conditionals.fy new file mode 100644 index 0000000..1260ae2 --- /dev/null +++ b/examples/conditionals.fy @@ -0,0 +1,41 @@ +#* + * Simple conditional tests + *# + +# "0010\n" +assert 0 == (put 1 < 1); +assert 0 == (put 1 < 0); +assert 1 == (put 0 < 1); +assert 0 == (say 0 < 0); + +# "0100\n" +assert 0 == (put 1 > 1); +assert 1 == (put 1 > 0); +assert 0 == (put 0 > 1); +assert 0 == (say 0 > 0); + +# "1001\n" +assert 1 == (put 1 == 1); +assert 0 == (put 1 == 0); +assert 0 == (put 0 == 1); +assert 1 == (say 0 == 0); + +# "0110\n" +assert 0 == (put 1 != 1); +assert 1 == (put 1 != 0); +assert 1 == (put 0 != 1); +assert 0 == (say 0 != 0); + +# "1011\n" +assert 1 == (put 1 <= 1); +assert 0 == (put 1 <= 0); +assert 1 == (put 0 <= 1); +assert 1 == (say 0 <= 0); + +## "1101\n" +assert 1 == (put 1 >= 1); +assert 1 == (put 1 >= 0); +assert 0 == (put 0 >= 1); +assert 1 == (say 0 >= 0); + + diff --git a/examples/control.fy b/examples/control.fy new file mode 100644 index 0000000..0deac78 --- /dev/null +++ b/examples/control.fy @@ -0,0 +1,32 @@ +#* + * Examples of how to use control statements + *# + +if 1 { + say "if 1"; +} + +ifnot 0 == 1 { + say "ifnot 0 == 1"; +} + +# Calculate 10! + +my n = 10, fac = 0; + +while n > 1 { + ifnot fac { + fac = 1; + } + say fac = (fac * n); + decr n; +} + +# Count up to 10 + +n = 0; + +until n == 10 { + say incr n; +} + diff --git a/examples/expressions.fy b/examples/expressions.fy new file mode 100644 index 0000000..93a278f --- /dev/null +++ b/examples/expressions.fy @@ -0,0 +1,31 @@ +#* + * Simple expression tests + *# + +# Result 10 +assert 10 == say (8 / 2) + 2 * 3; + +# Result 12 +assert 12 == say 2 * (4 + 2); + +# Result 4 +assert 4 == say 2 * (4 / 2); + +# Result 4 +assert 4 == say 2 * (4 / 2); + +# Result 4 +assert 4 == say 2 * (4 / 2); + +# Result 46 +assert 46 == say "12" + "34"; + +# Result 1231 +assert 1231 == say "1234" - "3"; + +# Result 24 +assert "24" == say "2ab" * "12"; + +# Result 5.0 +assert 5 == say "10 bla" / 2; + diff --git a/examples/fork.fy b/examples/fork.fy new file mode 100644 index 0000000..c49c878 --- /dev/null +++ b/examples/fork.fy @@ -0,0 +1,14 @@ +#* + * Examples of how to use fork + *# + +my pid = fork; + +if pid { + put "I am the parent process and the child has the pid "; + say pid; +} + +ifnot pid { + say "I am the child process"; +} diff --git a/examples/functions.fy b/examples/functions.fy new file mode 100644 index 0000000..15856a0 --- /dev/null +++ b/examples/functions.fy @@ -0,0 +1,25 @@ +#* + * Examples of how to use functions + *# + +func foo { + say 1 + a * 3 + b; + + func bar { + say "Hello i am nested"; + } + + bar; # Calling nested +} + +my a = 2, b = 4; # Create global variables +foo; +assert 0 == (defined bar); # bar is not available anymore + +func baz { + say "I am baz"; + undef baz; +} + +baz; # Baz deletes itself +assert 0 == (defined baz); # baz is not available anymore diff --git a/examples/inlinefunctions.fy b/examples/inlinefunctions.fy new file mode 100644 index 0000000..81848ce --- /dev/null +++ b/examples/inlinefunctions.fy @@ -0,0 +1,20 @@ +#* + * Simple builtin function tests + *# + +# Print "-20\n" +assert (neg 20) == (say neg 20); + +# Print "30\n" +assert 30 == (say 10 - neg 20); + +# Print "-30\n" +assert (neg 30) == (say neg neg neg 10 - neg 20); + +# Print "Hello\n" +put "Hello"; +ln; + +# Exit with exit code 0 +exit 10 + 10 - 5 - 15; + diff --git a/examples/io.fy b/examples/io.fy new file mode 100644 index 0000000..fda514d --- /dev/null +++ b/examples/io.fy @@ -0,0 +1,13 @@ +#* + * Simple I/O examples. Currently only output is supported. + *# + +# Print out 10 followed by a newline +say 10; + +# Print out 20 without a newline followed +put 20; + +# Print out a newline +ln; + diff --git a/examples/procedures.fy b/examples/procedures.fy new file mode 100644 index 0000000..cbe2121 --- /dev/null +++ b/examples/procedures.fy @@ -0,0 +1,30 @@ +#* + * Examples of how to use procedures + *# + +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"; + +proc bar { + say "I am bar"; + + undef baz; + + proc baz { + say "I am baz"; + } +} + +# Here bar would produce an error because the proc is not yet defined! +# bar; + +bar; # Here the procedure bar will define the procedure baz! +baz; # Now the procedure baz is defined! +bar; # Here the procedure bar will redefine baz again! diff --git a/examples/scopeing.fy b/examples/scopeing.fy new file mode 100644 index 0000000..434f38f --- /dev/null +++ b/examples/scopeing.fy @@ -0,0 +1,31 @@ +#* + * Examples of how to use scopeing + *# + +my foo = 1; + +{ + # Prints out 1 + assert 1 == (put defined foo); + + { + my bar = 2; + + # Prints out 1 + assert 1 == (put defined bar); + + # Prints out all available symbols at + # the current program position. + scope; + } + + # Prints out 0 + assert 0 == (put defined bar); + + my baz = 3; +} + +# Prints out 0 +assert 0 == (say defined bar); + + diff --git a/examples/synonyms.fy b/examples/synonyms.fy new file mode 100644 index 0000000..0dd30f5 --- /dev/null +++ b/examples/synonyms.fy @@ -0,0 +1,37 @@ +#* + * Examples of how to use synonyms + *# + +# Create a variable foo, and bar is a synonym for foo +my foo = "foo"; +my bar = \foo; + +# Reset the value of foo +foo = "bar"; + +# The synonym variable should now also set to "bar" +assert "bar" == say bar; + +# Create a new procedure baz +proc baz { + say "I am baz"; +} + +# Make a synonym baz, and undefine baz +my bay = \baz; + +# Should be the num of syms for the same value +assert 2 == syms baz; +assert 2 == syms bay; +undef baz; +assert 1 == syms bay; + +# bay still has a reference of the original procedure baz +bay; # this prints aut "I am baz" + +assert 0 == defined baz; +assert 1 == defined bay; + +# This removes the procedure from memory +undef bay; + diff --git a/examples/types.fy b/examples/types.fy new file mode 100644 index 0000000..1b9a0ac --- /dev/null +++ b/examples/types.fy @@ -0,0 +1,14 @@ +#* + * Examples how to convert types + *# + +assert 1 == say 1; # Integer output + +assert 1 == say double 1; # Double output + +assert 14 == say 1 + string 13; # Implicit type conversion to Integer + +assert 2 == say integer 2.8; # Rounds down to the Integer 2 + +assert say integer double string put say neg 12; # Nonsense but working :) + diff --git a/examples/variables.fy b/examples/variables.fy new file mode 100644 index 0000000..ac619c9 --- /dev/null +++ b/examples/variables.fy @@ -0,0 +1,21 @@ +#* + * Examples of how to define variables + *# + +# Defines the variables +my foo = 1 + 1; +my bar = 4 - 1, baz = 100 + 1, bay; + +# bay has been initialized with the default value of 0 +say bay; + +# Prints out "5\n" +assert 5 == (say foo + bar); + +# Pritns out "51101\n" +assert 51 == (put baz - 50); +assert 101 == (say baz); + +# Change the value of the variable to 99 and print it out +assert 99 == (baz = 99); +say baz; Binary files differdiff --git a/src/core/convert.c b/src/core/convert.c new file mode 100644 index 0000000..cf8987e --- /dev/null +++ b/src/core/convert.c @@ -0,0 +1,216 @@ +/*:* + *: File: ./src/core/convert.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include "convert.h" +#include "../data/array.h" + +void +convert_to_integer(Token *p_token) { + switch (token_get_tt(p_token)) { + case TT_INTEGER: + break; + case TT_DOUBLE: + token_set_tt(p_token, TT_INTEGER); + token_set_ival(p_token, (int)token_get_dval(p_token)); + break; + case TT_STRING: + token_set_tt(p_token, TT_INTEGER); + token_set_ival(p_token, atoi(token_get_val(p_token))); + break; + case TT_ARRAY: + token_set_tt(p_token, TT_INTEGER); + token_set_ival(p_token, array_get_size(p_token->p_array)); + break; + default: + ERROR("Ouups(%s)", tt_get_name(token_get_tt(p_token))); + break; + } +} + +int +convert_to_integer_get(Token *p_token) { + switch (token_get_tt(p_token)) { + case TT_INTEGER: + return (token_get_ival(p_token)); + case TT_DOUBLE: + return ((int) token_get_dval(p_token)); + case TT_STRING: + return (atoi(token_get_val(p_token))); + case TT_ARRAY: + return (array_get_size(p_token->p_array)); + break; + default: + ERROR("Ouups(%s)", tt_get_name(token_get_tt(p_token))); + } + + return (0); /* Never reach this point */ +} + +void +convert_to_double(Token *p_token) { + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_tt(p_token, TT_DOUBLE); + token_set_dval(p_token, token_get_ival(p_token)); + break; + case TT_DOUBLE: + break; + case TT_STRING: + token_set_tt(p_token, TT_DOUBLE); + token_set_dval(p_token, atof(token_get_val(p_token))); + break; + case TT_ARRAY: + token_set_tt(p_token, TT_DOUBLE); + token_set_dval(p_token, array_get_size(p_token->p_array)); + break; + default: + token_print_val(p_token); + ERROR("Datatype conversion error '%s'", token_get_val(p_token)); + break; + } +} + +void +convert_to_string(Token *p_token) { + switch (token_get_tt(p_token)) { + case TT_INTEGER: + { + token_set_tt(p_token, TT_STRING); + char c_tmp[1024]; + sprintf(c_tmp, "%d", token_get_ival(p_token)); + int i_len = strlen(c_tmp); + p_token->c_val = realloc(p_token->c_val, sizeof(char) * (i_len + 1)); + strcpy(p_token->c_val, c_tmp); + p_token->c_val[i_len] = 0; + } + break; + case TT_DOUBLE: + { + token_set_tt(p_token, TT_STRING); + char c_tmp[1024]; + sprintf(c_tmp, "%f", token_get_dval(p_token)); + int i_len = strlen(c_tmp); + p_token->c_val = realloc(p_token->c_val, sizeof(char) * (i_len + 1)); + strcpy(p_token->c_val, c_tmp); + p_token->c_val[i_len] = 0; + } + case TT_ARRAY: + { + token_set_tt(p_token, TT_STRING); + char c_tmp[1024]; + sprintf(c_tmp, "%d", array_get_size(p_token->p_array)); + int i_len = strlen(c_tmp); + p_token->c_val = realloc(p_token->c_val, sizeof(char) * (i_len + 1)); + strcpy(p_token->c_val, c_tmp); + p_token->c_val[i_len] = 0; + } + break; + case TT_STRING: + break; + default: + ERROR("Datatype conversion error"); + break; + } +} + +void +convert_to_array(Token *p_token) { + ERROR("not yet implemented"); +} + +void +convert_to_tt(Token *p_token, TokenType tt) { + switch (tt) { + case TT_INTEGER: + convert_to_integer(p_token); + break; + case TT_DOUBLE: + convert_to_double(p_token); + break; + case TT_STRING: + convert_to_string(p_token); + break; + case TT_ARRAY: + convert_to_array(p_token); + break; + default: + ERROR("Ouups!"); + } +} + +TokenType +convert_to_highest(Token *p_token1, Token *p_token2) { + TokenType tt_highest = token_get_tt(p_token1); + + if (tt_highest < token_get_tt(p_token2)) { + tt_highest = token_get_tt(p_token2); + + convert_to_tt(p_token1, tt_highest); + + } else { + convert_to_tt(p_token2, tt_highest); + } + + return (tt_highest); +} + +TokenType +convert_function_arg_types_to_highest(Stack *p_stack_args, int i_args) { + + if (i_args <= 0) + i_args = stack_size(p_stack_args); + + StackIterator *p_iter = stackiterator_new(p_stack_args); + TokenType tt_highest = TT_INTEGER; + + for (int i = 0; i < i_args && stackiterator_has_next(p_iter); ++i) { + Token *p_token = stackiterator_next(p_iter); + if (token_get_tt(p_token) > tt_highest) + tt_highest = token_get_tt(p_token); + } + + stackiterator_delete(p_iter); + p_iter = stackiterator_new(p_stack_args); + + for (int i = 0; i < i_args && stackiterator_has_next(p_iter); ++i) { + Token *p_token = stackiterator_next(p_iter); + convert_to_tt(p_token, tt_highest); + } + + stackiterator_delete(p_iter); + + return (tt_highest); +} + diff --git a/src/core/convert.h b/src/core/convert.h new file mode 100644 index 0000000..9dcf23e --- /dev/null +++ b/src/core/convert.h @@ -0,0 +1,55 @@ +/*:* + *: File: ./src/core/convert.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef CONVERT_H +#define CONVERT_H + +#include "../defines.h" + +#include "../data/stack.h" + +#include "token.h" + +int convert_to_integer_get(Token *p_token); +void convert_to_integer(Token *p_token); +void convert_to_double(Token *p_token); +void convert_to_string(Token *p_token); +void convert_to_array(Token *p_token); +void convert_to_tt(Token *p_token, TokenType tt); +TokenType convert_to_highest(Token *p_token1, Token *p_token2); +TokenType convert_function_arg_types_to_highest(Stack *p_stack_args, int + i_args); + +#endif diff --git a/src/core/function.c b/src/core/function.c new file mode 100644 index 0000000..70166ed --- /dev/null +++ b/src/core/function.c @@ -0,0 +1,51 @@ +/*:* + *: File: ./src/core/function.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include "../defines.h" + +#include "function.h" + +Function* +function_new() { + Function *p_function = malloc(sizeof(Function)); + + return (p_function); +} + +void +function_delete(Function *p_function) { + free(p_function); +} + diff --git a/src/core/function.h b/src/core/function.h new file mode 100644 index 0000000..748ebce --- /dev/null +++ b/src/core/function.h @@ -0,0 +1,46 @@ +/*:* + *: File: ./src/core/function.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef FUNCTION_H +#define FUNCTION_H + +typedef struct { + char *c_name; +} Function; + +Function* function_new(); +void function_delete(Function *p_function); + +#endif /* FUNCTION_H */ diff --git a/src/core/functions.c b/src/core/functions.c new file mode 100644 index 0000000..82efc4f --- /dev/null +++ b/src/core/functions.c @@ -0,0 +1,985 @@ +/*:* + *: File: ./src/core/functions.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include <stdlib.h> +#include <sys/types.h> +#include <unistd.h> + +#include "functions.h" + +#include "convert.h" +#include "scope.h" +#include "symbol.h" + +#define _FUNCTIONS_ERROR(m,t) \ + ERROR(\ + "%s: Function error in %s line %d pos %d near '%s'", m, \ + token_get_filename(t), \ + token_get_line_nr(t), \ + token_get_pos_nr(t), \ + token_get_val(t) \ + ) + +Functions* +functions_new() { + Functions *p_functions = malloc(sizeof(Functions)); + + p_functions->p_hash_functions = hash_new(1024); + functions_init(p_functions); + + return (p_functions); +} + +void +functions_delete(Functions *p_functions) { + hash_delete(p_functions->p_hash_functions); + free(p_functions); +} + + +void +_process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, + Token *p_token_op2, Token *p_token_next) { + + TokenType tt_op = token_get_tt(p_token_op); + TokenType tt_op2 = p_token_op2 == NULL + ? TT_NONE + : token_get_tt(p_token_op2); + +#ifdef DEBUG_FUNCTION_PROCESS + if (p_token_op2 == NULL) + printf("DEBUG::FUNCTION::PROCESS: Operator %s\n", tt_get_name(tt_op)); + else + printf("DEBUG::FUNCTION::PROCESS: Operator %s %s\n", tt_get_name(tt_op), + tt_get_name(tt_op2)); + + token_print(p_token_next); + printf("\n"); + token_print(p_token_store); + printf("\n"); +#endif /* DEBUG_FUNCTION_PROCESS */ + + if (p_token_op2 != NULL) { + switch (tt_op) { + case TT_NOT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_NEQ; + break; + default: + break; + } + break; + case TT_ASSIGN: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_EQ; + break; + default: + break; + } + break; + case TT_LT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_LE; + break; + default: + break; + } + break; + case TT_GT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_GE; + break; + default: + break; + } + break; + case TT_DDOT: + switch (tt_op2) { + case TT_LT: + tt_op = TT_LSHIFT; + break; + case TT_GT: + tt_op = TT_RSHIFT; + break; + default: + break; + } + break; + default: + break; + } + } else { + switch (tt_op) { + case TT_ASSIGN: + { + Token *p_token_assign = p_interpret->p_token_temp; + TokenType tt_assign = token_get_tt(p_token_assign); + + if (tt_assign != TT_IDENT) { + _FUNCTIONS_ERROR("Can only assign to symbols", + p_token_store); + } + + Symbol *p_symbol = scope_get(p_interpret->p_scope, + token_get_val(p_token_assign)); + + if (p_symbol == NULL) { + _FUNCTIONS_ERROR("No such symbol", + p_token_assign); + } + + symbol_set_val(p_symbol, p_token_store); + symbol_set_sym(p_symbol, SYM_VARIABLE); + + return; + } + + break; + NO_DEFAULT; + } + } + + p_token_next = token_new_copy(p_token_next); + TokenType tt_highest = convert_to_highest(p_token_store, p_token_next); + +#ifdef DEBUG_FUNCTION_PROCESS + printf("DEBUG::FUNCTION::PROCESS: ===> %s %s %s\n", + tt_get_name(tt_highest), + tt_get_name(tt_op), + tt_get_name(tt_highest)); +#endif /* DEBUG_FUNCTION_PROCESS */ + + switch (tt_op) { + case TT_ADD: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + token_get_ival(p_token_next) + + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) + + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) + + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + array_append(p_token_store->p_array, + p_token_next->p_array); + break; + NO_DEFAULT; + } + break; + case TT_SUB: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + token_get_ival(p_token_next) - + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) - + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) - + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("TT_ARRAY - TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_MULT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + token_get_ival(p_token_next) * + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) * + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) * + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("TT_ARRAY * TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_DIV: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) / + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) / + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_dval(p_token_store, + atof(token_get_val(p_token_next)) / + atof(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_DOUBLE); + break; + case TT_ARRAY: + ERROR("TT_ARRAY / TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_EQ: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) == + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) == + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) == 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("TT_ARRAY eq TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_NEQ: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) != + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) != + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) != 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_LE: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) <= + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) <= + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) <= 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_GE: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) >= + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) >= + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) >= 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_LT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) < + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) < + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) < 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_GT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) > + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) > + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) > 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_AND: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) & + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) & + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) & + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_OR: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) | + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) | + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) | + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_XOR: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) ^ + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) ^ + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) ^ + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_LSHIFT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) << + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) << + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) << + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_RSHIFT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) >> + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) >> + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) >> + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + + default: + _FUNCTIONS_ERROR("No such function/operator", p_token_op); + } + +#ifdef DEBUG_FUNCTION_PROCESS + token_print(p_token_store); + printf("\n\n"); +#endif /* DEBUG_FUNCTION_PROCESS */ + + token_delete(p_token_next); +} + +void +function_process(Interpret *p_interpret, Token *p_token_op, + Token *p_token_op2, Stack *p_stack_args, int i_args) { + + Token *p_token_store = token_new_copy(stack_pop(p_stack_args)); + + for (int i = 0; i < i_args -1 && !stack_empty(p_stack_args); ++i) { + Token *p_token_next = stack_pop(p_stack_args); + + _process(p_interpret, p_token_store, p_token_op, + p_token_op2, p_token_next); + } + + stack_push(p_stack_args, p_token_store); +} + +_Bool +function_is_buildin(Token *p_token_ident) { + /* TODO: optimize this function */ + if (strcmp("assert", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("decr", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("double", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("end", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("exit", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("fork", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("gc", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("incr", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("ind", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("integer", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("len", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("ln", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("neg", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("no", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("put", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("scope", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("say", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("string", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("yes", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("not", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("refs", token_get_val(p_token_ident)) == 0) + return (true); + + return (false); +} + +void +function_process_buildin(Interpret *p_interpret, Token *p_token_ident, + Stack *p_stack_args) { + + Token *p_token = stack_top(p_stack_args); + + if (token_get_tt(p_token) == TT_ARRAY) { + if (strcmp("len", token_get_val(p_token_ident)) == 0) { + stack_pop(p_stack_args); + stack_push(p_stack_args, + token_new_integer(array_get_used(p_token->p_array))); + + } else if (strcmp("ind", token_get_val(p_token_ident)) == 0) { + stack_pop(p_stack_args); + stack_push(p_stack_args, + token_new_integer(array_get_ind(p_token->p_array))); + + } else { + ArrayIterator *p_iter = arrayiterator_new(p_token->p_array); + + while (arrayiterator_has_next(p_iter)) { + stack_push(p_stack_args, arrayiterator_next(p_iter)); + function_process_buildin(p_interpret, p_token_ident, + p_stack_args); + stack_pop(p_stack_args); + } + + arrayiterator_delete(p_iter); + } + + return; + } + + if (strcmp("assert", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + if (token_get_ival(p_token) == 0) + _FUNCTIONS_ERROR("Assert failed", p_token); + break; + case TT_DOUBLE: + if (token_get_dval(p_token) == 0) + _FUNCTIONS_ERROR("Assert failed", p_token); + break; + case TT_STRING: + if (atoi(token_get_val(p_token)) == 0) + _FUNCTIONS_ERROR("Assert failed", p_token); + break; + NO_DEFAULT; + } + + } else if (strcmp("decr", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, token_get_ival(p_token) - 1); + break; + case TT_DOUBLE: + token_set_dval(p_token, token_get_dval(p_token) - 1); + break; + case TT_STRING: + convert_to_integer(p_token); + token_set_ival(p_token, token_get_ival(p_token) - 1); + break; + NO_DEFAULT; + } + + } else if (strcmp("double", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_double(p_token); + stack_push(p_stack_args, p_token); + + } else if (strcmp("end", token_get_val(p_token_ident)) == 0) { + exit(0); + + } else if (strcmp("fork", token_get_val(p_token_ident)) == 0) { + Token *p_token = token_new_integer((int) fork()); + stack_push(p_stack_args, p_token); + + } else if (strcmp("gc", token_get_val(p_token_ident)) == 0) { + int i_count = garbage_collect(); + Token *p_token = token_new_integer(i_count); + stack_push(p_stack_args, p_token); + + } else if (strcmp("exit", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + p_token = token_new_copy(p_token); + convert_to_integer(p_token); + exit(token_get_ival(p_token)); + + } else if (strcmp("incr", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, token_get_ival(p_token) + 1); + break; + case TT_DOUBLE: + token_set_dval(p_token, token_get_dval(p_token) + 1); + break; + case TT_STRING: + convert_to_integer(p_token); + token_set_ival(p_token, token_get_ival(p_token) + 1); + break; + NO_DEFAULT; + } + + } else if (strcmp("ind", token_get_val(p_token_ident)) == 0) { + _FUNCTIONS_ERROR("Expected array", p_token_ident); + + } else if (strcmp("integer", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_integer(p_token); + stack_push(p_stack_args, p_token); + + } else if (strcmp("len", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_string(p_token); + token_set_tt(p_token, TT_INTEGER); + token_set_ival(p_token, strlen(token_get_val(p_token))); + stack_push(p_stack_args, p_token); + + } else if (strcmp("ln", token_get_val(p_token_ident)) == 0) { + printf("\n"); + + } else if (strcmp("neg", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + stack_push(p_stack_args, p_token); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, -token_get_ival(p_token)); + break; + case TT_DOUBLE: + token_set_dval(p_token, -token_get_dval(p_token)); + break; + case TT_STRING: + token_set_ival(p_token, -atoi(token_get_val(p_token))); + token_set_tt(p_token, TT_INTEGER); + break; + NO_DEFAULT; + } + + } else if (strcmp("no", token_get_val(p_token_ident)) == 0) { + Token *p_token = NULL; + + if (0 == stack_size(p_stack_args)) { + p_token = token_new_integer(0); + + } else { + p_token = token_new_copy(stack_pop(p_stack_args)); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, !token_get_ival(p_token)); + break; + case TT_DOUBLE: + token_set_dval(p_token, !token_get_dval(p_token)); + break; + case TT_STRING: + token_set_ival(p_token, !atoi(token_get_val(p_token))); + token_set_tt(p_token, TT_INTEGER); + break; + NO_DEFAULT; + } + } + + stack_push(p_stack_args, p_token); + + } else if (strcmp("put", token_get_val(p_token_ident)) == 0) { + StackIterator *p_iter = stackiterator_new(p_stack_args); + while (stackiterator_has_next(p_iter)) { + Token *p_token = stackiterator_next(p_iter); + switch (token_get_tt(p_token)) { + case TT_INTEGER: + printf("%d", token_get_ival(p_token)); + break; + case TT_DOUBLE: + printf("%f", token_get_dval(p_token)); + break; + case TT_STRING: + printf("%s", token_get_val(p_token)); + break; + NO_DEFAULT; + } + } + stackiterator_delete(p_iter); + + } else if (strcmp("scope", token_get_val(p_token_ident)) == 0) { + scope_print(p_interpret->p_scope); + + } else if (strcmp("say", token_get_val(p_token_ident)) == 0) { + StackIterator *p_iter = stackiterator_new(p_stack_args); + while (stackiterator_has_next(p_iter)) { + Token *p_token = stackiterator_next(p_iter); + switch (token_get_tt(p_token)) { + case TT_INTEGER: + printf("%d", token_get_ival(p_token)); + break; + case TT_DOUBLE: + printf("%f", token_get_dval(p_token)); + break; + case TT_STRING: + printf("%s", token_get_val(p_token)); + break; + } + } + stackiterator_delete(p_iter); + printf("\n"); + + } else if (strcmp("string", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_string(p_token); + stack_push(p_stack_args, p_token); + + } else if (strcmp("yes", token_get_val(p_token_ident)) == 0) { + Token *p_token = NULL; + + if (0 == stack_size(p_stack_args)) { + p_token = token_new_integer(1); + + } else { + p_token = token_new_copy(stack_pop(p_stack_args)); + token_set_ival(p_token, 1); + token_set_tt(p_token, TT_INTEGER); + + } + + stack_push(p_stack_args, p_token); + + } else if (strcmp("not", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + stack_push(p_stack_args, p_token); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, !token_get_ival(p_token)); + break; + case TT_DOUBLE: + token_set_dval(p_token, !token_get_dval(p_token)); + break; + case TT_STRING: + token_set_ival(p_token, !atoi(token_get_val(p_token))); + token_set_tt(p_token, TT_INTEGER); + break; + NO_DEFAULT; + } + + } else if (strcmp("refs", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token_top = stack_pop(p_stack_args); + Token *p_token = token_new_integer(p_token_top->i_ref_count); + stack_push(p_stack_args, p_token); + } +} + +_Bool +function_is_self_defined(Interpret *p_interpret) { + Symbol *p_symbol = scope_get(p_interpret->p_scope, + token_get_val(p_interpret->p_token)); + + if (p_symbol == NULL) + return (false); + + switch (symbol_get_sym(p_symbol)) { + case SYM_PROCEDURE: + case SYM_FUNCTION: + return (true); + NO_DEFAULT; + } + + return (false); +} + +void +function_process_self_defined(Interpret *p_interpret, Token *p_token_ident) { + Symbol *p_symbol = scope_get(p_interpret->p_scope, + token_get_val(p_token_ident)); + + switch (symbol_get_sym(p_symbol)) { + case SYM_PROCEDURE: + { + List *p_list_token = symbol_get_val(p_symbol); + interpret_subprocess(p_interpret, p_list_token); + } + break; + case SYM_FUNCTION: + { + List *p_list_token = symbol_get_val(p_symbol); + scope_up(p_interpret->p_scope); + interpret_subprocess(p_interpret, p_list_token); + scope_down(p_interpret->p_scope); + } + NO_DEFAULT; + } +} + +void +functions_init(Functions *p_functions) { +} diff --git a/src/core/functions.h b/src/core/functions.h new file mode 100644 index 0000000..4e00dc2 --- /dev/null +++ b/src/core/functions.h @@ -0,0 +1,64 @@ +/*:* + *: File: ./src/core/functions.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef FUNCTIONS_H +#define FUNCTIONS_H + +#include "token.h" + +#include "interpret.h" +#include "../data/stack.h" +#include "../data/hash.h" + +typedef struct { + Hash *p_hash_functions; +} Functions; + +Functions* functions_new(); +void functions_delete(Functions *p_functions); +void functions_init(Functions *p_functions); + +void function_process(Interpret *p_interp, Token *p_token_op, + Token *p_token_op2, Stack *p_stack_args, + int i_args); +_Bool function_is_buildin(Token *p_token_ident); +void function_process_buildin(Interpret *p_interpret, + Token *p_token_ident, + Stack *p_stack_args); +_Bool function_is_self_defined(Interpret *p_interpret); +void function_process_self_defined(Interpret *p_interpret, + Token *p_token_ident); + +#endif /* FUNCTIONS_H */ diff --git a/src/core/garbage.c b/src/core/garbage.c new file mode 100644 index 0000000..23c73b8 --- /dev/null +++ b/src/core/garbage.c @@ -0,0 +1,144 @@ +/*:* + *: File: ./src/core/garbage.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include "garbage.h" + +#define _GARBAGE_ERROR(m) \ + ERROR("%s: Garbage error", m); + +List *LIST_GARBAGE = NULL; + +typedef struct { + void (*p_func)(void*); + void (*p_print)(void*); + int *p_ref_count; + void *p_2free; + GarbageType type; +} _Garbage; + +void +garbage_init() { + LIST_GARBAGE = list_new(); +} + +void +garbage_destroy() { + garbage_collect(); + if (!list_empty(LIST_GARBAGE)) { + EPRINTF("The garbage collector still has %d registered items " + " which don't have a zero ref count!\n", + list_size(LIST_GARBAGE)); + + _GARBAGE_ERROR("Garbage left"); + } + + list_delete(LIST_GARBAGE); +} + +int +garbage_collect() { + ListIterator *p_iter = listiterator_new(LIST_GARBAGE); + List *p_list_garbage_new = list_new(); + int i_count = 0; + + while (listiterator_has_next(p_iter)) { + _Garbage *p_garbage = listiterator_next(p_iter); + + if (p_garbage->p_ref_count == NULL || *p_garbage->p_ref_count <= 0) { +#ifdef DEBUG_GC + printf("DEBUG::GC: Freeing "); + if (NULL != p_garbage->p_print) + (*p_garbage->p_print) (p_garbage->p_2free); + else + printf("0x%x\n", (int) p_garbage->p_2free); +#endif /* DEBUG_GC */ + (*p_garbage->p_func) (p_garbage->p_2free); + free(p_garbage); + ++i_count; + + } else { + list_add_back(p_list_garbage_new, p_garbage); + } + } + + listiterator_delete(p_iter); + + list_delete(LIST_GARBAGE); + LIST_GARBAGE = p_list_garbage_new; +#ifdef DEBUG_GC + printf("DEBUG::GC: Freed %d items\n", i_count); +#endif /* DEBUG_GC */ + + return (i_count); +} + +void +garbage_add(void *p, GarbageType type) { + garbage_add2(p, free, NULL, type); +} + +void +garbage_add2(void *p, + void (*p_func)(void*), + int *p_ref_count, + GarbageType type) { + garbage_add3(p, free, p_func, NULL, type); +} + +void +garbage_add3(void *p, + void (*p_func)(void*), + void (*p_print)(void*), + int *p_ref_count, + GarbageType type) { + + _Garbage *p_garbage = malloc(sizeof(_Garbage)); + + p_garbage->p_2free = p; + p_garbage->p_func = p_func; + p_garbage->p_print = p_print; + p_garbage->p_ref_count = p_ref_count; + p_garbage->type = type; + + list_add_back(LIST_GARBAGE, p_garbage); +} + +void +garbage_add_token(Token *p_token) { + garbage_add3(p_token, + token_delete_cb, + token_print_cb, + &p_token->i_ref_count, GC_TOKEN); +} diff --git a/src/core/garbage.h b/src/core/garbage.h new file mode 100644 index 0000000..f7533eb --- /dev/null +++ b/src/core/garbage.h @@ -0,0 +1,60 @@ +/*:* + *: File: ./src/core/garbage.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef GARBAGE_H +#define GARBAGE_H + +#include "../defines.h" +#include "../data/list.h" +#include "token.h" + +typedef enum { + GC_TOKEN, +} GarbageType; + +void garbage_init(); +void garbage_destroy(); +int garbage_collect(); +void garbage_add(void *p, GarbageType type); +void garbage_add2(void *p, void (*p_func)(void*), + int *p_ref_count, + GarbageType type); +void garbage_add3(void *p, void (*p_func)(void*), + void (*p_print)(void*), + int *p_ref_count, + GarbageType type); +void garbage_add_token(Token *p_token); + +#endif diff --git a/src/core/reference.c b/src/core/reference.c new file mode 100644 index 0000000..3eccaaa --- /dev/null +++ b/src/core/reference.c @@ -0,0 +1,57 @@ +/*:* + *: File: ./src/core/reference.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include "reference.h" + +Reference* +reference_new(Symbol *p_symbol) { + Reference *p_reference = malloc(sizeof(Reference)); + + symbol_ref_up(p_symbol); + p_reference->p_symbol = p_symbol; + + return (p_reference); +} + +void +reference_delete_cb(void *p_void) { + reference_delete(p_void); +} + +void +reference_delete(Reference *p_reference) { + symbol_delete(p_reference->p_symbol); + free(p_reference); +} diff --git a/src/core/reference.h b/src/core/reference.h new file mode 100644 index 0000000..6cda63d --- /dev/null +++ b/src/core/reference.h @@ -0,0 +1,52 @@ +/*:* + *: File: ./src/core/reference.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef REFERENCE_H +#define REFERENCE_H + +#include "../defines.h" +#include "symbol.h" + +#define reference_get_sym(r) (r->p_symbol) + +typedef struct { + Symbol *p_symbol; +} Reference; + +Reference* reference_new(Symbol *p_symbol); +void reference_delete_cb(void *p_void); +void reference_delete(Reference *p_reference); + +#endif /* REFERENCE_H */ diff --git a/src/core/scope.c b/src/core/scope.c new file mode 100644 index 0000000..a9098a9 --- /dev/null +++ b/src/core/scope.c @@ -0,0 +1,169 @@ +/*:* + *: File: ./src/core/scope.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include "garbage.h" +#include "scope.h" +#include "symbol.h" + +Scope* +scope_new(Hash *p_hash_syms) { + Scope *p_scope = malloc(sizeof(Scope)); + + p_scope->p_hash_global = p_hash_syms; + p_scope->p_stack_scopes = stack_new(); + + return (p_scope); +} + +void +scope_delete(Scope *p_scope) { + while (!stack_empty(p_scope->p_stack_scopes)) + scope_down(p_scope); + + stack_delete(p_scope->p_stack_scopes); + + free(p_scope); +} + +void +scope_up(Scope *p_scope) { + stack_push(p_scope->p_stack_scopes, hash_new(1024)); +} + +void +scope_down(Scope *p_scope) { + Hash *p_hash_syms = stack_pop(p_scope->p_stack_scopes); + hash_iterate(p_hash_syms, symbol_cleanup_hash_syms_cb); + hash_delete(p_hash_syms); +} + +static Hash* +_scope_get_hash(Scope *p_scope, char *c_key) { + StackIterator *p_iter = stackiterator_new(p_scope->p_stack_scopes); + + while (stackiterator_has_next(p_iter)) { + Hash *p_hash_syms = stackiterator_next(p_iter); + Symbol *p_symbol = hash_get(p_hash_syms, c_key); + + if (p_symbol != NULL) { + stackiterator_delete(p_iter); + return (p_hash_syms); + } + } + + stackiterator_delete(p_iter); + + if (hash_get(p_scope->p_hash_global, c_key)) + return (p_scope->p_hash_global); + + return (NULL); +} + +Symbol* +scope_get(Scope *p_scope, char *c_key) { + Hash *p_hash_syms = _scope_get_hash(p_scope, c_key); + + if (p_hash_syms == NULL) + return (NULL); + + return (hash_get(p_hash_syms, c_key)); +} + +Symbol* +scope_remove(Scope *p_scope, char *c_key) { + Hash *p_hash_syms = _scope_get_hash(p_scope, c_key); + + if (p_hash_syms == NULL) + return (NULL); + + Symbol *p_symbol = hash_remove(p_hash_syms, c_key); + + return (p_symbol); +} + +_Bool +scope_exists(Scope *p_scope, char *c_key) { + return (scope_get(p_scope, c_key) != NULL); +} + +_Bool +scope_reset(Scope *p_scope, char *c_key, Symbol *p_symbol) { + Hash *p_hash_syms = _scope_get_hash(p_scope, c_key); + + if (p_hash_syms == NULL) + return (false); + + hash_remove(p_hash_syms, c_key); + hash_insert(p_hash_syms, c_key, p_symbol); + + return (true); +} + +_Bool +scope_newset(Scope *p_scope, char *c_key, Symbol *p_symbol) { + Hash *p_hash_syms = NULL; + + if (stack_empty(p_scope->p_stack_scopes)) { + if (hash_get(p_scope->p_hash_global, c_key) != NULL) + return (false); + + p_hash_syms = p_scope->p_hash_global; + + } else { + p_hash_syms = stack_top(p_scope->p_stack_scopes); + } + + hash_insert(p_hash_syms, c_key, p_symbol); + + return (true); +} + +void +_scope_print_cb(void *p_void, int i_level) { + Hash *p_hash_syms = p_void; + if (i_level > 0) + printf("%d level(s) up:\n", i_level); + hash_iterate_key(p_hash_syms, symbol_print_cb); +} + +void +scope_print(Scope *p_scope) { + printf("Scopes:\n"); + printf("Scope stack size: %d\n", stack_size(p_scope->p_stack_scopes)); + printf("Global symbols:\n"); + hash_iterate_key(p_scope->p_hash_global, symbol_print_cb); + printf("Local symbols:\n"); + stack_iterate_level(p_scope->p_stack_scopes, _scope_print_cb); +} diff --git a/src/core/scope.h b/src/core/scope.h new file mode 100644 index 0000000..c1193c9 --- /dev/null +++ b/src/core/scope.h @@ -0,0 +1,60 @@ +/*:* + *: File: ./src/core/scope.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef SCOPE_H +#define SCOPE_H + +#include "../data/hash.h" +#include "../data/stack.h" +#include "../defines.h" +#include "symbol.h" + +typedef struct { + Hash *p_hash_global; + Stack *p_stack_scopes; +} Scope; + +Scope* scope_new(Hash *p_hash_syms); +void scope_delete(Scope *p_scope); +Symbol *scope_get(Scope *p_scope, char *c_key); +Symbol *scope_remove(Scope *p_scope, char *c_key); +_Bool scope_exists(Scope *p_scope, char *c_key); +_Bool scope_newset(Scope *p_scope, char *c_key, Symbol *p_symbol); +_Bool scope_reset(Scope *p_scope, char *c_key, Symbol *p_symbol); +void scope_down(Scope *p_scope); +void scope_up(Scope *p_scope); +void scope_print(Scope *p_scope); + +#endif /* SCOPE_H */ diff --git a/src/core/symbol.c b/src/core/symbol.c new file mode 100644 index 0000000..f4ad990 --- /dev/null +++ b/src/core/symbol.c @@ -0,0 +1,122 @@ +/*:* + *: File: ./src/core/symbol.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#include "symbol.h" + +#include "../data/list.h" +#include "token.h" + +Symbol* +symbol_new(SymbolType sym, void *p_val) { + Symbol *p_symbol = malloc(sizeof(Symbol)); + + p_symbol->sym = sym; + p_symbol->p_val = p_val; + p_symbol->i_refs = 1; + + return p_symbol; +} + +void +symbol_delete(Symbol *p_symbol) { + if (--p_symbol->i_refs == 0) { + switch (symbol_get_sym(p_symbol)) { + case SYM_PROCEDURE: + { + List *p_list_token = symbol_get_val(p_symbol); + list_delete(p_list_token); + } + case SYM_ARRAY: + symbol_delete(symbol_get_val(p_symbol)); + break; + NO_DEFAULT; + } + free(p_symbol); + } +} + +void +symbol_cleanup_hash_syms_cb(void *p_void) { + symbol_delete(p_void); +} + +void +symbol_print(Symbol *p_symbol, char *c_key) { + printf("%s: %s", sym_get_name(p_symbol->sym), c_key); + + switch (p_symbol->sym) { + case SYM_BUILDIN: + case SYM_CONSTANT: + break; + case SYM_PROCEDURE: + case SYM_FUNCTION: + //list_iterate(symbol_get_val(p_symbol), token_print_cb); + break; + case SYM_ARRAY: + break; + case SYM_VARIABLE: + printf(" "); + token_print(symbol_get_val(p_symbol)); + break; + } + + printf("\n"); +} + +void +symbol_print_cb(void *p_void, char *c_key) { + symbol_print(p_void, c_key); +} + +char* +sym_get_name(SymbolType sym) { + switch (sym) { + case SYM_CONSTANT: + return ("SYM_CONSTANT"); + case SYM_ARRAY: + return ("SYM_ARRAY"); + case SYM_VARIABLE: + return ("SYM_VARIABLE"); + case SYM_BUILDIN: + return ("SYM_BUILDIN"); + case SYM_PROCEDURE: + return ("SYM_PROCEDURE"); + case SYM_FUNCTION: + return ("SYM_FUNCTION"); + } + + // Never reach this point + return ("NONE"); +} diff --git a/src/core/symbol.h b/src/core/symbol.h new file mode 100644 index 0000000..56f0e44 --- /dev/null +++ b/src/core/symbol.h @@ -0,0 +1,71 @@ +/*:* + *: File: ./src/core/symbol.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at dev.buetow.org + *: + *: Copyright (c) 2005 - 2009, Dipl.-Inform. (FH) Paul C. Buetow + *: 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 buetow.org 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 C. 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 C. 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. + *:*/ + +#ifndef SYMBOL_H +#define SYMBOL_H + +#include "../defines.h" + +#define symbol_set_val(s,v) s->p_val = v +#define symbol_set_sym(s,st) s->sym = st +#define symbol_get_val(s) s->p_val +#define symbol_get_sym(s) s->sym +#define symbol_ref_up(s) ++s->i_refs +#define IS_A_FUNCTION(s) (s == SYM_INLINEFUNCTION || s == SYM_FUNCTION) +#define IS_NOT_A_FUNCTION(s) !IS_A_FUNCTION(s) + +typedef enum { + SYM_BUILDIN, + SYM_CONSTANT, + SYM_FUNCTION, + SYM_PROCEDURE, + SYM_ARRAY, + SYM_VARIABLE, +} SymbolType; + +typedef struct { + SymbolType sym; + void *p_val; + unsigned i_refs; +} Symbol; + +Symbol* symbol_new(SymbolType sym, void *p_val); +void symbol_delete(Symbol *p_symbol); +void symbol_cleanup_hash_syms_cb(void *p_void); +void symbol_print(Symbol *p_symbol, char *c_key); +void symbol_print_cb(void *p_void, char *c_key); +char* sym_get_name(SymbolType sym); + +#endif @@ -0,0 +1,23 @@ +#* + * Examples of how to use arrays + *# + +# Create a function bar, returns 0 by default +func bar { say "bar" } + +# Create a multi dimensional array foo +my foo = [bar, 1, 4/2, double "3", ["A", ["BA", "BB"]]]; + +# Run on each element of foo recursive 'say' +say foo; + +# Print the length of the array +assert 5 == say len foo; + +# Print the last index of the array +assert 4 == say ind foo; + +# Print the 3rd element of the array +say foo[3]; + +#say "bla"; |