ForthMinus - Revision history

Kcozens: Reformatted code examples in Notes section

2018-11-21T23:16:44Z

Reformatted code examples in Notes section

MakoBot: Robot: Replacing 'OpenSim' to 'OpenSimulator', which is the precise name

2012-03-04T06:28:58Z

Robot: Replacing 'OpenSim' to 'OpenSimulator', which is the precise name

MakoBot: Removed 'Template:' prefix from template includings and/or changed external-link into internal-link

2011-06-10T14:25:24Z

Removed 'Template:' prefix from template includings and/or changed external-link into internal-link

Ideia Boa at 14:52, 21 May 2009

2009-05-21T14:52:22Z

Alondria: /* Quotations */

2008-01-23T19:47:46Z

‎Quotations

Alondria: /* Language Syntax */

2008-01-23T19:46:06Z

‎Language Syntax

Alondria: /* Events */

2008-01-23T19:36:27Z

‎Events

Alondria: /* Language Syntax */

2008-01-23T19:33:53Z

‎Language Syntax

Alondria: /* Using ForthMinus */

2008-01-22T21:22:04Z

‎Using ForthMinus

Alondria at 20:56, 22 January 2008

2008-01-22T20:56:08Z

@@ Line 405: / Line 405: @@
 == Notes ==
-- drop ( x -- )
+<pre>
-- 2drop ( x y -- )
+drop ( x -- )
-- 3drop ( x y z -- )
+drop ( x y -- )
-- nip ( x y -- y )
+drop ( x y z -- )
-- 2nip ( x y z -- z )
+nip ( x y -- y )
 Duplicating stack elements:
-- dup ( x -- x x )
+<pre>
-- 2dup ( x y -- x y x y )
+dup ( x -- x x )
-- 3dup ( x y z -- x y z x y z )
+dup ( x y -- x y x y )
-- dupd ( x y -- x x y )
+dup ( x y z -- x y z x y z )
-- over ( x y -- x y x )
+dupd ( x y -- x x y )
-- pick ( x y z -- x y z x )
+over ( x y -- x y x )
-- tuck ( x y -- y x y )
+pick ( x y z -- x y z x )
 Permuting stack elements:
-- swap ( x y -- y x )
+<pre>
-- swapd ( x y z -- y x z )
+swap ( x y -- y x )
-- rot ( x y z -- y z x )
+swapd ( x y z -- y x z )
-- -rot ( x y z -- z x y )
+rot ( x y z -- y z x )
-- roll ( x y z t -- y z t x )
+-rot ( x y z -- z x y )
-- -roll ( x y z t -- t x y z )
+roll ( x y z t -- y z t x )

@@ Line 4: / Line 4: @@
 == Description ==
-ForthMinus is an alternative scripting engine for OpenSim. It's dialect resembles (loosely) the [http://en.wikipedia.org/wiki/Forth_%28programming_language%29 FORTH]programming language and it's code runs within a Virtual Machine (VM). It's primary purpose was to test the feasibility of implementing a VM to handle the micro-threading of scripts as well as speed up the development of llFunctions for the main LSL script engine. It currently has some advantages and disadvantages versus the primary script engine (DotNetEngine):
+ForthMinus is an alternative scripting engine for OpenSimulator. It's dialect resembles (loosely) the [http://en.wikipedia.org/wiki/Forth_%28programming_language%29 FORTH]programming language and it's code runs within a Virtual Machine (VM). It's primary purpose was to test the feasibility of implementing a VM to handle the micro-threading of scripts as well as speed up the development of llFunctions for the main LSL script engine. It currently has some advantages and disadvantages versus the primary script engine (DotNetEngine):
 '''Advantages:'''
 * Micro-threading - User scripts cannot lock up the Engine's threads. Perpetual loops can be created without fear of the engine becoming unresponsive.
 * State Saving - A ForthMinus script can be state saved thus allowing for script persistence through sim resets.
-* Security - All scripts are ran under the VM opposed to being compiled into CIL and ran in parallel to OpenSim (although AppDomain implements some security measures).
+* Security - All scripts are ran under the VM opposed to being compiled into CIL and ran in parallel to OpenSimulator (although AppDomain implements some security measures).
 '''Disadvantages'''

@@ Line 1: / Line 1: @@
 __NOTOC__
-{{Template:Quicklinks}}
+{{Quicklinks}}
 <br />

