List of Instructions of DeathTalk

See DeathTalk on centerclause.com for the big picture.

1. dict://deathtalk/article
2. dict://deathtalk/command
3. dict://deathtalk/contract
4. dict://deathtalk/debug
5. dict://deathtalk/execution
6. dict://deathtalk/jack
7. dict://deathtalk/massive
8. dict://deathtalk/rhythm
9. dict://deathtalk/type
10. dict://deathtalk/value
11. resource://deathtalk/annotation
12. resource://deathtalk/system

An instruction may require static or runtime data which is either Parameter, Perimeter or Diameter. A parameter is required in advanced. A perimeter is static which in XML is either an attribute or a pure TextNode. A diameter is generated by inferiors.

Rhythm introduces continuity of first order by requiring specific hierarchies of instructions. This holds dependent data together and increases readability.

DeathTalk is not a product it is a presentation. Exceptions are not documented.

The DeathTalk source comes with a folder "resource/dtx" that contains a basic example of each instruction apart from exe:extend Applications with rhythm are included.

General perimeters as attributes are read for every node.

Keywords that skip instructions are not supported, which includes goto, continue, break, return. Such operations only control a single execution and thus do not determined a divided execution. Adjust conditions accordingly.

1) Part scheme: dict://deathtalk/article

Instruction attach of dict://deathtalk/article

Takes an article from register and attaches that article to the current stretch as if it is a classical scope before execution of inferior nodes. The article is detached after execution of inferior nodes and put back on register. This allows for more convenient editing. An article may be attached to several stretches in this way. The instruction fails if another article is already attached to the current stretch such that scopes nested in one stretch are not supported.

Write protection is a matter of a higher programming language. A basic write-protection is available with jack:const.

Instruction attachNew of dict://deathtalk/article

Creates a new article and attaches that article to the current stretch as if it is a classical scope before execution of inferior nodes. The article is detached after execution of inferior nodes and placed on register. This allows for more convenient editing. The instruction fails if another article is already attached to the current stretch such that scopes nested in one stretch are not supported.

Instruction bind of dict://deathtalk/article

Reads a name and a value. Binds the value by this name to the attached article. The Value remains in register for further operations which is a mere design decision. Remove a remaining Value with expression. This is a convenient operation that implies a given Article. See articleBindAs for an explicit operation.

Instruction join of dict://deathtalk/article

Takes an article and a type from register. Joins the article with the type. Similar to a classical instance, though, all members are dynamic. A previous type is overwritten.

Instruction new of dict://deathtalk/article

Puts a new empty Article in register.

Instruction referArray of dict://deathtalk/article

Reads a string from Register. Takes a reference by that string as name from the attached Article. Puts the type-safed reference in Register. This is a convenient operation that implies an Article attached to the current Outsource as parameter.

Instruction referInt of dict://deathtalk/article

Reads a string from Register. Takes a reference by that string as name from the attached Article. Puts the type-safed reference in Register. This is a convenient operation that implies an Article attached to the current Outsource as parameter.

Instruction referOutsource of dict://deathtalk/article

Reads a string from Register. Takes a reference by that string as name from the attached Article. Puts the type-safed reference in Register. This is a convenient operation that implies an Article attached to the current Outsource as parameter.

Instruction referReal of dict://deathtalk/article

Reads a string from Register. Takes a reference by that string as name from the attached Article. Puts the type-safed reference in Register. This is a convenient operation that implies an Article attached to the current Outsource as parameter.

Instruction referString of dict://deathtalk/article

Reads a string from Register. Takes a reference by that string as name from the attached Article. Puts the type-safed reference in Register. This is a convenient operation that implies an Article attached to the current Outsource as parameter.

Instruction this of dict://deathtalk/article

Places a reference to the article that is attached to the current stretch on register. Fails in case that no article is attached.

Instruction unbind of dict://deathtalk/article

Read a name from register. Unbind a value by that name from the Article that is supposed to be attached to the current Outsource. Put the unbound value in register. Remove a remaining Value with expression. This is a convenient implicit operation. See articleUnbind for an explicit operation.

2) Part scheme: dict://deathtalk/command

Instruction expression of dict://deathtalk/command

