/* Indentation functions.
Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1998, 2000, 2001,
- 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
+#include <setjmp.h>
#include "lisp.h"
#include "buffer.h"
#include "character.h"
#include "category.h"
+#include "composite.h"
#include "indent.h"
#include "keyboard.h"
#include "frame.h"
#include "termopts.h"
#include "disptab.h"
#include "intervals.h"
+#include "dispextern.h"
#include "region-cache.h"
/* Indentation can insert tabs if this is non-zero;
{
/* Don't scan terribly far. */
XSETFASTINT (proplimit, min (pos + 100, to));
- /* No matter what. don't go past next overlay change. */
+ /* No matter what, don't go past next overlay change. */
if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
proplimit = overlay_limit;
tmp = Fnext_single_property_change (position, Qinvisible,
return pos;
}
\f
-/* If a composition starts at POS/POS_BYTE and it doesn't stride over
- POINT, set *LEN / *LEN_BYTE to the character and byte lengths, *WIDTH
- to the width, and return 1. Otherwise, return 0. */
-
-static int
-check_composition (pos, pos_byte, point, len, len_byte, width)
- int pos, pos_byte, point;
- int *len, *len_byte, *width;
-{
- Lisp_Object prop;
- EMACS_INT start, end;
- int id;
-
- if (! find_composition (pos, -1, &start, &end, &prop, Qnil)
- || pos != start || point < end
- || !COMPOSITION_VALID_P (start, end, prop))
- return 0;
- if ((id = get_composition_id (pos, pos_byte, end - pos, prop, Qnil)) < 0)
- return 0;
-
- *len = COMPOSITION_LENGTH (prop);
- *len_byte = CHAR_TO_BYTE (end) - pos_byte;
- *width = composition_table[id]->width;
- return 1;
-}
-\f
/* Set variables WIDTH and BYTES for a multibyte sequence starting at P.
DP is a display table or NULL.
int c; \
\
wide_column = 0; \
- c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, bytes); \
+ c = STRING_CHAR_AND_LENGTH (p, bytes); \
if (BYTES_BY_CHAR_HEAD (*p) != bytes) \
width = bytes * 4; \
else \
register int ctl_arrow = !NILP (current_buffer->ctl_arrow);
register struct Lisp_Char_Table *dp = buffer_display_table ();
int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+ struct composition_it cmp_it;
+ Lisp_Object window;
+ struct window *w;
/* Start the scan at the beginning of this line with column number 0. */
register EMACS_INT col = 0, prev_col = 0;
next_boundary = scan;
}
+ window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
+ w = ! NILP (window) ? XWINDOW (window) : NULL;
+
if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
+ bzero (&cmp_it, sizeof cmp_it);
+ cmp_it.id = -1;
+ composition_compute_stop_pos (&cmp_it, scan, scan_byte, end, Qnil);
/* Scan forward to the target position. */
while (scan < end)
break;
prev_col = col;
- { /* Check composition sequence. */
- int len, len_byte, width;
-
- if (check_composition (scan, scan_byte, end,
- &len, &len_byte, &width))
- {
- scan += len;
- scan_byte += len_byte;
- if (scan <= end)
- col += width;
- continue;
- }
- }
-
{ /* Check display property. */
EMACS_INT end;
int width = check_display_width (scan, col, &end);
}
}
+ /* Check composition sequence. */
+ if (cmp_it.id >= 0
+ || (scan == cmp_it.stop_pos
+ && composition_reseat_it (&cmp_it, scan, scan_byte, end,
+ w, NULL, Qnil)))
+ composition_update_it (&cmp_it, scan, scan_byte, Qnil);
+ if (cmp_it.id >= 0)
+ {
+ scan += cmp_it.nchars;
+ scan_byte += cmp_it.nbytes;
+ if (scan <= end)
+ col += cmp_it.width;
+ if (cmp_it.to == cmp_it.nglyphs)
+ {
+ cmp_it.id = -1;
+ composition_compute_stop_pos (&cmp_it, scan, scan_byte, end,
+ Qnil);
+ }
+ else
+ cmp_it.from = cmp_it.to;
+ continue;
+ }
+
c = FETCH_BYTE (scan_byte);
/* See if there is a display table and it relates
EMACS_INT prev_tab_offset; /* Previous tab offset. */
EMACS_INT continuation_glyph_width;
+ struct composition_it cmp_it;
+
XSETBUFFER (buffer, current_buffer);
XSETWINDOW (window, win);
pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
contin_hpos = 0;
prev_tab_offset = tab_offset;
+ bzero (&cmp_it, sizeof cmp_it);
+ cmp_it.id = -1;
+ composition_compute_stop_pos (&cmp_it, pos, pos_byte, to, Qnil);
+
while (1)
{
while (pos == next_boundary)
EMACS_INT i, n;
Lisp_Object charvec;
- c = FETCH_BYTE (pos_byte);
-
/* Check composition sequence. */
- {
- int len, len_byte, width;
-
- if (check_composition (pos, pos_byte, to, &len, &len_byte, &width))
- {
- pos += len;
- pos_byte += len_byte;
- hpos += width;
- continue;
- }
- }
+ if (cmp_it.id >= 0
+ || (pos == cmp_it.stop_pos
+ && composition_reseat_it (&cmp_it, pos, pos_byte, to, win,
+ NULL, Qnil)))
+ composition_update_it (&cmp_it, pos, pos_byte, Qnil);
+ if (cmp_it.id >= 0)
+ {
+ pos += cmp_it.nchars;
+ pos_byte += cmp_it.nbytes;
+ hpos += cmp_it.width;
+ if (cmp_it.to == cmp_it.nglyphs)
+ {
+ cmp_it.id = -1;
+ composition_compute_stop_pos (&cmp_it, pos, pos_byte, to,
+ Qnil);
+ }
+ else
+ cmp_it.from = cmp_it.to;
+ continue;
+ }
+ c = FETCH_BYTE (pos_byte);
pos++, pos_byte++;
/* Perhaps add some info to the width_run_cache. */
}
else
{
- int it_start, oselective, first_x, it_overshoot_expected;
+ int it_start, first_x, it_overshoot_expected;
SET_TEXT_POS (pt, PT, PT_BYTE);
start_display (&it, w, pt);
/* See comments below for why we calculate this. */
if (XINT (lines) > 0)
{
- if (it.method == GET_FROM_STRING)
+ if (it.cmp_it.id >= 0)
+ it_overshoot_expected = 1;
+ else if (it.method == GET_FROM_STRING)
{
const char *s = SDATA (it.string);
const char *e = s + SBYTES (it.string);
}
else
it_overshoot_expected = (it.method == GET_FROM_IMAGE
- || it.method == GET_FROM_STRETCH
- || it.method == GET_FROM_COMPOSITION);
+ || it.method == GET_FROM_STRETCH);
}
/* Scan from the start of the line containing PT. If we don't
really at some x > 0. */
reseat_at_previous_visible_line_start (&it);
it.current_x = it.hpos = 0;
- /* Temporarily disable selective display so we don't move too far */
- oselective = it.selective;
- it.selective = 0;
- move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
- it.selective = oselective;
+ if (IT_CHARPOS (it) != PT)
+ /* We used to temporarily disable selective display here; the
+ comment said this is "so we don't move too far" (2005-01-19
+ checkin by kfs). But this does nothing useful that I can
+ tell, and it causes Bug#2694 . -- cyd */
+ move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
if (XINT (lines) <= 0)
{
}
else
{
- if (IT_CHARPOS (it) > PT)
+ if (IT_CHARPOS (it) > it_start)
{
/* IT may move too far if truncate-lines is on and PT
lies beyond the right margin. In that case,
which might span multiple screen lines (e.g., if it's
on a multi-line display string). We want to start
from the last line that it occupies. */
- it.vpos = 0;
- if (PT < ZV)
+ if (it_start < ZV)
{
- while (IT_CHARPOS (it) <= PT)
- move_it_by_lines (&it, 1, 0);
- move_it_by_lines (&it, XINT (lines) - 1, 0);
+ while (IT_CHARPOS (it) <= it_start)
+ {
+ it.vpos = 0;
+ move_it_by_lines (&it, 1, 0);
+ }
+ if (XINT (lines) > 1)
+ move_it_by_lines (&it, XINT (lines) - 1, 0);
}
else
- move_it_by_lines (&it, XINT (lines), 0);
+ {
+ it.vpos = 0;
+ move_it_by_lines (&it, XINT (lines), 0);
+ }
}
}