xemacs-beta: src/window.c comparison

comparison src/window.c @ 5581:56144c8593a8

Mechanically change INT to FIXNUM in our sources. src/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea@parhasard.net> [...] Mechanically change INT (where it refers to non-bignum Lisp integers) to FIXNUM in our sources. Done for the following functions, enums, and macros: Lisp_Type_Int_Even, Lisp_Type_Int_Odd, INT_GCBITS, INT_VALBITS, make_int(), INTP(), XINT(), CHECK_INT(), XREALINT(), INT_PLUS(), INT_MINUS(), EMACS_INT_MAX (to MOST_POSITIVE_FIXNUM), EMACS_INT_MIN (to MOST_NEGATIVE_FIXNUM), NUMBER_FITS_IN_AN_EMACS_INT() to NUMBER_FITS_IN_A_FIXNUM(), XFLOATINT, XCHAR_OR_INT, INT_OR_FLOAT. The EMACS_INT typedef was not changed, it does not describe non-bignum Lisp integers. Script that did the change available in http://mid.gmane.org/20067.17650.181273.12014@parhasard.net . modules/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea@parhasard.net> [...] Mechanically change INT to FIXNUM, where the usage describes non-bignum Lisp integers. See the src/ChangeLog entry for more details. man/ChangeLog addition: 2011-10-09 Aidan Kehoe <kehoea@parhasard.net> * internals/internals.texi (How Lisp Objects Are Represented in C): * internals/internals.texi (Integers and Characters): Mechanically change INT to FIXNUM, where the usage describes non-bignum Lisp integers.

author	Aidan Kehoe <kehoea@parhasard.net>
date	Sun, 09 Oct 2011 09:51:57 +0100
parents	4dee0387b9de
children	3fde0e346ad7

comparison

equal deleted inserted replaced

-:a0e81357194e
+:56144c8593a8
 /* the shadow thickness can be negative. This means that the divider
 will have a depressed look */
 if (FRAME_WIN_P (XFRAME (WINDOW_FRAME (w))))
 return
-XINT (w->vertical_divider_line_width)
+XFIXNUM (w->vertical_divider_line_width)
-+ 2 * XINT (w->vertical_divider_spacing)
++ 2 * XFIXNUM (w->vertical_divider_spacing)
-+ 2 * abs (XINT (w->vertical_divider_shadow_thickness));
++ 2 * abs (XFIXNUM (w->vertical_divider_shadow_thickness));
 else
-return XINT (w->vertical_divider_line_width) == 0 ? 0 : 1;
+return XFIXNUM (w->vertical_divider_line_width) == 0 ? 0 : 1;
 }
 int
 window_scrollbar_width (struct window * USED_IF_SCROLLBARS (w))
 {
 || NILP (w->buffer)
 || NILP (w->vertical_scrollbar_visible_p))
 /* #### when does NILP (w->buffer) happen? */
 return 0;
-return XINT (w->scrollbar_width);
+return XFIXNUM (w->scrollbar_width);
 #else
 return 0;
 #endif /* HAVE_SCROLLBARS */
 }
 || NILP (w->buffer)
 || NILP (w->horizontal_scrollbar_visible_p)
 || !window_truncation_on (w))
 return 0;
-return XINT (w->scrollbar_height);
+return XFIXNUM (w->scrollbar_height);
 #else
 return 0;
 #endif /* HAVE_SCROLLBARS */
 }
 /* The minibuffer never has margins. */
 if (MINI_WINDOW_P (w))
 return 0;
 window = wrap_window (w);
-margin_cwidth = (left_margin ? XINT (w->left_margin_width) :
+margin_cwidth = (left_margin ? XFIXNUM (w->left_margin_width) :
-		   XINT (w->right_margin_width));
+		   XFIXNUM (w->right_margin_width));
 default_face_width_and_height (window, &font_width, 0);
 /* The left margin takes precedence over the right margin so we
 subtract its width from the space available for the right
 margin. */
 if (!left_margin)
