Mercurial > emacs
view src/vm-limit.c @ 107998:531d454c3a99
Implement GUI display of R2L lines, fix TTY display of R2L lines.
xdisp.c [HAVE_WINDOW_SYSTEM]: Add prototype for
append_stretch_glyph.
(set_cursor_from_row) <cursor_x>: Remove unused variable. Fix
off-by-one error in computing x at end of text in the row.
(append_stretch_glyph): In reversed row, prepend the glyph rather
than append it. Set resolved_level and bidi_type of the glyph.
(extend_face_to_end_of_line): If the row is reversed, prepend a
stretch glyph whose width is such that the rightmost glyph will be
drawn at the right margin of the window. Fix off-by-one error on
TTY frames in testing whether a line needs face extension. Fix
face extension at ZV. If this is the last glyph row, use
DEFAULT_FACE_ID, to avoid painting the rest of the window with the
region face.
(set_cursor_from_row, display_line): Use
MATRIX_ROW_CONTINUATION_LINE_P instead of testing value of
row->continuation_lines_width.
(next_element_from_buffer): Don't call bidi_paragraph_init if we
are at ZV. Fixes a crash when reseated to ZV by
try_window_reusing_current_matrix.
(display_and_set_cursor, erase_phys_cursor): Handle negative HPOS,
which happens with R2L glyph rows. Fixes a crash when inserting a
character at end of an R2L line.
(set_cursor_from_row): Don't be fooled by truncated rows: don't
treat them as having zero-width characters. Improve comments.
Don't reverse pos_before and pos_after for reversed glyph rows.
Set cursor.x to negative value when the cursor might be on the
left fringe.
(IT_OVERFLOW_NEWLINE_INTO_FRINGE): For R2L lines, consider the
left fringe, not the right one.
(notice_overwritten_cursor, draw_phys_cursor_glyph)
(erase_phys_cursor): For reversed cursor_row, support cursor on
the left fringe.
fringe.c (update_window_fringes): For R2L rows, swap the bitmaps
of continuation indicators on the fringes.
(draw_fringe_bitmap): For reversed glyph rows, allow cursor on the
left fringe.
w32term.c (w32_draw_window_cursor): For reversed glyph rows,
draw cursor on the left fringe.
xterm.c (x_draw_window_cursor): For reversed glyph rows, draw
cursor on the left fringe.
dispnew.c (update_text_area): Handle reversed desired rows when
the cursor is on the left fringe.
(set_window_cursor_after_update): Limit cursor's hpos by -1 from
below, not by 0, for when the cursor is on the left fringe.
xdisp.c (unproduce_glyphs): New function.
(display_line): Use it when produced glyphs are discarded from R2L
glyph rows.
(append_composite_glyph): In R2L rows, prepend the glyph rather
than appending it.
term.c (append_composite_glyph): In R2L rows, prepend the glyph
rather than append it. Set up the resolved_level and bidi_type
attributes of the appended glyph.
(produce_special_glyphs): Mirror the backslash continuation
character in R2L lines.
author | Eli Zaretskii <eliz@gnu.org> |
---|---|
date | Tue, 20 Apr 2010 16:31:28 +0300 |
parents | 1d1d5d9bd884 |
children | ed7496d92467 376148b31b5e |
line wrap: on
line source
/* Functions for memory limit warnings. Copyright (C) 1990, 1992, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GNU Emacs. GNU Emacs is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. GNU Emacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */ #ifdef emacs #include <config.h> #include <setjmp.h> #include "lisp.h" #endif #ifndef emacs #include <stddef.h> typedef size_t SIZE; typedef void *POINTER; #define EXCEEDS_LISP_PTR(x) 0 #endif #include "mem-limits.h" #ifdef HAVE_GETRLIMIT #include <sys/resource.h> #endif /* Level number of warnings already issued. 0 -- no warnings issued. 1 -- 75% warning already issued. 2 -- 85% warning already issued. 3 -- 95% warning issued; keep warning frequently. */ enum warnlevel { not_warned, warned_75, warned_85, warned_95 }; static enum warnlevel warnlevel; /* Function to call to issue a warning; 0 means don't issue them. */ static void (*warn_function) (); /* Start of data space; can be changed by calling malloc_init. */ static POINTER data_space_start; /* Number of bytes of writable memory we can expect to be able to get. */ static unsigned long lim_data; #ifdef NO_LIM_DATA static void get_lim_data () { lim_data = -1; } #else /* not NO_LIM_DATA */ #if defined (HAVE_GETRLIMIT) && defined (RLIMIT_AS) static void get_lim_data () { struct rlimit rlimit; getrlimit (RLIMIT_AS, &rlimit); if (rlimit.rlim_cur == RLIM_INFINITY) lim_data = -1; else lim_data = rlimit.rlim_cur; } #else /* not HAVE_GETRLIMIT */ #ifdef USG static void get_lim_data () { extern long ulimit (); lim_data = -1; /* Use the ulimit call, if we seem to have it. */ #if !defined (ULIMIT_BREAK_VALUE) || defined (GNU_LINUX) lim_data = ulimit (3, 0); #endif /* If that didn't work, just use the macro's value. */ #ifdef ULIMIT_BREAK_VALUE if (lim_data == -1) lim_data = ULIMIT_BREAK_VALUE; #endif lim_data -= (long) data_space_start; } #else /* not USG */ #ifdef WINDOWSNT static void get_lim_data () { extern unsigned long reserved_heap_size; lim_data = reserved_heap_size; } #else #if !defined (BSD4_2) && !defined (__osf__) #ifdef MSDOS void get_lim_data () { _go32_dpmi_meminfo info; unsigned long lim1, lim2; _go32_dpmi_get_free_memory_information (&info); /* DPMI server of Windows NT and its descendants reports in info.available_memory a much lower amount that is really available, which causes bogus "past 95% of memory limit" warnings. Try to overcome that via circumstantial evidence. */ lim1 = info.available_memory; lim2 = info.available_physical_pages; /* DPMI Spec: "Fields that are unavailable will hold -1." */ if ((long)lim1 == -1L) lim1 = 0; if ((long)lim2 == -1L) lim2 = 0; else lim2 *= 4096; /* Surely, the available memory is at least what we have physically available, right? */ if (lim1 >= lim2) lim_data = lim1; else lim_data = lim2; /* Don't believe they will give us more that 0.5 GB. */ if (lim_data > 512U * 1024U * 1024U) lim_data = 512U * 1024U * 1024U; } unsigned long ret_lim_data () { get_lim_data (); return lim_data; } #else /* not MSDOS */ static void get_lim_data () { lim_data = vlimit (LIM_DATA, -1); } #endif /* not MSDOS */ #else /* BSD4_2 */ static void get_lim_data () { struct rlimit XXrlimit; getrlimit (RLIMIT_DATA, &XXrlimit); #ifdef RLIM_INFINITY lim_data = XXrlimit.rlim_cur & RLIM_INFINITY; /* soft limit */ #else lim_data = XXrlimit.rlim_cur; /* soft limit */ #endif } #endif /* BSD4_2 */ #endif /* not WINDOWSNT */ #endif /* not USG */ #endif /* not HAVE_GETRLIMIT */ #endif /* not NO_LIM_DATA */ /* Verify amount of memory available, complaining if we're near the end. */ static void check_memory_limits () { #ifdef REL_ALLOC extern POINTER (*real_morecore) (); #endif extern POINTER (*__morecore) (); register POINTER cp; unsigned long five_percent; unsigned long data_size; enum warnlevel new_warnlevel; if (lim_data == 0) get_lim_data (); five_percent = lim_data / 20; /* Find current end of memory and issue warning if getting near max */ #ifdef REL_ALLOC if (real_morecore) cp = (char *) (*real_morecore) (0); else #endif cp = (char *) (*__morecore) (0); data_size = (char *) cp - (char *) data_space_start; if (!warn_function) return; /* What level of warning does current memory usage demand? */ new_warnlevel = (data_size > five_percent * 19) ? warned_95 : (data_size > five_percent * 17) ? warned_85 : (data_size > five_percent * 15) ? warned_75 : not_warned; /* If we have gone up a level, give the appropriate warning. */ if (new_warnlevel > warnlevel || new_warnlevel == warned_95) { warnlevel = new_warnlevel; switch (warnlevel) { case warned_75: (*warn_function) ("Warning: past 75% of memory limit"); break; case warned_85: (*warn_function) ("Warning: past 85% of memory limit"); break; case warned_95: (*warn_function) ("Warning: past 95% of memory limit"); } } /* Handle going down in usage levels, with some hysteresis. */ else { /* If we go down below 70% full, issue another 75% warning when we go up again. */ if (data_size < five_percent * 14) warnlevel = not_warned; /* If we go down below 80% full, issue another 85% warning when we go up again. */ else if (warnlevel > warned_75 && data_size < five_percent * 16) warnlevel = warned_75; /* If we go down below 90% full, issue another 95% warning when we go up again. */ else if (warnlevel > warned_85 && data_size < five_percent * 18) warnlevel = warned_85; } if (EXCEEDS_LISP_PTR (cp)) (*warn_function) ("Warning: memory in use exceeds lisp pointer size"); } /* Enable memory usage warnings. START says where the end of pure storage is. WARNFUN specifies the function to call to issue a warning. */ void memory_warnings (start, warnfun) POINTER start; void (*warnfun) (); { extern void (* __after_morecore_hook) (); /* From gmalloc.c */ if (start) data_space_start = start; else data_space_start = start_of_data (); warn_function = warnfun; __after_morecore_hook = check_memory_limits; /* Force data limit to be recalculated on each run. */ lim_data = 0; } /* arch-tag: eab04eda-1f69-447a-8d9f-95f0a3983ca5 (do not change this comment) */