**Forth** er et programmeringsspråk og utviklingsmiljø utviklet av Charles Moore på slutten av 1960-tallet / begynnelsen av 1970-tallet. Språket er sentrert rundt bruken av en stack, og er kanskje mest kjent for sin postfiks-notasjon – også kalt omvendt polsk notasjon. Forth bruker en blanding av kompilering og sanntidstolkning, og er i stand til å kompilere seg selv til en ny kompilator (såkalt metakompilering).

Den grunnleggende enheten som kan utføres eller kjøres i et Forth-system er et **ord**. Ord er organisert i ordlister (dictionaries), og man kan enkelt lage nye ord ved hjelp av eksisterende ord. Ord skilles med mellomrom, noe som gjør tolkning av språket enkelt. 

Programmeringsspråket ble tatt opp som en ANSI standard i 1994, og kalles i den varianten for **ANS Forth**. Det har imidlertid vært tidligere defacto standarder i form av **FORTH-79** og **FORTH-83**, satt ned av Forth Interest Group (FIG) i hhv. 1979 og 1983. Det er også et initiativ på gang for å oppgradere den aldrende ANS Forth standarden, i form av **Forth 200x**.

Hello world eksempel
--------------------

Under er Hello world implementert i Forth:

```
: hello ( -- ) CR ." Hello World!" ;
```

Dette definerer et nytt ord **hello**, som vil skrive ut et linjeskift (CR – carriage return) etterfulgt av teksten «Hello World!» når det kjøres. 

```
hello
Hello World! ok
```

Parentesene regnes som kommentarer og viser en vanlig konvensjon for å angi hvilken innvirkning det definerte ordet vil ha på stacken når det kjøres. I dette tilfelle vil ikke stacken endres, noe vi angir med en parentes hvor kun skillet mellom før og etter kjøring er listet opp. Forth skriver ut « ok» etterfulgt av linjeskift når den er klar til å motta en ny kommando.

Kjøremiljø
----------

Kjøremiljøet til et Forthsystem er svært enkelt. En kommandolinje hvor hvert ord som skrives inn tolkes som et Forth-ord. I *Hello World*-eksemplet ovenfor er **:** (kolon) et ord som i Forth betyr «definér et nytt ord.» Det nye ordet kan kalles som en rutine i andre språk, og navnet er det neste ordet på linjen. 

