TinyMUCK 2.2fb5.30 MUF Manual

MATH OPERATORS

 + - * / % ( i1 i2 -- i )

These words perform arithmetic operations on numbers. '+' = addition (i1 + i2); '-' = subtraction (i1 - i2); '*' = multiplication (i1 times i2, or i1 * i2); '/' = division (i1 divided by i2, or i1 / i2) with integer division truncation of fractions; '%' = modulo (remainder of i1 / i2, or i1 % i2) Please note: all these operations may also be performed where i1 is a variable type. This is mainly useful in calculating an offset for a variable array.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

LOGICAL OPERATORS

 < > = <= >= ( i1 i2 -- i )

Performs relational operations on integers i1 and i2. These return i as 1 if the expression is true, and i as 0 otherwise.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

VARIABLE OPERATORS

 @ ( v -- x )

Retrieves variable v's value x.

! ( x v -- )

Sets variable v's value to x.

See also variable, var, lvar, localvar, and miscellaneous.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ADDPENNIES

 addpennies ( d i -- )

d must be a player or thing object. Adds i pennies to object d. Without Wizard permissions, addpennies may only give players pennies, limited to between zero and MAX_PENNIES.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ADDPROP

 addprop ( d s1 s2 i -- )

Sets property associated with s1 in object d. Note that if s2 is null "", then i will be used. Otherwise, s2 is always used. All four parameters must be on the stack; none may be omitted. If the effective user of the program does not control the object in question and the property begins with an underscore '_', the property cannot be changed. The same goes for properties beginning with a dot '.' which cannot be read without permission.

If you store values, you must ensure that it they are never zero. Otherwise, when the user stores a non-zero number into the string field, (users may only access string fields) the next time TinyMUCK is dumped and loaded up again, the value field will be replaced with atoi(string field). If it is necessary to store zero, it is safer to just add 1 to everything.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

AND

 and ( x y -- i )

Performs the boolean 'and' operation on x and y, returning i as 1 if both i1 and i2 are TRUE, and returning i as 0 otherwise.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ATOI

 atoi ( s -- i )

Turns string s into integer i. If s is not a string, then 0 is pushed onto the stack.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CALL

 call ( d -- ?? )