-window_cwidth -= XINT (w->left_margin_width);
+window_cwidth -= XFIXNUM (w->left_margin_width);
 /* The margin cannot be wider than the window is.  We allow the
 value to be bigger since it is possible for the user to enlarge
 the window such that the left margin value would no longer be too
 big, but we won't return a value that is larger. */
 if (NILP (pos))
 posint = BUF_PT (buf);
 else
 {
-CHECK_INT_COERCE_MARKER (pos);
+CHECK_FIXNUM_COERCE_MARKER (pos);
-posint = XINT (pos);
+posint = XFIXNUM (pos);
 }
 if (posint < top || posint > BUF_ZV (buf))
 return Qnil;
 (rows/columns)    ----                          window-displayed-height
 (pixels)          ----                     window-displayed-text-pixel-height
 */
 (window))
 {
-return make_int (window_char_height (decode_window (window), 1));
+return make_fixnum (window_char_height (decode_window (window), 1));
 }
 DEFUN ("window-displayed-height", Fwindow_displayed_height, 0, 1, 0, /*
 Return the number of lines currently displayed in WINDOW.
 This counts the actual number of lines displayed in WINDOW
 function pretends that there are lines of text in the default
 font there.
 */
 (window))
 {
-return make_int (window_displayed_height (decode_window (window)));
+return make_fixnum (window_displayed_height (decode_window (window)));
 }
 DEFUN ("window-pixel-height", Fwindow_pixel_height, 0, 1, 0, /*
 Return the height of WINDOW in pixels.  Defaults to current window.
 This includes the window's modeline and horizontal scrollbar (if any).
 */
 (window))
 {
-return make_int (window_pixel_height (decode_window (window)));
+return make_fixnum (window_pixel_height (decode_window (window)));
 }
 DEFUN ("window-text-area-height", Fwindow_text_area_height, 0, 1, 0, /*
 Return the number of default lines in the text area of WINDOW.
 This actually works by dividing the window's text area pixel height (i.e.
 be different.
 See also `window-height' and `window-displayed-height'.
 */
 (window))
 {
-return make_int (window_char_height (decode_window (window), 0));
+return make_fixnum (window_char_height (decode_window (window), 0));
 }
 DEFUN ("window-text-area-pixel-height",
 Fwindow_text_area_pixel_height, 0, 1, 0, /*
 Return the height in pixels of the text-displaying portion of WINDOW.
 */
 (window))
 {
 struct window *w = decode_window (window);
-return make_int (WINDOW_TEXT_HEIGHT (w));
+return make_fixnum (WINDOW_TEXT_HEIGHT (w));
 }
 DEFUN ("window-displayed-text-pixel-height",
 Fwindow_displayed_text_pixel_height, 0, 2, 0, /*
 Return the height in pixels of the text displayed in WINDOW.
 height = 0;
 for (i = elt; i < nelt; i++) {
 line = Dynarr_atp (cache, i)->height;
 if (height + line > hlimit)
-return make_int (!NILP (noclipped) ? height : hlimit);
+return make_fixnum (!NILP (noclipped) ? height : hlimit);
 height += line;
 if (height == hlimit || Dynarr_atp (cache, i)->end >= eobuf)
-return make_int (height);
+return make_fixnum (height);
 }
 /* get here => need more cache lines.  try again. */
 assert(height > prev_height); /* progress? */
 prev_height = height;
 needed += ((hlimit - height)*(nelt - elt) + height-1)/height + 3;
 }
-RETURN_NOT_REACHED(make_int (0));        /* shut up compiler */
+RETURN_NOT_REACHED(make_fixnum (0));        /* shut up compiler */
 }
 DEFUN ("window-width", Fwindow_width, 0, 1, 0, /*
 Return the number of display columns in WINDOW.
 This is the width that is usable columns available for text in WINDOW,
 and does not include vertical scrollbars, dividers, or the like.  See also
 `window-full-width' and `window-height'.
 */
 (window))
 {
-return make_int (window_char_width (decode_window (window), 0));
+return make_fixnum (window_char_width (decode_window (window), 0));
 }
 DEFUN ("window-full-width", Fwindow_full_width, 0, 1, 0, /*
 Return the total number of columns in WINDOW.
 This is like `window-width' but includes vertical scrollbars, dividers,
 etc.
 */
 (window))
 {
-return make_int (window_char_width (decode_window (window), 1));
+return make_fixnum (window_char_width (decode_window (window), 1));
 }
 DEFUN ("window-pixel-width", Fwindow_pixel_width, 0, 1, 0, /*
 Return the width of WINDOW in pixels.  Defaults to current window.
 */
 (window))
 {
-return make_int (decode_window (window)->pixel_width);
+return make_fixnum (decode_window (window)->pixel_width);
 }
 DEFUN ("window-text-area-pixel-width",
 Fwindow_text_area_pixel_width, 0, 1, 0, /*
 Return the width in pixels of the text-displaying portion of WINDOW.
 */
 (window))
 {
 struct window *w = decode_window (window);
-return make_int (WINDOW_TEXT_WIDTH (w));
+return make_fixnum (WINDOW_TEXT_WIDTH (w));
 }
 DEFUN ("window-hscroll", Fwindow_hscroll, 0, 1, 0, /*
 Return the number of columns by which WINDOW is scrolled from left margin.
 */
 (window))
 {
-return make_int (decode_window (window)->hscroll);
+return make_fixnum (decode_window (window)->hscroll);
 }
 DEFUN ("modeline-hscroll", Fmodeline_hscroll, 0, 1, 0, /*
 Return the horizontal scrolling amount of WINDOW's modeline.
 If the window has no modeline, return nil.
 */
 (window))
 {
 struct window *w = decode_window (window);
-return (WINDOW_HAS_MODELINE_P (w)) ? make_int ((int) w->modeline_hscroll) :
+return (WINDOW_HAS_MODELINE_P (w)) ? make_fixnum ((int) w->modeline_hscroll) :
 Qnil;
 }
 DEFUN ("set-modeline-hscroll", Fset_modeline_hscroll, 2, 2, 0, /*
 Set the horizontal scrolling amount of WINDOW's modeline to NCOL.
 if (WINDOW_HAS_MODELINE_P (w))
 {
 Charcount ncols;
-CHECK_INT (ncol);
+CHECK_FIXNUM (ncol);
-ncols = (XINT (ncol) <= 0) ? 0 : (Charcount) XINT (ncol);
+ncols = (XFIXNUM (ncol) <= 0) ? 0 : (Charcount) XFIXNUM (ncol);
 if (ncols != w->modeline_hscroll)
 	{
 	  MARK_MODELINE_CHANGED;
 	  w->modeline_hscroll = ncols;
 	}
-return make_int ((int) ncols);
+return make_fixnum ((int) ncols);
 }
 return Qnil;
 }
 (window, ncol))
 {
 struct window *w;
 int ncols;
-CHECK_INT (ncol);
+CHECK_FIXNUM (ncol);
-ncols = XINT (ncol);
+ncols = XFIXNUM (ncol);
 if (ncols < 0) ncols = 0;
 w = decode_window (window);
 if (w->hscroll != ncols)
 MARK_CLIP_CHANGED;	/* FSF marks differently but we aren't FSF. */
 w->hscroll = ncols;
 struct frame *f = XFRAME (w->frame);
 int left = w->pixel_left - FRAME_PANED_LEFT_EDGE (f);
 int top = w->pixel_top - FRAME_PANED_TOP_EDGE (f);
-return list4 (make_int (left),
+return list4 (make_fixnum (left),
-		make_int (top),
+		make_fixnum (top),
-		make_int (left + w->pixel_width),
+		make_fixnum (left + w->pixel_width),
-		make_int (top + w->pixel_height));
+		make_fixnum (top + w->pixel_height));
 }
 DEFUN ("window-text-area-pixel-edges",
 Fwindow_text_area_pixel_edges, 0, 1, 0, /*
 Return a list of the pixel edge coordinates of the text area of WINDOW.
 int left   = window_left_gutter_width (w, /* modeline = */ 0);
 int top    = window_top_gutter_height (w);
 int right  = WINDOW_WIDTH (w) - window_right_gutter_width (w, 0);
 int bottom = WINDOW_HEIGHT (w) - window_bottom_gutter_height (w);
