#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
-#include "xterm.h"
-#endif
-#ifdef WINDOWSNT
-#include "w32term.h"
-#endif
-#ifdef HAVE_NS
-#include "nsterm.h"
-#endif
+
+#ifdef HAVE_WINDOW_SYSTEM
+#include TERM_HEADER
+#endif /* HAVE_WINDOW_SYSTEM */
+
#include "buffer.h"
/* These help us bind and responding to switch-frame events. */
#include "commands.h"
#include "dosfns.h"
#endif
-
-#ifdef HAVE_WINDOW_SYSTEM
-
-#endif
-
#ifdef HAVE_NS
Lisp_Object Qns_parse_geometry;
#endif
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;
- WSET (w, top_line, make_number (XFASTINT (w->top_line) + n));
- WSET (w, total_lines, make_number (XFASTINT (w->total_lines) - n));
+ wset_top_line (w, make_number (XFASTINT (w->top_line) + n));
+ wset_total_lines (w, make_number (XFASTINT (w->total_lines) - n));
/* Handle just the top child in a vertical split. */
if (!NILP (w->vchild))
case output_ns:
return Qns;
default:
- abort ();
+ emacs_abort ();
}
}
/* Initialize Lisp data. Note that allocate_frame initializes all
Lisp data to nil, so do it only for slots which should not be nil. */
- FSET (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 ();
- WSET (XWINDOW (root_window), next, mini_window);
- WSET (XWINDOW (mini_window), prev, root_window);
+ wset_next (XWINDOW (root_window), mini_window);
+ wset_prev (XWINDOW (mini_window), root_window);
XWINDOW (mini_window)->mini = 1;
- WSET (XWINDOW (mini_window), frame, frame);
- FSET (f, minibuffer_window, mini_window);
+ wset_frame (XWINDOW (mini_window), frame);
+ fset_minibuffer_window (f, mini_window);
}
else
{
mini_window = Qnil;
- WSET (XWINDOW (root_window), next, Qnil);
- FSET (f, minibuffer_window, Qnil);
+ wset_next (XWINDOW (root_window), Qnil);
+ fset_minibuffer_window (f, Qnil);
}
- WSET (XWINDOW (root_window), frame, frame);
+ wset_frame (XWINDOW (root_window), frame);
/* 10 is arbitrary,
just so that there is "something there."
SET_FRAME_COLS (f, 10);
FRAME_LINES (f) = 10;
- WSET (XWINDOW (root_window), total_cols, make_number (10));
- WSET (XWINDOW (root_window), total_lines, make_number (mini_p ? 9 : 10));
+ wset_total_cols (XWINDOW (root_window), make_number (10));
+ wset_total_lines (XWINDOW (root_window), make_number (mini_p ? 9 : 10));
if (mini_p)
{
- 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));
+ wset_total_cols (XWINDOW (mini_window), make_number (10));
+ wset_top_line (XWINDOW (mini_window), make_number (9));
+ wset_total_lines (XWINDOW (mini_window), make_number (1));
}
/* Choose a buffer for the frame's root window. */
{
Lisp_Object buf;
- WSET (XWINDOW (root_window), buffer, Qt);
+ wset_buffer (XWINDOW (root_window), 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);
- FSET (f, buffer_list, Fcons (buf, Qnil));
+ fset_buffer_list (f, Fcons (buf, Qnil));
}
if (mini_p)
{
- WSET (XWINDOW (mini_window), buffer, Qt);
+ wset_buffer (XWINDOW (mini_window), Qt);
set_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
0, 0);
}
- FSET (f, root_window, root_window);
- FSET (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. */
- KSET (kb, Vdefault_minibuffer_frame,
- call1 (intern ("make-initial-minibuffer-frame"), display));
+ kset_default_minibuffer_frame
+ (kb, call1 (intern ("make-initial-minibuffer-frame"), display));
UNGCPRO;
}
= XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
}
- FSET (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. */
Avoid infinite looping on the window chain by marking next pointer
as nil. */
- mini_window = FSET (f, minibuffer_window, f->root_window);
+ mini_window = f->root_window;
+ fset_minibuffer_window (f, mini_window);
XWINDOW (mini_window)->mini = 1;
- WSET (XWINDOW (mini_window), next, Qnil);
- WSET (XWINDOW (mini_window), prev, Qnil);
- WSET (XWINDOW (mini_window), frame, frame);
+ wset_next (XWINDOW (mini_window), Qnil);
+ wset_prev (XWINDOW (mini_window), Qnil);
+ wset_frame (XWINDOW (mini_window), frame);
/* Put the proper buffer in that window. */
Vframe_list = Fcons (frame, Vframe_list);
tty_frame_count = 1;
- FSET (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);
- FSET (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. */
#ifdef MSDOS
if (sf->output_method != output_msdos_raw
&& sf->output_method != output_termcap)
- abort ();
+ emacs_abort ();
#else /* not MSDOS */
#ifdef WINDOWSNT /* This should work now! */
/* Make the frame face alist be frame-specific, so that each
frame could change its face definitions independently. */
- FSET (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 focus;
if (!FRAMEP (XCAR (tail)))
- abort ();
+ emacs_abort ();
focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
(Lisp_Object event)
{
/* Preserve prefix arg that the command loop just cleared. */
- KSET (current_kboard, Vprefix_arg, Vcurrent_prefix_arg);
+ kset_prefix_arg (current_kboard, Vcurrent_prefix_arg);
Frun_hooks (1, &Qmouse_leave_buffer_hook);
return do_switch_frame (event, 0, 0, Qnil);
}
/* There must always be at least one frame in Vframe_list. */
if (! CONSP (Vframe_list))
- abort ();
+ emacs_abort ();
/* If this frame is dead, it won't be in Vframe_list, and we'll loop
forever. Forestall that. */
/* There must always be at least one frame in Vframe_list. */
if (! CONSP (Vframe_list))
- abort ();
+ emacs_abort ();
prev = Qnil;
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
f = XCAR (tail);
if (!FRAMEP (f))
- abort ();
+ emacs_abort ();
if (EQ (frame, f) && !NILP (prev))
return prev;
/* 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);
- FSET (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. */
- FSET (f, menu_bar_vector, Qnil);
+ fset_menu_bar_vector (f, Qnil);
free_font_driver_list (f);
xfree (f->namebuf);
this = XCAR (frames);
if (!FRAMEP (this))
- abort ();
+ emacs_abort ();
f1 = XFRAME (this);
if (kb == FRAME_KBOARD (f1))
this = XCAR (frames);
if (!FRAMEP (this))
- abort ();
+ emacs_abort ();
f1 = XFRAME (this);
/* Consider only frames on the same kboard
that is prohibited at the top; you can't delete surrogate
minibuffer frames. */
if (NILP (frame_with_minibuf))
- abort ();
+ emacs_abort ();
- KSET (kb, Vdefault_minibuffer_frame, frame_with_minibuf);
+ kset_default_minibuffer_frame (kb, frame_with_minibuf);
}
else
/* No frames left on this kboard--say no minibuffer either. */
- KSET (kb, Vdefault_minibuffer_frame, Qnil);
+ kset_default_minibuffer_frame (kb, Qnil);
}
/* Cause frame titles to update--necessary if we now have just one frame. */
w = XWINDOW (window);
if (!NILP (w->buffer))
- BSET (XBUFFER (w->buffer), display_time, Fcurrent_time ());
+ bset_display_time (XBUFFER (w->buffer), Fcurrent_time ());
if (!NILP (w->vchild))
make_frame_visible_1 (w->vchild);
f = XFRAME (frame);
- FSET (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)
{
- FSET (XFRAME (frame), buffer_list,
- Fdelq (buffer, XFRAME (frame)->buffer_list));
- FSET (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));
}
}
error ("Frame names of the form F<num> are usurped by Emacs");
}
- FSET (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);
- FSET (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);
- FSET (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;
}
- default: abort ();
+ default: emacs_abort ();
}
}
/* Update the frame parameter alist. */
old_alist_elt = Fassq (prop, f->param_alist);
if (EQ (old_alist_elt, Qnil))
- FSET (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))
- FSET (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. */
- FSET (f, minibuffer_window, val);
+ fset_minibuffer_window (f, val);
}
}
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;
}
}
default:
- abort ();
+ emacs_abort ();
}
}
else
DEFSYM (Qx, "x");
DEFSYM (Qw32, "w32");
DEFSYM (Qpc, "pc");
- DEFSYM (Qmac, "mac");
DEFSYM (Qns, "ns");
DEFSYM (Qvisible, "visible");
DEFSYM (Qbuffer_predicate, "buffer-predicate");