#                   	@displayoptions     	mail                	regular-expressions
;                   	@egrep              	@measure            	@remove-feature
@add-feature        	errors              	options             	@rmproperty
@args               	eval                	precedence          	@rmverb
@check-chparent     	examine             	prepositions        	@setenv
@check-property     	expressions         	prog-index          	@show
@chmod              	features            	@prog-options       	statements
@chparent           	@forked             	@progoptions        	tasks
@clearproperty      	functions           	@program            	truth
@copy               	@grep               	.program            	utilities
@dbsize             	help                	@programmer-options 	utils
@disinherit         	@kids               	@programmeroptions  	@verb
@disown             	@kill               	programming         	
@display            	language            	@property           	
@display-options    	@list               	@prospectus         

If neither .<property>|.parent nor <code> is specified, just return <thing>.

If .<property> is named, return <thing>.<property>. .parent returns parent(<thing>).

If <code> is given, it is evaluated, with the value returned by the first part being substituted for %# in <code>.

For example, the command

	#JoeFeedback.parent player for tonum(%#)

Likewise you cannot chparent an object to a new parent if the new parent has a property that is also defined on the object or some descendant. Use @check-chparent to find out all instances of conflicting properties that would interfere with @chparent in this manner.

Note that @check-property requires either that you own the object or that it be writeable, the same conditions that need to hold if you are to create new properties on the object. Similarly, @check-chparent requires that you own the object and that the new parent is either fertile or likewise owned by you.

	<object-permissions>      r, w, f
    	<property-permissions>    r, w, c
    	<verb-permissions>        r, w, x, d

To clear all of the permissions for an object, verb, or property, use "" as the second argument.

@chmod also accepts +, !, and - as modifiers for a single permission to add or subtract that permission from the current set. (! and - are the same.)

Examples:

`@clearproperty' can be abbreviated as `@clearp'.

