MOO-cows Mailing List Archive
[Prev][Next][Index][Thread]
ALPHA-TEST release of LambdaMOO version 1.8.0alpha1
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.
-------------------------------------------------------------------------------
Home |
Subject Index |
Thread Index