../templates/command.lst

COMMAND LIST

+: Add

+|var: Adds the value of first byte in the variable current points to, to the value of the first byte in the named variable and overwrites it with the result. If the result is greater than 126, the operation is interrupted, and the next command is executed. If add succeeds, the next command is skipped.
Example: u<a,+|b (Adds the first byte of |a (=current) to the first byte of |b and overwrites |b)
+|var|var: Adds the value of the first byte in the second variable to the value of the first byte in the first variable and overwrites it with the result. If the result is greater than 126, the operation is interrupted, and the next command is executed. If add succeeds, the next command is skipped.
Example: +|a|b (Adds the value of the first byte in |b to the first byte in |a and overwrites |a)
+|var<text: Adds the value of the first byte in text to the value of the first byte in the named variable and overwrites it with the result. If the result is greater than 126, the operation is interrupted, and the next command is executed. If add succeeds, the next command is skipped.
Example: +|a<\1 (Adds 1 to |a and overwrites |a)

-: Subtract

-|var: Subtracts the value of the first byte in the variable current points to, from the value of the first byte in the named variable and overwrites it with the result. If the result is less than 0, the operation is interrupted, and the next command is executed. If subtract succeeds, the next command is skipped.
Example: u<a,-|b (Subtracts the value of the first byte in |a (=current) from the value of the first byte in |b and overwrites |b)
-|var|var: Subtracts the value of the first byte in the second variable from the value of the first byte in the first variable and overwrites it with the result. If the result is less than 0, the operation is interrupted, and the next command is executed. If subtract succeeds, the next command is skipped.
Example: -|a|b (Subtracts the value of the first byte in |b from the first byte in |a and overwrites |a)
-|var<text: Subtracts the value of the first byte in text from the value of the first byte in the named variable and overwrites it with the result. If the result is less than 0, the operation is interrupted, and the next command is executed. If subtract succeeds, the next command is skipped.
Example: -|a<\1 (Subtracts 1 from |a and overwrites |a)

0-4: Jump point

0-4: Defines a jump point at the current position in the active program file.
Example: 2

5-9: Bookmark

6-9: Defines a bookmark at the current position in the active input file.
Example: 7

a: Attach

a|var: Attaches the contents of the variable current points to, to the named variable and overwrites it with the result. If the new length exceeds 127 bytes, the operation is interrupted, and the next command is executed. On success, it is skipped.
Example: a|a (Attaches current to |a and overwrites |a)
a|var|var: Attaches the contents of the second variable to the first variable and overwrites it with the result. If the new length exceeds 127 bytes, the operation is interrupted, and the next command is executed. On success, it is skipped.
Example: a|a|b (Attaches |b to |a and overwrites |a)
a|var<text: Attaches the contents of text to the named variable and overwrites it with the result. If the new length exceeds 127 bytes, the operation is interrupted, and the next command is executed. On success, it is skipped.
Example: a|a<test (Attaches "test" to |a and overwrites |a)

b: Backwards

b: Goes back one element in the file that occupies a specified slot, at most a single line. The definition of an element depends on the value of the zone separator. The name of the slot is read from the first byte in the variable current points to. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: b
b|var: Goes back one element in the file that occupies a specified slot, at most a single line. The definition of an element depends on the value of the zone separator. The name of the slot is read from the first byte in the named variable. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: b|a
b<text: Goes back one element in the file that occupies a specified slot, at most a single line. The definition of an element depends on the value of the zone separator. The name of the slot is read from the first byte in text. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: b<3 (goes back one element in the file in slot 3)

c: Character

c|var: Chooses a character by its numbered place in a string and stores it in |1. The number is read from the first byte in the named variable, and the string is read from the variable current points to. If the number is larger than the length of the variable current points to, the operation is interrupted and the next command is executed. In the absence of an error, it is skipped. The part before the fetched byte is stored in |0, and the part after the fetched byte is stored in |2.
Example: d|4<\1,c|4 (Fetches the second character from current, the first byte is \0)
c|var|var: Chooses a character by its numbered place in a string and stores it in |1. The number is read from the first byte in the first variable, and the string is read from the second variable. If the number is larger than the length of the second variable, the operation is interrupted and the next command is executed. In the absence of an error, it is skipped. The part before the fetched byte is stored in |0, and the part after the fetched byte is stored in |2.
Example: d|4<\1,c|4|a (Fetches the second character from |a, the first byte is \0)
c|var<text: Chooses a character by its numbered place in a string and stores it in |1. The number is read from the first byte in the named variable, and the string is read from text. If the number is larger than the length of text, the operation is interrupted and the next command is executed. In the absence of an error, it is skipped. The part before the fetched byte is stored in |0, and the part after the fetched byte is stored in |2.
Example: d|4<\1,c|4<test (Fetches the second character from text (e), the first byte is \0)

