Home
Main website
Display Sidebar
Hide Ads
Recent Changes
View Source:
Forth
Edit
PageHistory
Diff
Info
LikePages
You are viewing an old revision of this page.
View the current version
.
!!! <tt>YOU FORTH LOVE IF HONK THEN</tt> [Forth] is a ProgrammingLanguage developed by ChuckMoore in the 1960s (see the [history of Forth | http://www.forth.com/Content/History/History1.htm]). Forth is a [Stack] based language with a ReversePolish syntax. A function call is very fast as the arguments are those on the [Stack] when the program enters and the return value is left on the [Stack] when it exits. A Forth program consists of many small functions, with just the essentials written in AssemblyLanguage. [Forth] is used in embedded systems. It produces very compact code. A whole [Forth] interpreter and development system will fit into 8 kilobytes, easily, and leave plenty of room for code. Back when the computer with 8 kilobytes of [RAM] that you were to write programs for was ''also'' the the computer you had to write programs ''on'' [Forth] was very popular. !!! Implementations [DragonForth | http://dragonforth.sf.net]: [Free] [Forth] compiler for PalmPilot [Quartus | http://www.quartus.net/products/forth/]: A [Forth] compiler for the PalmPilot [GForth | http://www.jwdt.com/~paysan/gforth.html]: [GNU]'s Forth. It's unusual for a [Forth] in that it comes with a manual. [Forth] programmers aren't big on manuals <tt>:-(</tt> [PFE | http://pfe.sourceforge.net]: It has a VirtualMachine and kernel (see below) written in [C]. It might be a good one to study. [RetroForth | http://retro.tunes.org]: Both a ForthOS and a [Forth] for [Linux] systems. [bigFORTH | http://bigforth.sf.net/]: A native code compiler for [x86] which includes a [GUI] library and form editor. [Forth] is also the basis for the [RPL] language used in HewlettPackard calculators and OpenFirmware. !!! [Forth] Machines Sentences long extremely and notation Polish reverse in writing about wrong is what? <br>— Jarkko Hietaniemi ''This is a general description of how [Forth] works. It's __different__. If you like [Brainf*ck] you will like [Forth].'' [Forth] functions are called ''words''. which are organised in the ''user dictionary''. A [Forth] machine has two stacks. When subroutines (called ''words'' in [Forth] lingo) are called they pop arguments off the ''parameter stack'' and push back return values. The ''return stack'' holds the return addresses of word calls. Finally, the input buffer for the [Forth] parser forms an integral part of a [Forth] system. [Forth] programs are written in ReversePolish notation. [Forth] words access the ''parameter stack'' directly to fetch arguments and leave return values. The stack is also used for temporary storage, as traditionally there are no local variables in [Forth]. There are words for flipping around values on the top of the stacks to help you with this. As you program in [Forth] you must keep careful track of what is supposed to be on the stack at every point. This is all part of ChuckMoore's philosophy of brutal simplicity in software engineering, and the most indigestible aspect of [Forth]. The ''user dictionary'' looks a bit like a stack and is organised in sets called ''vocabularies''. The first vocabulary is a tiny kernel of word definitions written in MachineCode, then there is a standard library vocabulary defined in [Forth] (compiled to ByteCode), and then optional vocabularies that define a simple text editor, assembler and disk OperatingSystem. (A modern [Forth] system might have a [TCP/IP] stack on there somewhere too.) There is no syntax in [Forth], just words for manipulating other words, the input buffer and the user dictionary. The word <tt>:</tt> tells [Forth] to begin compiling the subsequent words found on the input buffer. Some words have flags that tell [Forth] to execute them immediately while compiling: these create control structures in the ByteCode of a word. Ordinary words are compiled into <tt>call</tt> statements. Words that look like integers are compiled into <tt>push</tt> statements. The word <tt>;</tt> pushes the new defintion onto the dictionary and ends compilation. (This is the gist.) You use <tt>:</tt> to add new words to the [Forth] system until you've created a high-level [Forth] vocabulary that you can easily express your problem in… then you just keep going until you've defined a single word that, when called, executes your entire program. [Forth] is very much a BottomUp language. :-) MachineCode statements can be used as [Forth] ByteCode~s so the machine can execute them directly. This is called ''subroutine threading''. It is one of a number of approaches to reduce the overhead of interpretation (which spends a lot of time executing call statements). Real [Forth] geeks write their own [Forth] kernels from the metal up. (I wrote my own, on paper, when I was 14. (I don't think I can do that anymore.) I was working from a [Forth] book and a Z80 opcode table; I didn't have a computer. I still have pieces of it. God knows if it would have worked.) ChuckMoore creates his own [Forth] machines from silicon. It's not ''very'' hard once you've absorbed the [Forth] philosophy. There is shockingly little holding [Forth] up. !!! Examples This right here is a lovely example of [Forth]: LifeInForth. This more sober example comes from the IRC bot (in [ISForth | http://isforth.clss.net/]): <verbatim> \ receive up to 512 bytes from bot socket : bot-read off> #inbuff inbuff \ where to receive into begin 1 over bot-fd recv \ read one char from bot socket 1- \ result should be 0 now if \ if its not then we didnt get any input drop exit \ so discard buffer address and exit then incr> #inbuff \ we got a character dup c@ \ get the character we just read $0a <> \ while its not an eol #inbuff 512 <> and while 1+ \ advance buffer address repeat drop \ discard buffer address ; </verbatim> Yet another example, a simple text editor (from [Retro Native Forth | http://retro.tunes.org]): <verbatim> 0 variable lastBlock asmbase $1024 + constant blockBase : block 512 * blockBase + ; : select dup lastBlock ! ; : vl dup 40 type cr 40 + ; : view lastBlock @ block vl vl vl vl vl vl vl vl vl vl vl vl ; : edit select block s drop drop view ; : delete select block 512 0 fill view ; : edit-line 40 * lastBlock @ block + s drop drop view ; : delete-line 40 * lastBlock @ block + 37 0 fill view ; </verbatim> As you can see, [Forth] appeals most to AssemblyLanguage types. [Forth humour at UserFriendly|http://ars.userfriendly.org/cartoons/?id=20070213&mode=classic] ----- CategoryProgrammingLanguages, CategoryMachineOrientedProgrammingLanguages, CategorySystemsProgrammingLanguages
10 pages link to
Forth
:
CastingPointerToFunction
Acorn
Stack
KnowYourSysadmin
ChuckMoore
LifeInForth
ReversePolish
CarlWyles
PostScript
OpenFirmware