Mercurial > hg > xemacs-beta
annotate src/chartab.h @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| parents | d1247f3cc363 |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 428 | 1 /* Declarations having to do with Mule char tables. |
| 2 Copyright (C) 1992 Free Software Foundation, Inc. | |
| 3 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 1296 | 4 Copyright (C) 2002, 2003 Ben Wing. |
| 428 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
| 8 XEmacs is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 10 Free Software Foundation; either version 2, or (at your option) any | |
| 11 later version. | |
| 12 | |
| 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with XEmacs; see the file COPYING. If not, write to | |
| 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 21 Boston, MA 02111-1307, USA. */ | |
| 22 | |
| 23 /* Synched up with: Mule 2.3. Not synched with FSF. | |
| 24 | |
| 25 This file was written independently of the FSF implementation, | |
| 26 and is not compatible. */ | |
| 27 | |
| 440 | 28 #ifndef INCLUDED_chartab_h_ |
| 29 #define INCLUDED_chartab_h_ | |
| 428 | 30 |
| 771 | 31 #include "charset.h" |
| 32 | |
| 428 | 33 /************************************************************************/ |
| 34 /* Char Tables */ | |
| 35 /************************************************************************/ | |
| 36 | |
| 37 /* Under Mule, we use a complex representation (see below). | |
| 38 When not under Mule, there are only 256 possible characters | |
| 39 so we just represent them directly. */ | |
| 40 | |
| 41 #ifdef MULE | |
| 42 | |
| 43 struct Lisp_Char_Table_Entry | |
| 44 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
45 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 46 |
| 47 /* In the interests of simplicity, we just use a fixed 96-entry | |
| 48 table. If we felt like being smarter, we could make this | |
| 49 variable-size and add an offset value into this structure. */ | |
| 50 Lisp_Object level2[96]; | |
| 51 }; | |
| 440 | 52 typedef struct Lisp_Char_Table_Entry Lisp_Char_Table_Entry; |
| 53 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
54 DECLARE_LISP_OBJECT (char_table_entry, Lisp_Char_Table_Entry); |
| 440 | 55 #define XCHAR_TABLE_ENTRY(x) \ |
| 56 XRECORD (x, char_table_entry, Lisp_Char_Table_Entry) | |
| 617 | 57 #define wrap_char_table_entry(p) wrap_record (p, char_table_entry) |
| 440 | 58 #define CHAR_TABLE_ENTRYP(x) RECORDP (x, char_table_entry) |
| 59 /* #define CHECK_CHAR_TABLE_ENTRY(x) CHECK_RECORD (x, char_table_entry) | |
| 60 char table entries should never escape to Lisp */ | |
| 428 | 61 |
| 62 #endif /* MULE */ | |
| 63 | |
| 64 enum char_table_type | |
| 65 { | |
| 66 CHAR_TABLE_TYPE_GENERIC, | |
| 67 #ifdef MULE | |
| 68 CHAR_TABLE_TYPE_CATEGORY, | |
| 69 #endif | |
| 70 CHAR_TABLE_TYPE_SYNTAX, | |
| 71 CHAR_TABLE_TYPE_DISPLAY, | |
| 72 CHAR_TABLE_TYPE_CHAR | |
| 73 }; | |
| 74 | |
| 75 #ifdef MULE | |
| 76 #define NUM_ASCII_CHARS 160 | |
| 77 #else | |
| 78 #define NUM_ASCII_CHARS 256 | |
| 79 #endif | |
| 80 | |
| 81 struct Lisp_Char_Table | |
| 82 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
83 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 84 |
| 85 Lisp_Object ascii[NUM_ASCII_CHARS]; | |
| 826 | 86 Lisp_Object default_; |
| 793 | 87 Lisp_Object parent; /* #### not yet implemented */ |
| 88 | |
| 428 | 89 #ifdef MULE |
| 90 /* We basically duplicate the Mule vectors-of-vectors implementation. | |
| 91 We can do this because we know a great deal about the sorts of | |
| 92 things we are going to be indexing. | |
| 93 | |
| 94 The current implementation is as follows: | |
| 95 | |
| 96 ascii[0-159] is used for ASCII and Control-1 characters. | |
| 97 | |
| 98 level1[0 .. (NUM_LEADING_BYTES-1)] indexes charsets by leading | |
| 99 byte (subtract MIN_LEADING_BYTE from the leading byte). If the | |
| 100 value of this is not an opaque, then it specifies a value for all | |
| 101 characters in the charset. Otherwise, it will be a | |
| 102 96-Lisp-Object opaque that we created, specifying a value for | |
| 103 each row. If the value of this is not an opaque, then it | |
| 104 specifies a value for all characters in the row. Otherwise, it | |
| 105 will be a 96-Lisp-Object opaque that we created, specifying a | |
| 106 value for each character. | |
| 107 | |
| 108 NOTE: 1) This will fail if some C routine passes an opaque to | |
| 109 Fput_char_table(). Currently this is not a problem | |
| 110 since all char tables that are created are Lisp-visible | |
| 111 and thus no one should ever be putting an opaque in | |
| 112 a char table. Another possibility is to consider | |
| 113 adding a type to */ | |
| 114 | |
| 115 Lisp_Object level1[NUM_LEADING_BYTES]; | |
| 116 | |
| 117 #endif /* MULE */ | |
| 118 | |
| 119 enum char_table_type type; | |
| 120 | |
| 121 /* stuff used for syntax tables */ | |
| 1296 | 122 Lisp_Object mirror_table; /* points to mirror table for this table |
| 123 (a cache for quicker access), or a back | |
| 124 pointer if MIRROR_TABLE_P. */ | |
| 428 | 125 Lisp_Object next_table; /* DO NOT mark through this. */ |
| 1296 | 126 char dirty; /* nonzero if mirror dirty and needs updating. */ |
| 127 char mirror_table_p; /* nonzero if this is a mirror table. */ | |
| 428 | 128 }; |
| 440 | 129 typedef struct Lisp_Char_Table Lisp_Char_Table; |
| 130 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
131 DECLARE_LISP_OBJECT (char_table, Lisp_Char_Table); |
| 440 | 132 #define XCHAR_TABLE(x) XRECORD (x, char_table, Lisp_Char_Table) |
| 617 | 133 #define wrap_char_table(p) wrap_record (p, char_table) |
| 440 | 134 #define CHAR_TABLEP(x) RECORDP (x, char_table) |
| 135 #define CHECK_CHAR_TABLE(x) CHECK_RECORD (x, char_table) | |
| 136 #define CONCHECK_CHAR_TABLE(x) CONCHECK_RECORD (x, char_table) | |
| 137 | |
| 138 #define CHAR_TABLE_TYPE(ct) ((ct)->type) | |
| 139 #define XCHAR_TABLE_TYPE(ct) CHAR_TABLE_TYPE (XCHAR_TABLE (ct)) | |
| 428 | 140 |
| 440 | 141 Lisp_Object get_non_ascii_char_table_value (Lisp_Char_Table *ct, |
| 142 int leading_byte, | |
| 867 | 143 Ichar c); |
| 428 | 144 |
| 826 | 145 DECLARE_INLINE_HEADER ( |
| 146 Lisp_Object | |
| 1296 | 147 get_char_table_1 (Ichar ch, Lisp_Object table) |
| 826 | 148 ) |
| 428 | 149 { |
| 826 | 150 Lisp_Object retval; |
| 151 Lisp_Char_Table *ct = XCHAR_TABLE (table); | |
| 152 #ifdef MULE | |
| 153 if (ch < NUM_ASCII_CHARS) | |
| 154 retval = ct->ascii[ch]; | |
| 428 | 155 else |
| 826 | 156 { |
| 867 | 157 unsigned char lb = ichar_leading_byte (ch); |
| 826 | 158 if (!CHAR_TABLE_ENTRYP (ct->level1[lb - MIN_LEADING_BYTE])) |
| 159 retval = ct->level1[lb - MIN_LEADING_BYTE]; | |
| 160 else | |
| 161 retval = get_non_ascii_char_table_value (ct, lb, ch); | |
| 162 } | |
| 163 #else /* not MULE */ | |
| 164 retval = ct->ascii[(unsigned char) ch]; | |
| 165 #endif /* not MULE */ | |
| 166 if (!UNBOUNDP (retval)) | |
| 167 return retval; | |
| 168 else | |
| 169 return ct->default_; | |
| 428 | 170 } |
| 171 | |
| 1296 | 172 #ifdef ERROR_CHECK_TYPES |
| 173 DECLARE_INLINE_HEADER ( | |
| 174 Lisp_Object | |
| 175 get_char_table (Ichar ch, Lisp_Object table) | |
| 176 ) | |
| 177 { | |
| 178 assert (!XCHAR_TABLE (table)->mirror_table_p); | |
| 179 return get_char_table_1 (ch, table); | |
| 180 } | |
| 181 #else | |
| 182 #define get_char_table(ch, table) get_char_table_1 (ch, table) | |
| 183 #endif | |
| 184 | |
| 428 | 185 enum chartab_range_type |
| 186 { | |
| 187 CHARTAB_RANGE_ALL, | |
| 188 #ifdef MULE | |
| 189 CHARTAB_RANGE_CHARSET, | |
| 190 CHARTAB_RANGE_ROW, | |
| 191 #endif | |
| 192 CHARTAB_RANGE_CHAR | |
| 193 }; | |
| 194 | |
| 195 struct chartab_range | |
| 196 { | |
| 197 enum chartab_range_type type; | |
| 867 | 198 Ichar ch; |
| 428 | 199 Lisp_Object charset; |
| 200 int row; | |
| 201 }; | |
| 202 | |
| 826 | 203 void set_char_table_default (Lisp_Object table, Lisp_Object value); |
| 204 void put_char_table (Lisp_Object table, struct chartab_range *range, | |
| 428 | 205 Lisp_Object val); |
| 826 | 206 int map_char_table (Lisp_Object table, |
| 428 | 207 struct chartab_range *range, |
| 208 int (*fn) (struct chartab_range *range, | |
| 826 | 209 Lisp_Object table, |
| 428 | 210 Lisp_Object val, void *arg), |
| 211 void *arg); | |
| 212 void prune_syntax_tables (void); | |
| 826 | 213 Lisp_Object get_range_char_table (struct chartab_range *range, |
| 214 Lisp_Object table, Lisp_Object multi); | |
| 1296 | 215 #ifdef ERROR_CHECK_TYPES |
| 216 Lisp_Object updating_mirror_get_range_char_table (struct chartab_range *range, | |
| 217 Lisp_Object table, | |
| 218 Lisp_Object multi); | |
| 219 #else | |
| 220 #define updating_mirror_get_range_char_table get_range_char_table | |
| 221 #endif | |
| 826 | 222 void copy_char_table_range (Lisp_Object from, Lisp_Object to, |
| 223 struct chartab_range *range); | |
| 867 | 224 int word_boundary_p (Ichar c1, Ichar c2); |
| 428 | 225 |
| 226 EXFUN (Fcopy_char_table, 1); | |
| 227 EXFUN (Fmake_char_table, 1); | |
| 228 EXFUN (Fput_char_table, 3); | |
| 229 EXFUN (Fget_char_table, 2); | |
| 230 | |
| 231 extern Lisp_Object Vall_syntax_tables; | |
| 232 | |
| 233 | |
| 234 | |
| 235 #ifdef MULE | |
| 867 | 236 int check_category_char (Ichar ch, Lisp_Object ctbl, int designator, |
| 826 | 237 int not_p); |
| 428 | 238 |
| 239 extern Lisp_Object Vstandard_category_table; | |
| 240 | |
| 241 #define CATEGORY_DESIGNATORP(x) \ | |
| 242 (CHARP (x) && XCHAR (x) >= 32 && XCHAR (x) <= 126) | |
| 243 | |
| 244 #define CHECK_CATEGORY_DESIGNATOR(x) do { \ | |
| 245 if (!CATEGORY_DESIGNATORP (x)) \ | |
| 246 dead_wrong_type_argument (Qcategory_designator_p, x); \ | |
| 247 } while (0) | |
| 248 | |
| 249 #define CONCHECK_CATEGORY_DESIGNATOR(x) do { \ | |
| 250 if (!CATEGORY_DESIGNATORP (x)) \ | |
| 251 x = wrong_type_argument (Qcategory_designator_p, x); \ | |
| 252 } while (0) | |
| 253 | |
| 254 #define CATEGORY_TABLE_VALUEP(x) \ | |
| 255 (NILP (x) || (BIT_VECTORP (x) && (bit_vector_length (XBIT_VECTOR (x)) == 95))) | |
| 256 | |
| 257 #define CHECK_CATEGORY_TABLE_VALUE(x) do { \ | |
| 258 if (!CATEGORY_TABLE_VALUEP (x)) \ | |
| 259 dead_wrong_type_argument (Qcategory_table_value_p, x); \ | |
| 260 } while (0) | |
| 261 | |
| 262 #define CONCHECK_CATEGORY_TABLE_VALUE(x) do { \ | |
| 263 if (!CATEGORY_TABLE_VALUEP (x)) \ | |
| 264 x = wrong_type_argument (Qcategory_table_value_p, x); \ | |
| 265 } while (0) | |
| 266 | |
| 267 #endif /* MULE */ | |
| 268 | |
| 440 | 269 #endif /* INCLUDED_chartab_h_ */ |