From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Oleh Krehel Newsgroups: gmane.emacs.devel Subject: Re: Is it time to remove INTERNAL_FIELD? Date: Tue, 28 Apr 2015 20:58:38 +0200 Message-ID: <87vbggjd0h.fsf@gmail.com> References: <87lhhjuq26.fsf@gmail.com> <5538C48F.2020005@cs.ucla.edu> <87fv7rupcc.fsf@gmail.com> <5538C6C0.2000609@cs.ucla.edu> <83sibr15ac.fsf@gnu.org> <878udjun89.fsf@gmail.com> <83pp6v14cy.fsf@gnu.org> <87sibr84hb.fsf@gmail.com> <83oamf12ax.fsf@gnu.org> <87fv7rqcc7.fsf@gmail.com> <83lhhj10mb.fsf@gnu.org> <877ft0fpax.fsf@gmail.com> <83oamcxx99.fsf@gnu.org> <83k2x0xobm.fsf@gnu.org> <87d22oem75.fsf@gmail.com> <83vbgguw9j.fsf@gnu.org> <87wq0wmgn5.fsf@gmail.com> <83lhhcuviq.fsf@gnu.org> NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: text/plain X-Trace: ger.gmane.org 1430247896 1848 80.91.229.3 (28 Apr 2015 19:04:56 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Tue, 28 Apr 2015 19:04:56 +0000 (UTC) Cc: eggert@cs.ucla.edu, monnier@IRO.UMontreal.CA, emacs-devel@gnu.org To: Eli Zaretskii Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Tue Apr 28 21:04:50 2015 Return-path: Envelope-to: ged-emacs-devel@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1YnAoL-0004T1-KT for ged-emacs-devel@m.gmane.org; Tue, 28 Apr 2015 21:04:50 +0200 Original-Received: from localhost ([::1]:35528 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YnAoK-0006l3-S4 for ged-emacs-devel@m.gmane.org; Tue, 28 Apr 2015 15:04:48 -0400 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:54882) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YnAo6-0006Vb-Vy for emacs-devel@gnu.org; Tue, 28 Apr 2015 15:04:43 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1YnAo3-0004Cm-3N for emacs-devel@gnu.org; Tue, 28 Apr 2015 15:04:34 -0400 Original-Received: from mail-wg0-x22c.google.com ([2a00:1450:400c:c00::22c]:36312) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YnAo2-0004Cf-GS; Tue, 28 Apr 2015 15:04:31 -0400 Original-Received: by wgen6 with SMTP id n6so4598952wge.3; Tue, 28 Apr 2015 12:04:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:cc:subject:references:date:in-reply-to:message-id :user-agent:mime-version:content-type; bh=411GeH3PQs4D4W3oVihDR6s+LTE7pgignvXGymf+8R0=; b=B04boZBz4hALMlokdoqLUig0s2AB68JkaX85x7SBYo/Fk274oZ0ZRSuXedkZnL8xJv 9zj7UVgCBzaEUIiLYF2BLAQVWSSXjERGyzVrIN1HOppRpgksJtAUqxjsEqx3UEKYyGbG 8EiQ4z3OE/NSjFdleInpjo00RlGjFrUmWqHq7mIpqgmCeRAiei2IgA3aQeQltyTK1Ri4 ENMlz7f/07sFL+JF4oNqm3uD24/fPRT4G4w/L87j9bczmIG+0b+/SU7lc6K4dax/mo3p Np59pUZiSKnb025XKH4z9/kclFXZqZ5XcwHiowiy3F2B+vJdQxxO2pezVnfq5q+u4gIW +78g== X-Received: by 10.194.78.12 with SMTP id x12mr33845106wjw.112.1430247869842; Tue, 28 Apr 2015 12:04:29 -0700 (PDT) Original-Received: from firefly (dyn069045.nbw.tue.nl. [131.155.69.45]) by mx.google.com with ESMTPSA id l6sm4015461wjz.4.2015.04.28.12.04.28 (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Tue, 28 Apr 2015 12:04:29 -0700 (PDT) In-Reply-To: <83lhhcuviq.fsf@gnu.org> (Eli Zaretskii's message of "Tue, 28 Apr 2015 18:23:25 +0300") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.0.50 (gnu/linux) X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2a00:1450:400c:c00::22c X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Original-Sender: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Xref: news.gmane.org gmane.emacs.devel:185983 Archived-At: Eli Zaretskii writes: >> From: Oleh Krehel >> Cc: monnier@IRO.UMontreal.CA, eggert@cs.ucla.edu, emacs-devel@gnu.org >> Date: Tue, 28 Apr 2015 17:11:58 +0200 >> >> >> Should I update the patch to include the underscores everywhere? >> > >> > Not everywhere, only where the fields are used in BVAR and KVAR. >> >> So that means everywhere > > If you say so, I didn't double-check that. > >> except allow to use BVAR and KVAR macros without an underscore. Did >> I understand correctly? > > Yes, thanks. I attach the flattened patch. It compiles and runs fine, but please check it again. Oleh ===File /home/oleh/git/gnu-emacs/0001-Remove-the-deprecated-INTERNAL_FIELD-macro-by-expand.patch=== >From 8e906175c418b68c07df9f382713a34761092f51 Mon Sep 17 00:00:00 2001 From: Oleh Krehel Date: Thu, 23 Apr 2015 12:36:22 +0200 Subject: [PATCH] Remove the deprecated INTERNAL_FIELD macro by expanding it * src/lisp.h (INTERNAL_FIELD): Remove. (DEFVAR_KBOARD): Modify accordingly. * alloc.c, buffer.c, buffer.h, category.c, keyboard.c, keyboard.h: * syntax.c: Adjust users. * src/buffer.c (compact_buffer): Use BVAR. --- src/alloc.c | 2 +- src/buffer.c | 92 ++++++++++++++-------------- src/buffer.h | 188 ++++++++++++++++++++++++++++----------------------------- src/category.c | 2 +- src/keyboard.c | 18 +++--- src/keyboard.h | 52 ++++++++-------- src/lisp.h | 4 -- src/syntax.c | 2 +- 8 files changed, 178 insertions(+), 182 deletions(-) diff --git a/src/alloc.c b/src/alloc.c index 1f4b1a4..688363d 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -4496,7 +4496,7 @@ live_buffer_p (struct mem_node *m, void *p) must not have been killed. */ return (m->type == MEM_TYPE_BUFFER && p == m->start - && !NILP (((struct buffer *) p)->INTERNAL_FIELD (name))); + && !NILP (((struct buffer *) p)->name_)); } #endif /* GC_MARK_STACK || defined GC_MALLOC_CHECK */ diff --git a/src/buffer.c b/src/buffer.c index 332d6d5..b09676c 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -134,227 +134,227 @@ CHECK_OVERLAY (Lisp_Object x) static void bset_abbrev_mode (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (abbrev_mode) = val; + b->abbrev_mode_ = val; } static void bset_abbrev_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (abbrev_table) = val; + b->abbrev_table_ = val; } static void bset_auto_fill_function (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (auto_fill_function) = val; + b->auto_fill_function_ = val; } static void bset_auto_save_file_format (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (auto_save_file_format) = val; + b->auto_save_file_format_ = val; } static void bset_auto_save_file_name (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (auto_save_file_name) = val; + b->auto_save_file_name_ = val; } static void bset_backed_up (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (backed_up) = val; + b->backed_up_ = val; } static void bset_begv_marker (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (begv_marker) = val; + b->begv_marker_ = val; } static void bset_bidi_display_reordering (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (bidi_display_reordering) = val; + b->bidi_display_reordering_ = val; } static void bset_buffer_file_coding_system (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (buffer_file_coding_system) = val; + b->buffer_file_coding_system_ = val; } static void bset_case_fold_search (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (case_fold_search) = val; + b->case_fold_search_ = val; } static void bset_ctl_arrow (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (ctl_arrow) = val; + b->ctl_arrow_ = val; } static void bset_cursor_in_non_selected_windows (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (cursor_in_non_selected_windows) = val; + b->cursor_in_non_selected_windows_ = val; } static void bset_cursor_type (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (cursor_type) = val; + b->cursor_type_ = val; } static void bset_display_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (display_table) = val; + b->display_table_ = val; } static void bset_extra_line_spacing (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (extra_line_spacing) = val; + b->extra_line_spacing_ = val; } static void bset_file_format (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (file_format) = val; + b->file_format_ = val; } static void bset_file_truename (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (file_truename) = val; + b->file_truename_ = val; } static void bset_fringe_cursor_alist (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (fringe_cursor_alist) = val; + b->fringe_cursor_alist_ = val; } static void bset_fringe_indicator_alist (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (fringe_indicator_alist) = val; + b->fringe_indicator_alist_ = val; } static void bset_fringes_outside_margins (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (fringes_outside_margins) = val; + b->fringes_outside_margins_ = val; } static void bset_header_line_format (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (header_line_format) = val; + b->header_line_format_ = val; } static void bset_indicate_buffer_boundaries (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (indicate_buffer_boundaries) = val; + b->indicate_buffer_boundaries_ = val; } static void bset_indicate_empty_lines (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (indicate_empty_lines) = val; + b->indicate_empty_lines_ = val; } static void bset_invisibility_spec (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (invisibility_spec) = val; + b->invisibility_spec_ = val; } static void bset_left_fringe_width (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (left_fringe_width) = val; + b->left_fringe_width_ = val; } static void bset_major_mode (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (major_mode) = val; + b->major_mode_ = val; } static void bset_mark (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (mark) = val; + b->mark_ = val; } static void bset_minor_modes (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (minor_modes) = val; + b->minor_modes_ = val; } static void bset_mode_line_format (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (mode_line_format) = val; + b->mode_line_format_ = val; } static void bset_mode_name (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (mode_name) = val; + b->mode_name_ = val; } static void bset_name (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (name) = val; + b->name_ = val; } static void bset_overwrite_mode (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (overwrite_mode) = val; + b->overwrite_mode_ = val; } static void bset_pt_marker (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (pt_marker) = val; + b->pt_marker_ = val; } static void bset_right_fringe_width (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (right_fringe_width) = val; + b->right_fringe_width_ = val; } static void bset_save_length (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (save_length) = val; + b->save_length_ = val; } static void bset_scroll_bar_width (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (scroll_bar_width) = val; + b->scroll_bar_width_ = val; } static void bset_scroll_bar_height (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (scroll_bar_height) = val; + b->scroll_bar_height_ = val; } static void bset_scroll_down_aggressively (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (scroll_down_aggressively) = val; + b->scroll_down_aggressively_ = val; } static void bset_scroll_up_aggressively (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (scroll_up_aggressively) = val; + b->scroll_up_aggressively_ = val; } static void bset_selective_display (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (selective_display) = val; + b->selective_display_ = val; } static void bset_selective_display_ellipses (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (selective_display_ellipses) = val; + b->selective_display_ellipses_ = val; } static void bset_vertical_scroll_bar_type (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (vertical_scroll_bar_type) = val; + b->vertical_scroll_bar_type_ = val; } static void bset_horizontal_scroll_bar_type (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (horizontal_scroll_bar_type) = val; + b->horizontal_scroll_bar_type_ = val; } static void bset_word_wrap (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (word_wrap) = val; + b->word_wrap_ = val; } static void bset_zv_marker (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (zv_marker) = val; + b->zv_marker_ = val; } void @@ -1591,7 +1591,7 @@ compact_buffer (struct buffer *buffer) turned off in that buffer. Calling truncate_undo_list on Qt tends to return NULL, which effectively turns undo back on. So don't call truncate_undo_list if undo_list is Qt. */ - if (!EQ (buffer->INTERNAL_FIELD (undo_list), Qt)) + if (!EQ (BVAR(buffer, undo_list), Qt)) truncate_undo_list (buffer); /* Shrink buffer gaps. */ diff --git a/src/buffer.h b/src/buffer.h index 81852ca..a0410d4 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -483,7 +483,7 @@ struct buffer_text /* Most code should use this macro to access Lisp fields in struct buffer. */ -#define BVAR(buf, field) ((buf)->INTERNAL_FIELD (field)) +#define BVAR(buf, field) ((buf)->field ## _) /* This is the structure that the buffer Lisp object points to. */ @@ -492,17 +492,17 @@ struct buffer struct vectorlike_header header; /* The name of this buffer. */ - Lisp_Object INTERNAL_FIELD (name); + Lisp_Object name_; /* The name of the file visited in this buffer, or nil. */ - Lisp_Object INTERNAL_FIELD (filename); + Lisp_Object filename_; /* Directory for expanding relative file names. */ - Lisp_Object INTERNAL_FIELD (directory); + Lisp_Object directory_; /* True if this buffer has been backed up (if you write to the visited file and it hasn't been backed up, then a backup will be made). */ - Lisp_Object INTERNAL_FIELD (backed_up); + Lisp_Object backed_up_; /* Length of file when last read or saved. -1 means auto saving turned off because buffer shrank a lot. @@ -510,132 +510,132 @@ struct buffer (That value is used with buffer-swap-text.) This is not in the struct buffer_text because it's not used in indirect buffers at all. */ - Lisp_Object INTERNAL_FIELD (save_length); + Lisp_Object save_length_; /* File name used for auto-saving this buffer. This is not in the struct buffer_text because it's not used in indirect buffers at all. */ - Lisp_Object INTERNAL_FIELD (auto_save_file_name); + Lisp_Object auto_save_file_name_; /* Non-nil if buffer read-only. */ - Lisp_Object INTERNAL_FIELD (read_only); + Lisp_Object read_only_; /* "The mark". This is a marker which may point into this buffer or may point nowhere. */ - Lisp_Object INTERNAL_FIELD (mark); + Lisp_Object mark_; /* Alist of elements (SYMBOL . VALUE-IN-THIS-BUFFER) for all per-buffer variables of this buffer. For locally unbound symbols, just the symbol appears as the element. */ - Lisp_Object INTERNAL_FIELD (local_var_alist); + Lisp_Object local_var_alist_; /* Symbol naming major mode (e.g., lisp-mode). */ - Lisp_Object INTERNAL_FIELD (major_mode); + Lisp_Object major_mode_; /* Pretty name of major mode (e.g., "Lisp"). */ - Lisp_Object INTERNAL_FIELD (mode_name); + Lisp_Object mode_name_; /* Mode line element that controls format of mode line. */ - Lisp_Object INTERNAL_FIELD (mode_line_format); + Lisp_Object mode_line_format_; /* Analogous to mode_line_format for the line displayed at the top of windows. Nil means don't display that line. */ - Lisp_Object INTERNAL_FIELD (header_line_format); + Lisp_Object header_line_format_; /* Keys that are bound local to this buffer. */ - Lisp_Object INTERNAL_FIELD (keymap); + Lisp_Object keymap_; /* This buffer's local abbrev table. */ - Lisp_Object INTERNAL_FIELD (abbrev_table); + Lisp_Object abbrev_table_; /* This buffer's syntax table. */ - Lisp_Object INTERNAL_FIELD (syntax_table); + Lisp_Object syntax_table_; /* This buffer's category table. */ - Lisp_Object INTERNAL_FIELD (category_table); + Lisp_Object category_table_; /* Values of several buffer-local variables. */ /* tab-width is buffer-local so that redisplay can find it in buffers that are not current. */ - Lisp_Object INTERNAL_FIELD (case_fold_search); - Lisp_Object INTERNAL_FIELD (tab_width); - Lisp_Object INTERNAL_FIELD (fill_column); - Lisp_Object INTERNAL_FIELD (left_margin); + Lisp_Object case_fold_search_; + Lisp_Object tab_width_; + Lisp_Object fill_column_; + Lisp_Object left_margin_; /* Function to call when insert space past fill column. */ - Lisp_Object INTERNAL_FIELD (auto_fill_function); + Lisp_Object auto_fill_function_; /* Case table for case-conversion in this buffer. This char-table maps each char into its lower-case version. */ - Lisp_Object INTERNAL_FIELD (downcase_table); + Lisp_Object downcase_table_; /* Char-table mapping each char to its upper-case version. */ - Lisp_Object INTERNAL_FIELD (upcase_table); + Lisp_Object upcase_table_; /* Char-table for conversion for case-folding search. */ - Lisp_Object INTERNAL_FIELD (case_canon_table); + Lisp_Object case_canon_table_; /* Char-table of equivalences for case-folding search. */ - Lisp_Object INTERNAL_FIELD (case_eqv_table); + Lisp_Object case_eqv_table_; /* Non-nil means do not display continuation lines. */ - Lisp_Object INTERNAL_FIELD (truncate_lines); + Lisp_Object truncate_lines_; /* Non-nil means to use word wrapping when displaying continuation lines. */ - Lisp_Object INTERNAL_FIELD (word_wrap); + Lisp_Object word_wrap_; /* Non-nil means display ctl chars with uparrow. */ - Lisp_Object INTERNAL_FIELD (ctl_arrow); + Lisp_Object ctl_arrow_; /* Non-nil means reorder bidirectional text for display in the visual order. */ - Lisp_Object INTERNAL_FIELD (bidi_display_reordering); + Lisp_Object bidi_display_reordering_; /* If non-nil, specifies which direction of text to force in all the paragraphs of the buffer. Nil means determine paragraph direction dynamically for each paragraph. */ - Lisp_Object INTERNAL_FIELD (bidi_paragraph_direction); + Lisp_Object bidi_paragraph_direction_; /* Non-nil means do selective display; see doc string in syms_of_buffer (buffer.c) for details. */ - Lisp_Object INTERNAL_FIELD (selective_display); + Lisp_Object selective_display_; /* Non-nil means show ... at end of line followed by invisible lines. */ - Lisp_Object INTERNAL_FIELD (selective_display_ellipses); + Lisp_Object selective_display_ellipses_; /* Alist of (FUNCTION . STRING) for each minor mode enabled in buffer. */ - Lisp_Object INTERNAL_FIELD (minor_modes); + Lisp_Object minor_modes_; /* t if "self-insertion" should overwrite; `binary' if it should also overwrite newlines and tabs - for editing executables and the like. */ - Lisp_Object INTERNAL_FIELD (overwrite_mode); + Lisp_Object overwrite_mode_; /* Non-nil means abbrev mode is on. Expand abbrevs automatically. */ - Lisp_Object INTERNAL_FIELD (abbrev_mode); + Lisp_Object abbrev_mode_; /* Display table to use for text in this buffer. */ - Lisp_Object INTERNAL_FIELD (display_table); + Lisp_Object display_table_; /* t means the mark and region are currently active. */ - Lisp_Object INTERNAL_FIELD (mark_active); + Lisp_Object mark_active_; /* Non-nil means the buffer contents are regarded as multi-byte form of characters, not a binary code. */ - Lisp_Object INTERNAL_FIELD (enable_multibyte_characters); + Lisp_Object enable_multibyte_characters_; /* Coding system to be used for encoding the buffer contents on saving. */ - Lisp_Object INTERNAL_FIELD (buffer_file_coding_system); + Lisp_Object buffer_file_coding_system_; /* List of symbols naming the file format used for visited file. */ - Lisp_Object INTERNAL_FIELD (file_format); + Lisp_Object file_format_; /* List of symbols naming the file format used for auto-save file. */ - Lisp_Object INTERNAL_FIELD (auto_save_file_format); + Lisp_Object auto_save_file_format_; /* True if the newline position cache, width run cache and BIDI paragraph cache are enabled. See search.c, indent.c and bidi.c for details. */ - Lisp_Object INTERNAL_FIELD (cache_long_scans); + Lisp_Object cache_long_scans_; /* If the width run cache is enabled, this table contains the character widths width_run_cache (see above) assumes. When we @@ -643,104 +643,104 @@ struct buffer current display table to see whether the display table has affected the widths of any characters. If it has, we invalidate the width run cache, and re-initialize width_table. */ - Lisp_Object INTERNAL_FIELD (width_table); + Lisp_Object width_table_; /* In an indirect buffer, or a buffer that is the base of an indirect buffer, this holds a marker that records PT for this buffer when the buffer is not current. */ - Lisp_Object INTERNAL_FIELD (pt_marker); + Lisp_Object pt_marker_; /* In an indirect buffer, or a buffer that is the base of an indirect buffer, this holds a marker that records BEGV for this buffer when the buffer is not current. */ - Lisp_Object INTERNAL_FIELD (begv_marker); + Lisp_Object begv_marker_; /* In an indirect buffer, or a buffer that is the base of an indirect buffer, this holds a marker that records ZV for this buffer when the buffer is not current. */ - Lisp_Object INTERNAL_FIELD (zv_marker); + Lisp_Object zv_marker_; /* This holds the point value before the last scroll operation. Explicitly setting point sets this to nil. */ - Lisp_Object INTERNAL_FIELD (point_before_scroll); + Lisp_Object point_before_scroll_; /* Truename of the visited file, or nil. */ - Lisp_Object INTERNAL_FIELD (file_truename); + Lisp_Object file_truename_; /* Invisibility spec of this buffer. t => any non-nil `invisible' property means invisible. A list => `invisible' property means invisible if it is memq in that list. */ - Lisp_Object INTERNAL_FIELD (invisibility_spec); + Lisp_Object invisibility_spec_; /* This is the last window that was selected with this buffer in it, or nil if that window no longer displays this buffer. */ - Lisp_Object INTERNAL_FIELD (last_selected_window); + Lisp_Object last_selected_window_; /* Incremented each time the buffer is displayed in a window. */ - Lisp_Object INTERNAL_FIELD (display_count); + Lisp_Object display_count_; /* Widths of left and right marginal areas for windows displaying this buffer. */ - Lisp_Object INTERNAL_FIELD (left_margin_cols); - Lisp_Object INTERNAL_FIELD (right_margin_cols); + Lisp_Object left_margin_cols_; + Lisp_Object right_margin_cols_; /* Widths of left and right fringe areas for windows displaying this buffer. */ - Lisp_Object INTERNAL_FIELD (left_fringe_width); - Lisp_Object INTERNAL_FIELD (right_fringe_width); + Lisp_Object left_fringe_width_; + Lisp_Object right_fringe_width_; /* Non-nil means fringes are drawn outside display margins; othersize draw them between margin areas and text. */ - Lisp_Object INTERNAL_FIELD (fringes_outside_margins); + Lisp_Object fringes_outside_margins_; /* Width, height and types of scroll bar areas for windows displaying this buffer. */ - Lisp_Object INTERNAL_FIELD (scroll_bar_width); - Lisp_Object INTERNAL_FIELD (scroll_bar_height); - Lisp_Object INTERNAL_FIELD (vertical_scroll_bar_type); - Lisp_Object INTERNAL_FIELD (horizontal_scroll_bar_type); + Lisp_Object scroll_bar_width_; + Lisp_Object scroll_bar_height_; + Lisp_Object vertical_scroll_bar_type_; + Lisp_Object horizontal_scroll_bar_type_; /* Non-nil means indicate lines not displaying text (in a style like vi). */ - Lisp_Object INTERNAL_FIELD (indicate_empty_lines); + Lisp_Object indicate_empty_lines_; /* Non-nil means indicate buffer boundaries and scrolling. */ - Lisp_Object INTERNAL_FIELD (indicate_buffer_boundaries); + Lisp_Object indicate_buffer_boundaries_; /* Logical to physical fringe bitmap mappings. */ - Lisp_Object INTERNAL_FIELD (fringe_indicator_alist); + Lisp_Object fringe_indicator_alist_; /* Logical to physical cursor bitmap mappings. */ - Lisp_Object INTERNAL_FIELD (fringe_cursor_alist); + Lisp_Object fringe_cursor_alist_; /* Time stamp updated each time this buffer is displayed in a window. */ - Lisp_Object INTERNAL_FIELD (display_time); + Lisp_Object display_time_; /* If scrolling the display because point is below the bottom of a window showing this buffer, try to choose a window start so that point ends up this number of lines from the top of the window. Nil means that scrolling method isn't used. */ - Lisp_Object INTERNAL_FIELD (scroll_up_aggressively); + Lisp_Object scroll_up_aggressively_; /* If scrolling the display because point is above the top of a window showing this buffer, try to choose a window start so that point ends up this number of lines from the bottom of the window. Nil means that scrolling method isn't used. */ - Lisp_Object INTERNAL_FIELD (scroll_down_aggressively); + Lisp_Object scroll_down_aggressively_; /* Desired cursor type in this buffer. See the doc string of per-buffer variable `cursor-type'. */ - Lisp_Object INTERNAL_FIELD (cursor_type); + Lisp_Object cursor_type_; /* An integer > 0 means put that number of pixels below text lines in the display of this buffer. */ - Lisp_Object INTERNAL_FIELD (extra_line_spacing); + Lisp_Object extra_line_spacing_; /* Cursor type to display in non-selected windows. t means to use hollow box cursor. See `cursor-type' for other values. */ - Lisp_Object INTERNAL_FIELD (cursor_in_non_selected_windows); + Lisp_Object cursor_in_non_selected_windows_; /* No more Lisp_Object beyond this point. Except undo_list, which is handled specially in Fgarbage_collect. */ @@ -872,7 +872,7 @@ struct buffer buffer of an indirect buffer. But we can't store it in the struct buffer_text because local variables have to be right in the struct buffer. So we copy it around in set_buffer_internal. */ - Lisp_Object INTERNAL_FIELD (undo_list); + Lisp_Object undo_list_; }; /* Most code should use these functions to set Lisp fields in struct @@ -881,102 +881,102 @@ struct buffer INLINE void bset_bidi_paragraph_direction (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (bidi_paragraph_direction) = val; + b->bidi_paragraph_direction_ = val; } INLINE void bset_cache_long_scans (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (cache_long_scans) = val; + b->cache_long_scans_ = val; } INLINE void bset_case_canon_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (case_canon_table) = val; + b->case_canon_table_ = val; } INLINE void bset_case_eqv_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (case_eqv_table) = val; + b->case_eqv_table_ = val; } INLINE void bset_directory (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (directory) = val; + b->directory_ = val; } INLINE void bset_display_count (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (display_count) = val; + b->display_count_ = val; } INLINE void bset_display_time (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (display_time) = val; + b->display_time_ = val; } INLINE void bset_downcase_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (downcase_table) = val; + b->downcase_table_ = val; } INLINE void bset_enable_multibyte_characters (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (enable_multibyte_characters) = val; + b->enable_multibyte_characters_ = val; } INLINE void bset_filename (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (filename) = val; + b->filename_ = val; } INLINE void bset_keymap (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (keymap) = val; + b->keymap_ = val; } INLINE void bset_last_selected_window (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (last_selected_window) = val; + b->last_selected_window_ = val; } INLINE void bset_local_var_alist (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (local_var_alist) = val; + b->local_var_alist_ = val; } INLINE void bset_mark_active (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (mark_active) = val; + b->mark_active_ = val; } INLINE void bset_point_before_scroll (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (point_before_scroll) = val; + b->point_before_scroll_ = val; } INLINE void bset_read_only (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (read_only) = val; + b->read_only_ = val; } INLINE void bset_truncate_lines (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (truncate_lines) = val; + b->truncate_lines_ = val; } INLINE void bset_undo_list (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (undo_list) = val; + b->undo_list_ = val; } INLINE void bset_upcase_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (upcase_table) = val; + b->upcase_table_ = val; } INLINE void bset_width_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (width_table) = val; + b->width_table_ = val; } /* Number of Lisp_Objects at the beginning of struct buffer. @@ -1253,7 +1253,7 @@ extern int last_per_buffer_idx; from the start of a buffer structure. */ #define PER_BUFFER_VAR_OFFSET(VAR) \ - offsetof (struct buffer, INTERNAL_FIELD (VAR)) + offsetof (struct buffer, VAR ## _) /* Used to iterate over normal Lisp_Object fields of struct buffer (all Lisp_Objects except undo_list). If you add, remove, or reorder diff --git a/src/category.c b/src/category.c index b20493e..ab90f5f 100644 --- a/src/category.c +++ b/src/category.c @@ -41,7 +41,7 @@ along with GNU Emacs. If not, see . */ static void bset_category_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (category_table) = val; + b->category_table_ = val; } /* The version number of the latest category table. Each category diff --git a/src/keyboard.c b/src/keyboard.c index bd79f90..c2739df 100644 --- a/src/keyboard.c +++ b/src/keyboard.c @@ -391,47 +391,47 @@ static void store_user_signal_events (void); static void kset_echo_string (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (echo_string) = val; + kb->echo_string_ = val; } static void kset_kbd_queue (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (kbd_queue) = val; + kb->kbd_queue_ = val; } static void kset_keyboard_translate_table (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vkeyboard_translate_table) = val; + kb->Vkeyboard_translate_table_ = val; } static void kset_last_prefix_arg (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vlast_prefix_arg) = val; + kb->Vlast_prefix_arg_ = val; } static void kset_last_repeatable_command (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vlast_repeatable_command) = val; + kb->Vlast_repeatable_command_ = val; } static void kset_local_function_key_map (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vlocal_function_key_map) = val; + kb->Vlocal_function_key_map_ = val; } static void kset_overriding_terminal_local_map (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Voverriding_terminal_local_map) = val; + kb->Voverriding_terminal_local_map_ = val; } static void kset_real_last_command (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vreal_last_command) = val; + kb->Vreal_last_command_ = val; } static void kset_system_key_syms (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (system_key_syms) = val; + kb->system_key_syms_ = val; } diff --git a/src/keyboard.h b/src/keyboard.h index 0ce6d18..bcdeaf6 100644 --- a/src/keyboard.h +++ b/src/keyboard.h @@ -25,7 +25,7 @@ INLINE_HEADER_BEGIN /* Most code should use this macro to access Lisp fields in struct kboard. */ -#define KVAR(kboard, field) ((kboard)->INTERNAL_FIELD (field)) +#define KVAR(kboard, field) ((kboard)->field ## _) /* Each KBOARD represents one logical input stream from which Emacs gets input. If we are using ordinary terminals, it has one KBOARD @@ -78,32 +78,32 @@ struct kboard can effectively wait for input in the any-kboard state, and hence avoid blocking out the other KBOARDs. See universal-argument in lisp/simple.el for an example. */ - Lisp_Object INTERNAL_FIELD (Voverriding_terminal_local_map); + Lisp_Object Voverriding_terminal_local_map_; /* Last command executed by the editor command loop, not counting commands that set the prefix argument. */ - Lisp_Object INTERNAL_FIELD (Vlast_command); + Lisp_Object Vlast_command_; /* Normally same as last-command, but never modified by other commands. */ - Lisp_Object INTERNAL_FIELD (Vreal_last_command); + Lisp_Object Vreal_last_command_; /* User-supplied table to translate input characters through. */ - Lisp_Object INTERNAL_FIELD (Vkeyboard_translate_table); + Lisp_Object Vkeyboard_translate_table_; /* Last command that may be repeated by `repeat'. */ - Lisp_Object INTERNAL_FIELD (Vlast_repeatable_command); + Lisp_Object Vlast_repeatable_command_; /* The prefix argument for the next command, in raw form. */ - Lisp_Object INTERNAL_FIELD (Vprefix_arg); + Lisp_Object Vprefix_arg_; /* Saved prefix argument for the last command, in raw form. */ - Lisp_Object INTERNAL_FIELD (Vlast_prefix_arg); + Lisp_Object Vlast_prefix_arg_; /* Unread events specific to this kboard. */ - Lisp_Object INTERNAL_FIELD (kbd_queue); + Lisp_Object kbd_queue_; /* Non-nil while a kbd macro is being defined. */ - Lisp_Object INTERNAL_FIELD (defining_kbd_macro); + Lisp_Object defining_kbd_macro_; /* The start of storage for the current keyboard macro. */ Lisp_Object *kbd_macro_buffer; @@ -125,28 +125,28 @@ struct kboard ptrdiff_t kbd_macro_bufsize; /* Last anonymous kbd macro defined. */ - Lisp_Object INTERNAL_FIELD (Vlast_kbd_macro); + Lisp_Object Vlast_kbd_macro_; /* Alist of system-specific X windows key symbols. */ - Lisp_Object INTERNAL_FIELD (Vsystem_key_alist); + Lisp_Object Vsystem_key_alist_; /* Cache for modify_event_symbol. */ - Lisp_Object INTERNAL_FIELD (system_key_syms); + Lisp_Object system_key_syms_; /* The kind of display: x, w32, ... */ - Lisp_Object INTERNAL_FIELD (Vwindow_system); + Lisp_Object Vwindow_system_; /* Keymap mapping keys to alternative preferred forms. See the DEFVAR for more documentation. */ - Lisp_Object INTERNAL_FIELD (Vlocal_function_key_map); + Lisp_Object Vlocal_function_key_map_; /* Keymap mapping ASCII function key sequences onto their preferred forms. Initialized by the terminal-specific lisp files. See the DEFVAR for more documentation. */ - Lisp_Object INTERNAL_FIELD (Vinput_decode_map); + Lisp_Object Vinput_decode_map_; /* Minibufferless frames on this display use this frame's minibuffer. */ - Lisp_Object INTERNAL_FIELD (Vdefault_minibuffer_frame); + Lisp_Object Vdefault_minibuffer_frame_; /* Number of displays using this KBOARD. Normally 1, but can be larger when you have multiple screens on a single X display. */ @@ -154,7 +154,7 @@ struct kboard /* The text we're echoing in the modeline - partial key sequences, usually. This is nil when not echoing. */ - Lisp_Object INTERNAL_FIELD (echo_string); + Lisp_Object echo_string_; /* This flag indicates that events were put into kbd_queue while Emacs was running for some other KBOARD. @@ -179,42 +179,42 @@ struct kboard INLINE void kset_default_minibuffer_frame (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vdefault_minibuffer_frame) = val; + kb->Vdefault_minibuffer_frame_ = val; } INLINE void kset_defining_kbd_macro (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (defining_kbd_macro) = val; + kb->defining_kbd_macro_ = val; } INLINE void kset_input_decode_map (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vinput_decode_map) = val; + kb->Vinput_decode_map_ = val; } INLINE void kset_last_command (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vlast_command) = val; + kb->Vlast_command_ = val; } INLINE void kset_last_kbd_macro (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vlast_kbd_macro) = val; + kb->Vlast_kbd_macro_ = val; } INLINE void kset_prefix_arg (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vprefix_arg) = val; + kb->Vprefix_arg_ = val; } INLINE void kset_system_key_alist (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vsystem_key_alist) = val; + kb->Vsystem_key_alist_ = val; } INLINE void kset_window_system (struct kboard *kb, Lisp_Object val) { - kb->INTERNAL_FIELD (Vwindow_system) = val; + kb->Vwindow_system_ = val; } /* Temporarily used before a frame has been opened. */ diff --git a/src/lisp.h b/src/lisp.h index 55c4c66..6d34ce3 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -1144,10 +1144,6 @@ LISP_MACRO_DEFUN_VOID (CHECK_TYPE, (int ok, Lisp_Object predicate, Lisp_Object x), (ok, predicate, x)) -/* Deprecated and will be removed soon. */ - -#define INTERNAL_FIELD(field) field ## _ - /* See the macros in intervals.h. */ typedef struct interval *INTERVAL; diff --git a/src/syntax.c b/src/syntax.c index 2f82156..1695815 100644 --- a/src/syntax.c +++ b/src/syntax.c @@ -186,7 +186,7 @@ static bool in_classes (int, Lisp_Object); static void bset_syntax_table (struct buffer *b, Lisp_Object val) { - b->INTERNAL_FIELD (syntax_table) = val; + b->syntax_table_ = val; } /* Whether the syntax of the character C has the prefix flag set. */ -- 1.8.4 ============================================================