An expression as logic is a not self-ending hierarchy of operations and operands. Therefore this word expression is a command that takes the remaining value from register.

Instruction println of dict://deathtalk/command

Prints a single line to Console. There is no support to print a non-breaking string since that is useless in massive multitasking. Build line with concat.

Instruction sleepCycle100ms of dict://deathtalk/command

Takes an int from register that tells the number of 100ms to sleep for and puts currentThread to sleep accordingly.

A sleeping Thread states a problem in a race of Instructions and in exception handling. Therefore a Thread may only sleep for 100ms at a time. An according loop is implemented in Work.

3) Part scheme: dict://deathtalk/contract

Instruction bind of dict://deathtalk/contract

Takes a reference to a value after execution of all inferiors and binds it to the Contract of current Work. The Value remains in register for further operations which is a mere design decision. Remove a remaining Value with cmd:expression.

Instruction bindTop of dict://deathtalk/contract

Takes a reference to a Value before execution of all inferiors and binds it to the Contract of current Work. This is a common case with values spilled by routines. This is a rare case of instruction where evaluation takes place in reverse order. The Value remains in register for further operations which is a mere design decision. Remove a remaining Value with expression.

Instruction further of dict://deathtalk/contract

Begin a nested contract before execution of inferiors. Proceed execution within this new contract. End that contract after execution of inferiors.

Access to the new contract is public by default. An access of private allows references only from within the same contract. An access of protected also allows references from nearest descended contracts. An access of a N allows references from descended contracts of up to and including that depth. Thus protected equals a depth of 1.

Instruction referArticle of dict://deathtalk/contract

Take a name from register. Read the height from attribute super. The default height is zero which is the same Contract. The parental height is one. Put a reference to a value of given name from Contract of given height in register. The type of article is tested as safety.

Instruction referInt of dict://deathtalk/contract

Take a name from register. Read the height from attribute super. The default height is zero which is the same Contract. The parental height is one. Put a reference to a value of given name from Contract of given height in register. The type of int is tested as safety.

Instruction referOutsource of dict://deathtalk/contract

Take a name from register. Read the height from attribute super. The default height is zero which is the same Contract. The parental height is one. Put a reference to a value of given name from Contract of given height in register. The type of outsource is tested as safety.

Instruction referReal of dict://deathtalk/contract

Take a name from register. Read the height from attribute super. The default height is zero which is the same Contract. The parental height is one. Put a reference to a value of given name from Contract of given height in register. The type of real is tested as safety.

Instruction referString of dict://deathtalk/contract

Take a name from register. Read the height from attribute super. The default height is zero which is the same Contract. The parental height is one. Put a reference to a value of given name from Contract of given height in register. The type of string is tested as safety.

Instruction unbind of dict://deathtalk/contract

Read a name from register. Unbind a value by that name from current Contract and put the unbound value in register.

4) Part scheme: dict://deathtalk/debug

Instruction stretchSelfId of dict://deathtalk/debug

Pushes the id of self of Stretch of current Work as int onto register for debugging purposes.

Instruction stretchSelfIdString of dict://deathtalk/debug

Pushes the id of self of Stretch of current Work as string onto register for debugging purposes.

Instruction tellGoods of dict://deathtalk/debug

Tells Goods of current Work on console for debugging purpose. A label may be provided to find output in stream.

Instruction typePath of dict://deathtalk/debug

Pushes the absolute path of type of current Work onto register for debugging purposes.

Instruction workName of dict://deathtalk/debug

Pushes a name or short description of current Work in register for debugging purposes.

Instruction workNumber of dict://deathtalk/debug

Pushes the running number of current Work onto register for debugging purposes.

5) Part scheme: dict://deathtalk/execution

Instruction and of dict://deathtalk/execution

Takes two infinite values from hold. Applies the AND operation. Puts the result on hold.

massive:and is an alternative implementation with concurrent execution.

Instruction deathTalk of dict://deathtalk/execution

Root element of an DeathTalk XML.

Instruction divide of dict://deathtalk/execution

Divides execution. Each direct inferior node runs in its own work.

An optional label allows for referring to this node.

Instruction exitOne of dict://deathtalk/execution

Executes System.exit(1).