← Older revision		Revision as of 14:52, 21 May 2009
Line 1:		Line 1:
		+	__NOTOC__
		+	{{Template:Quicklinks}}
		+	<br />
		+
	== Description ==		== Description ==
	ForthMinus is an alternative scripting engine for OpenSim. It's dialect resembles (loosely) the [http://en.wikipedia.org/wiki/Forth_%28programming_language%29 FORTH]programming language and it's code runs within a Virtual Machine (VM). It's primary purpose was to test the feasibility of implementing a VM to handle the micro-threading of scripts as well as speed up the development of llFunctions for the main LSL script engine. It currently has some advantages and disadvantages versus the primary script engine (DotNetEngine):		ForthMinus is an alternative scripting engine for OpenSim. It's dialect resembles (loosely) the [http://en.wikipedia.org/wiki/Forth_%28programming_language%29 FORTH]programming language and it's code runs within a Virtual Machine (VM). It's primary purpose was to test the feasibility of implementing a VM to handle the micro-threading of scripts as well as speed up the development of llFunctions for the main LSL script engine. It currently has some advantages and disadvantages versus the primary script engine (DotNetEngine):

← Older revision		Revision as of 19:47, 23 January 2008
Line 160:		Line 160:

	This will execute the second quotation on each element of the first, pushing the results. In this case, the stack would be "2 3 4 5".		This will execute the second quotation on each element of the first, pushing the results. In this case, the stack would be "2 3 4 5".
		+
		+	Quotations can also be used to create custom user level words. The following two examples have the same end result:
		+
		+	: hello "Hello World!" 0 llsay ;
		+
		+	[ "Hello World!" 0 llsay ] hello qdef

	== Primitive Libraries ==		== Primitive Libraries ==

@@ Line 17: / Line 17: @@
 == Language Syntax ==
-'''Definitions'''
+=== Definitions ===
 * Word - A function or subroutine. These can be user defined, or build in (via libraries).
 * Data Stack - The main repository for data the script will manipulate
@@ Line 23: / Line 23: @@
 * Dictionary - The dictionary holds the user defined words
 * Variables - Variables can store data - however variables are much slower to utilize than the Data Stack.
 ForthMinus is a simple language with no explicit grammar. Everything is executed in a postfix (or RPN) method, where the arguments for an operator come before the operator itself. For example, take this simple LSL script of a math problem:
@@ Line 100: / Line 102: @@
 The word "@touched" is a special event word within ForthMinus. When an avatar touches a prim with a ForthMinus script in it, the engine checks to see if the script has "@touched" defined. If so, it pushes the word "@touched" to the ''bottom'' of the Execution Stack, thus not interrupting the current task of the script (this is similar to LSL - events are non-interrupting).
-'''Quotations'''
+=== Quotations ===
 The engine has a data type called a quotation. A quotation is signified by square brackets ("[","]"). A quotation holds a chunk of data or even code. Quotations can be stored and manipulated as any other data (e.g. stored in the data stack, assigned a variable name, etc.). A quotation can be executed by the the word qcall. For example:

@@ Line 381: / Line 381: @@
 | touch_start(integer num)
 | @touched
-| @touchednum
+| @touchednum @touchedname @touchedkey
 |-
 | ''listen(integer channel, string name, key id, string message)''

← Older revision		Revision as of 19:33, 23 January 2008
Line 99:		Line 99:

	The word "@touched" is a special event word within ForthMinus. When an avatar touches a prim with a ForthMinus script in it, the engine checks to see if the script has "@touched" defined. If so, it pushes the word "@touched" to the ''bottom'' of the Execution Stack, thus not interrupting the current task of the script (this is similar to LSL - events are non-interrupting).		The word "@touched" is a special event word within ForthMinus. When an avatar touches a prim with a ForthMinus script in it, the engine checks to see if the script has "@touched" defined. If so, it pushes the word "@touched" to the ''bottom'' of the Execution Stack, thus not interrupting the current task of the script (this is similar to LSL - events are non-interrupting).
		+
		+	'''Quotations'''
		+	The engine has a data type called a quotation. A quotation is signified by square brackets ("[","]"). A quotation holds a chunk of data or even code. Quotations can be stored and manipulated as any other data (e.g. stored in the data stack, assigned a variable name, etc.). A quotation can be executed by the the word qcall. For example:
		+
		+	[ "Hello World" . ] qcall
		+
		+	In this example, the quotation itself is placed onto the data stack. The word "qcall" pops a quotation from the stack, and executes what is inbetween the brackets.
		+
		+	Besides storing hunks of code, quotations can be utilized to mimic other data structures, such as lists, vectors, and rotations. For example:
		+
		+	[ 45.3 23.5 100.3 ] qcall llsetpos
		+
		+	This would execute the vector stored in the quotation, push'ing it's three values into the data stack. The llsetpos word would set the host's position in the sim.
		+
		+	There are words to construct common SL related quotations from the stack. For example:
		+
		+	llgetpos v>q curpos !
		+
		+	* llgetpos pushes the prims current x, y, and z position onto the data stack
		+	* v>q pops the top three values of the stack and creates a quotation containing the x, y, z values ([ x y z ])
		+	* curpos ! stores the quotation into the variable curpos, hence, curpos = [ x y z ]
		+
		+	Quotations can be used in conditional statements:
		+
		+	0 [ "True" 0 llsay ] [ "False" 0 llsay ] qif
		+
		+	In this example:
		+	* 0 is pushed to the stack
		+	* The quotation [ "True" 0 llsay ] is pushed to the stack
		+	* The quotation [ "False" 0 llsay ] is pushed to the stack
		+	* qif pops three values off the stack. If the third deep is true, it qcall's the first quotation, otherwise, it qcall's the second. In this example, since 0 == false, the program will say "False" in world.
		+
		+	QIf statements can be layered by placing additional qif chunks within the quotation. For example:
		+
		+	3 dup 0 < [ "Negative" drop ] [ 0 > [ "Positive" ] [ "Zero" ] qif ] qif 0 llsay
		+
		+	This:
		+	* Pushes 3 into the data stack, then "dup" duplicates it and then pushes 0 to the stack (thus, or data stack is 3 3 0)
		+	* "<" pops two values (3 and 0 in this case), and if 3 < 0, pushes 1, otherwise pushes 0 (and in this case, of course it pushes 0, since 3 is not < 0)
		+	* The two quotations ([ "Negative" drop ] and [ 0 > [ "Positive" ] [ "Zero" ] qif ]) are pushed to the data stack.
		+	* The qif pops the truth value from the second step and the two quotations. Since the test was false, it qcall's the second hunk of code (0 > [ "Positive" ] [ "Zero" ] qif)
		+	* 0 is pushed, then ">" tests if the number is larger than 0, if so pushes "Positive", if not, pushes "Zero". In our example, it will push "Positive"
		+	* "0 llsay" will push 0, then say "Positive" on channel 0 in world.
		+
		+	There are other conditional and control words that utilize quotations:
		+
		+	1 [ "True!" 0 llsay ] qwhen
		+
		+	This will qcall the quotation when the previous item on the data stack is true.
		+
		+	10 [ "Hello World" 0 llsay ] qdo
		+
		+	This will execute the quotation 10 times.
		+
		+	Another nifty function that effects quotations is qforeach:
		+
		+	[ 1 2 3 4 ] [ 1 + ] qforeach
		+
		+	This will execute the second quotation on each element of the first, pushing the results. In this case, the stack would be "2 3 4 5".

	== Primitive Libraries ==		== Primitive Libraries ==

@@ Line 14: / Line 14: @@
 To enable ForthMinus, you need to change the script_engine line within OpenSim.ini to:
-  script_engine = OpenSim.Region.ScriptEngine.ForthMinus
+  script_engine = OpenSim.Region.ScriptEngine.ForthMinus.dll
 == Language Syntax ==

← Older revision		Revision as of 20:56, 22 January 2008
Line 332:		Line 332:
	\| @changedwhat		\| @changedwhat
	\|}		\|}
		+
		+	== Notes ==
		+	- drop ( x -- )
		+	- 2drop ( x y -- )
		+	- 3drop ( x y z -- )
		+	- nip ( x y -- y )
		+	- 2nip ( x y z -- z )
		+	Duplicating stack elements:
		+	- dup ( x -- x x )
		+	- 2dup ( x y -- x y x y )
		+	- 3dup ( x y z -- x y z x y z )
		+	- dupd ( x y -- x x y )
		+	- over ( x y -- x y x )
		+	- pick ( x y z -- x y z x )
		+	- tuck ( x y -- y x y )
		+	Permuting stack elements:
		+	- swap ( x y -- y x )
		+	- swapd ( x y z -- y x z )
		+	- rot ( x y z -- y z x )
		+	- -rot ( x y z -- z x y )
		+	- roll ( x y z t -- y z t x )
		+	- -roll ( x y z t -- t x y z )