This page contains the official definitions of RCS-defined fingerprints. Where there are discrepencies between this page and the Rc/Funge-98 manual then this page is to be considered the authority.

Notes:

• Vectors used in any fingerprint are stored on the stack as (x y z) with x being farthest from the top of stack. Z only exists in Trefunge and y only exists in Befunge or Trefunge
• All vector operations in funge-space will use the IP's storage offset unless noted in the specific fingerprint
• Unless otherwise specified fingerprint data is local to the IP that loaded the fingerprint and unless noted should be copied if the IP executes a t command
• Rc/Funge-98 is the official implementation of these fingerprints. When a behavior is not specified in these specs, the way that Rc/Funge-98 operates is the correct behavior
• For any fingerprint, anything following the heading of Clarification is where other interpreters have implemented the fingerprint in a way other than how Rc/Funge-98 does. The Clarification section specifies how Rc/Funge-98 handles these cases. For portable programs be aware that behavior listed under this section is undefined across interpreters and therefore should not be relied upon.

"3DSP" 0x33445350

A	(V3a V3b -- V3)	Add two 3d vectors
B	(V3a V3b -- V3)	Subtract two 3d vectors
C	(V3a V3b -- V3)	Cross porduct of two vectors
D	(V3a V3b -- n)	Dot product of two vector
L	(V3 -- n)	Length of vector
M	(V3a V3b -- V3)	Multiply two 3d vectors
N	(V3 -- V3)	Normalize vector (sets length to 1)
P	(Vdm Vsm -- )	Copy a matrix
R	(Va axis ang -- )	Generate a rotation matrix
S	(Va V3 -- )	Generate a scale matrix
T	(Va V3 -- )	Generate a translation matrix
U	(V3 -- V3 V3)	Duplicate vector on top of stack
V	(V3 -- x y)	Map 3d point to 2d view
X	(V3 Vam -- V3)	Transform a vector using transformation matrix
Y	(Vdm Vam Vam -- )	Multiply two matrices
Z	(n V3 -- V3)	Scale a vector

• All numbers used by these functions are single precision floating point like in extension "FPSP"
  
• In R, ang is in degrees, axis is an integer (1=x,2=y,3=z)
• Matrices are stored in funge-space as 2-dimenstion 4x4 arrays. the address vector will point to the x1y1 cell.

"ARRY" 0x41525259

A	(Va n x -- Va)	Store to single dimension array
B	(Va x -- Va n)	Retrieve from single dimension array
C	(Va n x y -- Va)	Store to two dimension array
D	(Va x y -- Va n)	Retrieve from two dimension array
E	(Va n x y z -- Va)	Store to three dimension array
F	(Va x y z -- Va n)	Retrieve from three dimension array
G	( -- n)	Get maximum dimensions allowed

• Array data is stored in funge-space
• Negative array indexes are allowed
• Dimensionality of arrays is NOT tied to the dimensionality of the funge-space, however it is NOT required for an interpreter to support arrays greater than funge-space dimensions. G can be used to determine what array dimensionality can be used. Rc/Funge-98 supports three- dimensional arrays in all funge-spaces.
• Va is a vector in the form of the current funge-space, regardless of the array dimensionality
• Addresses used by this extension are absolute, the storage offset does NOT apply to these functions.

"BASE" 0x42415345

B	(n -- )	Ouptut top of stack in binary
H	(n -- )	Ouptut top of stack in hex
I	(b -- n)	Read input in specified base
N	(n b -- )	Output n in base b
O	(n -- )	Ouptut top of stack in octal

"BOOL" 0x424F4F4C

A	(a b -- r)	And
N	(a -- r)	Not
O	(a b -- r)	Or
X	(a b -- r)	Xor

"COPT" 0x434f5054

A	( -- 0gnirts ... )	Push all command line arguments on stack
C	( -- n)	Get count of command line arguments
G	(n -- 0gnirts)	Get specified command line argument on stack
S	(0gnirts -- 0gnirts)	Get argument with specified switch

• A First string on stack will be source file, second will be first argument.
• C returns the number of arguments, including the source file, so if no arguments were given besides the source file then C will return 1, 2 if one argument was given after source file, and so on.
• G Will reflect on negative or if argument n does not exist.
• Argument 0 is the name of the funge file loaded by the interpreter.
• S gets second argument from things like: switch arg, switcharg, switch=arg.
• S will reflect if a matching argument is not found.

"CPLI" 0x43504C49

A	(ar ai br bi -- r i)	Add two complex integers
D	(ar ai br bi -- r i)	Divide two complex integers
M	(ar ai br bi -- r i)	Multiply two complex integers
O	(r i -- )	Output a complex number
S	(ar ai br bi -- r i)	Subtract two complex integers
V	(r i -- n)	Absolute value of a complex integer

"DATE" 0x44415445

A	(y m d days -- y m d)	Add days to date
C	(jd -- y m d)	Convert julian day to calendar date
D	(y1 m1 d1 y2 m2 d2 -- days)	Days between dates
J	(y m d -- jd)	Calendar date to julian day
T	(y d -- y m d)	Year/day-of-year to full date
W	(y m d -- d)	Day of week (0=monday)
Y	(y m d -- d)	Day of year (0=Jan 1)

• A may be negative
• Since all these functions work with integer values, julian day calculations assume 12:00 noon as the time.
• Gregorian calendar is assumed for calendar dates

"DIRF" 0x44495246

C	(0gnirts -- )	Change directory
M	(0gnirts -- )	Make a directory
R	(0gnirts -- )	Remove a directory

• All functions act as r on failure

"EMEM" 0x454d454d

A	(size -- hnd)	Allocate memory
F	(hnd -- )	Free memory
G	(hnd n addr --)	Get bytes from memory
P	(.. hnd n addr --)	Put bytes into memory
R	(hnd size -- )	Reallocate memory

• Errors on any instructions will reflect
• This is essentially an interface into malloc.
• As far as implementing this, hnd can be the direct pointer if it fits within the cell size of the interprter, or else a seperate list can be maintained and this would be the handle into the list.
• Stack entries written to memory using P truncate to bytes.

"EVAR" 0x45564152