Instruction extend of dict://deathtalk/execution

Reads a string vom register as filename, reads file and extends the leaf node with according instructions. Returns the first inferior if any such that the extension is executed immediately. See extension on rhythm.

Instruction externIndex of dict://deathtalk/execution

Takes an int as parameter. Determines the insource by that index of the calling routine. Executes that insource. Values spill over works.

Requires according routine as environment. Fails if insource does not exist.

Instruction externName of dict://deathtalk/execution

Takes a string as parameter. Determines the insource by that name of the calling routine. Executes that insource. Values spill over works.

Requires according routine as environment. Fails if insource does not exist.

Instruction externSize of dict://deathtalk/execution

Determines the number of insources of the calling routine. Puts an int as that number on register. Requires according routine as environment.

Instruction ifThen of dict://deathtalk/execution

Executes first direct inferior node. Reads an infinity value from hold. If that value is infinite then executes second direct inferior node.

Nests allow for more decisions.

The number of direct inferior nodes has to be two. exe:superior allows for grouping nodes.

Instruction ifThenElse of dict://deathtalk/execution

Executes first direct inferior node. Reads an infinity value from hold. If that value is infinite then executes second direct inferior node else executes third direct inferior node.

Nests allow for more decisions.

The number of direct inferior nodes has to be three. exe:superior allows for grouping nodes.

Instruction infinity of dict://deathtalk/execution

Reads a perimeter from XML attribute. Builds infinity with Boolean.parseBoolean. Puts infinity value on hold. Java notation and exceptions apply.

Instruction not of dict://deathtalk/execution

Takes an infinite value from hold. Applies the NOT operation. Puts the result on hold. This produces a new value.

Instruction number of dict://deathtalk/execution

Takes a perimeter as name of a superior divisible node. Determines the unique number of the according work that leads to the current node. Puts that number as int on register.

Instruction or of dict://deathtalk/execution

Takes two infinite values from hold. Applies the OR operation. Puts the result on hold.

massive:or is an alternative implementation with concurrent execution.

Instruction otherwise of dict://deathtalk/execution

Is a direct inferior of switch. Requires one direct inferior. The direct inferior is executed if all other direct inferiors of superior switch are no valid cases.

Instruction println of dict://deathtalk/execution

Takes an infinity value from hold. Prints a description of that value.

Instruction serial of dict://deathtalk/execution

Sets the behaviour of execution from default concurrent to serial if not already set so.

Instruction superior of dict://deathtalk/execution

Contains inferiors. Either for a control that requires precisely one inferior or for improvent of readability.

Instruction switch of dict://deathtalk/execution

Takes a parameter to test against. Tests every direct inferior against that parameter. Executes the first valid direct inferior and returns.

Instruction times of dict://deathtalk/execution

Takes int as parameter. Multiplies execution by that parameter with separate works. Executes direct inferiors that many times.

Instruction utter of dict://deathtalk/execution

Takes an infinity value from hold. Generates a string that describes the value. Puts that string on register.

Instruction whenThen of dict://deathtalk/execution

Is a direct inferior of switch. Requires two direct inferiors. The first direct inferior is tested against. The second direct inferior is executed upon success.

Instruction whileDo of dict://deathtalk/execution

Executes first direct inferior node. Reads an infinity value from hold. If that value is infinite then executes second direct inferior node and then repeats execution.

The number of direct inferior nodes has to be two. exe:superior allows for grouping nodes.

6) Part scheme: dict://deathtalk/jack

Instruction const of dict://deathtalk/jack

Takes a finite value from register. Creates a const Jack for that value which prevents modifications. Puts Jack on register that behaves as a viewer.

Jacks are a matter of a higher programming language. A machine does not depend on Jacks. Therefore Jacks may not be fully implemented.

7) Part scheme: dict://deathtalk/massive

Instruction add of dict://deathtalk/massive

Determines operands concurrently. Takes two finite values from register. Executes appropriate addition. Puts the result on register.

Only very few operators are implemented. value:add is an alternative serial operation.

Instruction and of dict://deathtalk/massive

Executes inferiors concurrently. Applies the AND operation. Takes infinite value from hold on return of an inferior. Returns if the result is determined and lets remaining run away. Puts the result on hold.

