Mercurial > hg > xemacs-beta
comparison man/cl.texi @ 4677:8f1ee2d15784
Support full Common Lisp multiple values in C.
lisp/ChangeLog
2009-08-11 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el :
Update this file to support full C-level multiple values. This
involves:
-- Four new bytecodes, and special compiler functions to compile
multiple-value-call, multiple-value-list-internal, values,
values-list, and, since it now needs to pass back multiple values
and is a special form, throw.
-- There's a new compiler variable, byte-compile-checks-on-load,
which is a list of forms that are evaluated at the very start of a
file, with an error thrown if any of them give nil.
-- The header is now inserted *after* compilation, giving a chance
for the compilation process to influence what those checks
are. There is still a check done before compilation for non-ASCII
characters, to try to turn off dynamic docstrings if appopriate,
in `byte-compile-maybe-reset-coding'.
Space is reserved for checks; comments describing the version of
the byte compiler generating the file are inserted if space
remains for them.
* bytecomp.el (byte-compile-version):
Update this, we're a newer version of the byte compiler.
* byte-optimize.el (byte-optimize-funcall):
Correct a comment.
* bytecomp.el (byte-compile-lapcode):
Discard the arg with byte-multiple-value-call.
* bytecomp.el (byte-compile-checks-and-comments-space):
New variable, describe how many octets to reserve for checks at
the start of byte-compiled files.
* cl-compat.el:
Remove the fake multiple-value implementation. Have the functions
that use it use the real multiple-value implementation instead.
* cl-macs.el (cl-block-wrapper, cl-block-throw):
Revise the byte-compile properties of these symbols to work now
we've made throw into a special form; keep the byte-compile
properties as anonymous lambdas, since we don't have docstrings
for them.
* cl-macs.el (multiple-value-bind, multiple-value-setq)
(multiple-value-list, nth-value):
Update these functions to work with the C support for multiple
values.
* cl-macs.el (values):
Modify the setf handler for this to call
#'multiple-value-list-internal appropriately.
* cl-macs.el (cl-setf-do-store):
If the store form is a cons, treat it specially as wrapping the
store value.
* cl.el (cl-block-wrapper):
Make this an alias of #'and, not #'identity, since it needs to
pass back multiple values.
* cl.el (multiple-value-apply):
We no longer support this, mark it obsolete.
* lisp-mode.el (eval-interactive-verbose):
Remove a useless space in the docstring.
* lisp-mode.el (eval-interactive):
Update this function and its docstring. It now passes back a list,
basically wrapping any eval calls with multiple-value-list. This
allows multiple values to be printed by default in *scratch*.
* lisp-mode.el (prin1-list-as-multiple-values):
New function, printing a list as multiple values in the manner of
Bruno Haible's clisp, separating each entry with " ;\n".
* lisp-mode.el (eval-last-sexp):
Call #'prin1-list-as-multiple-values on the return value of
#'eval-interactive.
* lisp-mode.el (eval-defun):
Call #'prin1-list-as-multiple-values on the return value of
#'eval-interactive.
* mouse.el (mouse-eval-sexp):
Deal with lists corresponding to multiple values from
#'eval-interactive. Call #'cl-prettyprint, which is always
available, instead of sometimes calling #'pprint and sometimes
falling back to prin1.
* obsolete.el (obsolete-throw):
New function, called from eval.c when #'funcall encounters an
attempt to call #'throw (now a special form) as a function. Only
needed for compatibility with 21.4 byte-code.
man/ChangeLog addition:
2009-08-11 Aidan Kehoe <kehoea@parhasard.net>
* cl.texi (Organization):
Remove references to the obsolete multiple-value emulating code.
src/ChangeLog addition:
2009-08-11 Aidan Kehoe <kehoea@parhasard.net>
* bytecode.c (enum Opcode /* Byte codes */):
Add four new bytecodes, to deal with multiple values.
(POP_WITH_MULTIPLE_VALUES): New macro.
(POP): Modify this macro to ignore multiple values.
(DISCARD_PRESERVING_MULTIPLE_VALUES): New macro.
(DISCARD): Modify this macro to ignore multiple values.
(TOP_WITH_MULTIPLE_VALUES): New macro.
(TOP_ADDRESS): New macro.
(TOP): Modify this macro to ignore multiple values.
(TOP_LVALUE): New macro.
(Bcall): Ignore multiple values where appropriate.
(Breturn): Pass back multiple values.
(Bdup): Preserve multiple values.
Use TOP_LVALUE with most bytecodes that assign anything to
anything.
(Bbind_multiple_value_limits, Bmultiple_value_call,
Bmultiple_value_list_internal, Bthrow): Implement the new
bytecodes.
(Bgotoifnilelsepop, Bgotoifnonnilelsepop, BRgotoifnilelsepop,
BRgotoifnonnilelsepop):
Discard any multiple values.
* callint.c (Fcall_interactively):
Ignore multiple values when calling #'eval, in two places.
* device-x.c (x_IO_error_handler):
* macros.c (pop_kbd_macro_event):
* eval.c (Fsignal):
* eval.c (flagged_a_squirmer):
Call throw_or_bomb_out, not Fthrow, now that the latter is a
special form.
* eval.c:
Make Qthrow, Qobsolete_throw available as symbols.
Provide multiple_value_current_limit, multiple-values-limit (the
latter as specified by Common Lisp.
* eval.c (For):
Ignore multiple values when comparing with Qnil, but pass any
multiple values back for the last arg.
* eval.c (Fand):
Ditto.
* eval.c (Fif):
Ignore multiple values when examining the result of the
condition.
* eval.c (Fcond):
Ignore multiple values when comparing what the clauses give, but
pass them back if a clause gave non-nil.
* eval.c (Fprog2):
Never pass back multiple values.
* eval.c (FletX, Flet):
Ignore multiple when evaluating what exactly symbols should be
bound to.
* eval.c (Fwhile):
Ignore multiple values when evaluating the test.
* eval.c (Fsetq, Fdefvar, Fdefconst):
Ignore multiple values.
* eval.c (Fthrow):
Declare this as a special form; ignore multiple values for TAG,
preserve them for VALUE.
* eval.c (throw_or_bomb_out):
Make this available to other files, now Fthrow is a special form.
* eval.c (Feval):
Ignore multiple values when calling a compiled function, a
non-special-form subr, or a lambda expression.
* eval.c (Ffuncall):
If we attempt to call #'throw (now a special form) as a function,
don't error, call #'obsolete-throw instead.
* eval.c (make_multiple_value, multiple_value_aset)
(multiple_value_aref, print_multiple_value, mark_multiple_value)
(size_multiple_value):
Implement the multiple_value type. Add a long comment describing
our implementation.
* eval.c (bind_multiple_value_limits):
New function, used by the bytecode and by #'multiple-value-call,
#'multiple-value-list-internal.
* eval.c (multiple_value_call):
New function, used by the bytecode and #'multiple-value-call.
* eval.c (Fmultiple_value_call):
New special form.
* eval.c (multiple_value_list_internal):
New function, used by the byte code and
#'multiple-value-list-internal.
* eval.c (Fmultiple_value_list_internal, Fmultiple_value_prog1):
New special forms.
* eval.c (Fvalues, Fvalues_list):
New Lisp functions.
* eval.c (values2):
New function, for C code returning multiple values.
* eval.c (syms_of_eval):
Make our new Lisp functions and symbols available.
* eval.c (multiple-values-limit):
Make this available to Lisp.
* event-msw.c (dde_eval_string):
* event-stream.c (execute_help_form):
* glade.c (connector):
* glyphs-widget.c (glyph_instantiator_to_glyph):
* glyphs.c (evaluate_xpm_color_symbols):
* gui-x.c (wv_set_evalable_slot, button_item_to_widget_value):
* gui.c (gui_item_value, gui_item_display_flush_left):
* lread.c (check_if_suppressed):
* menubar-gtk.c (menu_convert, menu_descriptor_to_widget_1):
* menubar-msw.c (populate_menu_add_item):
* print.c (Fwith_output_to_temp_buffer):
* symbols.c (Fsetq_default):
Ignore multiple values when calling Feval.
* symeval.h:
Add the header declarations necessary for the multiple-values
implementation.
* inline.c:
#include symeval.h, now that it has some inline functions.
* lisp.h:
Update Fthrow's declaration. Make throw_or_bomb_out available to
all files.
* lrecord.h (enum lrecord_type):
Add the multiple_value type here.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Sun, 16 Aug 2009 20:55:49 +0100 |
| parents | b234386a35eb |
| children | 755ae5b97edb |
comparison
equal
deleted
inserted
replaced
| 4676:e3feb329bda9 | 4677:8f1ee2d15784 |
|---|---|
| 247 needed. | 247 needed. |
| 248 | 248 |
| 249 There is another file, @file{cl-compat.el}, which defines some | 249 There is another file, @file{cl-compat.el}, which defines some |
| 250 routines from the older @file{cl.el} package that are no longer | 250 routines from the older @file{cl.el} package that are no longer |
| 251 present in the new package. This includes internal routines | 251 present in the new package. This includes internal routines |
| 252 like @code{setelt} and @code{zip-lists}, deprecated features | 252 like @code{setelt} and @code{zip-lists}, and deprecated features |
| 253 like @code{defkeyword}, and an emulation of the old-style | 253 like @code{defkeyword}. @xref{Old CL Compatibility}. |
| 254 multiple-values feature. @xref{Old CL Compatibility}. | |
| 255 | 254 |
| 256 @node Installation, Naming Conventions, Organization, Overview | 255 @node Installation, Naming Conventions, Organization, Overview |
| 257 @section Installation | 256 @section Installation |
| 258 | 257 |
| 259 @noindent | 258 @noindent |
| 5343 @code{do-all-symbols} to locate any but the default obarray. | 5342 @code{do-all-symbols} to locate any but the default obarray. |
| 5344 | 5343 |
| 5345 The @code{loop} macro is complete except that @code{loop-finish} | 5344 The @code{loop} macro is complete except that @code{loop-finish} |
| 5346 and type specifiers are unimplemented. | 5345 and type specifiers are unimplemented. |
| 5347 | 5346 |
| 5348 The multiple-value return facility treats lists as multiple | |
| 5349 values, since Emacs Lisp cannot support multiple return values | |
| 5350 directly. The macros will be compatible with Common Lisp if | |
| 5351 @code{values} or @code{values-list} is always used to return to | |
| 5352 a @code{multiple-value-bind} or other multiple-value receiver; | |
| 5353 if @code{values} is used without @code{multiple-value-@dots{}} | |
| 5354 or vice-versa the effect will be different from Common Lisp. | |
| 5355 | |
| 5356 Many Common Lisp declarations are ignored, and others match | 5347 Many Common Lisp declarations are ignored, and others match |
| 5357 the Common Lisp standard in concept but not in detail. For | 5348 the Common Lisp standard in concept but not in detail. For |
| 5358 example, local @code{special} declarations, which are purely | 5349 example, local @code{special} declarations, which are purely |
| 5359 advisory in Emacs Lisp, do not rigorously obey the scoping rules | 5350 advisory in Emacs Lisp, do not rigorously obey the scoping rules |
| 5360 set down in Steele's book. | 5351 set down in Steele's book. |
| 5374 @appendix Old CL Compatibility | 5365 @appendix Old CL Compatibility |
| 5375 | 5366 |
| 5376 @noindent | 5367 @noindent |
| 5377 Following is a list of all known incompatibilities between this package | 5368 Following is a list of all known incompatibilities between this package |
| 5378 and the older Quiroz @file{cl.el} package. | 5369 and the older Quiroz @file{cl.el} package. |
| 5379 | |
| 5380 This package's emulation of multiple return values in functions is | |
| 5381 incompatible with that of the older package. That package attempted | |
| 5382 to come as close as possible to true Common Lisp multiple return | |
| 5383 values; unfortunately, it could not be 100% reliable and so was prone | |
| 5384 to occasional surprises if used freely. This package uses a simpler | |
| 5385 method, namely replacing multiple values with lists of values, which | |
| 5386 is more predictable though more noticeably different from Common Lisp. | |
| 5387 | 5370 |
| 5388 The @code{defkeyword} form and @code{keywordp} function are not | 5371 The @code{defkeyword} form and @code{keywordp} function are not |
| 5389 implemented in this package. | 5372 implemented in this package. |
| 5390 | 5373 |
| 5391 The @code{member}, @code{floor}, @code{ceiling}, @code{truncate}, | 5374 The @code{member}, @code{floor}, @code{ceiling}, @code{truncate}, |
| 5446 The @code{build-klist} mechanism for parsing keyword arguments | 5429 The @code{build-klist} mechanism for parsing keyword arguments |
| 5447 is emulated by @code{cl-compat}; the @code{with-keyword-args} | 5430 is emulated by @code{cl-compat}; the @code{with-keyword-args} |
| 5448 macro is not, however, and in any case it's best to change to | 5431 macro is not, however, and in any case it's best to change to |
| 5449 use the more natural keyword argument processing offered by | 5432 use the more natural keyword argument processing offered by |
| 5450 @code{defun*}. | 5433 @code{defun*}. |
| 5451 | |
| 5452 Multiple return values are treated differently by the two | |
| 5453 Common Lisp packages. The old package's method was more | |
| 5454 compatible with true Common Lisp, though it used heuristics | |
| 5455 that caused it to report spurious multiple return values in | |
| 5456 certain cases. The @code{cl-compat} package defines a set | |
| 5457 of multiple-value macros that are compatible with the old | |
| 5458 CL package; again, they are heuristic in nature, but they | |
| 5459 are guaranteed to work in any case where the old package's | |
| 5460 macros worked. To avoid name collision with the ``official'' | |
| 5461 multiple-value facilities, the ones in @code{cl-compat} have | |
| 5462 capitalized names: @code{Values}, @code{Values-list}, | |
| 5463 @code{Multiple-value-bind}, etc. | |
| 5464 | 5434 |
| 5465 The functions @code{cl-floor}, @code{cl-ceiling}, @code{cl-truncate}, | 5435 The functions @code{cl-floor}, @code{cl-ceiling}, @code{cl-truncate}, |
| 5466 and @code{cl-round} are defined by @code{cl-compat} to use the | 5436 and @code{cl-round} are defined by @code{cl-compat} to use the |
| 5467 old-style multiple-value mechanism, just as they did in the old | 5437 old-style multiple-value mechanism, just as they did in the old |
| 5468 package. The newer @code{floor*} and friends return their two | 5438 package. The newer @code{floor*} and friends return their two |