G	(0gnirts -- 0gnirts)	Get value of an environment variable
N	( -- n )	Get number of environment variables
P	(0gnirts --)	Put a value into the environemnt (form: name=value)
V	(n -- 0gnirts)	Get n'th environmnt variable (form: name=value)

"EXEC" 0x45584543

A	(V n -- )	Execute command at vector n times from current location, IP will be pointed at the A
B	(V n -- )	Like A but IP will be reset each iteration
G	(V --)	Set position of IP to vector
K	(n -- )	what k should have been, will skip following instruction if it is the iterated one
R	(n --)	Like K but IP is reset after each iteration
X	(cmd n --)	execute command on stack n times

• An IP reset as used in B and R reset the IP position only, nothing else
• On X, cmd is removed from the stack before it is iterated

"FILE" 0x46494C45

C	(h --)	Close a file
D	(0gnirts -- )	Delete specified file
G	(h -- h 0gnirts b)	Read string from file (like c fgets)
L	(h -- h n)	Get location of file pointer
O	(Va m 0gnirts -- h)	Open a file (Va=i/o buffer) m function 0 read 1 write 2 append 3 read/write 4 truncate read/write 5 append read/write
P	(h 0gnirts -- h)	Write string to file (like c fputs)
R	(h n -- h)	Read n bytes from file to buffer
S	(h m n -- h)	Seek to position n in file m function 0 from beginning 1 from current location 2 from end
W	(h n -- h)	Write n bytes from buffer to file

• All file functions on failure act as r.
• Functions W and R write cells as bytes, any cells containing values greater than 255 will have the top bits stripped.

• D was not in the original spec and may not be supported in all interpreters

"FING" 0x46494e47

X	(sem sem -- )	Swap two semantics
Y	(sem -- )	Pop semantic
Z	(src dst -- )	Push source semantic onto dst

• This fingerprint works by pushing and popping the semantic stacks. an empty stack will pop a reflect
• sem can be 0-25 or 'A through 'Z. Any other value is an error and will reflect
• X will swap a reflect in place of an empty stack
• Y will not reflect popping an empty semantic stack
• Z will push a reflect if the source semantic stack is empty

"FNGR" 0x464E4752

A	( -- )	Set ( and ) to work in absolute mode
B	( -- fp 1)	Create a Blank extension on top of stack (all entries are set to transparent). The standard fingerprint id for this copy will be 0xFFFFFFFF. This is useful to create a customized extension containing pieces from many others.
C	(new n old o -- )	Copy instruction 'old' in fingerprint 'o' to instruction 'new' in fingerprint 'n'
D	(inst n-- )	Delete an instruction from fingerprint with id n
F	(fp -- n)	Get current id for specified fingerprint fp is a 1 cell version, like from the ) command
K	(n -- )	Kill extension at selected position in fingerprint stack
N	( -- n)	Get number of fingerprints loaded
O	( -- )	Return ( and ) to the official functions
R	( -- )	Set ( and ) to work in roll mode
S	( -- )	Set ( and ) to work in swap mode
T	(fp n -- )	Tag stack entry n with new fingerprint fp
X	(n n -- )	Exchange the positions of two fingerprints in the stack
All instructions on failure act like r.

The fingerprint stack and fingerprint ids as used by this extension: The fingerprint stack consists of all loaded fingerprints. When a fingerprint is loaded it is pushed onto this stack. When an A-Z instruction is executed the tos of this stack is the first searched for the command, and then on downwards through the stack, if the bottom is hit, then an r command will be executed. For most all commands in this extension, the fingerprint id is actually the position on the fingerprint stack. The top has id 0, the second id 1, and so on. So, if you were to execute "'A1D" This would delete the 'A' command from the extension sitting on the second position on the fingerprint stack.