exe:and is an alternative implementation with serial execution.

Instruction concat of dict://deathtalk/massive

Executes inferiors concurrently. Takes two finite values from register. Executes appropriate concatenation. Puts the result on register.

Only very few operators are implemented. value:concat is an alternative serial operation.

Instruction or of dict://deathtalk/massive

Executes inferiors concurrently. Applies the OR operation. Takes infinite value from hold on return of an inferior. Returns if the result is determined and lets remaining run away. Puts the result on hold.

exe:and is an alternative implementation with serial execution.

8) Part scheme: dict://deathtalk/rhythm

Instruction articleAccess of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog.

Instruction callName of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. The first inferior is supposed to be a name to a bound outsource.

Instruction callValue of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog.

Instruction extension of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. The string is supposedly a path to a file.

Instruction externIndex of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. The first inferior is supposedly an index to an insource.

Instruction externName of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. The first inferior is supposedly a name to an insource.

Instruction for of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. This only capsules exe:times. Only very few loops are supported anyway for simplicity of this presentation of normal computational logic.

Instruction gettingArticle of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts void to article.

Instruction gettingInt of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts void to int.

Instruction gettingReal of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts void to real.

Instruction gettingString of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts void to string.

Instruction havingArticle of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Type saves an article.

Instruction havingInt of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Type saves an int.

Instruction havingString of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Type saves a string.

Instruction insource of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts void to Rhythm.SECTION. Behaves like a value in Epilog.

Instruction let of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts a value to a Rhythm.VOID.

Instruction rereferArray of dict://deathtalk/rhythm

Improves readability of indirect access and allows for generation of Epilog.

Instruction rereferInt of dict://deathtalk/rhythm

Improves readability of indirect access and allows for generation of Epilog.

Instruction rereferOutsource of dict://deathtalk/rhythm

Improves readability of indirect access and allows for generation of Epilog.

Instruction rereferReal of dict://deathtalk/rhythm

Improves readability of indirect access and allows for generation of Epilog.

Instruction rereferString of dict://deathtalk/rhythm

Improves readability of indirect access and allows for generation of Epilog.

Instruction top of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. States that a value is already available on top of register. Which turns a parameter into a diameter.

Instruction type of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog.

Instruction typeScroll of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog.

Instruction unvoid of dict://deathtalk/rhythm

Improves readability and allows for generation of Epilog. Casts void to Rhythm.SECTION. But behaves like void in Epilog.

9) Part scheme: dict://deathtalk/type

Instruction bindOutsource of dict://deathtalk/type

Takes a string as key from register. Takes an outsource as value from register. Binds outsource by that name to current type.

Instruction change of dict://deathtalk/type

Takes type from register. Changes current type of work to that type.

Instruction close of dict://deathtalk/type

Takes the current type of work. Dereferences its superior type. Makes that superior type the current type of work. Fails on root type.

Instruction current of dict://deathtalk/type

Takes a reference of the current type in current work. Puts that reference on register.

A type does not store its name.

Instruction joinAddArticleArticle of dict://deathtalk/type

Acts on current type of work. Takes another type from register. Takes an outsource from register. Binds outsource as add-operator with current type as left and other type as right operand. Operator is executed implicitly with value:add or massive:add.

Instruction joinMultiplyArticleReal of dict://deathtalk/type

Acts on current type of work. Takes outsource from register. Binds outsource as multiply-operator to current type. Operator is invoked implicitly with value:multiply.

Instruction joinMultiplyRealArticle of dict://deathtalk/type

Acts on current type of work. Takes outsource from register. Binds outsource as multiply-operator to current type. Operator is invoked implicitly with value:multiply.

Instruction joinUtter of dict://deathtalk/type

Acts on current type of work. Takes outsource from register. Binds outsource as utter-operator to current type.

Instruction new of dict://deathtalk/type

Takes a string as name from register. Creates type by that name as direct inferior of current type. Puts new type on register.

Instruction open of dict://deathtalk/type

Takes a string as name from register. Selects direct inferior type from current type by that name. Sets current type to that type.

Instruction refer of dict://deathtalk/type

Takes string as name from register. Takes a reference to the nested type of that name from the current type. Puts that reference on register.