d: Define

d|var: Defines the variable equal to the variable current points to. If current points to an empty variable, any previous contents of the named variable are deleted.
Example: u<a,d|'<Test,d|b (both |a and |b should now contain "Test")
d|var|var: Defines the first variable equal to the second one. If the second variable is empty, any previous contents of the first variable are deleted.
Example: d|a|b
d|var<expression: Defines the variable equal to expression. If expression is empty, any previous contents of the variable are deleted. If the length of the expression exceeds 127 bytes, you will bail out with an error message.
Example: d|a<Test

e: End

e: Goes to the end of the file that occupies a specified slot. The name of the slot is read from the first byte in the variable current points to. Valid arguments are 3-8 for ordinary files and 9 for the main program file. 9 also exits the program as a whole with exit code 0 (no error).
Example: u<a,d|'<3,e (|' is a marker for current)
e|var: Goes to the end of the file that occupies a specified slot. The name of the slot is read from the first byte in the named variable. Valid arguments are 3-8 for ordinary files and 9 for the main program file. 9 also exits the program as a whole with exit code 0 (no error).
Example: d|a<4,e|a
e<text: Goes to the end of the file that occupies a specified slot. The name of the slot is read from the first byte in text. Valid arguments are 3-8 for ordinary files and 9 for the main program file. 9 also exits the program as a whole with exit code 0 (no error).
Example: e<5

f: File

f|var: Takes the filename from the named variable and opens it in the chosen slot, unless the named variable is empty. If it is empty, the file in the slot is closed. The name of the slot is taken from the first byte in the variable current points to. Valid names are 3-8 for ordinary files and 9 for the main program file. A change of the main program file takes effect immediately. Standard input, output and error are always open and available to the program. An attempt to open files in /dev/std* will generate an error. All files are opened in read-write and append mode. If they do not exist already, they are created.
Example: u<a,d|b<test.txt,d|'<3,f|b (opens "test.txt" in slot 3)
f|var|var: Takes the filename from the first variable and opens it in the chosen slot, unless the the first variable is empty. If it is empty, the file in the slot is closed. The name of the slot is taken from the first byte in the second variable. Valid names are 3-8 for ordinary files and 9 for the main program file. A change of the main program file takes effect immediately. Standard input, output and error are always open and available to the program. An attempt to open files in /dev/std* will generate an error. All files are opened in read-write and append mode. If they do not exist already, they are created.
Example: d|a<test.txt,d|b<3,f|a|b (opens "test.txt" in slot 3)
f|var<text: Takes the filename from the named variable and opens it in the chosen slot, unless the variable is empty. If it is empty, the file in the slot is closed. The name of the slot is taken from the first byte in text. Valid names are 3-8 for ordinary files and 9 for the main program file. A change of the main program file takes effect immediately. Standard input, output and error are always open and available to the program. An attempt to open files in /dev/std* will generate an error. All files are opened in read-write and append mode. If they do not exit already, they are created.
Example: d|a<test.txt,f|a<4 (opens "test.txt" in slot 4)

g: Greater

g|var: Checks if the named variable contains a string that is greater than, but of the same length as the contents of the variable current points to. "bc" is greater than "ab". Greater also splits the named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: d|a<west,u<a,g|b,h<\0
g|var|var: Checks if the first variable contains a string that is greater than, but of the same length as the contents of the second named variable. "bc" is greater than "ab". Greater also splits the first variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: g|a|b,h<\0
g|var<text: Checks if the named variable contains a string that is greater than, but of the same length as text. "bc" is greater than "ab". Greater also splits the named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: g|a<vest,h<\0

h: Hurdle