Calls another program d. d must have been compiled already. d will inherit the values of ME, LOC, TRIGGER, and all other variables.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONTENTS

 contents ( d -- d' )

Pushes the dbref of the first thing contained by d. This dbref can then be referenced by 'next' to cycle through all of the contents of d. d may be a room or a player. See also NEXT

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

COPYOBJ

 copyobj ( d -- d' )

Creates a new object (returning d' on top of the stack), that is a copy of object d. Each program is allowed to create only one new object per run.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DBCMP

 dbcmp ( d1 d2 -- i )

Performs comparison of database objects d1 and d2. If they are the same object, then i is 1, otherwise i is 0.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DBREF

 dbref ( i -- d )

Converts integer i to object reference d.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DESC

 desc ( d -- s )

Takes object d and returns its description (@desc) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DROP

 drop ( d -- s )

Takes object d and returns its drop (@drop) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DUP

 dup ( x -- x x )

Duplicates the item at the top of the stack.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

EXECUTE

 execute ( a -- ?? )

Executes the function pointed to by the address a on the stack.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

EXIT

 exit ( -- )

Exits from the word currently being executed, returning control to the calling word, at the statement immediately after the invokation of the call (exiting the program if applicable).

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

EXIT?

 exit? ( d -- i )

Returns 1 if object d is an exit object, 0 if otherwise. See also player?, program?, room?, thing?, and ok?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

EXITS

 exits ( d -- d' )

Returns the first exit in the linked exit list of room/player/object d. This list can be transversed with 'next'. See also NEXT.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

EXPLODE

 explode ( s1 s2 -- ... i )

s2 is the delimiter string, and s1 is the target string, which will be fragmented, with i pushed on top of the stack as the number of strings s1 was broken into. For instance: 

    "Hello world" " " explode
will result in 
    "world" "Hello" 2
on the stack. (Note that if you read these items off in order, they will come out "Hello" first, then "world".) For TinyMUCK 2.2, s2 may be any length. But "" (null string) is not an acceptable string for parameter s2.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

FAIL

 fail ( d -- s )

Takes object d and returns its fail (@fail) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

FLAG?

 flag? ( d s -- i )

Reads the flag of object d, specified by s, and returns its state: 1 = on; 0 = off. Different flags may be supported in different installations. flag? returns 0 for unsupported or unrecognized flags. You can check the "interactive" flag to see if a player is currently in a program's READ, or if they are in the MUF editor.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

GETLINK

 getlink ( d -- d' )

Returns what object d is linked to, or #-1 if d is unlinked. The interpretation of link depends on the type of d: for an exit, returns the room, player, program, action, or thing that the exit is linked to. For a player, program, or thing, it returns its 'home', and for rooms returns the drop-to.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

GETPROPSTR

 getpropstr ( d s -- s )

s must be a string. Retrieves string associated with property s in object d. If the property is cleared, "" (null string) is returned.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

GETPROPVAL

 getpropval ( d s -- i )

s must be a string. Retrieves the integer value i associated with property s in object d. If the property is cleared, 0 is returned.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

IF ... ELSE ... THEN

if ... [ else ... ] then ( x -- )

Examines boolean value x. If x is TRUE, the sequence of statements after the 'if' up until the 'then' (or until the 'else' if it is present) performed. If it is FALSE, then these statements are skipped, and if an 'else' is present, the statements between the 'else' and the 'then' are performed. Control continues as usual at the statement after the 'then'. Note that checking the top of the stack actually pops it, so if you want to re-use it, you should dup (see also DUP) it before the if. For every IF in a word, there MUST be a THEN, and vice-versa. ELSE is optional.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

INSTR

 instr ( s s1 -- i )

Returns the first occurrence of string s1 in string s, or 0 if s1 is not found. See also rinstr.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

INT

 int ( x -- i )

Converts variable or object x to integer i.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

INTOSTR

 intostr ( x -- s )

x must be an integer or a dbref. Converts x into string s.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

LOCATION

 location ( d -- d' )

Returns location of object d as object d'.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

MATCH

 match ( s -- d )

Takes string s, first checks all objects in the user's inventory, then checks all objects in the current room, as well as all exits that the player may use, and returns object d which contains string s. If nothing is found, d = #-1. If ambiguous, d = #-2. If HOME, d = #-3.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

MOVETO

 moveto ( d1 d2 -- )

Moves object d1 to object d2. MOVETO is affected by the following rules:

  1. If the object being moved is !JUMP_OK and is it being moved by someone other than the object's owner, then the moveto fails.
  2. If the object being moved is a person and either the source or destination rooms (if not owned by the person being moved) are !JUMP_OK, the moveto fails.
  3. If the object being moved is not a player, is owned by the owner of either the source or destination rooms, and either room where the ownership matches is !JUMP_OK, the moveto fails.
The moveto succeeds under any other circumstances. MOVETO rules follow the permissions of the current effective userid. MOVETO will run programs in the @desc and @succ/@fail of a room when moving a player.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NAME

 name ( d -- s )

Takes object d and returns its name (@name) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NEXT

 next ( d -- d' )

Takes object d and returns the next thing in the linked contents/exits list of d's location. See also EXITS and CONTENTS.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NOT

 not ( x -- i )

Performs the boolean 'not' operation on x, returning i as 1 if x is FALSE, and returning i as 0 otherwise.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NOTIFY

 notify ( d s -- )

d must be a player object. s must be a string. Tells player d message s. If s is null it will print nothing. This primitive will trigger the _listen'er property on the object the message is sent to, unless the program that would be run is the same as one one currently running.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NOTIFY_EXCEPT

 notify_except ( d1 d2 s -- )

d1 must be a room object, s must be a string. Tells everyone at location d1 except object d2 message s. If object d2 is not a player or NOTHING (#-1) all players are notified. If s is null it prints nothing. NOTE: notify_except is now only an inserver $define. It is translated to '1 swap notify_exclude'. Please see the man sections on NOTIFY_EXCLUDE and DIRECTIVES for more information.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NUMBER?

 number? ( s -- i )

Returns 1 if string on top of the stack contains a number. Otherwise returns 0.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ODROP

 odrop ( d -- s )

Takes object d and returns its odrop (@odrop) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

OFAIL

 ofail ( d -- s )

Takes object d and returns its ofail (@ofail) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

OK?

 ok? ( x -- i )

Takes x and returns 1 if x is a type dbref, as well as 0 or above, below the top of the database, and is not an object of type garbage. See also exit?, player?, program?, and thing?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

OR

 or ( x y -- i )

Performs the boolean 'or' operation on x and y. Returns i as 1 if either x or y is TRUE, returns i as 0 otherwise.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

OSUCC

 osucc ( d -- s )

Takes object d and returns its osuccess (@osucc) string field.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

OVER

 over ( x y -- x y x )

Duplicates the second-to-top thing on the stack. This is the same as 2 pick.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

OWNER

 owner ( d -- d' )

d is any database object. Returns d', the player object that owns d. If d is a player, d' will be the same as d.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PENNIES

 pennies ( d -- i )

Gets the amount of pennies player object d has, or the penny value of thing d.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PICK

 pick ( ni ... n1 i -- ni ... n1 ni )

Takes the i'th thing from the top of the stack and pushes it on the top. 1 pick is equivalent to dup, and 2 pick is equivalent to over.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PLAYER?

 player? ( d -- i )

Returns 1 if object d is a player object, otherwise returns 0. If the dbref is that of an invalid object, it will return 0. See also program?, room?, thing?, exit?, and ok?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

POP

 pop ( x -- )

Pops the top of the stack into oblivion.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PROG

 prog ( -- d)

Returns the dbref of the currently running program.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PROGRAM?

 program? ( d -- i )

Returns 1 if object d is a program, otherwise returns 0. If the dbref is that of an invalid object, it will return 0. See also player?, room?, thing?, exit?, and ok?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PRONOUN_SUB

 pronoun_sub ( d s -- s' )

Takes database object d and substitutes string s according to o-message rules. For example: 

   me @ "%N has lost %p marbles." pronoun_sub
would return: 
   "Igor has lost his marbles."
if the player's name was Igor and his sex were male. d does not have to be a player for the substitutions to work.

The substitutions are

if it comes across a %X substitution, where X is any character not listed in the above substitutions table, it will search down the environment tree from d to try to find the appropriate %X property for use in substitution.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

RANDOM

 random ( -- i )

Returns a random integer from 0 to the MAXINT of the system running the MUCK. In general this number is (2^31)-1 or 2,147,483,647 (2.1 billion).

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

READ

 read ( -- s )

Reads a string s from the user. This command should not be used in a program that is locked (as opposed to linked) to an object, as the lock will always fail and print the fail messages at read time. It cannot be used in a program associated with a room object.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

REMOVE_PROP

 remove_prop ( d s -- )

Removes property s from object d. If the property begins with an underscore, '_' or a dot '.', and the effective user does not have permission on that object, the call fails.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

RINSTR

 rinstr ( s s1 -- i )

Returns the last occurrence of string s1 in string s, or 0 if s1 is not found. '"abcbcba" "bc" rinstr' returns 4. See also instr.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

RMATCH

 rmatch ( d s -- d' )

Takes string s, checks all objects and actions associated with object d, and returns object d' which matches that string. For example, matches actions and inventory objects for a player object, actions on a thing object, etc. If nothing is found, d' = #-1. if ambiguous, d' = #-2. If HOME, d' = #-3.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ROOM?

 room? ( d -- i )

Returns 1 if object d is a room, otherwise returns 0. If the dbref is that of an invalid object, it will return 0. A dbref of #-3 (HOME) returns 1. See also player?, program?, thing?, exit?, and ok?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ROT

 rot ( x y z -- y z x )

Rotates the top three things on the stack. This is equivalent to 3 rotate.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ROTATE

 rotate ( ni ... n1 i -- n(i-1) ... n1 ni )

Rotates the top i things on the stack. '"a" "b" "c" "d" 4 rotate' would leave "b" "c" "d" "a" on the stack. Using a negative rotational value rotates backwards. ie: '"a" "b" "c" "d" -4 rotate' would leave "d" "a" "b" "c" on the stack.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SET

 set ( d s -- )

Sets flag s to object d. Currently settable things are: abode, chown, dark, haven, jump, link, sticky. Boolean operations (e.g. '!abode') work as expected. See also setname, setdesc, and flag?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SETDESC SETSUCC SETFAIL SETDROP SETOSUCC SETOFAIL SETODROP

setdesc setsucc setfail setdrop setosucc setofail setodrop (d s -- ) Takes object d, and sets the string field specified to s. A program may only set string fields of objects that are owned by the effective user of the program, or any object if the program is Wizard. These are all actually $defines to addprop with the apprpriate property name. They are effectively defined as: See also set, setname, addprop, getpropstr, remove_prop, desc, succ, fail, drop, osucc, ofail, and odrop.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SETNAME

 setname ( d s -- )

Takes object d, and sets the name to s. A program may only set the names of objects that are owned by the effective user of the program, or any object if the program is Wizard. The name of a player can never be set, since that would normally require a password. See also set, name, and setdesc.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRCAT

 strcat ( s1 s2 -- s )

Concatenates two strings s1 and s2 and pushes the result s = s1s2 onto the stack.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRCMP

 strcmp ( s1 s2 -- i )

Compares strings s1 and s2. Returns i as 0 if they are equal, otherwise returns i as the difference between the first non-matching character in the strings. For example, "a" "z" strcmp returns 25. The reason it returns a 0 for a match, and the difference on a non-match, is to allow for nice things like string sorting functions. This primitive is case sensitive, unlike stringcmp. See also strncmp.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRCUT

 strcut ( s i -- s1 s2 )

Cuts string s after its i'th character. For example, 

   "Foobar" 3 strcut
returns 
   "Foo" "bar"
If i is zero or greater than the length of s, returns a null string in the first or second position, respectively.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRINGCMP

 stringcmp ( s1 s2 -- i )

Compares strings s1 and s2. Returns i as 0 if they are equal, otherwise returns i as the difference between the first non-matching character in the strings. For example, "a" "z" stringcmp returns 25. This function is not case sensitive, unlike strcmp. See also strncmp.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRLEN

 strlen ( s -- i )

Returns the length of string s.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRNCMP

 strncmp ( s1 s2 i -- i' )

Compares the first i characters in strings s1 and s2. Return value is like strcmp. See also stringcmp.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SUBST

 subst ( s1 s2 s3 -- s )

s1 is the string to operate on, s2 is the string to change all occurences of s3 into, and s is resultant string. For example: 

    "HEY_YOU_THIS_IS" " " "_" subst
results in 
    "HEY YOU THIS IS"
s2 and s3 may be of any length.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SUCC

 succ ( d -- s )

Takes object d and returns its success (@succ) string field s.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SWAP

 swap ( x y -- y x )

Takes objects x and y on the stack and reverses their order.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

THING?

 thing? ( d -- i )

Returns i as 1 if object d is a thing, otherwise returns i as 0. See also player?, program?, room?, exit?, and ok?.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TIME

 time ( -- s m h )

Returns the time of day as integers on the stack, seconds, then minutes, then hours.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

VAR

 var name

Var is not a 'true' primitive in that it must always be used outside words and does not alter the stack in any way. When the compiler sees a 'var' statement, it allows the use of name as a variable in all words sequentially defined after the var declaration. See also @, VARIABLE, and LOCALVAR.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

VARIABLE

 variable ( i -- v )

Converts integer i to variable reference v. Of the pre-defined variables, 'me' corresponds to integer 0, 'loc' to 1, and 'trigger' to 2. Thus: 

     me @
and 
     0 variable @
will do the same thing (returning the user's dbref). User-defined variables are numbered sequentially starting at 3 by the compiler. Note that these variable numbers can be used even if variables have not been formally declared, making implementation of such things as arrays conveniently easy. See also ! @, and VAR.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

AWAKE?

 awake? ( d -- i )

Passed a players dbref, returns the number of connections they have to the game. This will be 0 if they are not connected.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ONLINE

online ( -- d ... i )

Returns a dbref for every connection to the game, and lastly the number of connections.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SYSTIME

 systime ( -- i )

Returns the number of seconds from Jan 1, 1970. This is compatible with the system timestamps and may be broken down into useful values through 'timesplit'.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DBREF?

 dbref? ( x -- i )

Returns true if x is a dbref.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DEPTH

 depth ( -- i )

Returns the number of items on the stack.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TIMESTAMPS

 timestamps ( d -- i i2 i3 i4 )

Returns the following for a program, the time created (i), the time last modified (i2), the time last used (i3), and the number of uses(i4) for any object.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

INT?

 int? ( x -- i )

Returns true if x is a int.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SETLINK

 setlink ( d1 d2 -- )

Takes an exit dbref d1, and sets its destination to d2. You must have control of the exit, and if the exit is already linked, it must be unlinked first by doing setlink with #-1 as the destination.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRING?

 string? ( x -- i )

Returns true if x is a string.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TIMESPLIT

 timesplit ( i -- is im ih id im iy iw iyd )

Splits a systime value into 8 values in the following order: seconds, minutes, hours, monthday, month, year, weekday, yearday. Weekday starts with sunday as 1, and yearday is the day of the year (1-366).

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NEWROOM

 newroom (d s -- d)

Takes the dbref of the parent and the name of the room. It returns the dbref of the created room. Owner is the person running the program. (program must have a wizbit)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NEWOBJECT

 newobject (d s -- d)

Takes location and name and returns new thing's dbref. Owner is the person running the program. (program must have a wizbit)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NEWEXIT

newexit (d s -- d)

Takes location and name and returns new exit's dbref. Owner is the person running the program. (program must have a wizbit)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STATS

 stats ( d -- total rooms exits things programs players garbage )

Returns the number of objects owned by 'd', or the total objects in the system if d == #-1. This is broken up into a total, rooms, exits, things, programs, players, and garbage. This functions much as the @STAT command. (Needs Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PUBLIC

PUBLIC functionname

Declares a previously defined function to be public for execution by other programs. This is a compile-time directive, not a run-time primitive. To call a public function, put the dbref of the program on the stack, then put a string, containing the function name, on the stack, then use CALL. For example: 

  #888 "functionname" CALL

Return to the TinyMUCK P, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

LVAR

 LVAR varname

This declares a variable as a local variable, that is local to a specific program. If another program calls this program, the values of the local variables will not be changed in the calling program, even if the called program changes them.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

LOCALVAR

 localvar (i -- l)

Takes an integer and returns the respective local variable. Similar to the variable primitive.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SETOWN

 setown (d d -- )

Sets the ownership of the first object to the player given in the second dbref. (wizbit only)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

RECYCLE

 recycle (d -- )

Recycles the given object d. Will not recycle players, the global environment, the player starting room, or any currently running program. (Can recycle objects owned by uid if running with Mucker Level 3 permissions. Can recycle other people's items with wizbit)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONCOUNT

 concount ( -- i)

Returns how many connections to the server there are. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONDBREF

condbref (i -- d)

Returns the dbref of the player connected to this connection. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONTIME

 contime (i -- i)

Returns how many seconds the given connection has been connected to the server. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONIDLE

 conidle (i -- i)

Returns how many seconds the connection has been idle. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONDESCR

 condescr ( i -- i )

Takes a connection number and returns the descriptor number associated with it. (Requires Mucker Level 3) See also DESCRIPTORS, DESCRCON.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONHOST

 conhost (i -- s)

Returns the hostname of the connection. (wizbit only)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONBOOT

 conboot (i -- )

Takes a connection number and disconnects that connection from the server. Basically @boot for a specific connection. (wizbit only)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CONNOTIFY

 connotify (i s -- )

Sends a string to a specific connection to the server. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DESCRCON

 descrcon (i -- i)

Takes a descriptor and returns the associated connection number, or 0 if no match was found. See also DESCRIPTORS, CONDESCR. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NEXTDESCR

 nextdescr (i -- i)

Takes a descriptor number, and returns the next connected descriptor number. To get the first descriptor number, use '1 condescr'. Between these, you can step through the descriptors list. If you try to use nextdescr on an invalid descriptor, it will return 0. If you have reached the end of the descriptor list, it returns 0. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DESCRIPTORS

 descriptors (d -- ix...i1 i)

Takes a player dbref, or #-1, and returns the range of descriptor numbers associated with that dbref (or all for #-1) with their count on top. Descriptors are numbers that always stay the same for a connection, while a connection# is the relative position in the WHO list of a connection. See also DESCRCON, CONDESCR.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PID

 pid ( -- i)

Returns the process ID of the program that is currently running.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ISPID?

 ispid? (i -- i)

Takes a process id and checks to see if an event with that pid is in the timequeue. It returns 1 if it is, and 0 if it is not. ispid? will also return 1 if the given process id is that of the currently running program. This primitive requires at least mucker level 3.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NEXTPROP

 nextprop (d s -- s)

This takes a dbref and a string that is the full propdir pathname of a property and returns the full pathname of the next property in the given object's given propdir, or returns a null string if that was the last property in the propdir. To *start* the search, give it a propdir name ending in a '/', or a blank string.

For example, '#10 "/" NEXTPROP' returns the name of the first property in the root propdir of object #10, and '#28 "/letters/" NEXTPROP' would return the name of the first property in the 'letters/' propdir on object #28. A blank string is the same as "/". If you try to do a Nextprop on a non-existant property, you will have a null string returned to you. Nextprop will skip properties if they would not be readable by the program with the given permissions and effective user id. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

PROPDIR?

 propdir? (d s -- i)

Takes a dbref and a property name, and returns a boolean integer that tells if that property is a propdir that contains other props. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

ENVPROPSTR

envpropstr (d s -- d s )

Takes a starting object dbref and a property name and searches down the environment tree from that object for a property with the given name. If the property isn't found, it returns #-1 and a null string. If the property is found, it will return the dbref of the object it was found on, and the string value it contained.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

NOTIFY_EXCLUDE

notify_exclude (d dn ... d1 n s -- )

Displays the message s to all the players (or _listening objects), excluding the n given players, in the given room. For example: 

  #0 #1 #23 #7 3 "Hi!" notify_exclude
would send "Hi!" to everyone in room #0 except for players (or objects) #1, #7, and #23. _listener's will not be triggered by a notify_exclude if the program they would run is the same as the current program running.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TIMEFMT

 timefmt (s i -- s)

Takes a format string and a SYSTIME integer and returns a string formatted with the time. The format string is ascii text with formatting commands:

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SLEEP

 sleep (i -- )

Makes the program pause here for 'i' seconds. the value of i cannot be negative. If the sleep is for more than 0 seconds, then the program may not thereafter use the READ primitive.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

QUEUE

 queue (i d s -- i)

Takes a time in seconds, a program's dbref, and a parameter string. It will execute the given program with the given string as the only string on the stack, after a delay of the given number of second. Returns the pid of the queued process, or 0 if the timequeue was full. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

FORK

 fork ( -- i)

This primitive forks off a BACKGROUND (muf) process from the currently running program. It returns the pid of the child process to the parent process, and returns a 0 to the child. If the timequeue was full, then it returns a -1 to the parent process, and there is no child process. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

KILL

 kill (i -- i)

Attempts to kill the process referred to by the given process ID. Returns 1 if the process existed, and 0 if it didn't. (Requires Mucker Level 3)

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TOUPPER

toupper (s -- s)

Takes a string and returns it with all the letters in uppercase.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TOLOWER

tolower (s -- s)

Takes a string and returns it with all the letters in lowercase.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRIPLEAD

 striplead (s -- s)

Strips leading spaces from the given string.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRIPTAIL

striptail (s -- s)

Strips trailing spaces from the given string.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

STRIP

 strip (s -- s)

This is a built in $define. It is interpreted as "striplead striptail" It strips the spaces from both ends of a string.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SMATCH

 smatch ( s s2 -- i )

Takes a string s, and a string pattern, s2, to check against. Returns true if the string fits the pattern. This is case insensitive. In the pattern string, the following special characters will do as follows:

Example patterns:

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

SETLOCKSTR

 setlockstr (d s -- i)

Tries to set the lock on the given object to the lock expression given in the string. If it was a success, then it will return a 1, otherwise, if the lock expression was bad, it returns a 0. To unlock an object, set its lock to a null string.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

GETLOCKSTR

getlockstr ( d -- s )

Returns the lock expression for the given object in the form of a string. Returns "*UNLOCKED*" if the object doesn't have a lock set.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

LOCKED?

locked? (d d -- i)

Takes, in order, the dbref of the player to test the lock against, and the dbref of object the lock is on. It tests the lock, running programs as necessary, and returns a integer of 0 if it is not locked against them, or 1 if it is.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

UNPARSEOBJ

unparseobj ( d -- s )

Returns the name-and-flag string for an object. It always has the dbref and flag string after the name, even if the player doesn't control the object. For example: "One(#1PW)"

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

DBTOP

 dbtop ( -- d)

Returns the dbref of the first object beyond the top object of the database. 'dbtop ok?' would return a false value.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

VERSION

 version ( -- s)

Returns the version of this code in a string. "Muck2.2fb4.0", currently.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

TRIG

 trig ( -- d)

Returns the dbref of the original trigger.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

CALLER

 caller ( -- d)

Returns the dbref of the program that called this one, or the dbref of the trigger, if this wasn't called by a program.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

BITOR

 bitor (i i -- i)

Does a mathematical bitwise or.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

BITXOR

 bitxor (i i -- i)

Does a mathematical bitwise exclusive or.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

BUNNY

 Easter Egg!

Do 'man bunny' and find out for yourself! -- Telzey

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

BITAND

 bitand (i i -- i)

Does a mathematical bitwise and.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

BITSHIFT

 bitshift (i i -- i)

Shifts the first integer by the second integer's number of bit positions. Same as the C << operator. If the second integer is negative, its like >>.

Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

BITAND

 I'm not sure what the authors are talking about here. The only reference to "bitnot" in the FB5.31 documentation is in the
  • MUF Primitives listing. I presume the listing for this primitive should be:

    bitand (i -- i)

    Does a mathematical bitwise not.

    Although this is merely my own guess. -- Telzey

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    FORCE

     force (d s -- )

    Forces player d to do action s as if they were @forced. (wizbit only)

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PREEMPT

     preempt ( -- )

    Prevents a program from being swapped out to do multitasking. Needed in some cases to protect crutial data from being changed while it is being worked on. A program will remain in preempt mode until it's execution is completed. Basically what this command does is to turn off multitasking, but then you have a limit on how many instructions you can run without needing either to pause with a SLEEP, or have a wizbit on the program. See also, MULTITASKING.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    FOREGROUND

    foreground ( -- )

    To turn on multitasking, you can issue a foreground command. While a program is in foreground mode, the server will be multitasking and handling multiple programs at once, and input from other users, but it will be blocking any input from the user of the program until the program finishes. You cannot foreground a program once it is running in the background. A program will stay in foreground mode until it finishes running or until you change the mode. See also, MULTITASKING.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    BACKGROUND

    background ( -- )

    Another way to turn on multitasking is to use the background command. Programs in the background let the program user go on and be able to do other things while waiting for the program to finish. You cannot use the READ command in a background program. Once a program is put into background mode, you cannot set it into foreground or preempt mode. A program will remain in the background until it finishes execution. See also, MULTITASKING.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    BEGIN

     begin ( -- )

    Marks the beginning of begin-until or begin-repeat loops. See also, LOOPS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    UNTIL

     until (i -- )

    If the value on top of the stack is false, then it jumps execution back to the instruction after the matching BEGIN statement. (BEGIN-UNTIL, BEGIN-REPEAT, and IF-ELSE-THEN's can all be nested as much as you want.) If the value is true, it exits the loop, and executes the next instruction, following the UNTIL. Marks the end of the current loop. See also, LOOPS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    REPEAT

     repeat ( -- )

    Jumps execution to the instruction after the BEGIN in a BEGIN-REPEAT loop. Marks the end of the current loop. See also, LOOPS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    WHILE

     while (i -- )

    If the value on top of the stack is false, then this causes execution to jump to the instruction after the UNTIL or REPEAT for the current loop. If the value is true, however, execution falls through to the instruction after the WHILE. See also, LOOPS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    BREAK

     break ( -- )

    Breaks out of the innermost loop. Jumps execution to the instruction after the UNTIL or REPEAT for the current loop. See also, LOOPS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    CONTINUE

     continue ( -- )

    Jumps execution to the beginning of the current loop. See also, LOOPS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    INSTRING

     instring ( s s1 -- i )

    Returns the first occurrence of string s1 in string s, or 0 if s1 is not found. Non-case sensitive. This is an inserver define to 'tolower swap tolower swap instr'. See also RINSTRING, INSTR, and RINSTR.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    RINSTRING

     rinstring ( s s1 -- i )

    Returns the last occurrence of string s1 in string s, or -1 if s1 is not found. Non-case sensitive. This is an inserver define to 'tolower swap tolower swap rinstr'. See also INSTRING, INSTR, and RINSTR.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    MLEVEL

     mlevel (d -- i)

    returns the mucker (or priority) level of the given object. Also see MUCKER LEVELS.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PUT

     put ( nx...n1 ni i -- nx...ni...n1 )

    Replaces the i'th thing from the top of the stack with the value of ni. 1 put is equivalent to swap pop Example: 

       "a" "b" "c" "d" "e" 3 put
    would return on the stack: 
       "a", "e", "c", "d"

    Return to the TinyMUCK P, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    ABORT

     abort ( s -- )

    Aborts the MUF program with an error. ie: '"Bad vibes." abort' would Stop the MUF program and tell the user a message like: 

       Programmer error.  Please tell Revar the following message:
   #1234 (line 23) ABORT: Bad vibes.

    Return to the TinyMUCK P, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    CHECKARGS

     checkargs (??? s -- )

    Takes a string argument that contains an expression that is used to test the arguments on the stack below the given string. If they do not match what the expression says should be there, then it aborts the running program with an appropriate Program Error Message. The expression is formed from single character argument tests that refer to different argument types. The tests are:

    Tests can be repeated multiple times by following the test with a number. ie: '"i12" checkargs' would test the stack for 12 integers.

    The last test in the string expression will be done on the top stack item. Tests are done from the top of the stack down, in order, so the last test that fails in a string expression will be the one that the Program Error will be given for. ie: '"sdSi" checkargs' will test that the top stack item is an integer, then it tests that the next item down is a non-null string, then it tests the third item from the top to see if it is a dbref, and lastly it tests to make sure that the 4th item from the top is a string.

    Spaces are ignored, so "s d i" is the same as "sdi". However, multipliers are ignored if they follow a space, so "s 4d i" is also the same as "sdi". This is because you are basically telling it to repeat the space 4 times, and since spaces are ignored, it has no effect.

    If you have a function that takes a stack item of any type, you can use the "" test. "" will match a string, integer, dbref, or any other type.

    Since sometimes arguments are passed in ranges, such as the way that the explode primitive returns multiple strings with an integer count on top, there is a way to group arguments, to show that you expect to recieve a range of that type. ie: '"{s}" checkargs' would test the stack for a set of strings like '"first" "second" "third" "fourth" 4' where the top stack item tells how many strings to expect within the range.

    Sometimes a function takes a range of paired arguments, such as: '"one" 1 "two" 2 "three" 3 "four" 4 4' where the count on the top of the range refers to the number of pairs. To test for the range given above, you would use '"{si}" checkargs' to tell it that you want to check for a range of paired strings and integers. You can group as many argument tests together in a range as you would like. ie: you could use "{sida}" as an expression to test for a range of related strings, integers, dbrefs, and function addresses.

    Since the argument multipliers refer to the previous test OR range, you can test for two string ranges with the test '"{s}2" checkargs'. ie: It would succeed on a stack of: '"one" "two" "three" 3 "four" "five" 2'. '"{s2}" checkargs', however, would test for one range of paired strings. ie: It would succeed with a stack of: '"one" "1" "two" "2" "three" "3" 3'.

    If, for some reason, you need to pass a range of ranges to a function, you can test for it by nesting the braces. ie: '"{{s}}" checkargs'

    Now, as one last example, the primitive notify_exclude, if we were to test the arguments passed to it manually, would use the test '"R{p}s" checkargs' to test for a valid room dbref, a range of player dbrefs or #-1s, and a string.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    DATE

     date ( -- i i i)

    Returns the monthday, month, and year. ie: if it were February 6, 1992, date would return 6 2 1992 as three integers on the stack.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    GMTOFFSET

     gmtoffset ( -- i)

    Returns the machine's offset from Greenwich Mean Time in seconds.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    STRINGPFX

     stringpfx (s s2 -- i)

    Returns 1 if string s2 is a prefix of string s. If s2 is NOT a prefix of s, then it returns 0. Case insensitive.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PART_PMATCH

     part_pmatch (s -- d)

    Takes a player name, or the first part of the name, and matches it against the names of the players who are currently online. If the given string is a prefix of the name of a player who is online, then their dbref is returned. If two players could be matched by the given string, it returns a #-2. If None of the players online match, then it returns a #-1.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    MODE

     mode ( -- i)

    Returns an integer denoting the current multitasking mode. This ignores BOUND bits on programs. The integer this returns will be the same as one of those defined by the standard $defines bg_mode, fg_mode, and pr_mode, being background, foreground, and preempt mode, respectively. See also PR_MODE.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    SETMODE

     setmode (i -- )

    Sets the current multitasking mode to the given mode. The integer this uses will be the same as one of those defined by the standard $defines bg_mode, fg_mode, and pr_mode, being background, foreground, and preempt mode, respectively. Programs set BOUND will run PREEMPT, ignoring this mode. See also PR_MODE.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PR_MODE or FG_MODE or BG_MODE

    pr_mode ( -- i)

    fg_mode ( -- i)

    bg_mode ( -- i)

    These are all standard built in defines. They are used with MODE and SETMODE to show what mode the program is running in, or to set what mode it will run in. For example, MODE returns an integer on the stack, that you can compare against pr_mode, fg_mode, or bg_mode, to determine what mode the program is in. pr_mode is defined as 0, fg_mode is defined as 1, and bg_mode is defined as 2.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    ADDRESS?

     address? (? -- i)

    Returns true if the top stack item is a function address.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    LOCK?

     lock? (? -- i)

    Returns true if the top stack item is a lock. See Also GETPROP, SETPROP, PARSELOCK, UNPARSELOCK, PRETTYLOCK, and TESTLOCK.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    GETPROP

     getprop (d s -- ?)

    Gets the value of a given property, and puts it on the stack. This can return a lock, a string, a dbref, or an integer, depending on the type of the property. Permissions are the same as those for GETPROPSTR. This primitive returns 0 if no such property exists, of if it is a valueless propdir. See also SETPROP, ADDPROP, REMOVE_PROP, GETPROPSTR, GETPROPVAL, INT?, DBREF?, STRING?, and LOCK?.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    SETPROP

     setprop (d s ? -- )

    Stores a lock, dbref, integer, or string into the named property on the given object. Permissions are the same as for ADDPROP. See also SETPROP, ADDPROP, REMOVE_PROP, GETPROPSTR, and GETPROPVAL.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PARSELOCK

     parselock (s -- l)

    Parses a lock string into a lock. If the parsing failed, then the lock returned will be a TRUE_BOOLEXP, which is logically false to an 'if' test. See also UNPARSELOCK, LOCK?, PRETTYLOCK, TESTLOCK, GETLOCKSTR, SETLOCKSTR, and LOCKED?.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    UNPARSELOCK

     unparselock (l -- s)

    Unparses a lock into a string fit for program editing. See also LOCK?, PARSELOCK, PRETTYLOCK, TESTLOCK, GETLOCKSTR, SETLOCKSTR, and LOCKED?.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PRETTYLOCK

     prettylock (l -- s)

    Unparses a lock into a string fit for players to see. See also LOCK?, PARSELOCK, UNPARSELOCK, TESTLOCK, GETLOCKSTR, SETLOCKSTR, and LOCKED?.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    TESTLOCK

     testlock (l d -- i)

    Tests the player against the given lock. If the test was successful, then this returns a 1. If the test failed, then this returns a 0. See also LOCK?, PARSELOCK, UNPARSELOCK, PRETTYLOCK, GETLOCKSTR, SETLOCKSTR, and LOCKED?

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    PARSEPROP

     parseprop (d s s i -- s)

    Returns the string output of the MPI Parser, given an object, a property name to parse, an input string for the {&how} variable, and an integer that should either be 1, for when you want {delay} messages to be sent to the player only, or 0, when you want the rest of the players in the room to get the omessages. NOTE: for security reasons, you cannot use PARSEPROP with a mucker level of less than 3.

    Return to the TinyMUCK Page, the MUF Manual Index, the Primitives Index, or the Alphabetic Index.

    JMP

     jmp ( a -- )

    The JMP Muf primitive takes an address like those supplied by 'funcname and moves execution to that point. It's one early way that was used to do tail-recursion loops without as much overhead, and without failing due to system stack overflows. It's mostly obsolete now, except that it's one of the three or four internal primitives used to implement if-else-then and begin-while-repeat loops and such.

    Example of JMP as a tail-recursion optimization: 

        : countforever ( i -- )
	1 +
	dup intostr .tell
	'countforever jmp
    ;

    How MUF uses JMP internally to implement if-else-then. 

      The following line of MUF:
    random 2 % if "a" else "b" then me @ swap notify

  Is implemented internally like:
    1: Primitive: RANDOM
    2: Integer:   2
    3: Primitive: %
    4: Address:   Step 9       (address of instruction after ELSE)
    5: Primitive: IF           (basically a branch-if-zero command)
    6: String:    "a"
    7: Address:   Step 10      (address of instruction after THEN)
    8: Primitive: JMP          (Unconditional branch to implement ELSE)
    9: String:    "b"
   10: Variable:  0            (me global variable)
   11: Primitive: @
   12: Primitive: SWAP
   13: Primitive: NOTIFY
    Return to the TinyMUCK Page

    Page created by Telzey, and maintained by Tugrik d'Itichi.
    Comments/Questions/Flames to: FMPages@furry.com