xemacs-beta: src/specifier.c comparison

comparison src/specifier.c @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	3d3049ae1304

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 and associate them with particular locales (buffer, window, frame,
 device, global), and then the instance (i.e. actual value) is
 retrieved in a specific domain (window, frame, device) by looking
 through the possible instantiators (i.e. settings).  This process is
 called \"instantiation\".
 To put settings into a specifier, use `set-specifier', or the
 lower-level functions `add-spec-to-specifier' and
 `add-spec-list-to-specifier'.  You can also temporarily bind a setting
 to a specifier using `let-specifier'.  To retrieve settings, use
 `specifier-specs', or its lower-level counterpart
 recompute_cached_specifier_everywhere (specifier);
 RETURN_UNGCPRO (Qnil);
 }
 DEFUN ("add-spec-list-to-specifier", Fadd_spec_list_to_specifier, 2, 3, 0, /*
-Add a spec-list (a list of specifications) to SPECIFIER.
+Add SPEC-LIST (a list of specifications) to SPECIFIER.
-The format of a spec-list is
+The format of SPEC-LIST is
 ((LOCALE (TAG-SET . INSTANTIATOR) ...) ...)
 where
 LOCALE := a window, a buffer, a frame, a device, or 'global
 {
 Lisp_Object buffer = Qnil;
 Lisp_Object window = Qnil;
 Lisp_Object frame = Qnil;
 Lisp_Object device = Qnil;
-Lisp_Object tag = Qnil;
+Lisp_Object tag = Qnil;	/* #### currently unused */
-struct device *d;
+Lisp_Specifier *sp = XSPECIFIER (specifier);
-Lisp_Specifier *sp;
-sp = XSPECIFIER (specifier);
 /* Attempt to determine buffer, window, frame, and device from the
 domain. */
 /* #### get image instances out of domains! */
 if (IMAGE_INSTANCEP (domain))
 No. Errors are handled in Lisp primitives implementation.
 Invalid domain is a design error here - kkm. */
 abort ();
 if (NILP (buffer) && !NILP (window))
-buffer = XWINDOW (window)->buffer;
+buffer = WINDOW_BUFFER (XWINDOW (window));
 if (NILP (frame) && !NILP (window))
 frame = XWINDOW (window)->frame;
 if (NILP (device))
 /* frame had better exist; if device is undeterminable, something
 really went wrong. */
-device = XFRAME (frame)->device;
+device = FRAME_DEVICE (XFRAME (frame));
 /* device had better be determined by now; abort if not. */
-d = XDEVICE (device);
+tag = DEVICE_CLASS (XDEVICE (device));
-tag = DEVICE_CLASS (d);
 depth = make_int (1 + XINT (depth));
 if (XINT (depth) > 20)
 {
 maybe_error (Qspecifier, errb, "Apparent loop in specifier inheritance");
 		       (Lisp_Object specifier, struct window *w,
 			Lisp_Object oldval),
 		       int struct_frame_offset,
 		       void (*value_changed_in_frame)
 		       (Lisp_Object specifier, struct frame *f,
-			Lisp_Object oldval))
+			Lisp_Object oldval),
+		       int always_recompute)
 {
 Lisp_Specifier *sp = XSPECIFIER (specifier);
 assert (!GHOST_SPECIFIER_P (sp));
 if (!sp->caching)
 sp->caching = xnew_and_zero (struct specifier_caching);
 sp->caching->offset_into_struct_window = struct_window_offset;
 sp->caching->value_changed_in_window = value_changed_in_window;
 sp->caching->offset_into_struct_frame = struct_frame_offset;
 sp->caching->value_changed_in_frame = value_changed_in_frame;
+sp->caching->always_recompute = always_recompute;
 Vcached_specifiers = Fcons (specifier, Vcached_specifiers);
 if (BODILY_SPECIFIER_P (sp))
 GHOST_SPECIFIER(sp)->caching = sp->caching;
 recompute_cached_specifier_everywhere (specifier);
 }
 static void
 recompute_one_cached_specifier_in_window (Lisp_Object specifier,
 					  struct window *w)
 {
 Lisp_Object window;
-Lisp_Object newval, *location;
+Lisp_Object newval, *location, oldval;
 assert (!GHOST_SPECIFIER_P (XSPECIFIER (specifier)));
 XSETWINDOW (window, w);
 method the instantiation that specifier_instance will do will
 always create a new copy. Thus EQ will always fail. Unfortunately
 calling equal is no good either as this doesn't take into account
 things attached to the specifier - for instance strings on
 extents. --andyp */
-if (!EQ (newval, *location))
+if (!EQ (newval, *location) || XSPECIFIER (specifier)->caching->always_recompute)
 {
-Lisp_Object oldval = *location;
+oldval = *location;
 *location = newval;
 (XSPECIFIER (specifier)->caching->value_changed_in_window)
 	(specifier, w, oldval);
 }
 }
 static void
 recompute_one_cached_specifier_in_frame (Lisp_Object specifier,
 					 struct frame *f)
 {
 Lisp_Object frame;
-Lisp_Object newval, *location;
+Lisp_Object newval, *location, oldval;
 assert (!GHOST_SPECIFIER_P (XSPECIFIER (specifier)));
 XSETFRAME (frame, f);
 better be able to deal.  If not, set a default so this
 never happens or correct it in the value_changed_in_frame
 method. */
 location = (Lisp_Object *)
 ((char *) f + XSPECIFIER (specifier)->caching->offset_into_struct_frame);
-if (!EQ (newval, *location))
+if (!EQ (newval, *location) || XSPECIFIER (specifier)->caching->always_recompute)
 {
-Lisp_Object oldval = *location;
+oldval = *location;
 *location = newval;
 (XSPECIFIER (specifier)->caching->value_changed_in_frame)
 	(specifier, f, oldval);
 }
 }

Mercurial > hg > xemacs-beta

comparison src/specifier.c @ 444:576fb035e263 r21-2-37