85 files changed, 12941 insertions, 0 deletions

diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..ef7c913
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,26 @@
+Fype (http://fype.buetow.org) is ...
+... Copyright (c) 2005 2006 2007 2008 by Dipl.-Inf. (FH) Paul C. Buetow 
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of P. B. Labs nor the names of its contributors may 
+	  be used to endorse or promote products derived from this software 
+	  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY Paul Buetow ``AS IS'' AND ANY EXPRESS OR 
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Paul Buetow BE LIABLE FOR ANY DIRECT, 
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..669dabf
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,11 @@
+How to install fype:
+
+	make
+	sudo make install
+	make clean
+
+How to read the docu:
+
+	man fype
+
+Examples can be found in the ./examples directory.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..f9d8ce4
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,114 @@
+# THIS MAKEFILE ONLY WORKS WITH (NET)BSD MAKE AKA PMAKE!
+
+BIN=fype
+SRCS!=find ./src -name '*.c'
+OBJS=$(SRCS:.c=.o)
+CC?=cc
+#CC=mingw32-gcc
+DEBUG=-g3 -ggdb3
+CFLAGS+=-c -Wall -std=c99 -pedantic $(DEBUG)
+LDADD+=
+HEADER?=docs/header.txt
+OSYSTEM!=uname
+PREFIX=/usr/local
+all: build $(OBJS) newline stats-tofile	
+	@$(CC) -lm -o $(BIN) $(OBJS) $(LDADD) 	
+	@if test -z '$(DEBUG)'; then strip $(BIN) ; fi	
+	@awk '$$2 == "BUILDNR" { printf("===> Fype build number % 13s :% 6s%d\n", \
+		"", "", $$3); exit(0); }' src/build.h
+	@echo "===> Fype binary size			:     `du -hs $(BIN)`"	
+	@#echo "===> `./$(BIN) -v | sed 's/Build .*//'`"
+	@./fype -v > ./docs/version.txt
+	@./fype -h > ./docs/help.txt
+	@./fype -s > ./docs/synopses.txt
+	@echo
+$(OBJS):
+	$(CC) $(LDADD) $(CFLAGS) `echo $@ | sed 's/\.o/\.c/'` -o $@
+clean:
+	find ./ -name 1 -exec rm -f {} \;
+	find ./ -name '*.o' -exec rm -f {} \;
+	find ./ -name '*.bin' -exec rm -f {} \;
+	find . -name '*.core' -exec rm -f {} \;
+	if [ -f $(BIN) ]; then rm -f $(BIN); fi
+build: ctags
+	@awk '{ \
+		if ($$2 == "BUILDNR") print $$1,$$2,$$3+1; \
+		else if ($$2 ~ /OS_/) printf("%s OS_%s\n", $$1, \
+			toupper("$(OSYSTEM)")); \
+		else print }' \
+			src/build.h  >.tmp && mv -f .tmp src/build.h
+printbuild:
+	@awk '$$2 == "BUILDNR" { printf("%d\n", \
+		$$3); exit(0); }' src/build.h
+ctags:
+	@# Generating Source-Tags for Vim 
+	ctags `find . -name '*.c'`
+style: astyle check
+astyle:
+	find ./src -name '*.[ch]' -exec sh -c 'astyle -s3 {}; rm -f {}.orig' \;
+check:
+	for f in `find ./src -name '*.[ch]'`; do awk -v f=$$f \
+		'{ if (length($$0) > 80) { \
+		printf "Max line length reached @ %s:%d => %d\n", \
+		f, NR, length($$0) } }' $$f; done
+touch:
+	find ./src -name '*.c' -exec touch {} \;
+stats:
+	@sh -c 'wc=`find ./src -name "*.[ch]" | xargs wc -l`; \
+		echo "===> Num of C source files		: `echo \"$$wc\" | \
+		grep -E \"\\.(c|h)$$\" | wc -l`"; \
+		echo "===> Num of C source lines		: `echo \"$$wc\" | \
+		tail -n 1 | sed s/total//`"'
+	@sh -c 'wc=`find ./examples -name "*.fy" | xargs wc -l`; \
+		echo "===> Num of Fype source examples	: `echo \"$$wc\" | \
+		grep -E \"\\.fy$$\" | wc -l`"; \
+		echo "===> Num of Fype source lines		: `echo \"$$wc\" | \
+		tail -n 1 | sed s/total//`"'
+stats-tofile:
+	make stats | tee ./docs/stats.txt
+testrun:
+	cat ./test.fy > ./test.out
+	./$(BIN) -V ./test.fy | tee -a ./test.out
+tr: testrun
+test: all testrun
+t: test
+run:
+	./$(BIN) ./test.fy
+core:
+	gdb $(BIN) $(BIN).core
+gdb:
+	gdb --args $(BIN) .//test.fy
+newline:
+	@echo 
+examples: all
+	echo > ./examples/all-examples.txt
+	for i in ./examples/*.fy; do \
+		echo "===> Running $$i"; \
+		./$(BIN) $$i; \
+		cat $$i >> ./examples/all-examples.txt; \
+		echo >> ./examples/all-examples.txt; \
+	done
+replace:
+	find ./src -name '*.[ch]' -exec sh -c 'sed -n "s/$(FROM)/$(INTO)/g; \
+		w .tmp" {} && mv -f .tmp {}' \;
+headers:
+	@find ./src -name '*.[ch]' -exec sh -c 'export FILE={}; \
+		make header' \;
+header:
+	@echo "===> Processing $(FILE)"
+	@sed -n '/*:/d; w .tmp' $(FILE) 
+	@header=`sed 's/\(.*\)/ echo " \*: \1"/' $(HEADER)`; \
+		echo '/*:*' > $(FILE); eval "$$header" >> $(FILE); \
+		echo ' *:*/' >> $(FILE); cat .tmp >> $(FILE); rm -f .tmp
+tar: clean
+	sh -c 'build=`make printbuild`;cd ../;\
+		tar cvjf $(BIN)-$$build.tar.bz2 $(BIN)'
+install: all
+	cp ./$(BIN) $(PREFIX)/bin
+	cp ./docs/pod/fype.1.gz $(PREFIX)/man/man1
+deinstall:
+	rm $(PREFIX)/bin/$(BIN)
+	rm $(PREFIX)/man/man1/fype.1.gz
+uninstall: deinstall
+pod:
+	@cd ./docs/pod; make clean all
diff --git a/NEW b/NEW
new file mode 100644
index 0000000..b0dbb82
--- /dev/null
+++ b/NEW
@@ -0,0 +1,6 @@
+keywords:
+	refs
+
+functions:
+	ind
+	len
diff --git a/README b/README
new file mode 100644
index 0000000..a6be7b8
--- /dev/null
+++ b/README
@@ -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*