Go to the first, previous, next, last section, table of contents.


The MOO Editor

One can always enter an editor by teleporting to it, or you can use one of the commands provided

@edit object:verb
invokes the Verb Editor (edits verb code)
@notedit note_object
invokes the Note Editor (edits note text)
@notedit object.prop
invokes the Note Editor (edits text property)
@send list of recipients
invokes the Mailer (edits a mail message)
@answer [msg_number] [flags...]
invokes the Mailer (edits a reply)

This will transport you to one of several special rooms that have editing commands available. These editors are admittedly not as good as EMACS, but for those with no other editing capability on their host systems, it is better than nothing. In addition to the commands provided by the generic editor, individual editors provide their own additional commands for loading text from places, saving text to places, and various specialized functions. Note that a given editor only allows you one session at a time (ie. one verb, one note, or one mail message). If you leave an editor without either aborting or compiling/saving/sending the item you're working on, that editor remembers what you are doing next time you enter it, whether you enter it by teleporting or by using the appropriate command. Note that editors are periodically flushed so if you leave stuff there for sufficiently long, it will go away. A player may have his own .edit_options property which is a list containing one or more (string) flags from the following list

quiet_insert
suppresses those annoying `Line n added.' or `Appended...' messages that one gets in response to `say' or `emote'. This is useful if you're entering a long list of lines, perhaps via some macro on your client, and you don't want to see an equally long list of `Line n added...' messages. What you do want, however is some indication that this all got through, which is why the `.' command is an abbreviation for insert.

There will be more options, some day.

Editor Ranges

Most editor commands act upon a particular range of lines. Essentially, one needs to specify a first line and a last line. Line numbers may be given in any of the following forms

n
(i.e., the nth line of text)
n^
n-th line after/below the current insertion point
n_
n-th line before/above the current insertion point
n$
n-th line before the end.

In the latter three, n defaults to 1, so that `^' by itself refers to the line below the current (i.e., the line that gets `^' printed before it), and likewise for `_' while `$' refers to the last line. Note that the usage depends on whether you are specifying a line or an insertion point (space between lines). `^5' is the space above/before line 5, while `5^' is the fifth line after/below the current insertion point. Ranges of lines may be specified in any of the following ways:

line
just that line
from line to line
what it says; the following two forms are equivalent:
line-line            
line line

With the `from l to l' form, either the from or the to can be left off and it will default to whatever is usual for that command (usually a line above or below the insertion point).

Editor Commands

The following commands are provided by the editor classes. Those that are not generic are specifically marked so.

Command: say text
Command: "text
Adds text to whatever you are editing. The second form is equivalent to the first except in that it doesn't strip leading blanks off of text (just as with the normal `say' and `"' commands). The added text appears as a new line at the insertion point. The insertion point, in turn, gets moved so as to be after the added text. For example:
>"first line
-|Line 1 added.

>"  second line"
-|Line 2 added.

>list
-|1: first line
-|__2_   second line"
-|^^^^

