Straight up inport from STOICAL 1.8.0 by Jonathan Moore Liles

Author: mikewarot

COPYING

@@ -0,0 +1,68 @@
+2002-05-06 Jonathan M. Liles <wantingwaiting@users.sf.net>
+
+	* util/genvim: added syntax folding.
+	
+	* Makefile.in, util/genvim: generate vim syntax from documentation.
+	
+2002-05-05 Jonathan M. Liles <wantingwaiting@users.sf.net>
+
+	* kernel.c: fixed call to term_restore
+
+	* doc/stoical.1: added man page
+
+	* hash.c (hash_next): fixed member descent
+
+	* strings.c (interpolate): added mode option
+
+	* words.c (compile): run regex's through interpolate mode 1
+	
+	* util/docex: build one big file instead of many small ones
+
+	* debain/: added debian package support
+	
+	* Makefile.in, src/Makefile.in, config.h.in,
+	configure.in: Use autoconf
+	
+	* all: Built and tested on FreeBSD 4.5
+	
+2002-05-03 Jonathan M. Liles <wantingwaiting@users.sf.net>
+	
+	* NEWS: Version .06 released
+	
+	* words.c: added SEEK
+	
+2002-05-02 Jonathan M. Liles <wantingwaiting@users.sf.net>
+
+	* words.c: New type checking system.
+	
+	* kernel.c: No warnings with -Wall.
+	
+	* kernel.c: Much more informative output on errors.
+
+2002-04-29 Jonathan M. Liles <wantingwaiting@users.sf.net>
+
+	* words.c: All flow control is now based on code blocks (clauses).
+	
+	* debug.c, signal.c: Informative diagnostics displayed on exceptions.
+	
+2002-04-23 Jonathan M. Liles <wantingwaiting@users.sf.net>
+
+	* hash.c, hash.h,
+	words.c: Support for dynamically sized, hash based associative arrays.
+	
+	* doc/words: Documentation now generated from source code.
+	
+	* vim/: Vim syntax highlighting files included.
+	
+	* kernel.c: Intelligently accept command line arguments.
+	
+	* doc/Stoical: Now with -gasp- general documentation!
+
+2002-04-19 Jonathan M. Liles <wantingwaiting@users.sf.net>
+
+	* NEWS: Version .02 released.
+	
+	* dict.c: Better memory management for vocabulary entries.
+	
+	* words.c: Full POSIX compatible regular expression support.
+

ChangeLog