-return list4 (make_int (left),
+return list4 (make_fixnum (left),
-		make_int (top),
+		make_fixnum (top),
-		make_int (right),
+		make_fixnum (right),
-		make_int (bottom));
+		make_fixnum (bottom));
 }
 DEFUN ("window-point", Fwindow_point, 0, 1, 0, /*
 Return current value of point in WINDOW.
 For a non-selected window, this is the value point would have
 if (NILP (guarantee))
 {
 Lisp_Object buf;
 buf = w->buffer;
 CHECK_BUFFER (buf);
-return make_int (BUF_Z (XBUFFER (buf)) - w->window_end_pos[CURRENT_DISP]);
+return make_fixnum (BUF_Z (XBUFFER (buf)) - w->window_end_pos[CURRENT_DISP]);
 }
 else
 {
 Charbpos startp = marker_position (w->start[CURRENT_DISP]);
-return make_int (end_of_last_line (w, startp));
+return make_fixnum (end_of_last_line (w, startp));
 }
 }
 DEFUN ("window-last-line-visible-height", Fwindow_last_line_visible_height, 0, 1, 0, /*
 Return pixel height of visible part of last window line if it is clipped.
 dl = Dynarr_atp (dla, num_lines - 1);
 if (dl->clip == 0)
 return Qnil;
-return make_int (dl->ascent + dl->descent - dl->clip);
+return make_fixnum (dl->ascent + dl->descent - dl->clip);
 }
 DEFUN ("set-window-point", Fset_window_point, 2, 2, 0, /*
 Make point value in WINDOW be at position POS in WINDOW's buffer.
 If WINDOW is the selected window, and window's buffer is the current
 */
 (window, pos))
 {
 struct window *w = decode_window (window);
-CHECK_INT_COERCE_MARKER (pos);
+CHECK_FIXNUM_COERCE_MARKER (pos);
 /* Don't dereference selected-window because there may not
 be one -- e.g. at startup */
 if (EQ (wrap_window (w), Fselected_window (Qnil))
 && EQ (w->buffer, Fcurrent_buffer ()))
 */
 (window, pos, noforce))
 {
 struct window *w = decode_window (window);
-CHECK_INT_COERCE_MARKER (pos);
+CHECK_FIXNUM_COERCE_MARKER (pos);
 set_marker_restricted (w->start[CURRENT_DISP], pos, w->buffer);
 /* this is not right, but much easier than doing what is right. */
 /* w->start_at_line_beg = 0; */
 /* WTF is the above supposed to mean?  GE */
 w->start_at_line_beg = beginning_of_line_p (XBUFFER (w->buffer),
 {
 	marker = Fmake_marker ();
 	Fputhash (buf, marker, w->saved_point_cache);
 }
 Fset_marker (marker,
-		 selected ? make_int (BUF_PT (b)) : w->pointm[CURRENT_DISP],
+		 selected ? make_fixnum (BUF_PT (b)) : w->pointm[CURRENT_DISP],
 		 buf);
 marker = Fgethash (buf, w->saved_last_window_start_cache, Qnil);
 if (NILP (marker))
 (count, which_frames, which_devices))
 {
 int i;
 Lisp_Object w;
-CHECK_INT (count);
+CHECK_FIXNUM (count);
 w = Fselected_window (Qnil);
-i = XINT (count);
+i = XFIXNUM (count);
 while (i > 0)
 {
 w = Fnext_window (w, Qnil, which_frames, which_devices);
 i--;
 		  /* Ignore dedicated windows and minibuffers.  */
 		  if (MINI_WINDOW_P (p)
 		      || (dedicated_too ? 0 : !NILP (p->dedicated)))
 		    break;
 		  if (NILP (best_window)
-		      || (XINT (XWINDOW (best_window)->use_time)
+		      || (XFIXNUM (XWINDOW (best_window)->use_time)
-			  > XINT (p->use_time)))
+			  > XFIXNUM (p->use_time)))
 		    best_window = w;
 		  break;
 		}
 	      case GET_BUFFER_MRU_WINDOW:
 		    break;
 		  if (XBUFFER (p->buffer) == XBUFFER (obj))
 		    {
 		      if (NILP (best_window)
-			  || (XINT (XWINDOW (best_window)->use_time)
+			  || (XFIXNUM (XWINDOW (best_window)->use_time)
-			      < XINT (p->use_time)))
+			      < XFIXNUM (p->use_time)))
 			best_window = w;
 		    }
 		  break;
 		}
 	  w = next_window;
 	}
 }