Det neste ordet som blir tolket er **(** (parentes) som betyr «ignorer alt som kommer etter inntil vi finner en sluttparentes eller input slutter.» Altså en måte å lage kommentarer på. De resterende ordene utgjør selve rutinen, og **;** (semikolon) avslutter definisjonen.

Forth er i utgangspunktet et tolket språk, men har også en *kompileringssemantikk* som brukes i definisjonen av nye ord. Ord som kun har definert en kompileringssemantikk kan kun brukes i definisjonen av nye ord, mens andre ord kan utføres direkte ved å skrive ordet på kommandolinjen.

### Stacken

Forth er sentrert rundt en stack. De fleste ord manipulerer denne på en eller annen måte. Stacken kan litt forenklet visualiseres som en stabel, hvor man til enhver tid kun ser det øverste elementet i stabelen. Som en stabel av tallerkner hvor hver tallerken er påskrevet et tall.

Noen av de mest primitive operatorene definert av Forth er:

dupLag en kopi av det øverste elementet i stacken og legg det øverst.
swapBytt om rekkefølgen på de to øverste elementene i stacken.
rotHent det tredje elementet nede i stacken og legg det øverst.
.(punktum, benevnes **dot**) Henter det øverste elementet fra stacken og skriver det ut til terminalen. Det nest øverste elementet blir liggende øverst.
Tall er i seg selv ord som legger sin egen verdi øverst på stacken. Operatorer som +,-,\*,/ er definert som Forth-ord som henter to verdier fra stacken, og legger resultatet av operasjonen øverst.

Under er noen eksempler på bruk av stacken:

```
4 dup

```

Her legges verdien 4 på stacken, og dupliseres. Stacken vil nå inneholde to elementer, begge med verdien fire.

```
4 5 swap

```

Her legges verdien 4 på stacken etterfulgt av verdien 5. 5 ligger nå øverst på stacken og 4 nederst. **swap** bytter om på de to, så 4 ligger øverst og 5 ligger nederst.

```
4 5 – .

```

Trekker 5 fra 4 og skriver ut resultatet (-1).

```
4 5 swap – .

```

Trekker 4 fra 5 og skriver ut resultatet (1).

### Ord og ordlister

I Forth definerer man nye ord ved ordet **:** (kolon). Nedenfor definerer vi et nytt ord som kvadrerer tallet øverst på stacken:

```
: square dup * ;

```

Det nye ordet «square» vil hver gang det kalles utføre operasjonen «dup \*», som vil si å duplisere det øverste elementet i stacken, multiplisere de to og legge resultatet tilbake øverst på stacken. Resultatet vil bli at det øverste elementet i stacken har blitt kvadrert.

Legg forøvrig merke til mellomrommene mellom «:» og «square» og mellom uttrykket og «;». Både «:» og «;» er egne ord i Forth.

«square» er nå definert som et fullverdig ord på linje med alle andre ord som er definert i Forth. Vi kan bruke dette videre til å lage et ord som opphøyer verdien av det øverste elementet på stacken i tredje potens:

```
: cube dup square * ;

```

En kjøring av disse ordene vil f.eks. kunne se slik ut:

```
4 square. 16 ok
5 cube. 125 ok

```

Forth skriver ut resultatet og «ok» på samme linje idet vi trykker enter-tasten. (Noen versjoner vil skrive svaret på neste linje i stedet.)

Både ord som er ferdigdefinerte fra Forth sin side, og ord du definerer selv lagres i en ordliste. Samme ord kan lagres flere ganger. Den nye definisjonen av ordet vil da gjelde for all bruk etter det er definert, men vil ikke endre definisjonen til andre ord som bruker den gamle definisjonen. Man kan glemme definisjonen av et ord ved å bruke ordet **forget**. Forget vil få Forth til å glemme det ordet du ber den om *i tillegg til alle ord som er definert etter dette*.

Forth kan operere med flere ordlister, og kan veksle mellom dem.

### Interpreter

Forth er et utviklingsmiljø like mye som et programmeringsspråk. Miljøet er ganske enkelt en kommandolinje som tolker det som blir skrevet på den som Forth-ord. Interpreteren er i seg selv et Forth ord, og kan benyttes i interaktive Forth-programmer.

Å utvikle programmer i Forth består tradisjonelt for en stor del av å lage nye ord, og teste dem nesten øyeblikkelig på kommandolinjen. Dette gir en veldig interaktiv utviklingsmodell, og oppfordrer til utvikling i små inkrementelle skritt.

Se også
-------

* Programvareutvikling
* Liste over programmeringsspråk

Referanser
----------

1. ↑  «DPANS'94». Besøkt 22. mai 2008.
2. ↑  «The Forth-79 Standard» (PDF). Arkivert fra originalen (PDF) 24. juli 2008. Besøkt 21. mai 2008.
3. ↑  «The Forth-83 Standard». Besøkt 21. mai 2008.
4. ↑  «Forth 200x». Besøkt 23. mai 2008.

Eksterne lenker
---------------

* (en) Forth (programming language) – kategori av bilder, video eller lyd på Commons Rediger på Wikidata
* FIG (Forth Interest Group)
* The Evolution of Forth
* gforth (GNU Forth interpreter)
* RetroForth
* BigFORTH
* wForth En Forth skrevet i javascript hvor du kan prøve ut enkle Forth operasjoner direkte.

| * v
* d
* r
Programmeringsspråk |
| --- |
| Tidslinje |
| A# **·** ActionScript **·** Ada **·** Alef **·** ALGOL **·** ALGOL 58 **·** ALGOL 60 **·** ALGOL 68 **·** ALTRAN **·** APL **·** AppleScript **·** Argus **·** Assembler **·** Autokode **·** awk **·** B **·** BASIC **·** BCPL **·** BETA **·** BitC **·** BLISS **·** Bourne Shell **·** C **·** C++ **·** C-- **·** CHILL **·** C# **·** C shell **·** Caml **·** Ch **·** Cilk **·** Cilk++ **·** Cilk Plus **·** Clarion **·** Clipper **·** CLISP **·** Clojure **·** CLU **·** COBOL **·** COMAL **·** Common Lisp **·** Concurrent C **·** Concurrent Euclid **·** Concurrent Pascal **·** C shell **·** D **·** Delphi **·** Dylan **·** ECMAScript **·** Eiffel **·** Emacs Lisp **·** Erlang **·** Euclid **·** F\* **·** F# **·** Forth **·** Fortran **·** GNU Common Lisp **·** GNU Pascal **·** Go **·** Haskell **·** HyperTalk **·** Incr Tcl **·** INTERCAL **·** Interlisp **·** Java **·** JavaScript **·** JRuby **·** LaTeX **·** Legoscript **·** LilyPond **·** Limbo **·** Lisp **·** LPC **·** Lua **·** Lynx **·** Mary **·** MATLAB **·** Mesa **·** ML **·** MML **·** Modula **·** Modula-2 **·** MUMPS **·** Objective-C **·** Objective-C++ **·** OCaml **·** OpenVera **·** O'Haskell **·** Pascal **·** Perl **·** PHP **·** Pike **·** PL/I **·** Plankalkül **·** PLEX **·** Prolog **·** Protel **·** Pure Data **·** Python **·** R **·** Ratfor **·** REXX **·** RTL/2 **·** Ruby **·** Rust **·** SAS **·** Scala **·** Scheme **·** Scratch **·** Simula **·** SML **·** Smalltalk **·** SNOBOL **·** Tcsh **·** Tcl **·** TECO **·** TOM **·** Turbo Basic **·** Turbo Pascal **·** Verilog **·** Visual Prolog **·** Turing **·** TypeScript **·** Vala **·** VHDL **·** Visual Basic **·** Flere.. |
| 
* Kategori **Kategori**

 |

|  |  |
| --- | --- |
| Oppslagsverk/autoritetsdata | GND **·** LCCN
 |