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.

/* Window definitions for XEmacs.
   Copyright (C) 1985, 1986, 1992, 1993, 1994, 1995
   Free Software Foundation, Inc.
   Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
   Copyright (C) 1995, 1996, 2002 Ben Wing.
   Copyright (C) 1996 Chuck Thompson.

This file is part of XEmacs.

XEmacs is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

XEmacs is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with XEmacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

/* Synched up with: FSF 19.30. */

#ifndef INCLUDED_window_h_
#define INCLUDED_window_h_

#include "redisplay.h"
#ifdef HAVE_SCROLLBARS
#include "scrollbar.h"
#endif

struct window;

DECLARE_LRECORD (window, struct window);
#define XWINDOW(x) XRECORD (x, window, struct window)
#define wrap_window(p) wrap_record (p, window)
#define WINDOWP(x) RECORDP (x, window)
#define CHECK_WINDOW(x) CHECK_RECORD (x, window)
#define CONCHECK_WINDOW(x) CONCHECK_RECORD (x, window)

/* Basic properties available to non-privileged users; redefined in
   window-impl.h */

int window_live_p (struct window *w);
Lisp_Object window_frame (struct window *w);
Lisp_Object window_buffer (struct window *w);

#define WINDOW_LIVE_P(w) window_live_p (w)
#define WINDOW_FRAME(w) window_frame (w)
#define WINDOW_BUFFER(w) window_buffer (w)

#define WINDOW_XFRAME(w) XFRAME (WINDOW_FRAME (w))
#define WINDOW_DEVICE(w) XFRAME_DEVICE (WINDOW_FRAME (w))
#define WINDOW_XDEVICE(w) XDEVICE (WINDOW_DEVICE (w))
#define WINDOW_CONSOLE(w) XDEVICE_CONSOLE (WINDOW_DEVICE (w))
#define WINDOW_XCONSOLE(w) XCONSOLE (WINDOW_CONSOLE (w))
#define WINDOW_XBUFFER(w) XBUFFER (WINDOW_BUFFER (w))

#define XWINDOW_FRAME(w) WINDOW_FRAME (XWINDOW (w))
#define XWINDOW_XFRAME(w) XFRAME (XWINDOW_FRAME (w))
#define XWINDOW_DEVICE(w) XFRAME_DEVICE (XWINDOW_FRAME (w))
#define XWINDOW_XDEVICE(w) XDEVICE (XWINDOW_DEVICE (w))
#define XWINDOW_CONSOLE(w) XDEVICE_CONSOLE (XWINDOW_DEVICE (w))
#define XWINDOW_XCONSOLE(w) XCONSOLE (XWINDOW_CONSOLE (w))
#define XWINDOW_BUFFER(w) WINDOW_BUFFER (XWINDOW (w))
#define XWINDOW_XBUFFER(w) XBUFFER (XWINDOW_BUFFER (w))

#define CHECK_LIVE_WINDOW(x) do {			\
  CHECK_WINDOW (x);					\
  if (!WINDOW_LIVE_P (XWINDOW (x)))			\
    dead_wrong_type_argument (Qwindow_live_p, (x));	\
} while (0)
#define CONCHECK_LIVE_WINDOW(x) do {			\
  CONCHECK_WINDOW (x);					\
  if (!WINDOW_LIVE_P (XWINDOW (x)))			\
    x = wrong_type_argument (Qwindow_live_p, (x));	\
} while (0)

struct window_mirror;

DECLARE_LRECORD (window_mirror, struct window_mirror);
#define XWINDOW_MIRROR(x) XRECORD (x, window_mirror, struct window_mirror)
#define wrap_window_mirror(p) wrap_record (p, window_mirror)
#define WINDOW_MIRRORP(x) RECORDP (x, window_mirror)
#define CHECK_WINDOW_MIRROR(x) CHECK_RECORD (x, window_mirror)
#define CONCHECK_WINDOW_MIRROR(x) CONCHECK_RECORD (x, window_mirror)