h: Hurdles the rest of the current line and optionally n additional lines. N is taken from the first byte in the variable current points to. Hurdle can also be used as a comment initiator.
Example: u<a,d|'<\1,h (hurdles the current line and the next line)
h|var: Hurdles the rest of the current line and optionally n additional lines. N is taken from the first byte in the named variable. Hurdle can also be used as a comment initiator.
Example: d|a<\0,h|a (hurdles the rest of the current line)
h<text: Hurdles the rest of the current line and optionally n additional lines. N is taken from the first byte in text. Hurdle can also be used as a comment initiator.
Example: h<\3 (hurdles the rest of the current line and the next three lines)

i: Input

i: Switches input and takes the argument from the first byte in the variable that current points to. Valid arguments are 0 for standard input, 1 for standard output, 2 for standard error, 3-8 for ordinary files and 9 for the main program file.
Example: u<a,d|'<0,i (switches to standard input)
i|var: Switches input and takes the argument from the first byte in the named variable. Valid arguments are 0 for standard input, 1 for standard output, 2 for standard error, 3-8 for ordinary files and 9 for the main program file.
Example: d|a<2,i|a (switches to standard error)
i<text: Switches input and takes the argument from the first byte in text. Valid arguments are 0 for standard input, 1 for standard output, 2 for standard error, 3-8 for ordinary files and 9 for the main program file.
Example: i<3 (switches to an open file in slot 3)

j: Jump

j: Jumps to a previously defined location and takes the name of the location from the first byte in the variable current points to. If the name of the location is between 0 and 4, the location is in the program file. If it is between 5 and 9, it is in the input file. If the location is undefined, the command jumps back to the start of the relevant file.
Example: u<a,d|'<0,j (Jumps to the location that was stored by the 0-command)
j|var: Jumps to a previously defined location and takes the name of the location from the first byte in the named variable. If the name of the location is between 0 and 4, the location is in the program file. If it is between 5 and 9, it is in the input file. If the location is undefined, the command jumps back to the start of the relevant file.
Example: d|a<6,j|a (Jumps to the location that was stored by the 6-command)
Example: j<3 (Jumps to the location that was stored by the 3-command)

k: Keypress

k: Gets a single keypress from current input and stores it in the variable current points to.
Example: k
k|var: Gets a single keypress from current input and stores it in the named variable.
Example: k|a

l: Less

l|var: Checks if the named variable contains a string that is less than, but of the same length as the contents of the variable current points to. "ab" is less than "bc". Less also splits the named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: u<a,l|b,h<\0
l|var|var: Checks if the first variable contains a string that is less than, but of the same length as the contents of the second variable. "ab" is less than "bc". Less also splits the first named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: l|a|b,h<\0
l|var<text: Checks if the named variable contains a string that is less than, but of the same length as the contents of text. "ab" is less than "bc". Less also splits the named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: l|a<vest,h<\0

m: Match

m|var: Looks for a literal match and checks if the variable that current points to, is found as a substring within the named variable. "ab" matches "ab". Match also splits the named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: m|a,h<\0
m|var|var: Looks for a literal match and checks if the the second variable is found as a substring within the first variable. "ab" matches "ab". Match also splits the first variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: m|a|b,h<\0
m|var<text: Looks for a literal match and checks if text is found as a substring within the named variable. "ab" matches "ab". Match also splits the named variable and stores the parts in |0, |1 and |2. The match always ends up in |1. The variables 0-2 are only overwritten when a match is found and the first argument exceeds one byte in length. On success, the next command is skipped. If comparison is impossible (because an argument is empty or the second argument is longer than the first argument), it is treated as a failed comparison, and the next command is executed.
Example: m|a<test,h<\0

n: Num2string

n|var: Stores the first byte in the variable current points to, as a string representation of a number in the named variable. The named variable is overwritten. The operation is interrupted, and the next command is executed if the number is greater than 126. On success, the next command is skipped.
Example: d|a<\9,u<a,n|b,h<\0,w|b (Should print 9)
n|var|var: Stores the first byte of the second variable as a string representation of a number in the first variable. The first variable is overwritten. The operation is interrupted, and the next command is executed if the number is greater than 126. On success, the next command is skipped.
Example: d|a<\9,n|b|a,h<\0,w|b (Should print 9)
n|var<text: Stores the first byte in text as a string representation of a number in the named variable. The named variable is overwritten. The operation is interrupted, and the next command is executed if the number is greater than 126. On success, the next command is skipped.
Example: n|c<\a,h<\0,w|c (Should print 10)