-return type == GET_BUFFER_WINDOW_COUNT ? make_int (count) : best_window;
+return type == GET_BUFFER_WINDOW_COUNT ? make_fixnum (count) : best_window;
 }
 #if 0 /* not currently used */
 int
 Lisp_Object buffer, frame;
 frame = wrap_frame (f);
 buffer = wrap_buffer (b);
-return XINT (window_loop (GET_BUFFER_WINDOW_COUNT, buffer, 0, frame, 1,
+return XFIXNUM (window_loop (GET_BUFFER_WINDOW_COUNT, buffer, 0, frame, 1,
 			    Qnil));
 }
 int
 buffer_window_mru (struct window *w)
 Return the width in pixels of the left outside margin of window WINDOW.
 If WINDOW is nil, the selected window is assumed.
 */
 (window))
 {
-return make_int (window_left_margin_width (decode_window (window)));
+return make_fixnum (window_left_margin_width (decode_window (window)));
 }
 DEFUN ("window-right-margin-pixel-width", Fwindow_right_margin_pixel_width,
 0, 1, 0, /*
 Return the width in pixels of the right outside margin of window WINDOW.
 If WINDOW is nil, the selected window is assumed.
 */
 (window))
 {
-return make_int (window_right_margin_width (decode_window (window)));
+return make_fixnum (window_right_margin_width (decode_window (window)));
 }
 DEFUN ("delete-other-windows", Fdelete_other_windows, 0, 1, "", /*
 Make WINDOW (or the selected window) fill its frame.
 Only the frame WINDOW is on is affected.
 {
 Charbpos new_start = start_with_line_at_pixpos (w, start_pos, old_top);
 if (new_start >= BUF_BEGV (b) && new_start <= BUF_ZV (b))
 	{
-	  Fset_marker (w->start[CURRENT_DISP], make_int (new_start),
+	  Fset_marker (w->start[CURRENT_DISP], make_fixnum (new_start),
 		       w->buffer);
 	  w->start_at_line_beg = beginning_of_line_p (b, new_start);
 	}
 /* We need to do this, so that the window-scroll-functions
 	 get called.  */
 w->window_end_pos[CURRENT_DISP] = 0;
 w->hscroll = 0;
 w->modeline_hscroll = 0;
 #if 0 /* pre point caches */
 Fset_marker (w->pointm[CURRENT_DISP],
-	       make_int (BUF_PT (XBUFFER (buffer))),
+	       make_fixnum (BUF_PT (XBUFFER (buffer))),
 	       buffer);
 set_marker_restricted (w->start[CURRENT_DISP],
-			 make_int (XBUFFER (buffer)->last_window_start),
+			 make_fixnum (XBUFFER (buffer)->last_window_start),
 			 buffer);
 #else
 {
 Lisp_Object marker = Fgethash (buffer, w->saved_point_cache, Qnil);
 Lisp_Object newpoint =
-!NILP (marker) ? make_int (marker_position (marker)) :
+!NILP (marker) ? make_fixnum (marker_position (marker)) :
-make_int (BUF_PT (XBUFFER (buffer)));
+make_fixnum (BUF_PT (XBUFFER (buffer)));
 /* Previously, we had in here set-window-point, which did one of the
 following two, but not both.  However, that could result in pointm
 being in a different buffer from the window's buffer!  Probably
 not a travesty since it always occurred when the window was
 selected, meaning its value of point was ignored in favor of the
 Fgoto_char (newpoint, buffer); /* this will automatically clip to
 					accessible */
 marker = Fgethash (buffer, w->saved_last_window_start_cache, Qnil);
 set_marker_restricted (w->start[CURRENT_DISP],
 			   !NILP (marker) ?
-			   make_int (marker_position (marker)) :
+			   make_fixnum (marker_position (marker)) :
-			   make_int (XBUFFER (buffer)->last_window_start),
+			   make_fixnum (XBUFFER (buffer)->last_window_start),
 			   buffer);
 }
 #endif
 Fset_marker (w->sb_point, w->start[CURRENT_DISP], buffer);
 	Frecord_buffer (buffer);
 Fset_buffer (buffer);
 }
 if (NILP (XBUFFER (buffer)->display_count))
-XBUFFER (buffer)->display_count = make_int (1);
+XBUFFER (buffer)->display_count = make_fixnum (1);
 else
