Mercurial > hg > xemacs-beta
annotate lisp/mule/mule-category.el @ 4952:19a72041c5ed
Mule-izing, various fixes related to char * arguments
-------------------- ChangeLog entries follow: --------------------
modules/ChangeLog addition:
2010-01-26 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
* postgresql/postgresql.c (CHECK_LIVE_CONNECTION):
* postgresql/postgresql.c (print_pgresult):
* postgresql/postgresql.c (Fpq_conn_defaults):
* postgresql/postgresql.c (Fpq_connectdb):
* postgresql/postgresql.c (Fpq_connect_start):
* postgresql/postgresql.c (Fpq_result_status):
* postgresql/postgresql.c (Fpq_res_status):
Mule-ize large parts of it.
2010-01-26 Ben Wing <ben@xemacs.org>
* ldap/eldap.c (print_ldap):
* ldap/eldap.c (allocate_ldap):
Use write_ascstring().
src/ChangeLog addition:
2010-01-26 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (build_ascstring):
* alloc.c (build_msg_cistring):
* alloc.c (staticpro_1):
* alloc.c (staticpro_name):
* alloc.c (staticpro_nodump_1):
* alloc.c (staticpro_nodump_name):
* alloc.c (unstaticpro_nodump_1):
* alloc.c (mcpro_1):
* alloc.c (mcpro_name):
* alloc.c (object_memory_usage_stats):
* alloc.c (common_init_alloc_early):
* alloc.c (init_alloc_once_early):
* buffer.c (print_buffer):
* buffer.c (vars_of_buffer):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.c (init_initial_directory):
* bytecode.c (invalid_byte_code):
* bytecode.c (print_compiled_function):
* bytecode.c (mark_compiled_function):
* chartab.c (print_table_entry):
* chartab.c (print_char_table):
* config.h.in:
* console-gtk.c:
* console-gtk.c (gtk_device_to_console_connection):
* console-gtk.c (gtk_semi_canonicalize_console_connection):
* console-gtk.c (gtk_canonicalize_console_connection):
* console-gtk.c (gtk_semi_canonicalize_device_connection):
* console-gtk.c (gtk_canonicalize_device_connection):
* console-stream.c (stream_init_frame_1):
* console-stream.c (vars_of_console_stream):
* console-stream.c (init_console_stream):
* console-x.c (x_semi_canonicalize_console_connection):
* console-x.c (x_semi_canonicalize_device_connection):
* console-x.c (x_canonicalize_device_connection):
* console-x.h:
* data.c (eq_with_ebola_notice):
* data.c (Fsubr_interactive):
* data.c (Fnumber_to_string):
* data.c (digit_to_number):
* device-gtk.c (gtk_init_device):
* device-msw.c (print_devmode):
* device-x.c (x_event_name):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-msw.c (handle_file_dialog_box):
* dialog-msw.c (vars_of_dialog_mswindows):
* doc.c (weird_doc):
* doc.c (Fsnarf_documentation):
* doc.c (vars_of_doc):
* dumper.c (pdump):
* dynarr.c:
* dynarr.c (Dynarr_realloc):
* editfns.c (Fuser_real_login_name):
* editfns.c (get_home_directory):
* elhash.c (print_hash_table_data):
* elhash.c (print_hash_table):
* emacs.c (main_1):
* emacs.c (vars_of_emacs):
* emodules.c:
* emodules.c (_emodules_list):
* emodules.c (Fload_module):
* emodules.c (Funload_module):
* emodules.c (Flist_modules):
* emodules.c (find_make_module):
* emodules.c (attempt_module_delete):
* emodules.c (emodules_load):
* emodules.c (emodules_doc_subr):
* emodules.c (emodules_doc_sym):
* emodules.c (syms_of_module):
* emodules.c (vars_of_module):
* emodules.h:
* eval.c (print_subr):
* eval.c (signal_call_debugger):
* eval.c (build_error_data):
* eval.c (signal_error):
* eval.c (maybe_signal_error):
* eval.c (signal_continuable_error):
* eval.c (maybe_signal_continuable_error):
* eval.c (signal_error_2):
* eval.c (maybe_signal_error_2):
* eval.c (signal_continuable_error_2):
* eval.c (maybe_signal_continuable_error_2):
* eval.c (signal_ferror):
* eval.c (maybe_signal_ferror):
* eval.c (signal_continuable_ferror):
* eval.c (maybe_signal_continuable_ferror):
* eval.c (signal_ferror_with_frob):
* eval.c (maybe_signal_ferror_with_frob):
* eval.c (signal_continuable_ferror_with_frob):
* eval.c (maybe_signal_continuable_ferror_with_frob):
* eval.c (syntax_error):
* eval.c (syntax_error_2):
* eval.c (maybe_syntax_error):
* eval.c (sferror):
* eval.c (sferror_2):
* eval.c (maybe_sferror):
* eval.c (invalid_argument):
* eval.c (invalid_argument_2):
* eval.c (maybe_invalid_argument):
* eval.c (invalid_constant):
* eval.c (invalid_constant_2):
* eval.c (maybe_invalid_constant):
* eval.c (invalid_operation):
* eval.c (invalid_operation_2):
* eval.c (maybe_invalid_operation):
* eval.c (invalid_change):
* eval.c (invalid_change_2):
* eval.c (maybe_invalid_change):
* eval.c (invalid_state):
* eval.c (invalid_state_2):
* eval.c (maybe_invalid_state):
* eval.c (wtaerror):
* eval.c (stack_overflow):
* eval.c (out_of_memory):
* eval.c (print_multiple_value):
* eval.c (issue_call_trapping_problems_warning):
* eval.c (backtrace_specials):
* eval.c (backtrace_unevalled_args):
* eval.c (Fbacktrace):
* eval.c (warn_when_safe):
* event-Xt.c (modwarn):
* event-Xt.c (modbarf):
* event-Xt.c (check_modifier):
* event-Xt.c (store_modifier):
* event-Xt.c (emacs_Xt_format_magic_event):
* event-Xt.c (describe_event):
* event-gtk.c (dragndrop_data_received):
* event-gtk.c (store_modifier):
* event-gtk.c (gtk_reset_modifier_mapping):
* event-msw.c (dde_eval_string):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (FROB):
* event-msw.c (emacs_mswindows_format_magic_event):
* event-stream.c (external_debugging_print_event):
* event-stream.c (execute_help_form):
* event-stream.c (vars_of_event_stream):
* events.c (print_event_1):
* events.c (print_event):
* events.c (event_equal):
* extents.c (print_extent_1):
* extents.c (print_extent):
* extents.c (vars_of_extents):
* faces.c (print_face):
* faces.c (complex_vars_of_faces):
* file-coding.c:
* file-coding.c (print_coding_system):
* file-coding.c (print_coding_system_in_print_method):
* file-coding.c (default_query_method):
* file-coding.c (find_coding_system):
* file-coding.c (make_coding_system_1):
* file-coding.c (chain_print):
* file-coding.c (undecided_print):
* file-coding.c (gzip_print):
* file-coding.c (vars_of_file_coding):
* file-coding.c (complex_vars_of_file_coding):
* fileio.c:
* fileio.c (report_file_type_error):
* fileio.c (report_error_with_errno):
* fileio.c (report_file_error):
* fileio.c (barf_or_query_if_file_exists):
* fileio.c (vars_of_fileio):
* floatfns.c (matherr):
* fns.c (print_bit_vector):
* fns.c (Fmapconcat):
* fns.c (add_suffix_to_symbol):
* fns.c (add_prefix_to_symbol):
* frame-gtk.c:
* frame-gtk.c (Fgtk_window_id):
* frame-x.c (def):
* frame-x.c (x_cde_transfer_callback):
* frame.c:
* frame.c (Fmake_frame):
* gc.c (show_gc_cursor_and_message):
* gc.c (vars_of_gc):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate):
* glyphs-gtk.c (gtk_print_image_instance):
* glyphs-msw.c (mswindows_print_image_instance):
* glyphs-x.c (x_print_image_instance):
* glyphs-x.c (update_widget_face):
* glyphs.c (make_string_from_file):
* glyphs.c (print_image_instance):
* glyphs.c (signal_image_error):
* glyphs.c (signal_image_error_2):
* glyphs.c (signal_double_image_error):
* glyphs.c (signal_double_image_error_2):
* glyphs.c (xbm_mask_file_munging):
* glyphs.c (pixmap_to_lisp_data):
* glyphs.h:
* gui.c (gui_item_display_flush_left):
* hpplay.c (player_error_internal):
* hpplay.c (myHandler):
* intl-win32.c:
* intl-win32.c (langcode_to_lang):
* intl-win32.c (sublangcode_to_lang):
* intl-win32.c (Fmswindows_get_locale_info):
* intl-win32.c (lcid_to_locale_mule_or_no):
* intl-win32.c (mswindows_multibyte_to_unicode_print):
* intl-win32.c (complex_vars_of_intl_win32):
* keymap.c:
* keymap.c (print_keymap):
* keymap.c (ensure_meta_prefix_char_keymapp):
* keymap.c (Fkey_description):
* keymap.c (Ftext_char_description):
* lisp.h:
* lisp.h (struct):
* lisp.h (DECLARE_INLINE_HEADER):
* lread.c (Fload_internal):
* lread.c (locate_file):
* lread.c (read_escape):
* lread.c (read_raw_string):
* lread.c (read1):
* lread.c (read_list):
* lread.c (read_compiled_function):
* lread.c (init_lread):
* lrecord.h:
* marker.c (print_marker):
* marker.c (marker_equal):
* menubar-msw.c (displayable_menu_item):
* menubar-x.c (command_builder_operate_menu_accelerator):
* menubar.c (vars_of_menubar):
* minibuf.c (reinit_complex_vars_of_minibuf):
* minibuf.c (complex_vars_of_minibuf):
* mule-charset.c (Fmake_charset):
* mule-charset.c (complex_vars_of_mule_charset):
* mule-coding.c (iso2022_print):
* mule-coding.c (fixed_width_query):
* number.c (bignum_print):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-msw.c:
* objects-msw.c (mswindows_color_to_string):
* objects-msw.c (mswindows_color_list):
* objects-tty.c:
* objects-tty.c (tty_font_list):
* objects-tty.c (tty_find_charset_font):
* objects-xlike-inc.c (xft_find_charset_font):
* objects-xlike-inc.c (endif):
* print.c:
* print.c (write_istring):
* print.c (write_ascstring):
* print.c (Fterpri):
* print.c (Fprint):
* print.c (print_error_message):
* print.c (print_vector_internal):
* print.c (print_cons):
* print.c (print_string):
* print.c (printing_unreadable_object):
* print.c (print_internal):
* print.c (print_float):
* print.c (print_symbol):
* process-nt.c (mswindows_report_winsock_error):
* process-nt.c (nt_canonicalize_host_name):
* process-unix.c (unix_canonicalize_host_name):
* process.c (print_process):
* process.c (report_process_error):
* process.c (report_network_error):
* process.c (make_process_internal):
* process.c (Fstart_process_internal):
* process.c (status_message):
* process.c (putenv_internal):
* process.c (vars_of_process):
* process.h:
* profile.c (vars_of_profile):
* rangetab.c (print_range_table):
* realpath.c (vars_of_realpath):
* redisplay.c (vars_of_redisplay):
* search.c (wordify):
* search.c (Freplace_match):
* sheap.c (sheap_adjust_h):
* sound.c (report_sound_error):
* sound.c (Fplay_sound_file):
* specifier.c (print_specifier):
* symbols.c (Fsubr_name):
* symbols.c (do_symval_forwarding):
* symbols.c (set_default_buffer_slot_variable):
* symbols.c (set_default_console_slot_variable):
* symbols.c (store_symval_forwarding):
* symbols.c (default_value):
* symbols.c (defsymbol_massage_name_1):
* symbols.c (defsymbol_massage_name_nodump):
* symbols.c (defsymbol_massage_name):
* symbols.c (defsymbol_massage_multiword_predicate_nodump):
* symbols.c (defsymbol_massage_multiword_predicate):
* symbols.c (defsymbol_nodump):
* symbols.c (defsymbol):
* symbols.c (defkeyword):
* symbols.c (defkeyword_massage_name):
* symbols.c (check_module_subr):
* symbols.c (deferror_1):
* symbols.c (deferror):
* symbols.c (deferror_massage_name):
* symbols.c (deferror_massage_name_and_message):
* symbols.c (defvar_magic):
* symeval.h:
* symeval.h (DEFVAR_SYMVAL_FWD):
* sysdep.c:
* sysdep.c (init_system_name):
* sysdll.c:
* sysdll.c (MAYBE_PREPEND_UNDERSCORE):
* sysdll.c (dll_function):
* sysdll.c (dll_variable):
* sysdll.c (dll_error):
* sysdll.c (dll_open):
* sysdll.c (dll_close):
* sysdll.c (image_for_address):
* sysdll.c (my_find_image):
* sysdll.c (search_linked_libs):
* sysdll.h:
* sysfile.h:
* sysfile.h (DEFAULT_DIRECTORY_FALLBACK):
* syswindows.h:
* tests.c (DFC_CHECK_LENGTH):
* tests.c (DFC_CHECK_CONTENT):
* tests.c (Ftest_hash_tables):
* text.c (vars_of_text):
* text.h:
* tooltalk.c (tt_opnum_string):
* tooltalk.c (tt_message_arg_ival_string):
* tooltalk.c (Ftooltalk_default_procid):
* tooltalk.c (Ftooltalk_default_session):
* tooltalk.c (init_tooltalk):
* tooltalk.c (vars_of_tooltalk):
* ui-gtk.c (Fdll_load):
* ui-gtk.c (type_to_marshaller_type):
* ui-gtk.c (Fgtk_import_function_internal):
* ui-gtk.c (emacs_gtk_object_printer):
* ui-gtk.c (emacs_gtk_boxed_printer):
* unicode.c (unicode_to_ichar):
* unicode.c (unicode_print):
* unicode.c (unicode_query):
* unicode.c (vars_of_unicode):
* unicode.c (complex_vars_of_unicode):
* win32.c:
* win32.c (mswindows_report_process_error):
* window.c (print_window):
* xemacs.def.in.in:
BASIC IDEA: Further fixing up uses of char * and CIbyte *
to reflect their actual semantics; Mule-izing some code;
redoing of the not-yet-working code to handle message translation.
Clean up code to handle message-translation (not yet working).
Create separate versions of build_msg_string() for working with
Ibyte *, CIbyte *, and Ascbyte * arguments. Assert that Ascbyte *
arguments are pure-ASCII. Make build_msg_string() be the same
as build_msg_ascstring(). Create same three versions of GETTEXT()
and DEFER_GETTEXT(). Also create build_defer_string() and
variants for the equivalent of DEFER_GETTEXT() when building a
string. Remove old CGETTEXT(). Clean up code where GETTEXT(),
DEFER_GETTEXT(), build_msg_string(), etc. was being called and
introduce some new calls to build_msg_string(), etc. Remove
GETTEXT() from calls to weird_doc() -- we assume that the
message snarfer knows about weird_doc(). Remove uses of
DEFER_GETTEXT() from error messages in sysdep.c and instead use
special comments /* @@@begin-snarf@@@ */ and /* @@@end-snarf@@@ */
that the message snarfer presumably knows about.
Create build_ascstring() and use it in many instances in place
of build_string(). The purpose of having Ascbyte * variants is
to make the code more self-documenting in terms of what sort of
semantics is expected for char * strings. In fact in the process
of looking for uses of build_string(), much improperly Mule-ized
was discovered.
Mule-ize a lot of code as described in previous paragraph,
e.g. in sysdep.c.
Make the error functions take Ascbyte * strings and fix up a
couple of places where non-pure-ASCII strings were being passed in
(file-coding.c, mule-coding.c, unicode.c). (It's debatable whether
we really need to make the error functions work this way. It
helps catch places where code is written in a way that message
translation won't work, but we may well never implement message
translation.)
Make staticpro() and friends take Ascbyte * strings instead of
raw char * strings. Create a const_Ascbyte_ptr dynarr type
to describe what's held by staticpro_names[] and friends,
create pdump descriptions for const_Ascbyte_ptr dynarrs, and
use them in place of specially-crafted staticpro descriptions.
Mule-ize certain other functions (e.g. x_event_name) by correcting
raw use of char * to Ascbyte *, Rawbyte * or another such type,
and raw use of char[] buffers to another type (usually Ascbyte[]).
Change many uses of write_c_string() to write_msg_string(),
write_ascstring(), etc.
Mule-ize emodules.c, emodules.h, sysdll.h.
Fix some un-Mule-ized code in intl-win32.c.
A comment in event-Xt.c and the limitations of the message
snarfer (make-msgfile or whatever) is presumably incorrect --
it should be smart enough to handle function calls spread over
more than one line. Clean up code in event-Xt.c that was
written awkwardly for this reason.
In config.h.in, instead of NEED_ERROR_CHECK_TYPES_INLINES,
create a more general XEMACS_DEFS_NEEDS_INLINE_DECLS to
indicate when inlined functions need to be declared in
xemacs.defs.in.in, and make use of it in xemacs.defs.in.in.
We need to do this because postgresql.c now calls qxestrdup(),
which is an inline function.
Make nconc2() and other such functions MODULE_API and put
them in xemacs.defs.in.in since postgresql.c now uses them.
Clean up indentation in lread.c and a few other places.
In text.h, document ASSERT_ASCTEXT_ASCII() and
ASSERT_ASCTEXT_ASCII_LEN(), group together the stand-in
encodings and add some more for DLL symbols, function and
variable names, etc.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Tue, 26 Jan 2010 23:22:30 -0600 |
| parents | 980575c76541 |
| children | 311f6817efc2 308d34e9f07d |
| rev | line source |
|---|---|
| 502 | 1 ;;; mule-category.el --- category functions for XEmacs/Mule. -*- coding: iso-2022-7bit; -*- |
| 428 | 2 |
| 3 ;; Copyright (C) 1992,93,94,95 Free Software Foundation, Inc. | |
| 4 ;; Copyright (C) 1995, 1997, 1999 Electrotechnical Laboratory, JAPAN. | |
| 5 ;; Licensed to the Free Software Foundation. | |
| 6 ;; Copyright (C) 1995 Amdahl Corporation. | |
| 7 ;; Copyright (C) 1995 Sun Microsystems. | |
| 8 | |
| 9 ;; This file is part of XEmacs. | |
| 10 | |
| 11 ;; XEmacs is free software; you can redistribute it and/or modify it | |
| 12 ;; under the terms of the GNU General Public License as published by | |
| 13 ;; the Free Software Foundation; either version 2, or (at your option) | |
| 14 ;; any later version. | |
| 15 | |
| 16 ;; XEmacs is distributed in the hope that it will be useful, but | |
| 17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 19 ;; General Public License for more details. | |
| 20 | |
| 21 ;; You should have received a copy of the GNU General Public License | |
| 444 | 22 ;; along with XEmacs; see the file COPYING. If not, write to the |
| 428 | 23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 24 ;; Boston, MA 02111-1307, USA. | |
| 25 | |
| 26 ;;; Commentary: | |
| 27 | |
| 28 ;; Functions for working with category tables, which are a particular | |
| 29 ;; type of char table. Some function names / arguments should be | |
| 30 ;; parallel with syntax tables. | |
| 31 | |
| 32 ;; Written by Ben Wing <ben@xemacs.org>. The initialization code | |
| 33 ;; at the end of this file comes from Mule. | |
| 34 ;; Some bugfixes by Jareth Hein <jhod@po.iijnet.or.jp> | |
| 35 | |
| 36 ;;; Code: | |
| 37 | |
| 442 | 38 (defvar defined-category-hashtable (make-hash-table :size 50)) |
| 428 | 39 |
| 3970 | 40 (defun define-category (designator doc-string &optional table) |
| 428 | 41 "Make a new category whose designator is DESIGNATOR. |
| 42 DESIGNATOR should be a visible letter of ' ' thru '~'. | |
| 3970 | 43 DOC-STRING is a doc string for the category. |
| 44 Letters of 'a' thru 'z' are already used or kept for the system. | |
| 45 The category should be defined only in category table TABLE, which defaults | |
| 46 to the current buffer's category table, but this is not implemented. " | |
| 47 ;; #### Implement the limiting of the definition. | |
| 428 | 48 (check-argument-type 'category-designator-p designator) |
| 49 (check-argument-type 'stringp doc-string) | |
| 3970 | 50 (setq table (or table (category-table))) |
| 51 (check-argument-type 'category-table-p table) | |
| 428 | 52 (puthash designator doc-string defined-category-hashtable)) |
| 53 | |
| 54 (defun undefine-category (designator) | |
| 55 "Undefine DESIGNATOR as a designator for a category." | |
| 56 (check-argument-type 'category-designator-p designator) | |
| 57 (remhash designator defined-category-hashtable)) | |
| 58 | |
| 59 (defun defined-category-p (designator) | |
| 60 "Return non-nil if DESIGNATOR is a designator for a defined category." | |
| 61 (and (category-designator-p designator) | |
| 62 (gethash designator defined-category-hashtable))) | |
| 63 | |
| 64 (defun defined-category-list () | |
| 65 "Return a list of the currently defined categories. | |
| 66 Categories are given by their designators." | |
| 67 (let (list) | |
| 68 (maphash #'(lambda (key value) | |
| 69 (setq list (cons key list))) | |
| 70 defined-category-hashtable) | |
| 71 (nreverse list))) | |
| 72 | |
| 73 (defun undefined-category-designator () | |
| 74 "Return an undefined category designator, or nil if there are none." | |
| 75 (let ((a 32) found) | |
| 76 (while (and (< a 127) (not found)) | |
| 434 | 77 (unless (gethash a defined-category-hashtable) |
| 78 (setq found (make-char 'ascii a))) | |
| 428 | 79 (setq a (1+ a))) |
| 80 found)) | |
| 81 | |
| 82 (defun category-doc-string (designator) | |
| 83 "Return the doc-string for the category denoted by DESIGNATOR." | |
| 84 (check-argument-type 'defined-category-p designator) | |
| 85 (gethash designator defined-category-hashtable)) | |
| 86 | |
| 444 | 87 (defun modify-category-entry (char-range designator &optional category-table reset) |
| 428 | 88 "Add a category to the categories associated with CHAR-RANGE. |
| 89 CHAR-RANGE is a single character or a range of characters, | |
| 90 as per `put-char-table'. | |
| 91 The category is given by a designator character. | |
| 444 | 92 The changes are made in CATEGORY-TABLE, which defaults to the current |
| 93 buffer's category table. | |
| 428 | 94 If optional fourth argument RESET is non-nil, previous categories associated |
| 95 with CHAR-RANGE are removed before adding the specified category." | |
| 444 | 96 (or category-table (setq category-table (category-table))) |
| 97 (check-argument-type 'category-table-p category-table) | |
| 428 | 98 (check-argument-type 'defined-category-p designator) |
| 99 (if reset | |
| 100 ;; clear all existing stuff. | |
| 444 | 101 (put-char-table char-range nil category-table)) |
| 428 | 102 (map-char-table |
| 103 #'(lambda (key value) | |
| 104 ;; make sure that this range has a bit-vector assigned to it | |
| 105 (if (not (bit-vector-p value)) | |
| 106 (setq value (make-bit-vector 95 0)) | |
| 107 (setq value (copy-sequence value))) | |
| 108 ;; set the appropriate bit in that vector. | |
| 109 (aset value (- designator 32) 1) | |
| 110 ;; put the vector back, thus assuring we have a unique setting for this range | |
| 444 | 111 (put-char-table key value category-table)) |
| 112 category-table char-range)) | |
| 428 | 113 |
| 444 | 114 (defun char-category-list (character &optional category-table) |
| 115 "Return a list of the categories that CHARACTER is in. | |
| 116 CATEGORY-TABLE defaults to the current buffer's category table. | |
| 428 | 117 The categories are given by their designators." |
| 444 | 118 (or category-table (setq category-table (category-table))) |
| 119 (check-argument-type 'category-table-p category-table) | |
| 120 (let ((vec (get-char-table character category-table))) | |
| 428 | 121 (if (null vec) nil |
| 122 (let ((a 32) list) | |
| 123 (while (< a 127) | |
| 124 (if (= 1 (aref vec (- a 32))) | |
| 434 | 125 (setq list (cons (make-char 'ascii a) list))) |
| 428 | 126 (setq a (1+ a))) |
| 127 (nreverse list))))) | |
| 128 | |
| 444 | 129 ;; implemented in C, file chartab.c (97/3/14 jhod@po.iijnet.or.jp) |
| 428 | 130 ;(defun char-in-category-p (char category &optional table) |
| 131 ; "Return non-nil if CHAR is in CATEGORY. | |
| 132 ;TABLE defaults to the current buffer's category table. | |
| 133 ;Categories are specified by their designators." | |
| 134 ; (or table (setq table (category-table))) | |
| 135 ; (check-argument-type 'category-table-p table) | |
| 136 ; (check-argument-type 'category-designator-p category) | |
| 137 ; (let ((vec (get-char-table char table))) | |
| 138 ; (if (null vec) nil | |
| 139 ; (= 1 (aref vec (- category 32)))))) | |
| 140 | |
| 788 | 141 (put 'with-category-table 'lisp-indent-function 1) |
| 142 | |
| 143 (defmacro with-category-table (category-table &rest body) | |
| 144 `(let ((current-category-table (category-table))) | |
| 145 (set-category-table ,category-table) | |
| 146 (unwind-protect | |
| 147 (progn ,@body) | |
| 148 (set-category-table current-category-table)))) | |
| 149 | |
| 3970 | 150 (defun make-category-table () |
| 151 "Construct a new and empty category table and return it." | |
| 152 (make-char-table 'category)) | |
| 153 | |
| 428 | 154 (defun describe-category () |
| 155 "Describe the category specifications in the category table. | |
| 156 The descriptions are inserted in a buffer, which is then displayed." | |
| 157 (interactive) | |
| 434 | 158 (with-displaying-help-buffer |
| 159 (lambda () | |
| 160 (describe-category-table (category-table) standard-output)))) | |
| 428 | 161 |
| 162 (defun describe-category-table (table stream) | |
| 163 (let (first-char | |
| 164 last-char | |
| 165 prev-val | |
| 166 (describe-one | |
| 167 (lambda (first last value stream) | |
| 168 (if (and (bit-vector-p value) | |
| 169 (> (reduce '+ value) 0)) | |
| 170 (progn | |
| 171 (if (equal first last) | |
| 172 (cond ((vectorp first) | |
| 173 (princ (format "%s, row %d" | |
| 174 (charset-name | |
| 175 (aref first 0)) | |
| 176 (aref first 1)) | |
| 177 stream)) | |
| 178 ((charsetp first) | |
| 179 (princ (charset-name first) stream)) | |
| 180 (t (princ first stream))) | |
| 181 (cond ((vectorp first) | |
| 182 (princ (format "%s, rows %d .. %d" | |
| 183 (charset-name | |
| 184 (aref first 0)) | |
| 185 (aref first 1) | |
| 186 (aref last 1)) | |
| 187 stream)) | |
| 188 (t | |
| 189 (princ (format "%s .. %s" first last) | |
| 190 stream)))) | |
| 191 (describe-category-code value stream)))))) | |
| 192 (map-char-table | |
| 193 (lambda (range value) | |
| 194 (if (and (or | |
| 195 (and (characterp range) | |
| 196 (characterp first-char) | |
| 197 (eq (char-charset range) (char-charset first-char)) | |
| 198 (= (char-to-int last-char) (1- (char-to-int range)))) | |
| 199 (and (vectorp range) | |
| 200 (vectorp first-char) | |
| 201 (eq (aref range 0) (aref first-char 0)) | |
| 202 (= (aref last-char 1) (1- (aref range 1)))) | |
| 203 (equal value prev-val))) | |
| 204 (setq last-char range) | |
| 205 (if first-char | |
| 206 (progn | |
| 207 (funcall describe-one first-char last-char prev-val stream) | |
| 208 (setq first-char nil))) | |
| 209 (funcall describe-one range range value stream)) | |
| 210 nil) | |
| 211 table) | |
| 212 (if first-char | |
| 213 (funcall describe-one first-char last-char prev-val stream)))) | |
| 214 | |
| 215 (defun describe-category-code (code stream) | |
| 216 (let ((standard-output (or stream standard-output))) | |
| 217 (princ "\tin categories: ") | |
| 218 (if (not (bit-vector-p code)) | |
| 219 (princ "(none)") | |
| 220 (let ((i 0) | |
| 221 already-matched) | |
| 222 (while (< i 95) | |
| 223 (if (= 1 (aref code i)) | |
| 224 (progn | |
| 225 (if (not already-matched) | |
| 226 (setq already-matched t) | |
| 227 (princ " ")) | |
| 228 (princ (int-to-char (+ 32 i))))) | |
| 229 (setq i (1+ i))) | |
| 230 (if (not already-matched) | |
| 231 (princ "(none)"))) | |
| 232 (let ((i 0)) | |
| 233 (while (< i 95) | |
| 234 (if (= 1 (aref code i)) | |
| 235 (princ (format "\n\t\tmeaning: %s" | |
| 236 (category-doc-string (int-to-char (+ 32 i)))))) | |
| 237 (setq i (1+ i))))) | |
| 238 (terpri))) | |
| 239 | |
| 240 (defconst predefined-category-list | |
| 241 '((latin-iso8859-1 ?l "Latin-1 through Latin-5 character set") | |
| 242 (latin-iso8859-2 ?l) | |
| 243 (latin-iso8859-3 ?l) | |
| 244 (latin-iso8859-4 ?l) | |
| 245 (latin-iso8859-9 ?l) | |
| 246 (cyrillic-iso8859-5 ?y "Cyrillic character set") | |
|
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4491
diff
changeset
|
247 (arabic-iso8859-6 ?b "Arabic character set") |
| 428 | 248 (greek-iso8859-7 ?g "Greek character set") |
| 249 (hebrew-iso8859-8 ?w "Hebrew character set") | |
| 250 (katakana-jisx0201 ?k "Japanese 1-byte Katakana character set") | |
| 251 (latin-jisx0201 ?r "Japanese 1-byte Roman character set") | |
| 252 (japanese-jisx0208-1978 ?j "Japanese 2-byte character set (old)") | |
| 253 (japanese-jisx0208 ?j "Japanese 2-byte character set") | |
| 254 (japanese-jisx0212 ?j) | |
| 255 (chinese-gb2312 ?c "Chinese GB (China, PRC) 2-byte character set") | |
| 256 (chinese-cns11643-1 ?t "Chinese Taiwan (CNS or Big5) 2-byte character set") | |
| 257 (chinese-cns11643-2 ?t) | |
| 258 (chinese-big5-1 ?t) | |
| 259 (chinese-big5-2 ?t) | |
| 260 (korean-ksc5601 ?h "Hangul (Korean) 2-byte character set") | |
| 261 ) | |
| 262 "List of predefined categories. | |
| 263 Each element is a list of a charset, a designator, and maybe a doc string.") | |
| 264 | |
| 265 (let (i l) | |
| 266 (define-category ?a "ASCII character set.") | |
| 267 (define-category ?l "Latin-1 through Latin-5 character set") | |
| 268 (setq i 32) | |
| 269 (while (< i 127) | |
| 270 (modify-category-entry i ?a) | |
| 271 (modify-category-entry i ?l) | |
| 272 (setq i (1+ i))) | |
| 273 (setq l predefined-category-list) | |
| 274 (while l | |
| 275 (if (and (nth 2 (car l)) | |
| 276 (not (defined-category-p (nth 2 (car l))))) | |
| 277 (define-category (nth 1 (car l)) (nth 2 (car l)))) | |
| 952 | 278 (modify-category-entry (car (car l)) (nth 1 (car l)) nil t) |
| 428 | 279 (setq l (cdr l)))) |
| 280 | |
| 281 ;;; Setting word boundary. | |
| 282 | |
| 283 (setq word-combining-categories | |
| 284 '((?l . ?l))) | |
| 285 | |
| 286 (setq word-separating-categories ; (2-byte character sets) | |
| 287 '((?A . ?K) ; Alpha numeric - Katakana | |
| 288 (?A . ?C) ; Alpha numeric - Chinese | |
| 289 (?H . ?A) ; Hiragana - Alpha numeric | |
| 290 (?H . ?K) ; Hiragana - Katakana | |
| 291 (?H . ?C) ; Hiragana - Chinese | |
| 292 (?K . ?A) ; Katakana - Alpha numeric | |
| 293 (?K . ?C) ; Katakana - Chinese | |
| 294 (?C . ?A) ; Chinese - Alpha numeric | |
| 295 (?C . ?K) ; Chinese - Katakana | |
| 296 )) | |
| 297 | |
| 298 ;;; At the present, I know Japanese and Chinese text can | |
| 299 ;;; break line at any point under a restriction of 'kinsoku'. | |
| 450 | 300 ;;; #### SJT this needs to be set by language environments and probably should |
| 301 ;;; be buffer-local---strategy for dealing with this: check all $language.el | |
| 302 ;;; files and also mule-base/$language-utils.el files for variables set; | |
| 303 ;;; these should be made buffer local and some kind of a- or p-list of vars | |
| 304 ;;; to be set for a language environment created. | |
| 428 | 305 (defvar word-across-newline "\\(\\cj\\|\\cc\\|\\ct\\)" |
| 306 "Regular expression of such characters which can be a word across newline.") | |
| 307 | |
| 308 (defvar ascii-char "[\40-\176]") | |
| 309 (defvar ascii-space "[ \t]") | |
| 310 (defvar ascii-symbols "[\40-\57\72-\100\133-\140\173-\176]") | |
| 311 (defvar ascii-numeric "[\60-\71]") | |
| 312 (defvar ascii-English-Upper "[\101-\132]") | |
| 313 (defvar ascii-English-Lower "[\141-\172]") | |
| 314 (defvar ascii-alphanumeric "[\60-\71\101-\132\141-\172]") | |
| 315 | |
| 316 (defvar kanji-char "\\cj") | |
| 317 (defvar kanji-space "$B!!(B") | |
| 318 (defvar kanji-symbols "\\cS") | |
| 319 (defvar kanji-numeric "[$B#0(B-$B#9(B]") | |
| 320 (defvar kanji-English-Upper "[$B#A(B-$B#Z(B]") | |
| 321 (defvar kanji-English-Lower "[$B#a(B-$B#z(B]") | |
| 322 (defvar kanji-hiragana "\\cH") | |
| 323 (defvar kanji-katakana "\\cK") | |
| 324 (defvar kanji-Greek-Upper "[$B&!(B-$B&8(B]") | |
| 325 (defvar kanji-Greek-Lower "[$B&A(B-$B&X(B]") | |
| 326 (defvar kanji-Russian-Upper "[$B'!(B-$B'A(B]") | |
| 327 (defvar kanji-Russian-Lower "[$B'Q(B-$B'q(B]") | |
| 328 (defvar kanji-Kanji-1st-Level "[$B0!(B-$BOS(B]") | |
| 329 (defvar kanji-Kanji-2nd-Level "[$BP!(B-$Bt$(B]") | |
| 330 | |
| 331 (defvar kanji-kanji-char "\\(\\cH\\|\\cK\\|\\cC\\)") |