Command: emote text
Command: :text
Appends text to the end of the line before the insertion point. The second form is equivalent to the first except that it doesn't strip leading blanks off of text (just as with the normal `emote' and `:' commands). The insertion point is left unmoved.
>list .
-|_37_ Hello there
-|^38^ Oh, I'm fine.

>:, how are you
-|Appended to line 37.

>:?
-|Appended to line 37.

>list .
-|_37_ Hello there, how are you?
-|^38^ Oh, I'm fine.

Command: lis*t [range]
Prints some subset of the current verb text. The default range is some reasonable collection of lines around the current insertion point: currently this is `8_-8^', ie., 8 lines above the insertion point to 8 lines below it unless this runs up against the beginning or end of file, in which case we just take the first or last 16 lines, or just `1-$' if there aren't that many.
Command: ins*ert [ins] ["text]
Command: .
Many editor commands refer to an "insertion point" which is (usually) the place right below where the most recent line was inserted. The insertion point should really be thought of as sitting between lines. In listings, the line above the insertion point is marked with `_' while the one below is marked with `^'. The `insert' command, when given an argument, sets the insertion point. If text is provided, a new line will be created and inserted as with `say'. ins, both here and in other commands that require specifying an insertion point (e.g., copy/move), can be one of
^n
above line n
n
above line n
_n
below line n
$
at the end
^$
before the last line
n^$
n lines before the end
.
the current insertion point (i.e., `insert .' is a no-op)
+n
n lines below the current insertion point.
-n
n lines above the current insertion point.

For the truly perverse, there are other combinations that also work due to artifacts of the parsing process, but these might go away... A single dot `.' is the same as `insert' without any arguments ie, start insertion at the current insertion point.

Command: n*ext [n] ["text]
Moves the insertion point down n lines. If text is provided, inserts a new line there just like `say'. Equivalent to `insert +n'. As one might expect, n defaults to 1.
Command: p*rev [n] ["text]
Moves the insertion point up n lines. If text is provided, a new line is inserted as with `say'. Equivalent to `insert -n'. As one might expect, n defaults to 1.
Command: del*ete [range]
Deletes the specified range of lines. Note that range defaults to the line before the current insertion point.
Command: f*ind / str[/[c][ins]]
Command: / str[/[c][ins]]
Searches for the first line after ins containing str. ins defaults to the current insertion point . With the first form, any character (not just `/') may be used as a delimiter. For the second form, you must use `/'. The `c' flag, if given, indicates that case is to be ignored while searching
Command: s*ubst / str1 / str2[/[g][c][range]]
Substitutes str2 for str1, in all of the lines of range. Any character (not just `/') may be used to delimit the strings. If str1 is blank, str2 is inserted at the beginning of the line. (For inserting a string at the end of a line use `emote' or `:'). Normally, only one substitution is done per line in the specified range, but if the `g' flag is given, *all* instances of str1 are replaced. The `c' flag indicates that case is not significant when searching for substitution instances. range defaults to the line *before* the insertion point. You do not need a space between the verb and the delimiter before str1. [Bug: If you omit the space and the first whitespace in str1 is a run of more than one space, those spaces get treated as one.]
Command: m*ove [range] to ins
5Moves the range of lines to place specified by ins. If ins happens to be the current insertion point, the insertion point is moved to the end of the freshly moved lines. If the range of lines contains the insertion point, the insertion point is carried over to the range's new location.
Command: c*opy [range] to ins
Copies the specified range of lines to place given by ins. If ins happens to be the current insertion point, the insertion point moves to the end of the inserted lines.
Command: join [range]
Command: joinliteral [range]
This command combines the lines in the specified range. Normally, spaces are inserted and double space appears after periods and colons, but `joinliteral' (abbreviates to `joinl') supresses this and joins the lines as is. range defaults to the two lines surrounding the insertion point.
Command: fill [range] [@ c]
This command combines the specified lines as in join and then splits them so that no line is more than c characters (except in cases of pathological lines with very long words). c defaults to 70. range defaults to the single line preceding the insertion point.
Command: w*hat
Prints information about the editing session.
Command: abort
Abandons this editing session and any changes.
Command: q*uit
Command: done
Command: pause
Leaves the editor. If you have unsaved text it will be there when you return (and in fact you will not be able to do anything else with this editor until you `abort' or save the text).
Command: reply-to [recipients]
This is a mail room command. It reports the current contents of the Reply-to: field of your message. With arguments, adds (or changes) the Reply-to: field. When someone `@answers' a message, the Reply-to: field is checked first when determining to whom the reply should be sent. To clear the Reply-to: field, enter the command
reply-to ""

Command: edit object:verb
This is a verb editor command. It changes what verb you are editing and loads the code for that verb into the editor. Equivalent to
@edit object:verb.

Command: edit note-object
Command: edit object.property
This command is used for both note and verb editors. It changes to a different note or a different object text property and loads its text into the editor. These are equivalent to
@notedit note

or

@notedit object.property

respectively. For both the verb-editor and note-editor commands, object will match on the room you came from, though if the room you came from was another editor, then all bets are off...

Command: compile [as object:verb]
This is a verb editor command. It installs the new program into the system if there are no syntax errors. If a new object:verb is specified and actually turns out to exist, that object:verb becomes the default for subsequent compilations.
Command: save [note-object]
Command: save [object.property]
This is a note editor command. It installs the freshly edited text. If note or object.property is specified, text is installed on that note or property instead of the original one. In addition the new note or property becomes the default for future save commands.
Command: subj*ect [text]
This is a mail editor command. It is used to specify a Subject: line for your message. If text is "", the Subject: line is removed.
Command: to [recipients]
This is a mail editor command. Specifies a new set of recipients (the To: line) for your message. Recipient names not beginning with * are matched against the list of players. Recipient names beginning with * are interpreted as mailing-lists/archives/other types of non-person addresses and are matched against all such publically available objects. If the list you want to use isn't in the database (i.e., isn't located in the database ($mail_agent)) you need to refer to it by object id.
Command: also-to [recipients]
This is a mail editor command. Adds additional recipients to the To: line of your message. Same rules apply as for the `to' command.
Command: pri*nt
This is a mail editor command. Print your message as it is going to appear at the far end.
Command: send
This is a mail editor command. Send your message and exit the mail room. If there are bogus addresses on your To: line, the message will not be sent. It may be, however, that valid addresses on your To: line will forward to other addresses that are bogus; you'll receive warnings about these, but in this case your message will still be delivered to those addresses that are valid.
Command: who
Command: who rcpt...
This is a mail editor command. Invokes $mail_agent's mail-forwarding tracer and determines who (or what) is actually going to receive your message. The resulting list will not include destinations that will simply forward the message without :receive_message()'ing a copy for themselves. The second form expands an arbitrary list of recipients, for if e.g., you're curious about the members of particular mailing list.
Command: showlists
This is a mail editor command used to print a list of the publically available mailing lists or archives and other non-player entities that can receive mail.
Command: subscribe to list-name
Command: subscribe [name...] to list-name
This is a mail room command. Add yourself to the given mailing list. The second form adds arbitrary people to a mailing list. You can only do this if you own the list or if it is listed as [Public] and you own whatever is being added. Use the `who' command to determine if you are on a given mailing list.
Command: unsubscribe from list-name
Command: unsubscribe name... from list-name
This is a mail room command. It is used to remove yourself from the given mailing list. The second form removes arbitrary people from a mailing list. You can only do this if you own whatever is being removed or you own the list. You can use the `who' command to determine if you are on a given mailing list.


Go to the first, previous, next, last section, table of contents.