-XBUFFER (buffer)->display_count = make_int (1 + XINT (XBUFFER (buffer)->display_count));
+XBUFFER (buffer)->display_count = make_fixnum (1 + XFIXNUM (XBUFFER (buffer)->display_count));
 XBUFFER (buffer)->display_time = Fcurrent_time();
 return Qnil;
 }
 DEFUN ("select-window", Fselect_window, 1, 2, 0, /*
 /* we have already caught dead-window errors */
 if (!NILP (w->hchild) || !NILP (w->vchild))
 invalid_operation ("Trying to select non-leaf window", Qunbound);
-w->use_time = make_int (++window_select_count);
+w->use_time = make_fixnum (++window_select_count);
 if (EQ (window, old_selected_window))
 return window;
 /* deselect the old window, if it exists (it might not exist if
 if (!NILP (old_selected_window))
 {
 struct window *ow = XWINDOW (old_selected_window);
 Fset_marker (ow->pointm[CURRENT_DISP],
-		   make_int (BUF_PT (XBUFFER (ow->buffer))),
+		   make_fixnum (BUF_PT (XBUFFER (ow->buffer))),
 		   ow->buffer);
 MARK_WINDOWS_CHANGED (ow);
 }
 Vminibuffer_scroll_window = window;
 w = XWINDOW (window);
 w->hscroll = 0;
 w->modeline_hscroll = 0;
-set_marker_restricted (w->start[CURRENT_DISP], make_int (1), buf);
+set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (1), buf);
-set_marker_restricted (w->pointm[CURRENT_DISP], make_int (1), buf);
+set_marker_restricted (w->pointm[CURRENT_DISP], make_fixnum (1), buf);
-set_marker_restricted (w->sb_point, make_int (1), buf);
+set_marker_restricted (w->sb_point, make_fixnum (1), buf);
 }
 }
 static void
 make_dummy_parent (Lisp_Object window)
 	  csize = window_pixel_height_to_char_height (o, psize, 1);
 }
 }
 else
 {
-CHECK_INT (size);
+CHECK_FIXNUM (size);
-csize = XINT (size);
+csize = XFIXNUM (size);
 if (!NILP (horflag))
 	psize = window_char_width_to_pixel_width (o, csize, 0);
 else
 	psize = window_char_height_to_pixel_height (o, csize, 1);
 }
 check_min_window_sizes ();
 if (NILP (horflag))
 {
 if (csize < window_min_height)
-	signal_error (Qinvalid_operation, "Window height too small (after splitting)", make_int (csize));
+	signal_error (Qinvalid_operation, "Window height too small (after splitting)", make_fixnum (csize));
 if (csize + window_min_height > window_char_height (o, 1))
 	signal_error (Qinvalid_operation, "Window height too small (after splitting)",
-	       make_int (window_char_height (o, 1) - csize));
+	       make_fixnum (window_char_height (o, 1) - csize));
 if (NILP (o->parent)
 	  || NILP (XWINDOW (o->parent)->vchild))
 	{
 	  make_dummy_parent (window);
 #if 0
 	}
 }
 else
 {
 if (csize < window_min_width)
-	signal_error (Qinvalid_operation, "Window width too small (after splitting)", make_int (csize));
+	signal_error (Qinvalid_operation, "Window width too small (after splitting)", make_fixnum (csize));
 if (csize + window_min_width > window_char_width (o, 0))
 	signal_error (Qinvalid_operation, "Window width too small (after splitting)",
-	       make_int (window_char_width (o, 0) - csize));
+	       make_fixnum (window_char_width (o, 0) - csize));
 if (NILP (o->parent)
 	  || NILP (XWINDOW (o->parent)->hchild))
 	{
 	  make_dummy_parent (window);
 #if 0
 sideways COUNT columns, and optional third arg WINDOW specifies the
 window to change instead of the selected window.
 */
 (count, horizontalp, window))
 {
-CHECK_INT (count);
+CHECK_FIXNUM (count);
-change_window_height (window, XINT (count), horizontalp, /* inpixels */ 0);
+change_window_height (window, XFIXNUM (count), horizontalp, /* inpixels */ 0);
 return Qnil;
 }
 DEFUN ("enlarge-window-pixels", Fenlarge_window_pixels, 1, 3, "_p", /*
 Make the selected window COUNT pixels taller.
 sideways COUNT pixels, and optional third arg WINDOW specifies the
 window to change instead of the selected window.
 */
 (count, horizontalp, window))
 {
-CHECK_INT (count);
+CHECK_FIXNUM (count);
-change_window_height (window, XINT (count), horizontalp, /* inpixels */ 1);
+change_window_height (window, XFIXNUM (count), horizontalp, /* inpixels */ 1);
 return Qnil;
 }
 DEFUN ("shrink-window", Fshrink_window, 1, 3, "_p", /*
 Make the selected window COUNT lines shorter.
 sideways COUNT columns, and optional third arg WINDOW specifies the
 window to change instead of the selected window.
 */
 (count, horizontalp, window))
 {
-CHECK_INT (count);
+CHECK_FIXNUM (count);
-change_window_height (window, -XINT (count), horizontalp, /* inpixels */ 0);
+change_window_height (window, -XFIXNUM (count), horizontalp, /* inpixels */ 0);
 return Qnil;
 }
 DEFUN ("shrink-window-pixels", Fshrink_window_pixels, 1, 3, "_p", /*
 Make the selected window COUNT pixels smaller.
 sideways COUNT pixels, and optional third arg WINDOW specifies the
 window to change instead of the selected window.
 */
 (count, horizontalp, window))
 {
-CHECK_INT (count);
+CHECK_FIXNUM (count);
-change_window_height (window, -XINT (count), horizontalp, /* inpixels */ 1);
+change_window_height (window, -XFIXNUM (count), horizontalp, /* inpixels */ 1);
 return Qnil;
 }
 static int
 window_pixel_height_to_char_height (struct window *w, int pixel_height,
 display_line_dynarr *dla;
 int fheight, fwidth, modeline = 0;
 struct display_line* dl;
 if (selected)
-point = make_int (BUF_PT (b));
+point = make_fixnum (BUF_PT (b));
 else
 {
 Charbpos pos = marker_position (w->pointm[CURRENT_DISP]);
 if (pos < BUF_BEGV (b))
 	pos = BUF_BEGV (b);
 else if (pos > BUF_ZV (b))
 	pos = BUF_ZV (b);
-point = make_int (pos);
+point = make_fixnum (pos);
 }
 /* Always set force_start so that redisplay_window will run
 the window-scroll-functions.  */
 w->force_start = 1;
 completely documented the behavior of the scrolling functions under
 all circumstances. */
 tem = Fpos_visible_in_window_p (point, window, Qnil);
 if (NILP (tem))
 {
-Fvertical_motion (make_int (-window_char_height (w, 0) / 2),
+Fvertical_motion (make_fixnum (-window_char_height (w, 0) / 2),
 window, Qnil);
 Fset_marker (w->start[CURRENT_DISP], point, w->buffer);
-w->start_at_line_beg = beginning_of_line_p (b, XINT (point));
+w->start_at_line_beg = beginning_of_line_p (b, XFIXNUM (point));
 WINDOW_TEXT_TOP_CLIP (w) = 0;
 MARK_WINDOWS_CHANGED (w);
 }
 if (!NILP (count))
 if (EQ (count, Qminus))
 	direction *= -1;
 else
 	{
 	  count = Fprefix_numeric_value (count);
-	  value = XINT (count) * direction;
+	  value = XFIXNUM (count) * direction;
 	  if (!value)
 	    return;	/* someone just made a pointless call */
 	}
 }
 }
 /* Determine parameters to test for partial line scrolling with. */
 dla = window_display_lines (w, CURRENT_DISP);