o: Output

o: Switches output and takes the argument from the first byte in the variable that current points to. Valid arguments are 0 for standard input, 1 for standard output, 2 for standard error, 3-8 for ordinary files and 9 for the main program file.
Example: u<a,d|'<1,o (Switches to standard output)
o|var: Switches output and takes the argument from the first byte in the named variable. Valid arguments are 0 for standard input, 1 for standard output, 2 for standard error, 3-8 for ordinary files and 9 for the main program file.
Example: d|a<2,o|a (Switches to standard error)
o<text: Switches output and takes the argument from the first byte in text. Valid arguments are 0 for standard input, 1 for standard output, 2 for standard error, 3-8 for ordinary files and 9 for the main program file.
Example: o<3 (Switches to an open file in slot 3)

p: Program

p: Switches program source and takes the argument from the first byte in the variable that current points to. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: u<a,d|'<4,p (Switches to an open file in slot 4)
p|var: Switches program source and takes the argument from the first byte in the named variable. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: d|a<3,p|a (Switches to an open file in slot 3)
p<text: Switches program source and takes the argument from the first byte in text. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: p<5 (Switches to an open file in slot 5)

q: Quantify

q|var: Quantifies the variable current points to, and stores its length in the named variable. If the length is 0, the next command is executed. If it is longer, the next command is skipped.
Example: u<a,q|b
q|var|var: Quantifies the second variable and stores its length in the first variable. If the length is 0, the next command is executed. If it is longer, the next command is skipped.
Example: q|a|b
q|var<text: Quantifies text and stores its length in the named variable. If the length is 0, the next command is executed. If it is longer, the next command is skipped.
Example: q|a<This (Should store \4 in |a)

r: Read

r: Reads from the current input and stores the result in the variable current points to. Read stops at each newline, when the zone separator is encountered or when the buffer length is reached. If |3 is used as a parameter, an error will occur. Read deletes the contents of |3. Newline is not stored in the variable current points to, but the number of read bytes (including newline) is stored in |3. If that number is 0, the next command is executed. If it is larger, the next command is skipped. Read does not interpret backslash codes, but it is possible to call define afterwards and interpret them that way.
Example: u<a,r,h<\0,w (Reads a line and prints it)
r|var: Reads from the current input and stores the result in the named variable. Read stops at each newline, when the key character is encountered or when the buffer length is reached. If |3 is used as a parameter, an error will occur. Read deletes the contents of |3 . Newline is not stored in the named variable, but the number of read bytes (including newline) is stored in |3. If that number is 0, the next command is executed. If it is larger, the next command is skipped. Read does not interpret backslash codes, but it is possible to call define afterwards and interpret them that way.
Example: r|a,h<\0,w|a (Reads a line and prints it)

s: String2num

s|var: Interprets a string in the variable current points to, and stores it as a number in the named variable. The string may only contain letters in the range 0-9, and it can be no longer than three bytes. The operation is interrupted, and the next command is executed if the resulting number is larger than 126. On success, the next command is skipped.
Example: u<a,s|b
s|var|var: Interprets a string in the second variable and stores it as a number in the first variable. The string may only contain letters in the range 0-9, and it can be no longer than three bytes. The operation is interrupted, and the next command is executed if the resulting number is larger than 126. On success, the next command is skipped.
Example: s|a|b
s|var<text: Interprets a string in text, and stores it as a number in the named variable. The string may only contain letters in the range 0-9, and it can be no longer than three bytes. The operation is interrupted, and the next command is executed if the resulting number is larger than 126. On success, the next command is skipped.
Example: s|a<65 (should store A)

t: Top

t: Goes to the top of the file in the specified slot and takes the argument from the first byte in the variable current points to. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: u<a,d|'<3,t (Goes to the top of the file in slot 3)
t|var: Goes to the top of the file in the specified slot and takes the argument from the first byte in the named variable. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: d|a<4,t|a (Goes to the top of the file in slot 4)
t<text: Goes to the top of the file in the specified slot and takes the argument from the first byte in text. Valid arguments are 3-8 for ordinary files and 9 for the main program file.
Example: t<5 (Goes to the top of the file in slot 5)