DECLARE_LRECORD (window_configuration, struct window_config);

EXFUN (Fget_buffer_window, 3);
EXFUN (Fmove_to_window_line, 2);
EXFUN (Frecenter, 2);
EXFUN (Freplace_buffer_in_windows, 3);
EXFUN (Fselect_window, 2);
EXFUN (Fselected_window, 1);
EXFUN (Fset_window_buffer, 3);
EXFUN (Fset_window_hscroll, 2);
EXFUN (Fset_window_point, 2);
EXFUN (Fset_window_start, 3);
EXFUN (Fwindow_buffer, 1);
EXFUN (Fwindow_highest_p, 1);
EXFUN (Fwindow_point, 1);
EXFUN (Fwindow_start, 1);

Lisp_Object save_window_excursion_unwind (Lisp_Object);
extern Lisp_Object Qcurrent_window_configuration, Qset_window_configuration;
Lisp_Object display_buffer (Lisp_Object, Lisp_Object, Lisp_Object);

/* The minibuffer window of the selected frame.
   Note that you cannot test for minibufferness of an arbitrary window
   by comparing against this; but you can test for minibufferness of
   the selected window or of any window that is displayed.  */
extern Lisp_Object minibuf_window;

/* Prompt to display in front of the minibuffer contents, or nil */
extern Lisp_Object Vminibuf_prompt;
/* Prompt to display in front of the minibuffer prompt, or nil */
extern Lisp_Object Vminibuf_preprompt;

Lisp_Object allocate_window (void);
int window_char_width (struct window *, int include_margins_p);
int window_char_height (struct window *, int include_gutters_p);
int window_displayed_height (struct window *);
int window_is_leftmost (struct window *w);
int window_is_rightmost (struct window *w);
int window_is_lowest (struct window *w);
int window_is_highest (struct window *w);
int window_truncation_on (struct window *w);
int window_needs_vertical_divider (struct window *);
int window_scrollbar_width (struct window *w);
int window_scrollbar_height (struct window *w);
int window_modeline_height (struct window *w);
int window_left_margin_width (struct window *w);
int window_right_margin_width (struct window *w);
int window_top_gutter_height (struct window *w);
int window_bottom_gutter_height (struct window *w);
int window_left_gutter_width (struct window *w, int modeline);
int window_right_gutter_width (struct window *w, int modeline);

void delete_all_subwindows (struct window *w);
void set_window_pixheight (Lisp_Object window, int pixheight,
			   int nodelete);
void set_window_pixwidth (Lisp_Object window, int pixwidth,
			  int nodelete);
void window_scroll (Lisp_Object window, Lisp_Object n, int direction,
		    Error_Behavior errb);
int buffer_window_count (struct buffer *b, struct frame *f);
int buffer_window_mru (struct window *w);
void check_frame_size (struct frame *frame, int *rows, int *cols);
int frame_pixsize_valid_p (struct frame *frame, int width, int height);
int frame_size_valid_p (struct frame *frame, int rows, int cols);
struct window *decode_window (Lisp_Object window);
struct window *find_window_by_pixel_pos (int pix_x, int pix_y, Lisp_Object win);

void free_window_mirror (struct window_mirror *mir);
Lisp_Object real_window (struct window_mirror *mir, int no_abort);
struct window_mirror *find_window_mirror (struct window *w);
display_line_dynarr *window_display_lines (struct window *w, int);
struct buffer *window_display_buffer (struct window *w);
void set_window_display_buffer (struct window *w, struct buffer *b);
void update_frame_window_mirror (struct frame *f);

int map_windows (struct frame *f,
		 int (*mapfun) (struct window *w, void *closure),
		 void *closure);
void some_window_value_changed (Lisp_Object specifier, struct window *w,
				Lisp_Object oldval);
int invalidate_vertical_divider_cache_in_window (struct window *w,
						 void *u_n_u_s_e_d);
int window_divider_width (struct window *w);

#endif /* INCLUDED_window_h_ */