-if (INTP (Vwindow_pixel_scroll_increment))
+if (FIXNUMP (Vwindow_pixel_scroll_increment))
-fheight = XINT (Vwindow_pixel_scroll_increment);
+fheight = XFIXNUM (Vwindow_pixel_scroll_increment);
 else if (!NILP (Vwindow_pixel_scroll_increment))
 default_face_width_and_height (window, &fwidth, &fheight);
 if (Dynarr_length (dla) >= 1)
 modeline = Dynarr_begin (dla)->modeline;
 	      maybe_signal_error_1 (Qend_of_buffer, Qnil, Qwindow, errb);
 	      return;
 	    }
 	  else
 	    {
-	      set_marker_restricted (w->start[CURRENT_DISP], make_int (startp),
+	      set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (startp),
 				     w->buffer);
 	      w->force_start = 1;
 	      w->start_at_line_beg = beginning_of_line_p (b, startp);
 	      MARK_WINDOWS_CHANGED (w);
-	      if (!point_would_be_visible (w, startp, XINT (point), 0))
+	      if (!point_would_be_visible (w, startp, XFIXNUM (point), 0))
-		Fset_window_point (wrap_window (w), make_int (startp));
+		Fset_window_point (wrap_window (w), make_fixnum (startp));
 	    }
 	}
 }
 else if (value < 0)
 {
 	      maybe_signal_error_1 (Qbeginning_of_buffer, Qnil, Qwindow, errb);
 	      return;
 	    }
 	  else
 	    {
-	      set_marker_restricted (w->start[CURRENT_DISP], make_int (startp),
+	      set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (startp),
 				     w->buffer);
 	      w->force_start = 1;
 	      w->start_at_line_beg = beginning_of_line_p (b, startp);
 	      MARK_WINDOWS_CHANGED (w);
 		  && dl->ascent + fheight * value > 0)
 		{
 		  WINDOW_TEXT_TOP_CLIP (w) = (dl->ascent + fheight * value);
 		}
-	      if (!point_would_be_visible (w, startp, XINT (point), 0))
+	      if (!point_would_be_visible (w, startp, XFIXNUM (point), 0))
 		{
 		  Charbpos new_point;
 		  if (MINI_WINDOW_P (w))
 		    new_point = startp;
 		  else
 		    new_point = start_of_last_line (w, startp);
-		  Fset_window_point (wrap_window (w), make_int (new_point));
+		  Fset_window_point (wrap_window (w), make_fixnum (new_point));
 		}
 	    }
 	}
 }
 else	/* value == 0 && direction == -1 */
 					      -1 - (movement - vtarget));
 	  if (startp >= old_startp)
 	    startp = vmotion (w, old_startp, -1, NULL);