@@ -0,0 +1,123 @@
+
+Above and beyond the grace and efficiency of its syntax, STOICAL
+provides several additional features that make it a truly powerful
+tool in any programmer's arsenal. Among these are:
+
+
+Extensibility.
+	
+	This may be something of a buzz word these days, but
+	Forth like languages have been extensible from their very
+	beginning. To understand what this means you must first
+	consider a language that is not extensible. We shall
+	take C to be an example. Though it is true that you can
+	define additional functions or procedures in C, you cannot
+	extend the language itself. The syntax and operators are fixed
+	and unyielding. In an extensible language, however, all of these
+	things are liquid, and may be altered at any time. In STOICAL,
+	the programmer may define his program as a little language
+	in its own right.	
+
+Interactivity.
+
+	STOICAL, like its predecessor, is completely interactive.
+	It incrementally compiles and executes instructions and
+	definitions as you enter them. This allows for easy testing
+	and development of applications. And because of its speed you
+	don't have to suffer for this convenience.
+
+Cooperation
+	
+	Many people in my circles seem to be of the opinion that all
+	Reverse Polish languages must, by very definition, also be their
+	own operating system*. This is foolish. I like my operating system,
+	and I like other computer languages. Moreover, I like them all to
+	interact in an intelligent and useful way. It is for this reason that
+	STOICAL strives to exploit the operating system and environment
+	in any way that it can.
+
+	* - The most notable exception being Jason Evans and his Onyx
+	extension language.
+
+Networking.
+
+	For the past 10 years a large percentage of computer programs have
+	had to deal with the interconnection of systems in some way.
+	Currently, nearly every application must deal with the extreme
+	interconnection known as the Internet. To facilitate this, STOICAL
+	supports socket based networking in a straight forward, familiar
+	and empowering fashion.
+	
+POSIX Threading.
+
+	Obviously, networking isn't of much use without concurrency of
+	some kind, and threads are the best form of concurrency made 
+	available by the operating system. STOICAL makes handling
+	multiplicity uncommonly simple.
+
+POSIX Regular Expressions.
+
+	STOICAL integrates support for the POSIX Regular Expression
+	(regex) pattern matching facility, a truly striking feature for a
+	stack based language. In fact, regex's are more integrated with
+	STOICAL than they are with languages specially designed for them,
+	such as Perl.
+
+Associative Arrays (Hash Tables).
+
+	This powerful programming tool is overlooked by far too many languages.
+	Associative arrays are one of those features that most languages never
+	provide, even though you really must have them to write anything of
+	consequence. Oddly, almost all modern compilers use associative arrays
+	internally, to store their symbol table data. In any event, STOICAL
+	integrates hash table based associative arrays seamlessly with the
+	language; Another ground breaking feature in the world of RPN.
+
+Passive Garbage Collection.
+
+	Many modern, dynamic languages put a great deal of effort
+	into active, mark and sweep garbage collection algorithms and
+	implementations. The design of some of these languages makes
+	this necessary, because the object name space is an infinite
+	resource. However, in a stack based language the name space
+	is replaced by a finite store, quite obviously referred to
+	as 'the stack'. Because this stack can only hold a specific
+	number of items at any one time, garbage collection becomes
+	a simple matter of trust. The programmer trusts the language
+	not to free his memory until a reasonable amount of activity
+	has taken place on the stack. Garbage collection is implemented
+	internally as a FIFO stack, which is, unlike the parameter stack,
+	infinite. However, only the topmost X elements of this stack ever
+	have actual storage allocated to them. This fits well with
+	normal usage patterns of the language. If the programmer needs
+	a dynamic object to remain permanently, he simply does the
+	obvious thing, and files it into the dictionary.
+	Currently, nameless, non constant strings are the only dynamically
+	allocated objects in the language; The dictionary grows and shrinks
+	dynamically, but it isn't an object, and doesn't require garbage
+	collection.
+	
+Passive Type-checking.
+
+	Passive type-checking means that only words which desire type-checking
+	will incur any performance penalty, and even then the extra computation
+	is miniscule. The type-checking system also allows word (operator)
+	overloading. This is why you can use the word + (plus) to add figures,
+	as well as to concatenate strings.
+	
+Floating Point Arithmetic.
+
+	Anyone who has used a Forth system in the past knows what a headache
+	it can be to do floating point calculations. In STOICAL, this is
+	completely transparent, as floats and integers occupy the same
+	stack and behave identically.
+
+More.
+
+	Of course, it is 4:00 in the morning right now, and I cannot
+	be expected to remember every exciting little detail.
+	Just know that you will come to appreciate many new things about
+	language in time, and likely discover features that even I have
+	overlooked.
+
+

FEATURES

@@ -0,0 +1,52 @@
+
+STOICAL is a modern adaptation of the classic stack language STOIC. STOIC was
+developed circa 1977 by Jonathan M. Sachs while at the Biomedical Engineering
+Center for Clinical Instrumentation under the Massachusetts Institute of
+Technology Program in Health Sciences and Technology. STOIC was itself preceded
+by a language called FORTH, developed circa '68 for the National Radio
+Astronomy Observatory in Charlottesville Virginia by Charles H. Moore. Moore,
+though clinically insane, has continued to extend his language over the years.
+At the time of this writing FORTH is known to him as colorForth; One imagines
+that these colors are much like those present in his twisted visions and terror
+filled dreams. Sachs, however, is now dabbling in software for the Pocket PC
+architecture, and appears to have all but forgotten about STOIC. At one point
+in the early '80s, a fellow named Ernest E. Bergmann attempted to reincarnate
+STOIC in a language dubbed PISTOL (Portably Implemented STack Oriented
+Language). This implementation had its roots in BDS C, and remains something of
+an amusement.
+
+This sordid history is further complicated by the fact that the components
+of my name, Jonathan and Moore, were attributed to me by my father in honor
+of these two men, Sachs and Chuck.
+
+I came to work on STOICAL by way of my quest for the perfect language. You see,
+I recently ran across a language called Onyx, developed by Jason Evans. Onyx
+has its roots in Forth and PostScript. Jason had never even heard about STOIC,
+although his language implements features that are strikingly similar to
+those I remembered reading about in the papers that Sachs gave my father. The
+source code and documentation for Onyx exceed 10 megabytes in size, and
+the runtime is sluggish compared to more simplistic implementations. This
+can be attributed to the extra storage and calculation used to support
+multi-threaded execution, type-checking and exception recovery. I found this
+to be quite divergent from the capabilities, and thereby efficiency of STOIC.
+So, I set out to port STOIC to a modern environment and compare it with the
+alternatives. This effort soon failed as STOIC's assembly language source is
+intrinsically tied to the system for which it was written. So, if Sachs
+doesn't care about abstraction, why should I? At this point I could almost
+feel the beast of free software rising up inside me. "Go forth! Re-implement
+and adapt!", the creature shouted out from within my gut. And hence forth this
+creation shall be known to men of earth as STOICAL; And he shall stop times to
+reflect on its initial five letters. These five commandments, if you will,
+that STOICAL lives up to, and more than that, expands upon. I recite them now:
+
+STack: because of the way she walks.
+Oriented: for that hungry gleam in her eyes.
+Interactive: because she wears not panties!
+Compiler: need I say more!?
+
+Interestingly enough, this brings me back to the point I made previously
+about the mental state of one Chuck H. Moore. For reasons that I've yet to
+fully appreciate, both Hewlett Packard calculators and RPN computer languages
+appear to have an unhealthy effect on the human psyche. Luckily, however,
+they also happen to stimulate the pleasure centers of the brain. Take note;
+You have been warned, and yet you have also been encouraged.