u: Use

u: Uses the first byte in the variable current points to, as the name of the variable current points to. It has to be in the range a-z or 0-9. This won't work if the variable is empty!
Example: d|c<f,u<c (Current points to |c), u (Current points to |f)
u|var: Uses the first byte in the named variable as the name of the variable current points to. It has to be in the range a-z or 0-9. This won't work if the variable is empty!
Example: d|c<b,u|c (Current points to |b)
u|<text: Uses the first byte in text as the name of the variable that current points to. It has to be in the range a-z or 0-9.
Example: u<a (Current points to |a)

v: Verity

v: Sets the verity or truth level equal to the first byte in the variable current points to. Valid values are 0-2. When the truth level is 1, greater, less and match behave as expected. When the truth level is 0, all matches are inverted. When the truth level is 2, all comparisons are true.
Example: u|a,v
v|var: Sets the verity or truth level equal to the first byte in the named variable. Valid values are 0-2. When the truth level is 1, greater, less and match behave as expected. When the truth level is 0, all matches are inverted. When the truth level is 2, all comparisons are true.
Example: v|b
v<text: Sets the verity or truth level equal to the first byte in text. Valid values are 0-2. When the truth level is 1, greater, less and match behave as expected. When the truth level is 0, all matches are inverted. When the truth level is 2, all comparisons are true.
Example: v<2

w: Write

w: Writes the contents of the variable current points to, with expansion of one level of embedded variables. Write always prints to current output.
Example: u<a,w
w|var: Writes the contents of the named variable with expansion of one level of embedded variables. Write always prints to current output.
Example: w|a
w<text: Writes text with expansion of the variables in text. If they contain embedded variables, the embedded variables are printed as text, not expanded. Backslash codes in text are interpreted. Write always prints to current output.
Example: w<This\9is a test.

x: Xecute

x: Xecute is the system command. It executes a command with or without parameters through /bin/sh -c. The command is taken from the variable current points to.
Example: d|a<ls -lh ./,u<a,x
x|var: Xecute is the system command. It executes a command with or without parameters through /bin/sh -c. The command is taken from the named variable.
Example: d|a<ls -lh ./,x|a
x<text: Xecute is the system command. It executes a command with or without parameters through /bin/sh -c. The command is taken from text.
Example: x</bin/ls -lh ./

y: Yawn

y: Yawns for n seconds. N is the value of the first byte in the variable current points to.
Example: u|a,y
y|var: Yawns for n seconds. N is the value of the first byte in the named variable.
Example: y|b
y<text: Yawns for n seconds. N is the value of the first byte in text.
Example: y<\1 (Yawns or sleeps for one second)

z: Zone separator

z: Defines the zone separator equal to the first byte in the variable current points to. The zone separator will not change unless you change it explicitly.
Example: u<a,d|a<:,z
z|var: Defines the zone separator equal to the first byte in the named variable. The zone separator will not change unless you change it explicitly.
Example: z|a
Example: z<:

Backslash codes

The following codes are understood by define and the <text option of most commands. The information has been borrowed from "man ascii" under Linux. In many cases, the explaining text has historical significance only. The last number is the ASCII value:

\0 NUL (0)
\1 Start of heading (1)
\2 Start of text (2)
\3 End of text (3)
\4 End of transmission (4)
\5 Enquiry (5)
\6 Acknowledge (6)
\7 Alert (7)
\8 Backspace (8)
\9 Tab (9)
\a Newline (10)
\b Vertical tab (11)
\c Form feed (12)
\d Carriage return (13)
\e Shift out (14)
\f Shift in (15)
\g Data link escape (16)
\h Device control 1 (17)
\i Device control 2 (18)
\j Device control 3 (19)
\k Device control 4 (20)
\l Negative acknowledgement (21)
\m Synchronous idle (22)
\n End of transmission block (23)
\o Cancel (24)
\p End of medium (25)
\q Substitute (26)
\r Escape (27)
\s File separator (28)
\t Group separator (29)
\u Record separator (30)
\v Unit separator (31)
\w Space (32)
\x Comma (44)
\y Semi-colon (59)
\z Left bracket [ (91)