Mercurial > emacs

comparison src/xdisp.c @ 9104:610e18fd64a9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
(redisplay, mark_window_display_accurate, try_window_id, display_text_line, display_mode_element, decode_mode_spec, display_string): Use type test macros.
author Karl Heuer <kwzh@gnu.org>
date Tue, 27 Sep 1994 00:37:04 +0000
parents f29b14d21b26
children db4473eb2265
comparison
equal deleted inserted replaced
9103:948e8acb6990 9104:610e18fd64a9
636 && (XFASTINT (w->last_modified) >= MODIFF 636 && (XFASTINT (w->last_modified) >= MODIFF
637 || (beg_unchanged >= tlbufpos - 1 637 || (beg_unchanged >= tlbufpos - 1
638 && GPT >= tlbufpos 638 && GPT >= tlbufpos
639 /* If selective display, can't optimize 639 /* If selective display, can't optimize
640 if the changes start at the beginning of the line. */ 640 if the changes start at the beginning of the line. */
641 && ((XTYPE (current_buffer->selective_display) == Lisp_Int 641 && ((INTEGERP (current_buffer->selective_display)
642 && XINT (current_buffer->selective_display) > 0 642 && XINT (current_buffer->selective_display) > 0
643 ? (beg_unchanged >= tlbufpos 643 ? (beg_unchanged >= tlbufpos
644 && GPT > tlbufpos) 644 && GPT > tlbufpos)
645 : 1)) 645 : 1))
646 && end_unchanged >= tlendpos 646 && end_unchanged >= tlendpos
788 788
789 for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr) 789 for (tail = Vframe_list; CONSP (tail); tail = XCONS (tail)->cdr)
790 { 790 {
791 FRAME_PTR f; 791 FRAME_PTR f;
792 792
793 if (XTYPE (XCONS (tail)->car) != Lisp_Frame) 793 if (!FRAMEP (XCONS (tail)->car))
794 continue; 794 continue;
795 795
796 f = XFRAME (XCONS (tail)->car); 796 f = XFRAME (XCONS (tail)->car);
797 if (FRAME_VISIBLE_P (f)) 797 if (FRAME_VISIBLE_P (f))
798 { 798 {
926 { 926 {
927 register struct window *w; 927 register struct window *w;
928 928
929 for (;!NILP (window); window = w->next) 929 for (;!NILP (window); window = w->next)
930 { 930 {
931 if (XTYPE (window) != Lisp_Window) abort (); 931 if (!WINDOWP (window)) abort ();
932 w = XWINDOW (window); 932 w = XWINDOW (window);
933 933
934 if (!NILP (w->buffer)) 934 if (!NILP (w->buffer))
935 { 935 {
936 XFASTINT (w->last_modified) 936 XFASTINT (w->last_modified)
1461 int lmargin = hscroll > 0 ? 1 - hscroll : 0; 1461 int lmargin = hscroll > 0 ? 1 - hscroll : 0;
1462 register int vpos; 1462 register int vpos;
1463 register int i, tem; 1463 register int i, tem;
1464 int last_text_vpos = 0; 1464 int last_text_vpos = 0;
1465 int stop_vpos; 1465 int stop_vpos;
1466 int selective 1466 int selective = (INTEGERP (current_buffer->selective_display)
1467 = XTYPE (current_buffer->selective_display) == Lisp_Int 1467 ? XINT (current_buffer->selective_display)
1468 ? XINT (current_buffer->selective_display) 1468 : !NILP (current_buffer->selective_display) ? -1 : 0);
1469 : !NILP (current_buffer->selective_display) ? -1 : 0;
1470 1469
1471 struct position val, bp, ep, xp, pp; 1470 struct position val, bp, ep, xp, pp;
1472 int scroll_amount = 0; 1471 int scroll_amount = 0;
1473 int delta; 1472 int delta;
1474 int tab_offset, epto; 1473 int tab_offset, epto;
2031 /* 1 if we should highlight the region. */ 2030 /* 1 if we should highlight the region. */
2032 int highlight_region 2031 int highlight_region
2033 = !NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active); 2032 = !NILP (Vtransient_mark_mode) && !NILP (current_buffer->mark_active);
2034 int region_beg, region_end; 2033 int region_beg, region_end;
2035 2034
2036 int selective 2035 int selective = (INTEGERP (current_buffer->selective_display)
2037 = XTYPE (current_buffer->selective_display) == Lisp_Int 2036 ? XINT (current_buffer->selective_display)
2038 ? XINT (current_buffer->selective_display) 2037 : !NILP (current_buffer->selective_display) ? -1 : 0);
2039 : !NILP (current_buffer->selective_display) ? -1 : 0;
2040 register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f); 2038 register struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f);
2041 register struct Lisp_Vector *dp = window_display_table (w); 2039 register struct Lisp_Vector *dp = window_display_table (w);
2042 2040
2043 Lisp_Object default_invis_vector[3]; 2041 Lisp_Object default_invis_vector[3];
2044 /* Nonzero means display something where there are invisible lines. 2042 /* Nonzero means display something where there are invisible lines.
2045 The precise value is the number of glyphs to display. */ 2043 The precise value is the number of glyphs to display. */
2046 int selective_rlen 2044 int selective_rlen
2047 = (selective && dp && XTYPE (DISP_INVIS_VECTOR (dp)) == Lisp_Vector 2045 = (selective && dp && VECTORP (DISP_INVIS_VECTOR (dp))
2048 ? XVECTOR (DISP_INVIS_VECTOR (dp))->size 2046 ? XVECTOR (DISP_INVIS_VECTOR (dp))->size
2049 : selective && !NILP (current_buffer->selective_display_ellipses) 2047 : selective && !NILP (current_buffer->selective_display_ellipses)
2050 ? 3 : 0); 2048 ? 3 : 0);
2051 /* This is the sequence of Lisp objects to display 2049 /* This is the sequence of Lisp objects to display
2052 when there are invisible lines. */ 2050 when there are invisible lines. */
2053 Lisp_Object *invis_vector_contents 2051 Lisp_Object *invis_vector_contents
2054 = (dp && XTYPE (DISP_INVIS_VECTOR (dp)) == Lisp_Vector 2052 = (dp && VECTORP (DISP_INVIS_VECTOR (dp))
2055 ? XVECTOR (DISP_INVIS_VECTOR (dp))->contents 2053 ? XVECTOR (DISP_INVIS_VECTOR (dp))->contents
2056 : default_invis_vector); 2054 : default_invis_vector);
2057 2055
2058 GLYPH truncator = (dp == 0 || XTYPE (DISP_TRUNC_GLYPH (dp)) != Lisp_Int 2056 GLYPH truncator = (dp == 0 || !INTEGERP (DISP_TRUNC_GLYPH (dp))
2059 ? '$' : XINT (DISP_TRUNC_GLYPH (dp))); 2057 ? '$' : XINT (DISP_TRUNC_GLYPH (dp)));
2060 GLYPH continuer = (dp == 0 || XTYPE (DISP_CONTINUE_GLYPH (dp)) != Lisp_Int 2058 GLYPH continuer = (dp == 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp))
2061 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp))); 2059 ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));
2062 2060
2063 /* The next buffer location at which the face should change, due 2061 /* The next buffer location at which the face should change, due
2064 to overlays or text property changes. */ 2062 to overlays or text property changes. */
2065 int next_face_change; 2063 int next_face_change;
2229 2227
2230 p = &FETCH_CHAR (pos); 2228 p = &FETCH_CHAR (pos);
2231 } 2229 }
2232 c = *p++; 2230 c = *p++;
2233 if (c >= 040 && c < 0177 2231 if (c >= 040 && c < 0177
2234 && (dp == 0 || XTYPE (DISP_CHAR_VECTOR (dp, c)) != Lisp_Vector)) 2232 && (dp == 0 || !VECTORP (DISP_CHAR_VECTOR (dp, c))))
2235 { 2233 {
2236 if (p1 >= leftmargin) 2234 if (p1 >= leftmargin)
2237 *p1 = MAKE_GLYPH (f, c, current_face); 2235 *p1 = MAKE_GLYPH (f, c, current_face);
2238 p1++; 2236 p1++;
2239 } 2237 }
2305 *p1++ = FAST_MAKE_GLYPH (' ', current_face); 2303 *p1++ = FAST_MAKE_GLYPH (' ', current_face);
2306 } 2304 }
2307 #endif 2305 #endif
2308 break; 2306 break;
2309 } 2307 }
2310 else if (dp != 0 && XTYPE (DISP_CHAR_VECTOR (dp, c)) == Lisp_Vector) 2308 else if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
2311 { 2309 {
2312 p1 = copy_part_of_rope (f, p1, leftmargin, 2310 p1 = copy_part_of_rope (f, p1, leftmargin,
2313 XVECTOR (DISP_CHAR_VECTOR (dp, c))->contents, 2311 XVECTOR (DISP_CHAR_VECTOR (dp, c))->contents,
2314 XVECTOR (DISP_CHAR_VECTOR (dp, c))->size, 2312 XVECTOR (DISP_CHAR_VECTOR (dp, c))->size,
2315 current_face); 2313 current_face);
2316 } 2314 }
2317 else if (c < 0200 && ctl_arrow) 2315 else if (c < 0200 && ctl_arrow)
2318 { 2316 {
2319 if (p1 >= leftmargin) 2317 if (p1 >= leftmargin)
2320 *p1 = fix_glyph (f, (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int 2318 *p1 = fix_glyph (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
2321 ? XINT (DISP_CTRL_GLYPH (dp)) : '^'), 2319 ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
2322 current_face); 2320 current_face);
2323 p1++; 2321 p1++;
2324 if (p1 >= leftmargin && p1 < endp) 2322 if (p1 >= leftmargin && p1 < endp)
2325 *p1 = MAKE_GLYPH (f, c ^ 0100, current_face); 2323 *p1 = MAKE_GLYPH (f, c ^ 0100, current_face);
2326 p1++; 2324 p1++;
2327 } 2325 }
2328 else 2326 else
2329 { 2327 {
2330 if (p1 >= leftmargin) 2328 if (p1 >= leftmargin)
2331 *p1 = fix_glyph (f, (dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int 2329 *p1 = fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
2332 ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'), 2330 ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
2333 current_face); 2331 current_face);
2334 p1++; 2332 p1++;
2335 if (p1 >= leftmargin && p1 < endp) 2333 if (p1 >= leftmargin && p1 < endp)
2336 *p1 = MAKE_GLYPH (f, (c >> 6) + '0', current_face); 2334 *p1 = MAKE_GLYPH (f, (c >> 6) + '0', current_face);
2520 desired_glyphs->glyphs[vpos][desired_glyphs->used[vpos]] = 0; 2518 desired_glyphs->glyphs[vpos][desired_glyphs->used[vpos]] = 0;
2521 2519
2522 /* If the start of this line is the overlay arrow-position, 2520 /* If the start of this line is the overlay arrow-position,
2523 then put the arrow string into the display-line. */ 2521 then put the arrow string into the display-line. */
2524 2522
2525 if (XTYPE (Voverlay_arrow_position) == Lisp_Marker 2523 if (MARKERP (Voverlay_arrow_position)
2526 && current_buffer == XMARKER (Voverlay_arrow_position)->buffer 2524 && current_buffer == XMARKER (Voverlay_arrow_position)->buffer
2527 && start == marker_position (Voverlay_arrow_position) 2525 && start == marker_position (Voverlay_arrow_position)
2528 && XTYPE (Voverlay_arrow_string) == Lisp_String 2526 && STRINGP (Voverlay_arrow_string)
2529 && ! overlay_arrow_seen) 2527 && ! overlay_arrow_seen)
2530 { 2528 {
2531 unsigned char *p = XSTRING (Voverlay_arrow_string)->data; 2529 unsigned char *p = XSTRING (Voverlay_arrow_string)->data;
2532 int i; 2530 int i;
2533 int len = XSTRING (Voverlay_arrow_string)->size; 2531 int len = XSTRING (Voverlay_arrow_string)->size;
2780 if (!NILP (tem)) 2778 if (!NILP (tem))
2781 { 2779 {
2782 tem = Fsymbol_value (elt); 2780 tem = Fsymbol_value (elt);
2783 /* If value is a string, output that string literally: 2781 /* If value is a string, output that string literally:
2784 don't check for % within it. */ 2782 don't check for % within it. */
2785 if (XTYPE (tem) == Lisp_String) 2783 if (STRINGP (tem))
2786 { 2784 {
2787 if (frame_title_ptr) 2785 if (frame_title_ptr)
2788 hpos = store_frame_title (XSTRING (tem)->data, 2786 hpos = store_frame_title (XSTRING (tem)->data,
2789 minendcol, maxendcol); 2787 minendcol, maxendcol);
2790 else 2788 else
2810 at most that many characters. If positive, pad (with spaces) 2808 at most that many characters. If positive, pad (with spaces)
2811 to at least that many characters. 2809 to at least that many characters.
2812 If first element is a symbol, process the cadr or caddr recursively 2810 If first element is a symbol, process the cadr or caddr recursively
2813 according to whether the symbol's value is non-nil or nil. */ 2811 according to whether the symbol's value is non-nil or nil. */
2814 car = XCONS (elt)->car; 2812 car = XCONS (elt)->car;
2815 if (XTYPE (car) == Lisp_Symbol) 2813 if (SYMBOLP (car))
2816 { 2814 {
2817 tem = Fboundp (car); 2815 tem = Fboundp (car);
2818 elt = XCONS (elt)->cdr; 2816 elt = XCONS (elt)->cdr;
2819 if (XTYPE (elt) != Lisp_Cons) 2817 if (!CONSP (elt))
2820 goto invalid; 2818 goto invalid;
2821 /* elt is now the cdr, and we know it is a cons cell. 2819 /* elt is now the cdr, and we know it is a cons cell.
2822 Use its car if CAR has a non-nil value. */ 2820 Use its car if CAR has a non-nil value. */
2823 if (!NILP (tem)) 2821 if (!NILP (tem))
2824 { 2822 {
2830 Get the cddr of the original list 2828 Get the cddr of the original list
2831 and if possible find the caddr and use that. */ 2829 and if possible find the caddr and use that. */
2832 elt = XCONS (elt)->cdr; 2830 elt = XCONS (elt)->cdr;
2833 if (NILP (elt)) 2831 if (NILP (elt))
2834 break; 2832 break;
2835 else if (XTYPE (elt) != Lisp_Cons) 2833 else if (!CONSP (elt))
2836 goto invalid; 2834 goto invalid;
2837 elt = XCONS (elt)->car; 2835 elt = XCONS (elt)->car;
2838 goto tail_recurse; 2836 goto tail_recurse;
2839 } 2837 }
2840 else if (XTYPE (car) == Lisp_Int) 2838 else if (INTEGERP (car))
2841 { 2839 {
2842 register int lim = XINT (car); 2840 register int lim = XINT (car);
2843 elt = XCONS (elt)->cdr; 2841 elt = XCONS (elt)->cdr;
2844 if (lim < 0) 2842 if (lim < 0)
2845 /* Negative int means reduce maximum width. 2843 /* Negative int means reduce maximum width.
2860 if (lim > minendcol) 2858 if (lim > minendcol)
2861 minendcol = lim; 2859 minendcol = lim;
2862 } 2860 }
2863 goto tail_recurse; 2861 goto tail_recurse;
2864 } 2862 }
2865 else if (XTYPE (car) == Lisp_String || XTYPE (car) == Lisp_Cons) 2863 else if (STRINGP (car) || CONSP (car))
2866 { 2864 {
2867 register int limit = 50; 2865 register int limit = 50;
2868 /* LIMIT is to protect against circular lists. */ 2866 /* LIMIT is to protect against circular lists. */
2869 while (XTYPE (elt) == Lisp_Cons && --limit > 0 2867 while (CONSP (elt) && --limit > 0
2870 && hpos < maxendcol) 2868 && hpos < maxendcol)
2871 { 2869 {
2872 hpos = display_mode_element (w, vpos, hpos, depth, 2870 hpos = display_mode_element (w, vpos, hpos, depth,
2873 hpos, maxendcol, 2871 hpos, maxendcol,
2874 XCONS (elt)->car); 2872 XCONS (elt)->car);
2934 case 'f': 2932 case 'f':
2935 obj = b->filename; 2933 obj = b->filename;
2936 #if 0 2934 #if 0
2937 if (NILP (obj)) 2935 if (NILP (obj))
2938 return "[none]"; 2936 return "[none]";
2939 else if (XTYPE (obj) == Lisp_String && XSTRING (obj)->size > maxwidth) 2937 else if (STRINGP (obj) && XSTRING (obj)->size > maxwidth)
2940 { 2938 {
2941 bcopy ("...", decode_mode_spec_buf, 3); 2939 bcopy ("...", decode_mode_spec_buf, 3);
2942 bcopy (XSTRING (obj)->data + XSTRING (obj)->size - maxwidth + 3, 2940 bcopy (XSTRING (obj)->data + XSTRING (obj)->size - maxwidth + 3,
2943 decode_mode_spec_buf + 3, maxwidth - 3); 2941 decode_mode_spec_buf + 3, maxwidth - 3);
2944 return decode_mode_spec_buf; 2942 return decode_mode_spec_buf;
3181 } 3179 }
3182 return decode_mode_spec_buf; 3180 return decode_mode_spec_buf;
3183 } 3181 }
3184 } 3182 }
3185 3183
3186 if (XTYPE (obj) == Lisp_String) 3184 if (STRINGP (obj))
3187 return (char *) XSTRING (obj)->data; 3185 return (char *) XSTRING (obj)->data;
3188 else 3186 else
3189 return ""; 3187 return "";
3190 } 3188 }
3191 3189
3367 /* Use the standard display table, not the window's display table. 3365 /* Use the standard display table, not the window's display table.
3368 We don't want the mode line in rot13. */ 3366 We don't want the mode line in rot13. */
3369 register struct Lisp_Vector *dp = 0; 3367 register struct Lisp_Vector *dp = 0;
3370 int i; 3368 int i;
3371 3369
3372 if (XTYPE (Vstandard_display_table) == Lisp_Vector 3370 if (VECTORP (Vstandard_display_table)
3373 && XVECTOR (Vstandard_display_table)->size == DISP_TABLE_SIZE) 3371 && XVECTOR (Vstandard_display_table)->size == DISP_TABLE_SIZE)
3374 dp = XVECTOR (Vstandard_display_table); 3372 dp = XVECTOR (Vstandard_display_table);
3375 3373
3376 if (tab_width <= 0 || tab_width > 1000) tab_width = 8; 3374 if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
3377 3375
3418 /* Unspecified length (null-terminated string). */ 3416 /* Unspecified length (null-terminated string). */
3419 else if (c == 0) 3417 else if (c == 0)
3420 break; 3418 break;
3421 3419
3422 if (c >= 040 && c < 0177 3420 if (c >= 040 && c < 0177
3423 && (dp == 0 || XTYPE (DISP_CHAR_VECTOR (dp, c)) != Lisp_Vector)) 3421 && (dp == 0 || !VECTORP (DISP_CHAR_VECTOR (dp, c))))
3424 { 3422 {
3425 if (p1 >= start) 3423 if (p1 >= start)
3426 *p1 = c; 3424 *p1 = c;
3427 p1++; 3425 p1++;
3428 } 3426 }
3434 *p1 = SPACEGLYPH; 3432 *p1 = SPACEGLYPH;
3435 p1++; 3433 p1++;
3436 } 3434 }
3437 while ((p1 - start + hscroll - (hscroll > 0)) % tab_width); 3435 while ((p1 - start + hscroll - (hscroll > 0)) % tab_width);
3438 } 3436 }
3439 else if (dp != 0 && XTYPE (DISP_CHAR_VECTOR (dp, c)) == Lisp_Vector) 3437 else if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
3440 { 3438 {
3441 p1 = copy_part_of_rope (f, p1, start, 3439 p1 = copy_part_of_rope (f, p1, start,
3442 XVECTOR (DISP_CHAR_VECTOR (dp, c))->contents, 3440 XVECTOR (DISP_CHAR_VECTOR (dp, c))->contents,
3443 XVECTOR (DISP_CHAR_VECTOR (dp, c))->size, 3441 XVECTOR (DISP_CHAR_VECTOR (dp, c))->size,
3444 0); 3442 0);
3445 } 3443 }
3446 else if (c < 0200 && ! NILP (buffer_defaults.ctl_arrow)) 3444 else if (c < 0200 && ! NILP (buffer_defaults.ctl_arrow))
3447 { 3445 {
3448 if (p1 >= start) 3446 if (p1 >= start)
3449 *p1 = fix_glyph (f, (dp && XTYPE (DISP_CTRL_GLYPH (dp)) == Lisp_Int 3447 *p1 = fix_glyph (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
3450 ? XINT (DISP_CTRL_GLYPH (dp)) : '^'), 3448 ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
3451 0); 3449 0);
3452 p1++; 3450 p1++;
3453 if (p1 >= start && p1 < end) 3451 if (p1 >= start && p1 < end)
3454 *p1 = c ^ 0100; 3452 *p1 = c ^ 0100;
3455 p1++; 3453 p1++;
3456 } 3454 }
3457 else 3455 else
3458 { 3456 {
3459 if (p1 >= start) 3457 if (p1 >= start)
3460 *p1 = fix_glyph (f, (dp && XTYPE (DISP_ESCAPE_GLYPH (dp)) == Lisp_Int 3458 *p1 = fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
3461 ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'), 3459 ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
3462 0); 3460 0);
3463 p1++; 3461 p1++;
3464 if (p1 >= start && p1 < end) 3462 if (p1 >= start && p1 < end)
3465 *p1 = (c >> 6) + '0'; 3463 *p1 = (c >> 6) + '0';