# ALPHA-TEST release of LambdaMOO version 1.8.0alpha1

Pavel Curtis (pavel@parc.xerox.com)
Wed, 29 Nov 1995 21:07:28 PST

- Messages sorted by:[ date ][ thread ][ subject ][ author ]

    I have made an *alpha-test* release of version 1.8.0 of the LambdaMOO server in
    the usual place:

    	ftp://ftp.parc.xerox.com/pub/MOO/LambdaMOO-1.8.0alpha1.tar.Z

    Here's what the README file says about this release:

    -------------------------------------------------------------------------------
    This is an ALPHA release of version 1.8.0 of the LambdaMOO server.  It is
    almost certainly full of really nasty bugs that could crash your server, lose
    your database changes, or perhaps ever corrupt your database completely beyond
    repair.  It contains perhaps an unprecedented amount of completely new code,
    including versions of the database and decompilation modules that were
    rewritten from scratch for this release.  Even the simplest, previously most
    stable features may contain fatal bugs in this release; for example, during
    recent random testing, I found server-crashing bugs in create() and
    delete_verb().

    I do *not* recommend that you use this release in a production setting at the
    current time.  I *do* request that you try out as much as possible of both your
    existing code and the various new features in this release; let the community
    know (via the MOO-Cows@Xerox.Com mailing list) of any problems you encounter.

    Thanks for your assistance.

    	Pavel
    -------------------------------------------------------------------------------

    As you might ascertain from the above, I expect folks to find a lot of basty
    bugs in this release; please send your bug reports to the main MOO-Cows mailing
    list so that everyone can stay informed and we can perhaps thereby cut down on
    useless duplication of bug reporting.

    I expect to make more than one test release before the final,
    production-approved one.  For particularly nasty reported bugs, I will either
    make another test release containing the fix or else send out a patch;
    announcements of new test releases will be made to MOO-Cows-Announce, but all
    test-release patches will just be posted to the main MOO-Cows list, to reduce
    the amount of noise on the -Announce list.

    PLEASE NOTE: If you ignore all of my warnings and run this release (or any
    other test release) in a production setting, and if that causes you significant
    problems, I'm going to consider it `evolution in action' and claim that you
    deserve what you get.  I don't have time to help people so clueless right now.

    Here's the ChangeLog.txt entry for this release:
    -------------------------------------------------------------------------------
    Version 1.8.0alpha1, 29 November 1995
    -- Much internal cleanup, especially surrounding the interface between the DB
       module and the rest of the server.
    -- Added an optional argument to the built-in function callers(); if provided
       and true, each element of the returned value will have a sixth element, the
       currently executing line number of the corresponding verb.
    -- Added new facilities for raising and handling MOO errors, as described in
       the next four points.
    -- Added built-in function `raise(CODE [, MSG [, VALUE]])' where CODE can be
       any MOO value (*not* just one of type ERR), MSG defaults to `tostr(CODE)',
       and VALUE defaults to 0.  This raises CODE as an error, just like dividing
       by zero raises E_DIV.  If the error is not caught (by one of the other new
       constructs described below), then MSG will appear on the first line of the
       resulting traceback printed to the user.  VALUE is accessible to an error
       handler established by the new TRY-EXCEPT-ENDTRY construct; see below.
    -- Added new error-catching expression:
    		`EXPR ! CODES => EXPR_H'
       NOTE: The open- and close-quotation marks in the previous line are really
       part of the syntax!
          In this new expression, EXPR and EXPR_H are arbitrary expressions.  CODES
       is either the new keyword "ANY" or a non-empty "argument list" of
       expressions; just like normal argument lists, CODES can contain "@"-marked
       expressions that evaluate to lists to be spliced into the resulting list of
       error codes.  The "=> EXPR_H" part is optional.
          First, CODES is evaluated yielding a list of error codes that should be
       caught if raised; if CODES is "ANY", then it is equivalent to the list of
       all possible MOO values.
          Next, EXPR is evaluated.  If it evaluated normally, without raising an
       error, then its value becomes the value of the entire error-catching
       expression.   If evaluating EXPR results in an error being raised, then call
       it E.  If E is in the list resulting from CODES, then E is considered
       "caught" by this error-catching expression.  In such a case, if EXPR_H was
       given, it is evaluated to get the outcome of the entire error-catching
       expression; if EXPR_H was omitted, then E is the value of the entire
       expression.  If E is *not* in the list resulting from CODES, then this
       expression does not catch the error and it continues to be raised, possibly
       to be caught by some piece of code either surrounding this expression or
       higher up on the verb-call stack.
          Here are some examples:
    	`x + 1 ! E_TYPE => 0'
    		Returns x + 1 if x is a number, returns 0 if x is not a number,
    		and raises E_VARNF if x doesn't have a value.
    	`x.y ! E_PROPNF, E_PERM => 17'
    		Returns x.y if that doesn't cause an error, 17 if x doesn't
    		have a "y" property or that property isn't readable, and raises
    		some other kind of error (like E_INVIND) if x.y does.
    	`1 / 0 ! ANY'
    		Returns E_DIV.
    -- Added new error-catching statement:
    		TRY
    		  statements_0
    		EXCEPT id_1 (codes_1)
    		  statements_1
    		EXCEPT id_2 (codes_2)
    		  statements_2
    		ENDTRY
       The IDs are optional, CODES has the same syntax as above, and there can be
       anywhere from 1 to 255 EXCEPT clauses.
          First, each CODES is evaluated yielding a list of error codes that should
       be caught if raised; if any CODES is "ANY", then it is equivalent to the
       list of all possible MOO values.
          Next, STATEMENTS_0 is executed; if it doesn't raise an error, then that's
       all that happens for the entire TRY statement.  Otherwise, let E be the
       error it raises.  From top to bottom, E is searched for in the lists
       resulting from the various CODES_i; if it isn't found in any of them, then
       it continues to be raised, possibly to be caught by some piece of code
       either surrounding this TRY statement or higher up on the verb-call stack.
          If E is found first in CODES_i, then ID_i (if provided) assigned a value
       containing information about the error being raised and STATEMENTS_i is
       executed.  The value assigned to ID_i list a list of four elements:
    		{CODE, MSG, VALUE, TRACEBACK}
       where CODE is E, the error being raised, MSG and VALUE are as provided by
       the code that raised the error (built-in errors, such as division by zero,
       currently act as if the MSG and VALUE arguments to raise() were omitted),
       and TRACEBACK is a list like that returned by callers(), including line
       numbers.  The TRACEBACK list contains entries for every verb from the one
       that raised the error through the one containing this TRY statement.
          Here is an example:
    		try
    		  result = object:(command)(@arguments);
    		  player:tell("=> ", toliteral(result));
    		except v (ANY)
    		  tb = v[4];
    		  if (length(tb) == 1)
    		    player:tell("** Illegal command: ", v[2]);
    		  else
    		    top = tb[1];
    		    tb[1..1] = {};
    		    player:tell(top[1], ":", top[2], ", line ", top[6], ":",
    		                v[2]);
    		    for fr in (tb)
    		      player:tell("... called from ", fr[1], ":", fr[2],
    		                  ", line ", fr[6]);
    		    endfor
    		    player:tell("(End of traceback)");
    		  endif
    		endtry
    -- Added new error-cleanup statement:
    		TRY
    		  statements_0
    		FINALLY
    		  statements_1
    		ENDTRY
       STATEMENTS_0 is executed; if it completes without raising an error or
       returning from this verb, then STATEMENTS_1 is executed and that's
       all that happens for the entire TRY statement.  Otherwise, the process of
       raising the error past this point or returning from this verb (as
       appropriate) is interrupted and STATEMENTS_1 is executed.  If STATEMENTS_1
       itself completes without raising an error or returning from this verb, then
       the interrupted raising or returning process is resumed.  If STATEMENTS_1
       does return or raise an error, then the interrupted raising or returning
       process is simply forgotten in favor of the new one.
          In short, this statement ensures that STATEMENTS_1 is executed after
       control leaves STATEMENTS_0 for whatever reason; it can thus be used to make
       sure that some piece of cleanup code is run even if STATEMENTS_0 doesn't
       simply run normally to completion.
          Here's an example:
    		try
    		  start = time();
    		  object:(command)(@arguments);
    		finally
    		  end = time();
    		  this:charge_user_for_seconds(player, end - start);
    		endtry
    -- Completely rewrote the MOO-code decompiler, restructuring it to be able to
       cope with the new exception-handling constructs.
    -- Fixed bug in handling of EOF in emergency wizard mode; it is now treated as
       equivalent to the `quit' command.
    -- Added internal interfaces allowing built-in function implementations (a) to
       be notified when given file descriptors are readable/writable (see file
       net_multi.h), (b) to resume tasks that they earlier caused to suspend (see
       resume_task() in file tasks.h), and (c) to make it possible for their
       suspended tasks to be listed by queued_tasks() and killed by kill_task().
    -- Added a new, essentially empty module `extensions.c', intended to be easily
       replaced by users with a file of their own MOO extensions.  The file also
       contains some examples of extensions using all of the new internal
       interfaces.
    -- Clarification to change made in 1.7.9alpha1: $server_options.max_stack_depth
       can only be used to override DEFAULT_MAX_STACK_DEPTH if it *increases* the
       value.  This is good because (a) there probably aren't any good reasons to
       want to lower the limit, and (b) you could get good and screwed if you set
       it too low.
    -- Fixed match() and rmatch() to treat unrecognized escape sequences in
       patterns as if the `%' were not there.  Thus, `%X' in a pattern is now
       equivalent to simply `X', for all X not explicitly mentioned in the
       programmer's manual.
    -------------------------------------------------------------------------------