-	  set_marker_restricted (w->start[CURRENT_DISP], make_int (startp),
+	  set_marker_restricted (w->start[CURRENT_DISP], make_fixnum (startp),
 				 w->buffer);
 	  w->force_start = 1;
 	  w->start_at_line_beg = beginning_of_line_p (b, startp);
 	  MARK_WINDOWS_CHANGED (w);
-	  if (!point_would_be_visible (w, startp, XINT (point), 0))
+	  if (!point_would_be_visible (w, startp, XFIXNUM (point), 0))
 	    {
 	      Charbpos new_point = start_of_last_line (w, startp);
-	      Fset_window_point (wrap_window (w), make_int (new_point));
+	      Fset_window_point (wrap_window (w), make_fixnum (new_point));
 	    }
 	}
 }
 }
 {
 Lisp_Object window = Fselected_window (Qnil);
 struct window *w = XWINDOW (window);
 int n = (NILP (count) ?
 	   window_char_width (w, 0) - 2 :
-	   XINT (Fprefix_numeric_value (count)));
+	   XFIXNUM (Fprefix_numeric_value (count)));
-return Fset_window_hscroll (window, make_int (w->hscroll + n));
+return Fset_window_hscroll (window, make_fixnum (w->hscroll + n));
 }
 DEFUN ("scroll-right", Fscroll_right, 0, 1, "_P", /*
 Scroll selected window display COUNT columns right.
 Default for COUNT is window width minus 2.
 {
 Lisp_Object window = Fselected_window (Qnil);
 struct window *w = XWINDOW (window);
 int n = (NILP (count) ?
 	   window_char_width (w, 0) - 2 :
-	   XINT (Fprefix_numeric_value (count)));
+	   XFIXNUM (Fprefix_numeric_value (count)));
-return Fset_window_hscroll (window, make_int (w->hscroll - n));
+return Fset_window_hscroll (window, make_fixnum (w->hscroll - n));
 }
 DEFUN ("center-to-window-line", Fcenter_to_window_line, 0, 2, "_P", /*
 Center point in WINDOW.  With N, put point on line N.
 The desired position of point is always relative to the window.
 if (NILP (n))
 startp = start_with_line_at_pixpos (w, opoint, window_half_pixpos (w));
 else
 {
 n = Fprefix_numeric_value (n);
-CHECK_INT (n);
+CHECK_FIXNUM (n);
-startp = start_with_point_on_display_line (w, opoint, XINT (n));
+startp = start_with_point_on_display_line (w, opoint, XFIXNUM (n));
 }
-Fset_marker (w->start[CURRENT_DISP], make_int (startp), w->buffer);
+Fset_marker (w->start[CURRENT_DISP], make_fixnum (startp), w->buffer);
 w->start_at_line_beg = beginning_of_line_p (b, startp);
 w->force_start = 1;
 MARK_WINDOWS_CHANGED (w);
 return Qnil;
 if (NILP (arg))
 {
 int retval;
-if (XINT (w->last_modified[CURRENT_DISP]) >= BUF_MODIFF (b)
+if (XFIXNUM (w->last_modified[CURRENT_DISP]) >= BUF_MODIFF (b)
-	  && XINT (w->last_facechange[CURRENT_DISP]) >= BUF_FACECHANGE (b))
+	  && XFIXNUM (w->last_facechange[CURRENT_DISP]) >= BUF_FACECHANGE (b))
 	{
 	  new_point = point_at_center (w, CURRENT_DISP, 0, 0);
 	  /* #### Here we are checking the selected window of the frame
 	     instead of the selected window period.  Elsewhere we check
 	     the selected window of the device.  What a mess! */
 	  if (selected)
 	    BUF_SET_PT (b, new_point);
 	  else
-	    Fset_window_point (window, make_int (new_point));
+	    Fset_window_point (window, make_fixnum (new_point));
 	  retval = line_at_center (w, CURRENT_DISP, 0, 0);
 	}
 else
 	{
 	  new_point = point_at_center (w, CMOTION_DISP, start, BUF_PT (b));
 	  if (selected)
 	    BUF_SET_PT (b, new_point);
 	  else
-	    Fset_window_point (window, make_int (new_point));
+	    Fset_window_point (window, make_fixnum (new_point));
 	  retval = line_at_center (w, CMOTION_DISP, start, BUF_PT (b));
 	}