Example:

  @create #1 named foo
  You now have foo with object number #42 and parent Root Class (#1).
    [foo, as a child of #1 has a .description property which starts out clear]
  ;#1.description   => ""
  ;#1.description = "You see nothing special"
  => "You see nothing special"
  ;#42.description  
  => "You see nothing special"
  ;#42.description = "Something special"
  => "Something special"
   [foo.description is now no longer clear; it has a value of its own]
  ;#1.description = "Boring"
  => "Boring"
  ;#42.description  
  => "Something special"
   
  @clearp foo.description
  Property #42.description cleared; value is now "Boring".
   [foo.description is now clear again]
  ;#1.description = ""
  => ""
  ;#42.description
  => ""

Examples:
  @copy me:verbname to myobject
  @copy me:test_verb to myobject:real_verb

Both forms of this command chparent <object> to its grandparent, provided you own the parent. The second form matches the string you supply for <object> against the list of children of the given <parent>.

You may mix properties and verbs on the command line, but the parser may become confused. (E.g. @display object,: displays all properties including inherited ones plus all locally defined verbs on the object.)

Examples:
Individual property:
  @display poolsweep.count
  .count              		  yduJ (#68)            r c    8

Individual verb:
  @display poolsweep:tell
  #3560:tell                     yduJ (#68)           rxd    this none this

All properties, including one truncated value:
  @display poolsweep.
  poolsweep (#3560) [ readable ]
    Owned by yduJ (#68).
    Child of generic thing (#5).
    Location The Pool (#1428).
  .gagged        		yduJ (#68)            r c    0
  .count               		yduJ (#68)            r c    8
  .messages                	yduJ (#68)            r c    {"The poolsweep stir..
  .index                   	yduJ (#68)            r c    2
  .quantum                 	yduJ (#68)            r c    20

Inherited verbs, edited for brevity, showing verbs from various parents, with owners,
permissions, and argument lists.
  @d poolsweep;
  poolsweep (#3560) [ readable ]
      #3560:tell            yduJ (#68)           rxd    this none this
      #3560:description	    yduJ (#68)           rxd    this none this
      #5:"g*et t*ake"       Haakon (#2)          rxd    this none none
      #5:"d*rop th*row"     Haakon (#2)          rxd    this none none
      #5:moveto             Haakon (#2)          rxd    this none this
      #1:description        Haakon (#2)          rxd    this none this
      #1:look_self          Haakon (#2)          rxd    this none this

For programmers, this is such a mind-bogglingly useful thing to do that there is a simple abbreviation for this command; any command beginning with a semicolon (';') is treated as a use of 'eval'.

Eval treats specially a duplicated semicolon at the beginning. It enables you to make multi-statement programs within eval (but does not by default print the return value).

Eval-d (no ";" abbreviation for this) evaluates the following text exactly as eval, except that the "d" debug flag (see programmer's manual for explanation) is turned off. Thus errors will cause an error return value rather than a traceback.

If you set the player property .eval_time to 1, then eval will print out how many ticks and seconds the program required.

Examples:
   eval 3 + 4
   =>  7
   ;3+4
   =>  7
   ;for x in (player.aliases) player:tell(x); endfor
   Haakon
   Wizard
   ArchWizard
   =>  0
   ;;l = {}; for i in [1..10] l = {@l, i}; endfor return l
   =>  {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
   eval-d 8 + "foo"
   => E_TYPE  (Type mismatch)

Eval_env:    "me=player;here=player.location;"
eval_ticks:  3

        number
        # number
        # - number
        "character string"
        error-name

        { expression , expression , ... , expression }

        name

            OBJ, STR, LIST, ERR, NUM
            player, caller, this, verb, args
            argstr, dobj, dobjstr, prepstr, iobj, iobjstr

        expression . name
        expression . ( expression )
        $ name

        expression : name ( arguments )
        expression : ( expression ) ( arguments )

        function ( arguments )

        expression [ expression ]

        expression [ expression .. expression ]

        name = expression
        expression . name = expression
        expression . ( expression ) = expression
        $ name = expression

        expression + expression
        expression - expression
        expression * expression
        expression / expression
        expression % expression
        - expression

        expression == expression
        expression != expression
        expression  expression
        expression <= expression
        expression > expression
        expression >= expression

        expression ? expression | expression
        expression && expression
        expression || expression
        ! expression

        expression IN expression

Queue ID:
   A numeric identifier for the task, for use in killing it (see 'help @kill').

Start Time:
   The time after which the task will begin execution.

Owner:
   The player whose permissions under which the task is running.
   Unless you are a wizard, @forked will show only your tasks.

Verb:
   The object and verb-name of the code that forked the task.

Line:

  help object:verbname   -- prints any documentation strings that are present
                            at the beginning of the program for that verb.
  help $<whatever>_utils -- prints general information about one of the 
                            $..._utils objects (e.g., $string_utils, 
                            $list_utils, etc...), which are all libraries 
                            of generally used verbs.
  help builtin()         -- prints documentation from the programmers manual
                            about the named primitive, for example length()

Example:
  @kids #3107
  Generic Body of Chlorinated Water(#3107) has 3 kids.
  The Pool(#1428)   The Hot Tub(#388)   Deep Blue Underground Pool(#17340)

@kill task_id kills only the task with that id.

@kill object:verb kills all tasks which were scheduled by the object running the verb named. Both object and verb are optional: @kill object: kills all tasks scheduled by that object, and @kill :verb kills all tasks which were scheduled by any object running that verb. This can be useful if you have several similar objects which are running tasks from similarly named verbs. (Perversely, @kill : kills all tasks... Any object running any task.)

@kill soon kills all tasks scheduled within the next minute. @kill soon number kills all tasks scheduled within that number of seconds, e.g. @kill soon 300 would kill all tasks scheduled within the next five minutes. This can be useful if you have a runaway task you want to quickly remove, but don't want to kill you later tasks.

@kill all kills all tasks. Like @kill soon, but more dramatic.

@kill %trailing_id expects you to specify the last few digits of a task id. It then kills all tasks that end with those digits.

statements 	-- the syntax and semantics of the various kinds of MOO statements
expressions     -- the same for the various kinds of MOO expressions
functions 	-- a list of the primitive functions available to MOO programs

Normally, the code is shown with each line numbered and with only those parentheses that are necessary to show the meaning of the program. You can e.g., specify `without numbers' to have the numbers omitted or `with parentheses' to include all parentheses or even `with parentheses without numbers' to do both.

The 3rd form of the verb lists the verb matching the given dobj/prep/iobj specification if such exists.

Example:
  Type `@list $room:@move' to see the code for the `@move' command, or even
 `@list $prog:@list' to see the code implementing @list itself...

  @list frobule:burfle this in front of any without numbers