Absolute Mode: In absolute mode, the ( and ) instructions take on new meanings: (   A number is popped of off the stack, this numbers is the fingerprint id (stack position) of what should be considered the top of stack. It does not actually move anything, it only changes where the instruction search starts. Extensions on the stack above the selected one will not be searched whereas the selected and donward will still be searched. Executing "0(" will return the search to the top of the fingerprint stack. )   A number is popped of off the stack, this number specifies which fingerprint is to be copied over the top of the current top of stack. The extenstion that is currently on the top of the fingerprint stack will be deleted amd the selected one takes its place. The selected entry also remains in its original stack position, only a copy is made. The search point is then reset to the top of the fingerprint stack. Unlike the ( command, this will allow all other stack entries to be searched.

Roll Mode: In roll mode, the ( and ) instructions take on new meanings: (   A number is popped off the data stack and is used to roll the fingerprint stack. The item at the selected entry is removed and moved to the top of stack, while all other entries are moved down. This operates like the forth "roll" command. )   This works like (, but the roll is reversed. The top of stack is moved to the selected position while all other entries are moved up. This operates like the forth "-roll" command.

Swap Mode: In swap mode, the ( and ) instructions take on new meanings: (   A number is popped from the data stack. This specifies which entry in the fingerprint stack is to be swapped with the top of the fingerprint stack. )   This command uses no arguments from the data stack. It merely swaps the top two entries on the fingerprint stack

Note: In all modes, on failure ( and ) will act like r. When FNGR is loaded the fingerprint stack does NOT act like the spec, Instead there is a single fingerprint stack and unloading a fingerprint will remove the semantics for that fingerprint and not the semantics assigned to the various commands of the unloaded fingerprint. When FNGR is unloaded then the ( and ) commands will work like the official specs.

"FOBJ" 0x464f424a

D	(ref -- )	Destruct an object
I	(0gnirts -- ref)	Instantiate an object
M	(nargs ref meth -- ret)	Call an object method
N	(ref -- 0gnirts)	Get object name

• All functions reflect upon error
• ref referes to an index into a global object table
• In Funge/Multiverse each universe has its own global object table
• I 0gnirts referes to the funge file containing the code for the object
• M nargs specifies how many stack entries to transfer to the IP created in the object funge-space. Stack order is preserved. The count is NOT placed on the destination IPs stack.
• Funge files are in trefunge format. Each z level is a message handler, therefore message handlers start at 0 and go up.
• Funge-space for objects is in Trefunge mode.
• Starting point for any message handler is always [0][0][m] with a delta of [1][0][0]
• if cell[0][0][m] is a space then cause M to reflect
• Object method calls execute in a single tick
• The full capabilites of the funge engine should be available to object message handlers, this includes i,o,=,t, fingerprints, etc.
• Funge multiverse is not required for this extension, but each object must be its own funge-space.
• In Rc/Funge-98, each object is a stand-alone VM that is NOT part of the funge multiverse.
• Funge-space of a loaded object must remain consistant across method calls. In other words, if the method modifies its own funge-space, that change must remain for further method calls.
• When the last IP terminates a value is popped off its stack, that many stack entries are transferred back to the calling IP. Order is preserved.
• Global object table should be initialized at interpreter startup, and not by loading this fingerprint
• Object reference numbers may be reused

"FORK" 0x4464F524B

T

( -- pid flg)

Fork new process

• T - flg=0 for parent, 1 for child.
• T - child gets parent's pid, parent gets child's pid
• T - child has its IP delta reflected
• T - flg=-1 error in fork, does not reflect
• Other IPs in the forked process are unaffected

• The function forks the actual interpreter, creating an additional interpreter process.

"FPDP" 0x46504450

A	(a b -- n)	Add two double precision fp numbers
B	(n -- n)	Sin of double precision fp number
C	(n -- n)	Cosin of double precision fp number
D	(a b -- n)	Divide two double precision fp numbers
E	(n -- n)	Arcsin of double precision fp number
F	(n -- n)	Convert integer to floating point
G	(n -- n)	Arctangent of double precision fp number
H	(n -- n)	Arccosin of double precision fp number
I	(n -- n)	Convert floating point to integer
K	(n -- n)	Natural logarithm of double precision fp number
L	(n -- n)	Base 10 logarithm of double precision fp number
M	(a b -- n)	Multiply two double precision fp numbers
N	(n -- n)	Negate double precision fp number
P	(n -- )	Print a floating point number
Q	(n -- n)	Double precision square root
R	(0gnirts -- n)	Convert ascii number to floating point
S	(a b -- n)	Subtract two double precision fp numbers
T	(n -- n)	Tangent of double precision fp number
V	(n -- n)	Absolute value of double precision fp number
X	(n -- n)	Exponential of double precision fp number (e**n)
Y	(x y -- n)	Raise x to the power of y

"FPRT" 0x46505254

D	(fmt fh fl -- 0gnirts)	Format FPDP type number
F	(fmt f -- 0gnirts)	Format FPSP type number
I	(fmt i -- 0gnirts)	Format an integer
L	(fmt h l -- 0gnirts)	Format a long integer
S	(fmt 0gnirts -- 0gnirts)	Format a string

• Formats are printf style
• Error in any function reflects

"FPSP" 0x46505350

A	(a b -- n)	Add two single precision fp numbers
B	(n -- n)	Sin of single precision fp number
C	(n -- n)	Cosin of single precision fp number
D	(a b -- n)	Divide two single precision fp numbers
E	(n -- n)	Arcsin of single precision fp number
F	(n -- n)	Convert integer to floating point
G	(n -- n)	Arctangent of single precision fp number
H	(n -- n)	Arccosin of single precision fp number
I	(n -- n)	Convert floating point to integer
K	(n -- n)	Natural logarithm of single precision fp number
L	(n -- n)	Base 10 logarithm of single precision fp number
M	(a b -- n)	Multiply two single precision fp numbers
N	(n -- n)	Negate single precision fp number
P	(n -- )	Print a floating point number
Q	(n -- n)	Single precision square root
R	(0gnirts -- n)	Convert ascii number to floating point
S	(a b -- n)	Subtract two single precision fp numbers
T	(n -- n)	Tangent of single precision fp number
V	(n -- n)	Absolute value of single precision fp number
X	(n -- n)	Exponential of single precision fp number (e**n)
Y	(x y -- n)	Raise x to the power of y

• Trig functions work in radians

"FIXP" 0x4649585

A	(a b -- a and b)	And
B	(n -- arccos(b))	Find arccosin of tos
C	(n -- cos(b))	Find cosin of tos
D	(n -- rnd(n))	RanDom number
I	(n -- sin(b))	Find sin of tos
J	(n -- arcsin(b))	Find arcsin of tos
N	(a -- 0-a)	Negate
O	(a b -- a or b)	Or
P	(a -- a*pi)	Multiply by pi
Q	(a -- sqrt(a))	Square root
R	(a b -- a**b)	Raise a to the power of b
S	(n -- n)	Replace tos with sign of tos
T	(n -- tan(b))	Find tangent of tos
U	(n -- arctan(b)	Find arctangent of tos
V	(n -- n)	Absolute value of tos
X	(a b -- a xor b)	Xor

• The functions C,I,T,B,J,U expect their arguments times 10000, for example: 45 should be passed as 450000. The results will also be multiplied by 10000, thereby giving 4 digits of decimal precision.
• Trigonometric functions work in degrees. not radians.

"FRTH" 0x46525448

D	( .. -- .. n)	Push depth of stack to tos
L	( .. n -- .. n)	Forth Roll command
O	(a b -- a b a)	Forth Over command
P	(.. n -- .. n)	Forth Pick command
R	(a b c -- b c a)	Forth Rot command

• Stack operations are subject to the modes set by MODE

• P should reflect on a negative argument
• P should push 0 if argument is greater than stack size
• L should act like forth -roll with a negative argument
• L with an argument larger than the stack size is allowed, enough zeroes will be created in order to fulfill the request. Example: n543210a-L will leave a stack of: 2 3 4 5 0 0 0 0 0 0 1
• L,P the top of stack is position 0

"ICAL" 0x4943414c

A	(a -- r)	Unary AND
F	(n -- )	Forget entries from nexting stack
I	(a b -- r)	Interleave a $ b
N	(Va -- )	Jump to new location
O	(a -- r)	Unary OR
R	(n -- )	Resume
S	(a b -- r)	Select a ~ b
X	(a -- r)	Unary XOR

• A,O,X work in 16 bits unless a is greater than 16 bits
• I a and b are 16-bits and will produce a 32 bit result
• N reflects if there are already 79 entries on the Next stack
• Neither N nor R affect the delta!
• 0R is not an error and will just continue without resuming
• Negative argument to R is an error and will reflect
• R on an empty nexting stack will continue without resuming
• R if n is greater than the number of nexting stack entries, the nexting stack will be cleared and no resume will take place

"IIPC" 0x49495043

A	( -- n)	Get ancestors unique id
D	( -- )	Go Dormant until stack is manipulated by another ip
G	(i -- n)	Get the top value of another ip's stack (pop)
I	( -- n)	Get ip's own unique id
L	(i -- n)	Look at top stack value of another ip
P	(n i -- )	Put a value onto another ip's stack

"IMAP" 0x494D4150

C	( -- )	Clear all instruction remaps
M	(new old -- )	Remap an instruction
O	(n -- )	Return instruction n to its old function

Clarification

• This extension is intended to map instructions in the 0-255 range. Other interpreters may have a more limited or more expanded range
• Attempting to map instructions outside of the 0-255 range reflect. Some interpreters may ignore an out of range map without reflecting
• Chained remaps are not supported by this extension. Only a single level of mapping is supported. Other interpreters may have implemented chained remaps

"IMTH" 0x494d5448

A	(.. n -- r)	Average
B	(n -- r)	Absolute value
C	(n -- r)	Multiply by 100
D	(n -- r)	Decrease towards zero
E	(n -- r)	Multiply by 10,000
F	(n -- r)	Factorial
G	(n -- r)	Sign
H	(n -- r)	Multiply by 1,000
I	(n -- r)	Increase away from zero
L	(n c -- r)	Shift n left c times
N	(.. n -- r)	Minimum value
R	(n c -- r)	Shift n right c times
S	(.. n -- r)	Sum
T	(n -- r)	Multiply by 10
U	(n -- )	Unsigned print
X	(.. n -- r)	Maximum value
Z	(n -- r)	Negate

• A n=0 is not an error and will return 0
• A n<0 is an error and will reflect
• A n>stacksize is not an error
• F will reflect on negative
• L c can be negative and will shift right
• R c can be negative and will shift left
• L,R count of zero will return the argument unmodified
• N,X will reflect if count <= 0
• N,X count greater than stack size is not an error
• S n=0 is not an error and will return 0
• S n<0 is an error and will reflect
• S n>stacksize is not an error
• D input of zero is not an error and will produce zero
• I input of zero is not an error and will produce zero

"INDV" 0x494E4456

G	(Vp - n)	Pointer get number
P	(n Vp -- )	Pointer put number
V	(Va -- V)	Pointer get vector
W	(V Va --)	Pointer put vector

• Pointer functions pop a vector off the stack which points to another vector in memory which is the pointer to the target cell.

• This fingerprint was originally called PNTR. Early on it was renamed. to INDV. Some interpreters may implement this fingerprint as PNTR. Any use of PNTR should be changed to use INDV. Otherwise consider PNTR to be a synonum of INDV
• Vectors are stored in memory with a delta of 1,0,0 with Z being first in trefunge, and Y first in befunge. Originally Rc/Funge-98 stored this vector in reverse and became known as Rc/Funge-98 illogical order. Other interpreters may have copied the original way that Rc/Funge-98 stored the vectors.

"IPMD" 0x49504d44

B	( -- )	Run in BeFunge mode
D	( -- )	Run in default mode for VM
Q	( -- d)	Query for mode IP is running in
T	( -- )	Run in TreFunge mode
U	( -- )	Run in UneFunge mode

• These commands only affect the IP executing them. Other IPs running in the same VM are not affected.
• These functions affect how the IP interprets instructions, they will be limited or expanded based upon the mode the IP is running in.
• These modes are NOT affected by the mode the VM is running in. It is allowed to set an IP into TreFunge mode in a BeFunge funge-space. The TreFunge instructions must however work.
• Vectors will be affected by the mode the IP is running in. Example: If a VM is running in BeFunge mode and an IP is running in TreFunge mode and wants to pop a vector, it will pop a 3 coordinate vector, likewise if the IP were running in UneFunge mode, then it will pop a single value vector.
• When running in a mode less than Funge-Space, coordinates above the mode of the IP will be set for the coordinate of the ip. For example if the IP is at 20,30 then exectues U and then a g command is exectued, g will retrieve a value from row 30, not 0
• When running in a mode less than Funge-Space, x will set unpopped delta values to 0.
• Funge-space supports up to TreFunge when using this extension

"LONG" 0x4c4f4e47

A	(ah al bh bl -- rh rl)	Addition
B	(ah al -- rh rl)	Absolute value
D	(ah al bh bl -- rh rl)	Division
E	(n -- rh rl)	Sign extend single to long
L	(ah al n -- rh rl)	Shift left n times
M	(ah al bh bl -- rh rl)	Multiplication
N	(ah al -- rh rl)	Negate
O	(ah al bh bl -- rh rl)	Modulo
P	(ah al -- )	Print
R	(ah al n -- rh rl)	Shift right n times
S	(ah al bh bl -- rh rl)	Subraction
Z	(0gnirts -- rh rl)	Ascii to long

• long integers are 2 cell integers, if the interpreter's cell size is 32, then long integers are 64-bits.
• Division by zero results in zero, not error

"MACR" 0x4d414352

A-Y	( -- )	Execute specified macro
Z	(V -- )	Specify where macro block is located

• Macros are simple mini-funge like Befunge-like subroutines that execute in a single tick
• The Macro block may be located anywhere in Funge-Space. Each macro runs with a delta of 1,0,0 (Befunge like macros) macro A is located at the macro block vector, Macro B is one line below at the same starting X, C below that, etc
• Macros execute with the IP where it is! not in the macro space
• Instructions affect the IP that called the Macro
• A macro teminates when either a @ is found or an invalid instruction is found
• Most standard Funge-98 instructions can be used within macro blocks, but keep in mind they affect the IP where it is and not inside the macro block
• A-Z generally are not allowed within macros, however some A-Z commands perform special functions when executed inside of a macro:

  A	-	like _ but affects the macro pointer instead of the IP
  B	-	Move IP backwards
  E	-	Change macro delta to 1,0,0
  F	-	Move IP forwards
  G	-	Get next macro cell onto stack
  I	-	like | but affects the macro pointer instead of the IP
  J	-	like j but affects the macro pointer instead of the IP
  L	-	like [ but affects the macro pointer instead of the IP
  N	-	Change macro delta to 0,-1,0
  R	-	like ] but affects the macro pointer instead of the IP
  S	-	Change macro delta to 0,1,0
  T	-	like # but affects the macro pointer instead of the IP
  W	-	Change macro delta to -1,0,0

"MSGQ" 0x4d534751

G	(key flags -- id)	Get message queue identifier
K	(id -- )	Kill message queue
R	(n mtyp id flags -- .. n t)	Receive message to stack
S	(.. n mtyp id flags -- )	Send bytes on stack as message
T	(id -- nmsg maxsize)	Get message system info

• G Flags:
  

  4096	- IPC_CREAT	- Create if id does not exist
  8192	- IPC_EXCL	- Open in exclusive mode
  16384	- IPC_PRIVATE	- Create private
  low 9 bits are Unix standard access permissions

• R Flags:
  

  1	- IPC_NOWAIT	- Do not block if no messages available
  2	- MSG_NOERROR	- Truncate too-long message instead of error

• S Flags:
  

  1

  - IPC_NOWAIT

  - Do not block if message queue full

• All functions reflect on error with the error code on the stack
  

  1	- EACCESS	- A message queue exists for key, but no permission to access
  2	- EEXIST	- Message queue exist when IPC_CREAT and IPC_EXCL are both specified
  3	- ENOENT	- No mesage queue exists for key and IPC_CREAT was not specified
  4	- ENOMEM	- Not enough memory
  5	- ENOSPC	- Message queue needs to be create but no more message queues allowed
  6	- EFAULT	- Address for IPC_SET or IPC_STAT not accessable
  7	- EINVAL	- Invalid value for cmd or id
  8	- EPERM	- No permissions to perform action
  9	- EAGAIN	- A blocking condition was created and IPC_NOWAIT was specified
  10	- EIDRM	- Message queue was removed
  11	- EINTR	- Sleeping on a full message queue, the process caught a signal
  12	- E2BIG	- Message size greater than specified maximum
  13	- ENOMSG	- IPC_NOWAIT was specifed and no message of the required type was available

• Maximum message size MAY BE limited to a set size. Rc/Funge-98 allows for messages up to 4096 bytes

• Not all implementations will support all possible error types. If an implementation supports the error then it should use the number above.
• Implementations may define additional errors as such portable code should be careful how it handles errors

"MVRS" 0x4d565253

B	(0gnirts flgs lng dim -- )	Big-Bang, create another universe
C	( -- n)	Number of existing universes
F	(0gnirts Vd Vs Vsz -- )	Copy funge-space from another universe
G	(0gnirts Vpos Vdlt -- )	Go to another universe
J	(0gnirts -- )	Jump to another universe
N	( -- 0gnirts)	Get name of current universe
P	(0gnirts Vd Vs Vsz -- )	Copy funge-space to another universe

• F source vector must be x,y,z even if source universe is unefunge or befunge
• F size vector is based upon current universe
• J keeps position and delta
• Any command specifying a universe will reflect if the universe does not exist

• Flags from 512 upwards are implementation dependent and may vary from interpreter to interpreter. Flags 256 and below are reserved and may change in the future.
• Interpreters are not required to support any flags
• If an unsupported flag below 512 is used, B should reflect
• If an unsupported flag 512 and up is used, B should ignore it

• All others reserved and may change in the future
• If an unsupported language is specified, B should reflect

"RAND" 0x52414e44

I	(n -- r)	Integer random number 0 <= r < n
M	( -- max)	Maximum allowed integer range
R	( -- r)	FPSP random number 0 <= r < 1
S	(n -- )	Reseed rng with n
T	( -- )	Reseed rng with system timer or other source

• I n will be considered to be unsigned
• I n=0 is an error and will reflect

"REXP" 0x52455850

C	(0gnirts flags -- )	Compile a regular expression
E	(0gnirts flags -- results)	Execute regular expression on string
F	( -- )	Free compiled regex buffer

• Flags for C command:
  

  1	- REG_EXTENDED	- use posix extended regular expressions
  2	- REG_ICASE	- ignore case
  4	- REG_NOSUB	- Do not retrieve submatches
  8	- REG_NEWLINE	- match any characters do not match newlines

• Flags for E command:
  

  1	- REG_NOTBOL	- beginning of line always fails
  2	- REG_NOTEOL	- end of line always fails

• C Reflects on error with error number on stack:
  

  1	- REG_BADBR	- Invalid use of back reference
  2	- REG_BADPAT	- Invalid use of pattern operators
  3	- REG_BADRPT	- Invalid use of repitition operators
  4	- REG_EBRACE	- Unmatched brace
  5	- REG_EBRACK	- Unmatched bracket
  6	- REG_ECOLLATE	- Invalid collating element
  7	- REG_ECTYPE	- Invalid character class name
  8	- REG_EEND	- Non-specific error
  9	- REG_EESCAPE	- Trailing backslash
  10	- REG_EPAREN	- Unmatched parenthesis
  11	- REG_ERANGE	- Invalid use of range operator
  12	- REG_ESIZE	- Compiled pattern too large
  13	- REG_ESPACE	- Regex routines ran out of memory
  14	- REG_ESUBREG	- Invalid backreference to subexpression

• E leaves the results of the match as a series of 0gnirts strings. Each string representing the matched portion of a substring. Top of stack will have the count of these 0gnirts strings.
• E Reflects if no match
• If REG_EXTENDED is not specified, then the base level of regular expressions is what is supported, similar to grep or sed. The commands . * [ ] ^ $ \( \) should all be supported

• Not all implementations will support all possible error types. If an implementation supports the error then it should use the number above.
• Implementations may define additional errors as such portable code should be careful how it handles errors

"SETS" 0x53455453

A	(set v -- set)	Add value to set
C	(set -- set n)	Get count of items in set
D	(set -- set set)	Duplicate set on stack
G	(Vdlt Vsrc -- set)	Get set from Funge-space
I	(seta setb -- seta setb setr)	Instersection of sets
M	(set v -- set r)	r=0 if v is not member of set, else r=1
P	(set -- set)	Print a set
R	(set v -- set)	Remove value from set
S	(seta setb -- seta setb setr)	Subtract setb from seta
U	(seta setb -- seta setb setr)	Union of sets
W	(set Vdlt Vdst -- set)	Write set to Funge-space
X	(seta setb -- setb seta)	Swap two sets
Z	(set -- )	Drop set from stack

• all reflect if stack does not appear to have a proper set
• Sets are in the form (v1 v2 v3 .. vn ) n, n being closes to top of stack denotes how many items are in the set
• Nearly all instructions leave the work sets on the stack at the completion of the instruction
• Order within the sets need not be maintained. These are sets and not arrays

"SGNE" 0x53474E45

A	(sec -- old)	Set alarm
I	( -- pid)	Get PID of current process
L	(sec -- )	Sleep
P	( -- )	Pause until signal
S	(s -- )	Send signal to self
T	( -- )	Abort

• These instructions affect the interpreter and therefore all IPs will be subject to the effects of these functions.
• L - If process is worken up because of a signal, then the IP is reflected and the stack will contain the number of unslept seconds. If the Process wakes up normally after the sleep period is over then the IP continues along its delta and nothing will be pushed onto the stack
• S - Reflects on error

"SMEM" 0x534d454d

G	(key size flags -- id)	Get shared memory segment
K	(id -- )	Remove shared memory segment
R	(n addr id flags -- ..)	Read bytes from shared memory
T	(id -- size)	Get shared memory info
W	(.. n addr id flags -- )	Write bytes to shared memory

• G Flags:
  

  4096	- IPC_CREATE	- Create segment if it does not exist
  8192	- IPC_EXCL	- Open for exclusive use
  16384	- IPC_PRIVATE	- Create private
  Low 9 bits are Unix pattern permisssions

• R Flags:
  

  1

  - SHM_RDONLY

  - Attach segment readonly

• W Flags:
  

  1

  - SHM_RDONLY

  - Attach segment readonly

• All commands reflect on error with the error code on the stack:
  

  1	- EACCES	- User does not have permission to access
  2	- EEXIST	- IPC_CREAT|IPC_EXCL was specified and sement exists
  3	- EFAULT	- Address is not accessable
  4	- EIDRM	- Shared memory segment was removed
  5	- EINVAL	- id is not a valid id
  6	- ENFILE	- System limit on open files has been reached
  7	- EOVERFLOW	-
  8	- ENOENT	- No segment exists for key and IPC_CREAT was not specified
  9	- ENOMEM	- No memory could be allocated
  10	- ENOSPC	- All possible shared memory IDs have been taken
  11	- EPERM	- No permissions

• Not all implementations will support all possible error types. If an implementation supports the error then it should use the number above.
• Implementations may define additional errors as such portable code should be careful how it handles errors

"SMPH" 0x534d5048

A	(sem id flags -- id)	Allocate semaphore
D	(sem id flags -- id)	De-allocate semaphore
G	(key nsems flags -- id)	Get a semaphore set
K	(id -- )	Remove a semaphore set
M	(op sem id n -- )	Multiple semaphore operations
N	(sem id -- z n)	Get number of processes waiting on semaphore
R	(sem id -- n)	Read semaphore value
W	(v sem id -- )	Write semaphore value
Z	(sem id -- )	Wait for zero semaphore

• A,D,Z Flags:
  

  1	- IPC_NOWAIT	- Do not block
  2	- SEM_UNDO	- Undo operation on program exit

• G Flags:
  

  4096	- IPC_CREATE	- Create if it does not exist
  8192	- IPC_EXCL	- Open for exclusive use
  16384	- IPC_PRIVATE	- Create a private semaphore set
  Low 9 bits are Unix pattern permisssions

• M (op sem id) is repeated on the stack n times, one set for each semaphore to be changed.
• N result z is the number of processes waiting for semaphore to be zero, n is the number of processes waiting for a positive value
• All commands reflect on error with the error code on the stack:
  

  1	- E2BIG	- Value was too large
  2	- EACCESS	- Semaphore exists but no access allowed
  3	- EAGAIN	- Operation could not go through with IPC_NOWAIT specified
  4	- EEXIST	- IPC_CREAT|IPC_EXCL were specified and semaphore exists
  5	- EFAULT	- Address isn't accessible
  6	- EFBIG	- Invalid semaphore number
  7	- EIDRM	- Semaphore set was removed
  8	- EINTR	- Sleeping on a wait queue and process receives a signal
  9	- EINVAL	- Semaphore set does not exist
  10	- ENOENT	- No semaphore set exists and IPC_CREAT was not specified
  11	- ENOMEM	- Not enough memory to create new semaphore set
  12	- ENOSPC	- Maximum semaphore limit has been reached
  13	- EPERM	- Insuficient privileges to execute command
  14	- ERANGE	- Semaphore value exceeded allowed count

• Not all implementations will support all possible error types. If an implementation supports the error then it should use the number above.
• Implementations may define additional errors as such portable code should be careful how it handles errors

"SOCK" 0x534F434B

A	(s -- prt addr s)	Accept a connection
B	(s ct prt addr -- )	Bind a socket
C	(s ct prt addr -- )	Open a connection
I	(0gnirts -- addr)	Convert an ascii ip address to a 32 bit address
K	(s -- )	Kill a connection
L	(n s -- )	Set a socket to listening mode (n=backlog size)
O	(n o s -- )	Set socket option
R	(V l s -- bytes)	Receive from a socket,
S	(pf typ pro -- s)	Create a socket
W	(V l s -- retcode)	Write to a socket

note: All functions act as r on failure
addr:	32 bit destination address
ct:	1=AF_UNIX 2=AF_INET
o:	1=SO_DEBUG 2=SO_REUSEADDR 3=SO_KEEPALIVE 4=SO_DONTROUTE 5=SO_BROADCAST 6=OOBINLINE
pf:	1=PF_UNIX 2=PF_INET
prt:	Port to connect to
s:	Socket identifier
typ:	1=SOCK_DGRAM 2=SOCK_STREAM
pro:	1=tcp 2=udp
V:	Vector to io buffer

Clarification

• The socket descriptor s used in these functions could be either an index into a table of open sockets or else use the id returned by the OS. In either case the socket identifier needs to be usable by other IPs, therefore a socket table that is global to all IPs or else use the OS descriptors.
• ct=1 and pf=1 are a broken spec and should not be implemented. Usage of either of these should reflect.

"SORT" 0x534f5254

B	(Va Vld Vbd w n -- )	Sort block in funge-space
F	(Va Vd n -- )	Sort funge-space
K	(.. n -- ..)	Sort stack
S	(Va Vld Vsd w n -- )	Sort strings

• Reflect if n<=0
• Reflect if w<=0
• Any delta of all zeros is an error and will reflect
• All arguments are popped from the stack before error checking
• B Sorts only on first cell in each entry

"STCK" 0x5354434b

B	(v n -- v ..)	Bury v value n deep into the stack
C	(.. -- cnt)	Get count of items on stack
D	(.. n -- ..)	Duplicate top n stack items
G	(n Vdlt Vsrc -- ..)	Read n stack entires from Funge-Space
K	(st en -- ..)	Push block of stack cells on top
N	(.. n -- ..)	Reverse n items on stack
P	(.. -- ..)	Print contents of stack, non-destructive
R	(.. -- ..)	Reverse all items on stack
S	(a b -- a a b)	Duplicate second on stack
T	(a b c -- b a c)	Swap second and third items on stack
U	(n -- n r)	Drop items from stack until n is found
W	(n Vdlt Vsrc -- )	Write n stack entires to Funge-Space
Z	(0string -- 0gnirts)	Reverse 0 terminated string on stack

• B if stack is not as deep as specified will reflect
• B if n is negative, push n zeroes above v
• K moves the block
• K if end is deeper than start, reflect
• K if end or start is negative, reflect
• K with start or end deeper than stack is NOT an error
• D works like ( a b c 3 -- a a b b c c )
• U reflects if the item is not found. r is the number of dropped items, next on stack will be the found value
• S with stack size <= 1 is NOT an error
• T with stack size <3 is NOT an error
• Both W and G will reflect on a negative count
• G must reproduce the stack written by W

"STRN" 0x5354524E

A	(0gnirts 0gnirts -- 0gnirts)	Append bottom string to upper string
C	(0gnirts 0gnirts -- n)	Compare strings
D	(0gnirts --)	Display a string
F	(0gnirts 0gnirts -- 0gnirts)	Search for bottom string in upper string
G	(Va -- 0gnirts)	Get string from specified position
I	( -- 0gnirts)	Input a string
L	(0gnirts n -- 0gnirts)	Leftmost n characters of string
M	(0gnirts s n -- 0gnirts)	n characters starting at position s
N	(0gnirts -- 0gnirts n)	Get length of string
P	(0gnirts Va -- )	Put string at specified position
R	(0gnirts n -- 0gnirts)	Rightmost n characters of string
S	(n -- 0gnirts)	String representation of a number
V	(0gnirts -- n)	Retreive value from string

• functions G and P use deltas of 1,0,0

• For M, requesting zero characters from the string will return an empty string. Other interpreters may have implemented this as reflecting
• For M, specifying a length that would go beyond the end of the string is legal and will return from the start til the end of the string. Other interpreters may have implemented this as reflecting.
• For M, specifying a negative start or a start beyond the end of the string is an error and will reflect. Other interpreters may have implemented this as returning a null string
• For R,L,M Requesting 0 or more characters from an empty string returns an empty string. Other interpreters may have implemented this as reflecting.
• Specifiying a negative size for R,L,M is an error and will reflect. Other interpreters may have implemented this as returning a null string
• For R,L requesting more characters than the length of the string will return the whole string. Other interpreters may have implemented this as reflecting or returning a null string.
• For V, a non-numeric value in the string is not an error and will push a 0. Other interpreters may have implemented this as reflecting. This function is implemented as the c function atoi (or equivalent for cell size), It will not search the string for a numeric value.

"SUBR" 0x53554252

A	( -- )	Set absolute mode
C	(Va n -- Va Vd .. )	Call a subroutine
J	(Va -- )	Jump to another location
O	( -- )	Set Relative mode
R	(Va Vd .. n -- ..)	Return from subroutine

• Default mode when SUBR is loaded is absolute mode.
• Mode setting is individual per IP
• Relative mode only affects the vectors from J and C. R should always return to the point of the original Call
• J and C each set delta to 1,0,0 at target, R restores the delta before the call.
• When C is executed, the tos specifies how many stack entries to retrieive from the stack and then place back onto the stack after the retrurn address and delta vectors are pushed on the stack.
• When R is executed, the tos specifies how many stack entries to retrieve from the stack before retrieving the delta and address vectors. The popped entries will be restored to the stack after the vectors are popped.
• Vectors in this function work directly on the IP and not through funge-space, therefore the IP storage offset does not apply to these vectors.

• A and O were not part of the original spec and therefore there may be interpreters that will not handle these.
• If A and O are not supported then absolute mode should be the mode that C and J will operate in. Some interpreters may have however implemented these in relative mode

"TIME" 0x54494D45

D	( -- n)	Day of Month
F	( -- n)	Day since First of year
G	( -- )	Set time functions to GMT
H	( -- n)	Hours
L	( -- )	Set time functions to local time (default)
M	( -- n)	Minutes
O	( -- n)	Month (1=January)
S	( -- n)	Seconds
W	( -- n)	Day of Week (1=Sunday)
Y	( -- n)	Year

"TERM" 0x5445524D

C	( -- )	Clear the screen
D	( n -- )	Move cursor down n lines
G	(x y -- )	Put cursor at position x,y (home is 0,0)
H	( -- )	Move cursor to home
L	( -- )	Clear to end of line
S	( -- )	Clear to end of screen
U	( n -- )	Move cursor up n lines

"TRDS" 0x54524453

C	( -- )	Continue normal time
D	(V -- )	Set absolute destination space coordinates
E	(V -- )	Set relative destination space corrdinates
G	( -- n)	Get current time point
I	( -- )	Set inverse settings
J	( -- )	Initiate a jump
P	( -- n)	Maximum distance in the past ip can jump to
R	( -- )	Reset all tardis controls to default
S	( -- )	Stop time
T	(n -- )	Set absolute destination time
U	(n -- )	Set relative destination time
V	(V -- )	Set destination vector

Notes to time travelling ips:

Usage of time travel can be very punishing on the performance of the funge interpreter. If travel is performed to the past, the interpreter must be capable of reproducing all conditions that existed at the destination time, which includes all ips, stacks, and funge space cells. Some interpreters may only store time snapshots from only so far back (The furthest point in the past that can be jumped to can be determined with the P command). The RCS interpreter essentially reruns from point 0 and therefore all points in time can be jumped to (note: this can be quite time consuminmg if the destination time point is tens or hundreds of thousands of instructions from time point 0).

Time travel into the future is not quite so punishing. The ip that time travels will merely be frozen until time catches up with it, at which point it will continue to execute.

Time travel into the past has the following consequences: It is not possible to travel further back than time point 0. Attempts to travel beyond the beginning will leave the ip at time point 0. The original ip will still be born as per normal. example. If ip #2 is born at time 100 and then performs a jump at time 200 to time 50, ip #2 will be born again at time 100, and there will now be 2 of them (the newly born ip #2 in addition to the one that jumped) When the newly born ip #2 reaches the time it jumped (time point 200) it will cease to exist, it will not perform another jump into the past, the original ip #2 however can still jump. If the new ip #2 performs a time jump earlier than when the original jumped, the original will cease to exist. An ip travelling in the past can kill its parent prior to its own birth, and will still exist. A time travelling ip will retain its memory, in other words, its stack will be the same after the jump as before. Also, unless the jump also included a space jump, the location will be the same physical space coodinates as when it jumped. An ip that perfroms a time jump without a space jump will execute the next instruction as if it had never jumped. An ip that performs a space jump (with or without a time jump) will first execute the instruction it jumped to.

When Multiple IPs Time Travel:

In order to decrease the work on the interpreter, it is not necessary for the interpreter to remember future events. In other words when an ip travels back in time, everything occuring after the time point of destination need not recur if it does not occur in the further course of the program. When IPs time travel, only those ips that are currently in funge space at the time of arrival (either normally or from time travelling) will exist. Any ips that time travelled to a point later in time will not recur, unless the original time travel for these ips recur. Here are two examples to illustrate this point:

Example 1: Ip#1 travels back in time and arrives to time point 100, Ip#2 travels back to point 150. At point 150 the time travelled copies of both ips will exist.

Example 2: Ip#1 travels back in time and arrives to time point 150, Ip#2 travels back to point 100. At the point where ip#2 arrives, ip#1 has not yet arrived and therefore does not exist, it will also not exist when time point 150 arrives, only when the original jump for Ip#1 occurs, will history again be rewritten.

Tardis Operators Manual:

Before attempting any jumps, the ip's tardis should be reset to clear out any unwanted coordinates. There are three coordinate settings: Space coordinates, vector after jump, and destination time. Any coordinate that is not set will remain at the last setting, or at default if the tardis is reset. Default coordinates are the current time, space, and vector. Absolute coordinates are based from time point 0, and space 0,0,0. Relative coordinates are based from the point the jump is actually made. All tardis coordinates are retained following a jump. The I command will set the tardis for the last source jump point.

Stopping Time:

An ip that issues a <S>top time command freezes the time counter. All other ips will be frozen until a <C>ontinue time command is executed. During the time that time is stopped, only the ip that executed the S command will continue to run. For the purposes of time travel, the time used while time is stopped does not actually exist, and therefore cannot be jumped to. In other words everything the ip does is considered to have taken no time. If an ip that stops time is terminated, time will be continued

"TRGR" 0x54524752

A-Y	( -- )	Activate a trigger
Z	(V -- )	Specify where trigger table is located

• When an IP executes a trigger a new IP is created that will then run concurrently with the rest of the IPs. The new IP will be generated in the same from as t, but will contain the position associated with the relevent entry in the trigger table
• The original IP is unaffected and continues to run normally after having executed the trigger
• The trigger table contains executable code for the new IP, the code for A begins at the trigger table vector, B starts at the same X one line lower, C below that, etc
• Both the original IP and the new IP will have the uid of the other pushed onto its stack

• Like in command 't', the newly created IP should execute first before the triggering IP.
• Initial direction of the trigger IP is 1,0,0.

"UNIX" 0x554e4958

A	(id -- )	Set effective uid
B	(id -- )	Set effective gid
C	(0gnirts uid gid -- )	Change owner of a file
D	( -- 0gnirts)	Get domain name of host
E	( -- id)	Get effective uid
G	( -- id)	Get real gid
H	( -- id)	Get host id
K	(mask -- old)	Set umask
M	(0gnirts mode -- )	Change file access
N	( -- 0gnirts)	Get host name
P	( -- id)	Get process id
R	( -- id)	Get effective gid
S	(id -- )	Set uid
T	(id -- )	Set gid
U	( -- id)	Get real uid

• All functions reflect on error
• C: if uid or gid is -1 that component will not be set

"WIND" 0x57494E44

B	(x1 y1 width height h -- )	Draw a box
C	(h -- )	Close GC
D	(h -- )	Drop (lower) Window
E	(h -- )	Call event checker
I	(Va e h -- )	Install event handler e function 1 - Mouse Down 2 - Mouse Up 3 - Mouse Motion 4 - Key Pressed 5 - Expose 6 - Configuration
F	(r g b h -- )	Change foreground color
K	(h -- )	Kill a window
L	(x1 y1 x2 y2 h -- )	Draw a line
M	(x y h -- )	Move a window
O	(h -- )	Open GC
P	(x y h -- )	Draw a point
R	(h -- )	Raise Window
S	(x y h -- )	resize a window
T	(0gnirts x y h --)	Draw text in a window
W	(x y w h -- h)	Open a window
Y	(h -- )	Copy back-buffer to screen

• Drawing commands: B, L, P, and T require an open GC