for elt in (biglist[first..last])
          ...
        endfor
     is
        handle = :start(biglist,first,last);
        while(handle)
          for elt in (handle[1])
            ...
          endfor
          handle = :next(@listdelete(handle,1));
        endwhile

:set_opened(newvalue)
opens/closes the container (updates .open and .dark) according to newvalue => newvalue or E_PERM

:is_openable_by(player)
what the :open command uses to test whether the player should be able to open the container. By default this refers to .open_key (set by @(un)lock_for_open), but the object owner is free to customize this.

Random notes about $error:

(1) The exit may be locked against the object, in which case we print the nogo messages and quit.

(2) (room=exit.dest):bless_for_entry(object) is called. Assuming that exit is recognized by room as being a legitimate entrance (i.e., is in room.entrances), this will enable room:accept(object) to return true.

(3) object:moveto(room) is called and the various messages (see `help exit-messages') are :announced/:told. Note that this, in accordance with the way the builtin move() (and hence the default :moveto()) works, we get a call to room:accept(object) which checks for the room itself being locked against the object, and otherwise returns true if the blessing in the previous step worked. The move is performed, here:exitfunc(object) and room:enterfunc(object) are called. In particular, room:enterfunc clears the blessing bestowed in (2) now that it is no longer needed.

say         <text>                      w*hat       
emote       <text>                      abort       
lis*t       [<range>] [nonum]           q*uit,done,pause 
ins*ert     [<ins>] ["<text>]           
n*ext,p*rev [n] ["<text>]               
del*ete     [<range>]                   
f*ind       /<str>[/[c][<range>]]       
s*ubst      /<str>1;/<str>2;[/[g][c][<range>]]
m*ove,c*opy [<range>] to <ins>          
join*l      [<range>]                   
fill        [<range>] [@<col>]          

You'll notice that nowhere does it say how to load in a given list of strings or how and where one may save said list away when one is done editing. These commands are supplied by the child editor object. The generic editor contains only the code for editing lines, though it defines additional functions for use by the children:

:loaded(player)
returns the index (player in this.active) iff text has been loaded from somewhere, otherwise returns 0.

Note that, by default, there is a difference between

        having nothing loaded                (:text(who)==0) and 
        having loaded something with no text (:text(who)=={}).

        @stateprop texts={} for <youreditor>

In all functions below, 'who' is the index returned by :loaded(player)

BTW, be careful about using 'player' in non-user (i.e., +x this-none-this) verbs --- much better to have the user verb get the index with :loaded() and then pass that around.

Also be careful about suspend() and verbs that call suspend(). In particular, the player's index in the .active list can change during the suspend interval, so you must be sure to obtain the index (e.g., using :loaded()) again after the suspend() returns.

For your non-user verbs, we have

:ok(who)
returns E_PERM if the caller is not an editor verb and E_RANGE if 'who' does not point to a valid session.

which should take care of the more egregious security holes (but maybe not the less egregious ones). For getting and loading text, we have

:text(who)
the current text string list or 0 if nothing loaded yet.

:load(who,text)
loads the given list of strings as the text to be edited. this also resets the 'changed' flag and pushes the insertion point to the end. and various flags and properties (all of the set_* routines return E_PERM when not called from an editor verb, E_RANGE if who is out of bounds, E_INVARG if something is wrong with the 2nd arg, or the new value, which may not necessarily be the same as the 2nd arg (e.g., set_insertion(..,37) on a 5 line text buffer returns 6).

:changed(who)
has the text been altered since the last save/load? (the child editor gets to define what "save" means).

:set_changed(who,value)
Any child editor command that is considered to save the text should do a

:set_changed(who,0).
Note that if the changed flag is 0, the session will be flushed when the player leaves the editor, so you may also want certain commands to do set_changed(who,1)...

:origin(who)
room where the player came from.

:set_origin(who,room)
can be used to change the room the player will return to when finished editing. Since origin gets set even in cases where the player teleports into the editor you probably won't usually need to do this.

:insertion(who)
current insertion point.

:set_insertion(who,linenumber)
linenumber needs to be a positive integer and will get

:readable(who)
whether the current editing session has been made globally readable.

:set_readable(who,boolean)
change the readability of the current editing session. This is used by the publish/perish verbs.

We also provide

:invoke(...)
If the player has a previous unsaved (i.e., :changed()!=0) session, we return to it, moving the player to the editor. If the player is already in the editor, this has no effect other than to print a few nasty messages. In any case a :changed() session must be aborted or set_changed(,0) before anything else can be started

Otherwise, we pass the arguments (which are assumed to be the result of some munging of the command line) to :parse_invoke(), move the player to the editor and load whatever parse_invoke() specified. The only interpretation the generic editor makes on the arguments is that if the boolean value of the first is true, this indicates that the player wanted to load something as opposed to resume a previous session. Usually a command calling :invoke will have a true (i.e., nonzero number, nonempty list or string) first arg iff the command line is nonempty, in which case 'args' works fine for this purpose.

If the command parses sucessfully (:parse_invoke() returns a list), we move the player to the editor if necessary and then call :init_session() to set things up.

The child editor is assumed to provide

:parse_invoke(...)
given :invoke()'s arguments, determines what the player wants to edit. It either returns 0 and reports syntax errors to player, or it returns some list that :init_session() will understand.

:init_session(who,@spec)
where spec is something that was returned by :parse_invoke(). Loads the text and sets the stateprops (below) to indicate that we are working on whatever it is we're suppose to be working on.

:working_on(who)
returns a string X as in "You are working on X." This is called by the 'w*hat' command, among other things.

Child editors may have their own properties giving state information for the various editing sessions. The value of each such property will be a list giving a value for each player in the editor. For each such property, you should, once the editor object has been created, initialize the property to {} and do one of

    @stateprop <propname>                 for <editor>
    @stateprop <propname>=<default-value> for <editor>
               (0 is the default <default-value>)

   if(!(who=this:loaded(player)))
        player:tell(nothing_loaded_msg());
   else
      ... various references to  this.<propname>[who] ...
   endif

    @rmstateprop <propname> from <editor>

Sometimes you may wish to @stateprop a new property on an editor where active editing sessions exist. @stateprop will fail if the property in question does not hold a list of the correct length (== length(editor.active); one value for each editing session). You need to either give the @flush command to clear out all sessions and boot all players currently in the editor or somehow manually initialize the property to a list of appropriate values and pray that nobody enters/exits the editor between the property initialization and the @stateprop command --- this problem can be avoided by doing an eval() that does all of the initializations (beware of suspends()) and calls :set_stateprops directly. Incidentally, the @flush command may be used at any time to clean out the editor or to remove all sessions older than a given date.

There are also numerous _msg properties that may be customized

    @depart            announced at the origin when :invoke() is called. 
    @return            announced at the origin the player is returned
	                   there.
    @nothing_loaded    printed when user attempts editing 
                       before anything has been loaded.
    @no_text           response to 'list' when :text()=={}
    @no_change         printed by 'what' when :changed()==0
    @change            printed by 'what' when :changed()==1
    @no_littering      printed upon leaving the editor with :changed()==1.
    @previous_session  printed by :invoke() when player tries to start a 
                       new session without aborting or saving the old one

. @create $generic_editor named <editor>

. define additional <editor> verbs/properties
At the very least you need 'edit' and 'save' commands.
Usually you can get away with just having 'edit' call :invoke();
Presumably, you'll need at least a command to load text from somewhere as well as a command to save it back out.

. define a verb (somewhere) to invoke the editor
This could be just a one-liner that calls <editor>:invoke(args,verb). Either that or

. you have to set up an exit somewhere whose destination is <editor>
. you have to advertise the object number so that people can teleport to it. . @stateprop x for <editor>

. if you want the 'abort' command to boot the player from the editor do <editor>.exit_on_abort = 1;

. set <editor>.commands to be the list of additional commands defined by <editor>.
Each element of the list is itself a list of the form {name,args}. set <editor>.commands2 to be the list of commands that should appear in the `look' listing, and should be a list of strings appearing as names in .commands on either <editor> or some editor ancestor. look at $verb_editor or $note_editor for an example.

One may however designate a wider range of possible values for an option "foo" by either installing one of

pkg.type_foo
    -- list of allowed types, 
       e.g., {NUM,STR}   => must be a number or a string
       e.g., {OBJ,{OBJ}} => must be an object or a list of objects
    for anything fancier use:

  pkg:check_foo(value)
    => string error message or {value munged as desired}

When presented with an option that is in .extras, :set will typecheck the value as described, however, then :actual(name, value) will be called to obtain a list of {name-of-real-option, value} pairs indicating which combination of real options should be set.

Other verbs
  pkg:parse(args,...)
    parses the command line arguments of a @whatever_option command
    => {optionname, value}  if the player wants to set an option
    => {optionname}         if the player wants to view an option
    => string error message  otherwise

  one may install pkg:parse_foo to parse arguments for option "foo" 
    !foo     => {"foo",0}  (:parse_foo not called)
    foo=     => {"foo",0}  (:parse_foo not called)
    -foo     => {"foo",0}  (:parse_foo not called)
    +foo     => pkg:parse_foo("foo",1)
    foo=word => pkg:parse_foo("foo","word")
    foo word1 word2    => pkg:parse_foo("foo",{"word1","word2"})
    foo is word1 word2 => pkg:parse_foo("foo",{"word1","word2"})

 pkg:show(options,name|list of names)
    => list of strings describing the current value of the named option(s).
       calls     pkg:show_foo(options,list of names) or
       refers to pkg.show_foo
       to describe option "foo"