Instruction referOutsource of dict://deathtalk/type

Takes string as name from register. Selects outsource by that name from current type. Puts reference to outsource on register.

Instruction root of dict://deathtalk/type

Puts reference to root type on register.

Instruction routine of dict://deathtalk/type

Takes a string as name from register. Selects outsource from current type by that name. Executes that outsource. All direct inferior nodes are insources.

Instruction select of dict://deathtalk/type

Takes type from register. Takes name as string from register. Selects nested type by that name from type. Puts selected type on register.

Instruction selectSuper of dict://deathtalk/type

Selects direct superior type of current type as current type of work. Fails on root type.

Instruction there of dict://deathtalk/type

Takes type from register as parameter. Sets current type.

10) Part scheme: dict://deathtalk/value

Instruction add of dict://deathtalk/value

Takes two finite values from register. Executes appropriate addition. Puts the result on register.

Only very few operators are implemented. massive:add is an alternative concurrent operation.

Instruction addAssign of dict://deathtalk/value

Takes two finite values from register. Executes appropriate addition. Assigns result to first operand. Puts first operand back on register.

Only very few operators are implemented.

Instruction arrayAt of dict://deathtalk/value

Takes a parameter as impression. Takes a diameter as index. Expects an array contained in impression. Dereferences array at index. Impression is mutated accordingly. Puts impression back on register.

Instruction arrayBindAt of dict://deathtalk/value

Takes an array from register. Takes an int as index from register. Takes a finite value from register. Binds value at index in array. Puts value back on register.

Instruction arrayDeclaration of dict://deathtalk/value

Creates a stack-value that contains a new array on register before execution of inferiors. Inferiors add dimensions to contained array. Puts fully declared array on register after execution of inferiors.

Instruction arrayDefinition of dict://deathtalk/value

Puts a special value on register that contains a new array before execution of inferiors. Inferiors add elements to array. Puts newly defined array on register after execution of inferiors.

Instruction arrayDesign of dict://deathtalk/value

Takes an array of any dimensions from register. Takes a finite value from register. Assigns a copy of that value to each leaf of the array. This supposes a copy constructor outsource for articles and a copy operator for arrays which are not implemented for simplicity of the presentation.

Instruction arrayElement of dict://deathtalk/value

Takes a special array definition value value:arrayDefinition from register. Takes a finite value from register. Appends value to array contained in special value. Puts special array definition value back on register.

Instruction articleAt of dict://deathtalk/value

Takes a parameter as impression from register. Takes a string as key from register. Expects an article contained in impression. Dereferences article with key. Mutates impression accordingly. Puts impression back on register.

Instruction articleBindAs of dict://deathtalk/value

Binds value by key in article directly. Leaves value on register.

Instruction articleUnbind of dict://deathtalk/value

Takes article from register. Takes string as key from register. Unbinds value by that key from article. Puts unbound value on register.

Instruction assign of dict://deathtalk/value

Takes two finite values from register. Executes appropriate assignment from second to first operand. Puts the first operand back on register.

Only very few operators are implemented.

Instruction concat of dict://deathtalk/value

Takes two finite values from register. Executes appropriate concatenation. Puts the result on register.

Only very few operators are implemented. massive:concat is an alternative concurrent operation.

Instruction dimension of dict://deathtalk/value

Takes an ArrayDeclarationFiniteValue from register. Takes an int from register. Increases the dimension of the array inside ArrayDeclarationFiniteValue. Puts back the ArrayDeclarationFiniteValue. All arrays are nested arrays in DeathTalk and as such graphs.

Instruction divide of dict://deathtalk/value

Takes two finite values from register. Executes appropriate division. Puts the result on register.

Only very few operators are implemented.

Instruction divideAssign of dict://deathtalk/value

Takes two finite values from register. Executes appropriate division. Assigns result to first operand. Puts first operand back on register.

Only very few operators are implemented.

Instruction duplicate of dict://deathtalk/value

Takes and leaves a reference to a finite value on register. Duplicates value. Puts copy on register. Meant only as work-around. Deep cloning is a matter of a higher programming language.

Instruction equal of dict://deathtalk/value