HISTORY

@@ -0,0 +1,57 @@
+ChangeLog
+COPYING
+FEATURES
+HISTORY
+MANIFEST
+Makefile.in
+README
+TODO
+configure
+configure.ac
+config.h.in
+install.sh
+doc/Stoical
+doc/stoical.1.in
+examples/dir
+examples/threads
+lib/cryptic
+lib/def
+lib/hash
+lib/stoic
+src/Makefile.in
+src/builtins.h
+src/config.h
+src/debug.c
+src/debug.h
+src/dict.c
+src/hash.c
+src/hash.h
+src/help.h
+src/kernel.c
+src/kernel.h
+src/mem.c
+src/signal.c
+src/string.c
+src/term.c
+src/words.c
+test/Makefile.in
+test/array
+test/hash
+test/test
+test/thread
+util/docex
+util/genvim
+vim/filetype.vim
+vim/scripts.vim
+debian/changelog
+debian/README.Debian
+debian/control
+debian/dirs
+debian/info
+debian/copyright
+debian/docs
+debian/menu
+debian/postinst
+debian/postrm
+debian/watch
+debian/rules

MANIFEST

@@ -0,0 +1,57 @@
+
+# Makefile for Stoical.	
+#
+# See src/config.h for build options.
+
+VERS= 0.1.8
+META= Makefile
+OBJS= kernel.o term.o mem.o hash.o dict.o debug.o string.o signal.o
+SRCS= kernel.c term.c dict.c string.c hash.c debug.c mem.c signal.c
+PREFIX= /usr/local
+NAME = stoical-$(VERS)
+LIBROOT= $(PREFIX)/lib/stoical
+CFLAGS= -c -DVERSION=\"$(VERS)\" -DLIBROOT=\"$(LIBROOT)\" -Wall -w -O0
+LIBS= -lm 
+
+all: src/.depend 
+	cd src && $(MAKE)
+
+src/.depend:
+	@echo Generating dependencies
+	@cd src && $(CC) -MM $(SRCS) > .depend
+
+doc:
+	@echo Generating documentation
+	@./stoical -l lib util/docex src/words.c lib/def doc/words.d
+	@echo Generating Vim syntax
+	@mkdir -p vim/syntax
+	@./stoical -l lib util/genvim doc/words.d >vim/syntax/stoical.vim
+	@cat doc/words.d/* >doc/words; rm -rf doc/words.d
+
+test:
+	cd $@ && $(MAKE)
+
+install: all doc
+	install -s stoical $(PREFIX)/bin
+	mkdir -p $(LIBROOT); cp -R lib/* $(LIBROOT)
+	mkdir -p $(PREFIX)/share/doc/stoical
+	cp -R COPYING README doc/Stoical doc/words $(PREFIX)/share/doc/stoical
+	cp doc/stoical.1 $(PREFIX)/share/man/man1
+
+clean:
+	rm -f stoical
+	cd src && $(MAKE) $@
+
+distclean: clean
+	rm -f Makefile src/Makefile config.cache config.h config.log
+	echo -e 'all:\n%:\n\t./configure && $(MAKE) $$@' > Makefile
+
+pkg: distclean
+	rm -f $(NAME)
+	ln -sf . $(NAME)
+	cat MANIFEST | sed 's/^/$(NAME)\//' | xargs tar czvf $(NAME).tar.gz
+	rm -f $(NAME)
+
+.PHONY: doc test clean
+.EXPORT_ALL_VARIABLES:
+