-return make_int (retval);
+return make_fixnum (retval);
 }
 else
 {
 /* #### Is this going to work right when at eob? */
 arg = Fprefix_numeric_value (arg);
-if (XINT (arg) < 0)
+if (XFIXNUM (arg) < 0)
-	arg = make_int (XINT (arg) + height);
+	arg = make_fixnum (XFIXNUM (arg) + height);
 }
 start = marker_position (w->start[CURRENT_DISP]);
 if (start < BUF_BEGV (b) || start > BUF_ZV (b))
 {
 new_point = vmotion (XWINDOW (window), new_point, -height / 2, 0);
 if (selected)
 	BUF_SET_PT (b, new_point);
 else
-	Fset_window_point (window, make_int (new_point));
+	Fset_window_point (window, make_fixnum (new_point));
-Fset_marker (w->start[CURRENT_DISP], make_int (new_point),
+Fset_marker (w->start[CURRENT_DISP], make_fixnum (new_point),
 		   w->buffer);
 w->start_at_line_beg = beginning_of_line_p (b, new_point);
 w->force_start = 1;
 }
 else
 {
 if (selected)
 	BUF_SET_PT (b, start);
 else
-	Fset_window_point (window, make_int (start));
+	Fset_window_point (window, make_fixnum (start));
 }
 if (selected)
 return Fvertical_motion (arg, window, Qnil);
 else
 {
 int vpos;
 new_point = vmotion (XWINDOW (window),
 			   marker_position (w->pointm[CURRENT_DISP]),
-			   XINT (arg), &vpos);
+			   XFIXNUM (arg), &vpos);
-Fset_window_point (window, make_int (new_point));
+Fset_window_point (window, make_fixnum (new_point));
-return make_int (vpos);
+return make_fixnum (vpos);
 }
 }
 static int
 Charbpos point;
 if (NILP (pos))
 	pos = Fwindow_point (window);
-CHECK_INT (pos);
+CHECK_FIXNUM (pos);
-point = XINT (pos);
+point = XFIXNUM (pos);
 if (Dynarr_length (dla) && Dynarr_begin (dla)->modeline)
 	first_line = 1;
 else
 	first_line = 0;
 struct rune* rb;
 if (!get_current_pixel_pos(window, pos, &w, &rb, &dl))
 return Qnil;
-return make_int (rb->xpos - WINDOW_LEFT (w));
+return make_fixnum (rb->xpos - WINDOW_LEFT (w));
 }
 DEFUN ("current-pixel-row", Fcurrent_pixel_row, 0, 2, 0, /*
 Return the vertical pixel position of point POS in window.  Top of
 window is row 0.  If WINDOW is nil, the current window is assumed.  If
 struct rune* rb;
 if (!get_current_pixel_pos(window, pos, &w, &rb, &dl))
 return Qnil;
-return make_int (dl->ypos - dl->ascent - WINDOW_TOP (w));
+return make_fixnum (dl->ypos - dl->ascent - WINDOW_TOP (w));
 }
 #ifdef DEBUG_XEMACS
 /* This is short and simple in elisp, but... it was written to debug
 /* The initial value for modeline-shadow-thickness is 2, but if the
 user removes all specifications we provide a fallback value of 0,
 which is probably what was expected. */
 set_specifier_fallback (Vmodeline_shadow_thickness,
 			  list1 (Fcons (Qnil, Qzero)));
-Fadd_spec_to_specifier (Vmodeline_shadow_thickness, make_int (2),
+Fadd_spec_to_specifier (Vmodeline_shadow_thickness, make_fixnum (2),
 			  Qnil, Qnil, Qnil);
 set_specifier_caching (Vmodeline_shadow_thickness,
 			 offsetof (struct window, modeline_shadow_thickness),
 			 modeline_shadow_thickness_changed,
 			 0, 0, 0);
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vvertical_divider_shadow_thickness = Fmake_specifier (Qinteger);
 set_specifier_fallback (Vvertical_divider_shadow_thickness,
 			  list1 (Fcons (Qnil, Qzero)));
-Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_int (2),
+Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_fixnum (2),
 			  Qnil, Qnil, Qnil);
 set_specifier_caching (Vvertical_divider_shadow_thickness,
 			 offsetof (struct window,
 				   vertical_divider_shadow_thickness),
 			 vertical_divider_changed_in_window,
 Vvertical_divider_line_width = Fmake_specifier (Qnatnum);
 {
 Lisp_Object fb = Qnil;
 #ifdef HAVE_TTY
-fb = Fcons (Fcons (list1 (Qtty), make_int (1)), fb);
+fb = Fcons (Fcons (list1 (Qtty), make_fixnum (1)), fb);
 #endif
 #ifdef HAVE_GTK
-fb = Fcons (Fcons (list1 (Qgtk), make_int (3)), fb);
+fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (3)), fb);
 #endif
 #ifdef HAVE_X_WINDOWS
-fb = Fcons (Fcons (list1 (Qx), make_int (3)), fb);
+fb = Fcons (Fcons (list1 (Qx), make_fixnum (3)), fb);
 #endif
 #ifdef HAVE_MS_WINDOWS
 /* #### This should be made magic and made to obey system settings */
-fb = Fcons (Fcons (list1 (Qmswindows), make_int (3)), fb);
+fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (3)), fb);
 #endif
 set_specifier_fallback (Vvertical_divider_line_width, fb);
 }
 set_specifier_caching (Vvertical_divider_line_width,
 offsetof (struct window,
 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
 #endif
 #ifdef HAVE_X_WINDOWS
 /* #### 3D dividers look great on MS Windows with spacing = 0.
 Should not the same value be the fallback under X? - kkm */
-fb = Fcons (Fcons (list1 (Qx), make_int (2)), fb);
+fb = Fcons (Fcons (list1 (Qx), make_fixnum (2)), fb);
 #endif
 #ifdef HAVE_GTK
 fb = Fcons (Fcons (list1 (Qgtk), Qzero), fb);
 #endif
 #ifdef HAVE_MS_WINDOWS

Mercurial > hg > xemacs-beta

comparison src/window.c @ 5581:56144c8593a8