#include <config.h>
+#define FRAME_INLINE EXTERN_INLINE
+
#include <stdio.h>
-#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <setjmp.h>
+
+#include <c-ctype.h>
+
#include "lisp.h"
#include "character.h"
#ifdef HAVE_X_WINDOWS
Lisp_Object Qframep, Qframe_live_p;
Lisp_Object Qicon, Qmodeline;
-Lisp_Object Qonly;
+Lisp_Object Qonly, Qnone;
Lisp_Object Qx, Qw32, Qmac, Qpc, Qns;
Lisp_Object Qvisible;
Lisp_Object Qdisplay_type;
static void x_report_frame_params (struct frame *, Lisp_Object *);
#endif
+/* These setters are used only in this file, so they can be private. */
+static inline void
+fset_buffer_predicate (struct frame *f, Lisp_Object val)
+{
+ f->buffer_predicate = val;
+}
+static inline void
+fset_minibuffer_window (struct frame *f, Lisp_Object val)
+{
+ f->minibuffer_window = val;
+}
+
\f
static void
set_menu_bar_lines_1 (Lisp_Object window, int n)
struct window *w = XWINDOW (window);
w->last_modified = 0;
- XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
- XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
+ WSET (w, top_line, make_number (XFASTINT (w->top_line) + n));
+ WSET (w, total_lines, make_number (XFASTINT (w->total_lines) - n));
/* Handle just the top child in a vertical split. */
if (!NILP (w->vchild))
/* Initialize Lisp data. Note that allocate_frame initializes all
Lisp data to nil, so do it only for slots which should not be nil. */
- f->tool_bar_position = Qtop;
+ fset_tool_bar_position (f, Qtop);
/* Initialize non-Lisp data. Note that allocate_frame zeroes out all
non-Lisp data, so do it only for slots which should not be zero.
if (mini_p)
{
mini_window = make_window ();
- XWINDOW (root_window)->next = mini_window;
- XWINDOW (mini_window)->prev = root_window;
+ WSET (XWINDOW (root_window), next, mini_window);
+ WSET (XWINDOW (mini_window), prev, root_window);
XWINDOW (mini_window)->mini = 1;
- XWINDOW (mini_window)->frame = frame;
- f->minibuffer_window = mini_window;
+ WSET (XWINDOW (mini_window), frame, frame);
+ fset_minibuffer_window (f, mini_window);
}
else
{
mini_window = Qnil;
- XWINDOW (root_window)->next = Qnil;
- f->minibuffer_window = Qnil;
+ WSET (XWINDOW (root_window), next, Qnil);
+ fset_minibuffer_window (f, Qnil);
}
- XWINDOW (root_window)->frame = frame;
+ WSET (XWINDOW (root_window), frame, frame);
/* 10 is arbitrary,
just so that there is "something there."
SET_FRAME_COLS (f, 10);
FRAME_LINES (f) = 10;
- XSETFASTINT (XWINDOW (root_window)->total_cols, 10);
- XSETFASTINT (XWINDOW (root_window)->total_lines, (mini_p ? 9 : 10));
+ WSET (XWINDOW (root_window), total_cols, make_number (10));
+ WSET (XWINDOW (root_window), total_lines, make_number (mini_p ? 9 : 10));
if (mini_p)
{
- XSETFASTINT (XWINDOW (mini_window)->total_cols, 10);
- XSETFASTINT (XWINDOW (mini_window)->top_line, 9);
- XSETFASTINT (XWINDOW (mini_window)->total_lines, 1);
+ WSET (XWINDOW (mini_window), total_cols, make_number (10));
+ WSET (XWINDOW (mini_window), top_line, make_number (9));
+ WSET (XWINDOW (mini_window), total_lines, make_number (1));
}
/* Choose a buffer for the frame's root window. */
{
Lisp_Object buf;
- XWINDOW (root_window)->buffer = Qt;
+ WSET (XWINDOW (root_window), buffer, Qt);
buf = Fcurrent_buffer ();
/* If buf is a 'hidden' buffer (i.e. one whose name starts with
a space), try to find another one. */
etc. Running Lisp functions at this point surely ends in a
SEGV. */
set_window_buffer (root_window, buf, 0, 0);
- f->buffer_list = Fcons (buf, Qnil);
+ fset_buffer_list (f, Fcons (buf, Qnil));
}
if (mini_p)
{
- XWINDOW (mini_window)->buffer = Qt;
+ WSET (XWINDOW (mini_window), buffer, Qt);
set_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
0, 0);
}
- f->root_window = root_window;
- f->selected_window = root_window;
+ fset_root_window (f, root_window);
+ fset_selected_window (f, root_window);
/* Make sure this window seems more recently used than
a newly-created, never-selected window. */
XWINDOW (f->selected_window)->use_time = ++window_select_count;
XSETFRAME (frame_dummy, f);
GCPRO1 (frame_dummy);
/* If there's no minibuffer frame to use, create one. */
- KVAR (kb, Vdefault_minibuffer_frame) =
- call1 (intern ("make-initial-minibuffer-frame"), display);
+ KSET (kb, Vdefault_minibuffer_frame,
+ call1 (intern ("make-initial-minibuffer-frame"), display));
UNGCPRO;
}
- mini_window = XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
+ mini_window
+ = XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
}
- f->minibuffer_window = mini_window;
+ fset_minibuffer_window (f, mini_window);
/* Make the chosen minibuffer window display the proper minibuffer,
unless it is already showing a minibuffer. */
if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
- Fset_window_buffer (mini_window,
- (NILP (Vminibuffer_list)
- ? get_minibuffer (0)
- : Fcar (Vminibuffer_list)), Qnil);
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)), 0, 0);
return f;
}
Avoid infinite looping on the window chain by marking next pointer
as nil. */
- mini_window = f->minibuffer_window = f->root_window;
+ mini_window = f->root_window;
+ fset_minibuffer_window (f, mini_window);
XWINDOW (mini_window)->mini = 1;
- XWINDOW (mini_window)->next = Qnil;
- XWINDOW (mini_window)->prev = Qnil;
- XWINDOW (mini_window)->frame = frame;
+ WSET (XWINDOW (mini_window), next, Qnil);
+ WSET (XWINDOW (mini_window), prev, Qnil);
+ WSET (XWINDOW (mini_window), frame, frame);
/* Put the proper buffer in that window. */
- Fset_window_buffer (mini_window,
- (NILP (Vminibuffer_list)
- ? get_minibuffer (0)
- : Fcar (Vminibuffer_list)), Qnil);
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)), 0, 0);
return f;
}
#endif /* HAVE_WINDOW_SYSTEM */
Vframe_list = Fcons (frame, Vframe_list);
tty_frame_count = 1;
- f->name = build_pure_c_string ("F1");
+ fset_name (f, build_pure_c_string ("F1"));
f->visible = 1;
f->async_visible = 1;
XSETFRAME (frame, f);
Vframe_list = Fcons (frame, Vframe_list);
- f->name = make_formatted_string (name, "F%"pMd, ++tty_frame_count);
+ fset_name (f, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
f->visible = 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
f->async_visible = 1; /* Don't let visible be cleared later. */
if (!NILP (tty))
{
name = alloca (SBYTES (tty) + 1);
- strncpy (name, SSDATA (tty), SBYTES (tty));
+ memcpy (name, SSDATA (tty), SBYTES (tty));
name[SBYTES (tty)] = 0;
}
if (!NILP (tty_type))
{
type = alloca (SBYTES (tty_type) + 1);
- strncpy (type, SSDATA (tty_type), SBYTES (tty_type));
+ memcpy (type, SSDATA (tty_type), SBYTES (tty_type));
type[SBYTES (tty_type)] = 0;
}
/* Make the frame face alist be frame-specific, so that each
frame could change its face definitions independently. */
- f->face_alist = Fcopy_alist (sf->face_alist);
+ fset_face_alist (f, Fcopy_alist (sf->face_alist));
/* Simple Fcopy_alist isn't enough, because we need the contents of
the vectors which are the CDRs of associations in face_alist to
be copied as well. */
(Lisp_Object event)
{
/* Preserve prefix arg that the command loop just cleared. */
- KVAR (current_kboard, Vprefix_arg) = Vcurrent_prefix_arg;
+ KSET (current_kboard, Vprefix_arg, Vcurrent_prefix_arg);
Frun_hooks (1, &Qmouse_leave_buffer_hook);
return do_switch_frame (event, 0, 0, Qnil);
}
/* Don't allow minibuf_window to remain on a deleted frame. */
if (EQ (f->minibuffer_window, minibuf_window))
{
- Fset_window_buffer (sf->minibuffer_window,
- XWINDOW (minibuf_window)->buffer, Qnil);
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, 0, 0);
minibuf_window = sf->minibuffer_window;
/* If the dying minibuffer window was selected,
/* Mark all the windows that used to be on FRAME as deleted, and then
remove the reference to them. */
delete_all_child_windows (f->root_window);
- f->root_window = Qnil;
+ fset_root_window (f, Qnil);
Vframe_list = Fdelq (frame, Vframe_list);
FRAME_SET_VISIBLE (f, 0);
garbage collection. The frame object itself may not be garbage
collected until much later, because recent_keys and other data
structures can still refer to it. */
- f->menu_bar_vector = Qnil;
+ fset_menu_bar_vector (f, Qnil);
free_font_driver_list (f);
xfree (f->namebuf);
if (NILP (frame_with_minibuf))
abort ();
- KVAR (kb, Vdefault_minibuffer_frame) = frame_with_minibuf;
+ KSET (kb, Vdefault_minibuffer_frame, frame_with_minibuf);
}
else
/* No frames left on this kboard--say no minibuffer either. */
- KVAR (kb, Vdefault_minibuffer_frame) = Qnil;
+ KSET (kb, Vdefault_minibuffer_frame, Qnil);
}
/* Cause frame titles to update--necessary if we now have just one frame. */
w = XWINDOW (window);
if (!NILP (w->buffer))
- BVAR (XBUFFER (w->buffer), display_time) = Fcurrent_time ();
+ BSET (XBUFFER (w->buffer), display_time, Fcurrent_time ());
if (!NILP (w->vchild))
make_frame_visible_1 (w->vchild);
if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
{
struct frame *sf = XFRAME (selected_frame);
- Fset_window_buffer (sf->minibuffer_window,
- XWINDOW (minibuf_window)->buffer, Qnil);
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, 0, 0);
minibuf_window = sf->minibuffer_window;
}
Fhandle_switch_frame (next_frame (frame, Qt));
#endif
- /* Don't allow minibuf_window to remain on a deleted frame. */
+ /* Don't allow minibuf_window to remain on an iconified frame. */
if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
{
struct frame *sf = XFRAME (selected_frame);
- Fset_window_buffer (sf->minibuffer_window,
- XWINDOW (minibuf_window)->buffer, Qnil);
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, 0, 0);
minibuf_window = sf->minibuffer_window;
}
request a switch to FOCUS-FRAME, and `last-event-frame' will be
FOCUS-FRAME after reading an event typed at FRAME.
-If FOCUS-FRAME is omitted or nil, any existing redirection is
-canceled, and the frame again receives its own keystrokes.
+If FOCUS-FRAME is nil, any existing redirection is canceled, and the
+frame again receives its own keystrokes.
Focus redirection is useful for temporarily redirecting keystrokes to
a surrogate minibuffer frame when a frame doesn't have its own
f = XFRAME (frame);
- f->focus_frame = focus_frame;
+ fset_focus_frame (f, focus_frame);
if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
(*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
FOR_EACH_FRAME (tail, frame)
{
- XFRAME (frame)->buffer_list
- = Fdelq (buffer, XFRAME (frame)->buffer_list);
- XFRAME (frame)->buried_buffer_list
- = Fdelq (buffer, XFRAME (frame)->buried_buffer_list);
+ fset_buffer_list
+ (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buffer_list));
+ fset_buried_buffer_list
+ (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buried_buffer_list));
}
}
/* Check for no change needed in this very common case
before we do any consing. */
- if (frame_name_fnn_p (SSDATA (f->name),
- SBYTES (f->name)))
+ if (frame_name_fnn_p (SSDATA (f->name), SBYTES (f->name)))
return;
name = make_formatted_string (namebuf, "F%"pMd, ++tty_frame_count);
error ("Frame names of the form F<num> are usurped by Emacs");
}
- f->name = name;
+ fset_name (f, name);
update_mode_lines = 1;
}
for (; CONSP (val); val = XCDR (val))
if (!NILP (Fbuffer_live_p (XCAR (val))))
list = Fcons (XCAR (val), list);
- f->buffer_list = Fnreverse (list);
+ fset_buffer_list (f, Fnreverse (list));
return;
}
if (EQ (prop, Qburied_buffer_list))
for (; CONSP (val); val = XCDR (val))
if (!NILP (Fbuffer_live_p (XCAR (val))))
list = Fcons (XCAR (val), list);
- f->buried_buffer_list = Fnreverse (list);
+ fset_buried_buffer_list (f, Fnreverse (list));
return;
}
case SYMBOL_PLAINVAL: case SYMBOL_FORWARDED: break;
case SYMBOL_LOCALIZED:
{ struct Lisp_Buffer_Local_Value *blv = sym->val.blv;
- if (blv->frame_local && BLV_FOUND (blv) && XFRAME (blv->where) == f)
+ if (blv->frame_local && blv_found (blv) && XFRAME (blv->where) == f)
swap_in_global_binding (sym);
break;
}
/* Update the frame parameter alist. */
old_alist_elt = Fassq (prop, f->param_alist);
if (EQ (old_alist_elt, Qnil))
- f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
+ fset_param_alist (f, Fcons (Fcons (prop, val), f->param_alist));
else
Fsetcdr (old_alist_elt, val);
in addition to the alist. */
if (EQ (prop, Qbuffer_predicate))
- f->buffer_predicate = val;
+ fset_buffer_predicate (f, val);
if (! FRAME_WINDOW_P (f))
{
error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
/* Install the chosen minibuffer window, with proper buffer. */
- f->minibuffer_window = val;
+ fset_minibuffer_window (f, val);
}
}
: FRAME_MINIBUF_WINDOW (f)));
store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
- store_in_alist (&alist, Qburied_buffer_list, XFRAME (frame)->buried_buffer_list);
+ store_in_alist (&alist, Qburied_buffer_list,
+ XFRAME (frame)->buried_buffer_list);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
struct gcpro gcpro1, gcpro2;
i = 0;
- for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ for (tail = alist; CONSP (tail); tail = XCDR (tail))
i++;
parms = alloca (i * sizeof *parms);
}
/* Don't die if just one of these was set. */
- if (! TYPE_RANGED_INTEGERP (int, left))
+ if (EQ (left, Qunbound))
{
left_no_change = 1;
if (f->left_pos < 0)
else
XSETINT (left, f->left_pos);
}
- if (! TYPE_RANGED_INTEGERP (int, top))
+ if (EQ (top, Qunbound))
{
top_no_change = 1;
if (f->top_pos < 0)
fontset = fs_query_fontset (arg, 0);
if (fontset < 0)
{
- font_object = font_open_by_name (f, SSDATA (arg));
+ font_object = font_open_by_name (f, arg);
if (NILP (font_object))
error ("Font `%s' is not defined", SSDATA (arg));
arg = AREF (font_object, FONT_NAME_INDEX);
}
else if (fontset > 0)
{
- Lisp_Object ascii_font = fontset_ascii (fontset);
-
- font_object = font_open_by_name (f, SSDATA (ascii_font));
+ font_object = font_open_by_name (f, fontset_ascii (fontset));
if (NILP (font_object))
error ("Font `%s' is not defined", SDATA (arg));
arg = AREF (font_object, FONT_NAME_INDEX);
new_value = Qnil;
while (*p0)
{
- while (*p1 && ! isspace (*p1) && *p1 != ',') p1++;
+ while (*p1 && ! c_isspace (*p1) && *p1 != ',') p1++;
if (p0 < p1)
new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
new_value);
{
int c;
- while ((c = *++p1) && isspace (c));
+ while ((c = *++p1) && c_isspace (c));
}
p0 = p1;
}
char *
x_get_resource_string (const char *attribute, const char *class)
{
- char *name_key;
- char *class_key;
char *result;
struct frame *sf = SELECTED_FRAME ();
ptrdiff_t invocation_namelen = SBYTES (Vinvocation_name);
/* Allocate space for the components, the dots which separate them,
and the final '\0'. */
- SAFE_ALLOCA (name_key, char *, invocation_namelen + strlen (attribute) + 2);
- class_key = alloca ((sizeof (EMACS_CLASS) - 1) + strlen (class) + 2);
+ char *name_key = SAFE_ALLOCA (invocation_namelen + strlen (attribute) + 2);
+ char *class_key = alloca ((sizeof (EMACS_CLASS) - 1) + strlen (class) + 2);
esprintf (name_key, "%s.%s", SSDATA (Vinvocation_name), attribute);
sprintf (class_key, "%s.%s", EMACS_CLASS, class);
DEFSYM (Qminibuffer, "minibuffer");
DEFSYM (Qmodeline, "modeline");
DEFSYM (Qonly, "only");
+ DEFSYM (Qnone, "none");
DEFSYM (Qwidth, "width");
DEFSYM (Qgeometry, "geometry");
DEFSYM (Qicon_left, "icon-left");
Vmake_pointer_invisible = Qt;
DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions,
- doc: /* Functions to be run before deleting a frame.
+ doc: /* Functions run before deleting a frame.
The functions are run with one arg, the frame to be deleted.
See `delete-frame'.