Takes two finite values from register. Executes appropriate equal. Puts the result on hold.

Only very few operators are implemented.

Instruction exchange of dict://deathtalk/value

Takes to finite values from register. Sets and gets value thread-safe which is only meaningful on a reference to a binding.

Instruction greaterEqual of dict://deathtalk/value

Takes two finite values from register. Executes appropriate greaterEqual. Puts the result on hold.

Only very few operators are implemented.

Instruction greaterThan of dict://deathtalk/value

Takes two finite values from register. Executes appropriate greaterThan. Puts the result on hold.

Only very few operators are implemented.

Instruction impression of dict://deathtalk/value

Takes a finite value from register before execution of inferiors. Puts that value into a special impression value. Puts that special impression value on register. Inferiors dereference value contained in impression like value:arrayAt and value:articleAt. Takes impression after execution of all inferiors from register. Puts a reference that is now contained in impression on register.

Instruction increment of dict://deathtalk/value

Increments finite value on top of register.

Instruction int of dict://deathtalk/value

Takes an XML textnode. Parses that text with Javas Integer.parseInt. Puts the int value on register. Java notation and exceptions apply.

Instruction multiply of dict://deathtalk/value

Takes two finite values from register. Executes appropriate multiplication. Puts result on register.

Only very few operators are implemented.

Instruction multiplyAssign of dict://deathtalk/value

Takes two finite values from register. Executes appropriate multiplication. Assigns result to first operand. Puts first operand back on register.

Only very few operators are implemented.

Instruction null of dict://deathtalk/value

Puts a universal null on register.

Instruction outsource of dict://deathtalk/value

Creates value that contains this node cycle. Puts value on register.

Instruction real of dict://deathtalk/value

Takes an XML textnode. Parses that text with Javas Float.parseFloat. Puts the float value as real on register. Java notation and exceptions apply.

Instruction repeat of dict://deathtalk/value

Repeats the reference that is on top of register.

Instruction routine of dict://deathtalk/value

Takes a reference to an outsource from register. Executes that outsource bidirectionally.

This is a leaf node at execution. Every direct inferior node in source code is an insource that may be called back by index or by a given name.

Instruction smallerEqual of dict://deathtalk/value

Takes two finite values from register. Executes appropriate smallerEqual aka lessEqual. Puts the result on hold.

Only very few operators are implemented.

Instruction smallerThan of dict://deathtalk/value

Takes two finite values from register. Executes appropriate smallerThan aka lessThan. Puts the result on hold.

Only very few operators are implemented.

Instruction string of dict://deathtalk/value

Takes an XML textnode. Puts the string value on register. Java notation and exceptions apply.

Instruction subtract of dict://deathtalk/value

Takes two finite values from register. Executes appropriate subtraction. Puts the result on register.

Only very few operators are implemented.

Instruction toInt of dict://deathtalk/value

Takes a diameter from register. Calls toInt of that diameter. Puts the result on register.

Fails if an int can neither be cast nor parsed.

Instruction typeReferOutsource of dict://deathtalk/value

Takes type from register. Takes string as key from register. Selects outsource by that key from type. Puts reference to outsource on register.

Instruction utter of dict://deathtalk/value

Gives a literal representation of a value. Which usually is only descriptive and not definitive and thus the command is called utter.

11) Part scheme: resource://deathtalk/annotation

Instruction breakpoint of resource://deathtalk/annotation

A primitive breakpoint at which a thread waits if run in debug mode. Execution stops. The focus is not set to the according position. The thread continues if interrupted with for example the debugger.

breakpoint stops only if at least one valid direction (down|right|up) is stated with attribute on. Separate directions with |.

Instruction comment of resource://deathtalk/annotation

DTX comments are collected by DtxReader, added to the NodeStuff of the next instruction and put out to the generated source. Comments cannot contain further XML elements.XML comments are not stored.

Instruction location of resource://deathtalk/annotation

Used for documentation.

Instruction xignore of resource://deathtalk/annotation

Used for documentation.

Instruction xsection of resource://deathtalk/annotation

Used for documentation.

12) Part scheme: resource://deathtalk/system

Instruction random of resource://deathtalk/system

Pushes a random real number between 0 and, not including, 1 on the stack.

############