Mercurial > hg > xemacs-beta
annotate src/lisp.h @ 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 | 8b63e21b0436 |
| children | 304aebb79cd3 |
| rev | line source |
|---|---|
| 428 | 1 /* Fundamental definitions for XEmacs Lisp interpreter. |
| 2 Copyright (C) 1985-1987, 1992-1995 Free Software Foundation, Inc. | |
| 3 Copyright (C) 1993-1996 Richard Mlynarik. | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
4 Copyright (C) 1995, 1996, 2000-2005, 2009, 2010 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: FSF 19.30. */ | |
| 24 | |
| 853 | 25 /* Authorship: |
| 26 | |
| 27 Based on code from pre-release FSF 19, c. 1991. | |
| 28 Various changes by Jamie Zawinski 1991-1994: | |
| 29 converting to ANSI C, splitting out function prototypes to a separate | |
| 30 file (later moved back for unknown reasons by Steve Baur?), debug-gcpro | |
| 31 stuff (now moribund). | |
| 32 ANSI-fication of DEFUN macros by Felix Lee, c. 1992? | |
| 33 NOT_REACHED, DOESNT_RETURN, PRINTF_ARGS by Richard Mlynarik, c. 1994. | |
| 34 Many changes over the years corresponding to Lisp_Object definition | |
| 35 changes, esp. by Richard Mlynarik (c. 1993) and Kyle Jones (c. 1998). | |
| 36 See alloc.c for more details. | |
| 37 Overhauled and reordered by Ben Wing, 1995-1996, and many things added: | |
| 38 Dynarrs, REALLOC macros, asserts, typedefs, inline header code, | |
| 39 first LIST_LOOP macros, CONCHECK_*, all error-checking code | |
| 40 (e.g. error-checking versions of XFOO macros), structure read syntax, | |
| 41 weak lists, lcrecord lists, reworking of quit handling, object hashing, | |
| 42 nested GCPRO, character objects and Ebola checking, memory usage stats, | |
| 43 others. | |
| 44 LOADHIST changes from Steve Baur, c. 1997? | |
| 45 Various macro-related changes by Martin Buchholz, 1998-1999: | |
| 46 LIST_LOOP macros greatly expanded and tortoise-hared; | |
| 47 RETURN_SANS_WARNINGS; reworked DEFUN macros; EXFUN macros (???). | |
| 1743 | 48 Various macro-related changes by Jerry James, 2003: |
| 49 MODULE_API introduced; | |
| 50 Compiler-specific definitions modernized and moved to compiler.h. | |
| 853 | 51 */ |
| 52 | |
| 440 | 53 #ifndef INCLUDED_lisp_h_ |
| 54 #define INCLUDED_lisp_h_ | |
| 428 | 55 |
| 56 /************************************************************************/ | |
| 57 /* general definitions */ | |
| 58 /************************************************************************/ | |
| 59 | |
| 2367 | 60 /* Conventions in comments: |
| 61 | |
| 62 "Mule-izing" is the process of going through a file and eliminating | |
| 63 assumptions that the internal format (Ibyte * text) is the same as the | |
| 64 external format used by library routines. Mule-ization should also | |
| 65 include replacing *ALL* raw references to `char' or `unsigned char' with | |
| 66 one of the self-documenting types created below. How exactly to do the | |
| 67 conversion, and how to write correctly Mule-ized code, is described in | |
| 68 the internals manual. Files that say "This file is Mule-ized" have | |
| 69 been reviewed at some point; that's not to say that incorrect code hasn't | |
| 70 crept in, though. | |
| 71 | |
| 72 "Unicode-splitting" is the process of fixing a file so that it will | |
| 73 handle external text in Unicode under Microsoft Windows, as appropriate. | |
| 74 ("splitting" because it needs to handle either Unicode or variable-width | |
| 75 multibyte depending on the OS -- NT or 9x). See intl-win32.c. | |
| 76 | |
| 77 #### is a way of marking problems of any sort. | |
| 78 | |
| 79 !!#### marks places that are not properly Mule-ized. | |
| 80 | |
| 81 &&#### marks places that need to be fixed in order for the "8-bit mule" | |
| 82 conversion to work correctly, i.e. in order to support multiple different | |
| 83 buffer formats under Mule, including a fixed 8-bit format. | |
| 84 | |
| 85 ^^#### marks places that need to be fixed in order to eliminate the | |
| 86 assumption that Ibyte * text is composed of 1-byte units (e.g. UTF-16 | |
| 87 is composed of 2-byte units and might be a possible format to consider | |
| 88 for Ibyte * text). | |
| 89 | |
| 90 %%#### marks places that need work for KKCC (the new garbage collector). | |
| 91 | |
| 92 */ | |
| 93 | |
| 1318 | 94 /* -------------------------- include files --------------------- */ |
| 442 | 95 |
| 428 | 96 /* We include the following generally useful header files so that you |
| 97 don't have to worry about prototypes when using the standard C | |
| 98 library functions and macros. These files shouldn't be excessively | |
| 99 large so they shouldn't cause that much of a slowdown. */ | |
| 100 | |
| 101 #include <stdlib.h> | |
| 102 #include <string.h> /* primarily for memcpy, etc. */ | |
| 103 #include <stdio.h> /* NULL, etc. */ | |
| 104 #include <ctype.h> | |
| 105 #include <stdarg.h> | |
| 106 #include <stddef.h> /* offsetof */ | |
| 107 #include <sys/types.h> | |
| 442 | 108 #include <limits.h> |
| 4932 | 109 #ifdef __cplusplus |
| 110 #include <limits> /* necessary for max()/min() under G++ 4 */ | |
| 111 #endif | |
| 112 | |
| 442 | 113 |
| 1318 | 114 /* -------------------------- error-checking ------------------------ */ |
| 853 | 115 |
| 116 /* The large categories established by configure can be subdivided into | |
| 117 smaller subcategories, for problems in specific modules. You can't | |
| 118 control this using configure, but you can manually stick in a define as | |
| 119 necessary. */ | |
| 120 | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
121 /* How these work: |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
122 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
123 The most common classes will be `text' and `type', followed by `structure'. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
124 `text' is for problems related to bad textual format. `type' is for |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
125 problems related to wrongly typed arguments, structure fields, etc. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
126 `structure' is for bad data inside of a structure. Sometimes these are |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
127 used "incorrectly", e.g. `type' is often used for structure-checking. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
128 Consider `text': |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
129 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
130 `text_checking_assert() will assert() only when ERROR_CHECK_TEXT is defined; |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
131 otherwise it's a no-op. text_checking_assert_at_line() is similar, but |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
132 allows you to override the file name and line number normally supplied in |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
133 the message. This is especially useful in inline header functions, and |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
134 so there's a special inline_text_checking_assert() for this; this works |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
135 like text_checking_assert() but supplies the file and line of the calling |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
136 function. In order for this to work, you need to declare your inline |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
137 function with INLINE_TEXT_CHECK_ARGS at the end of its argument list, |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
138 and give its function name a _1 extension or similar. Then create a |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
139 macro that calls your inline function and includes INLINE_TEXT_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
140 at the end of the parameter list. This will arrange to pass in and receive |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
141 the file and line (__FILE__, __LINE__) at place where the call occurs in |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
142 the calling function; but nothing will get passed in when ERROR_CHECK_TEXT |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
143 is not defined. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
144 */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
145 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
146 |
| 853 | 147 #ifdef ERROR_CHECK_STRUCTURES |
| 148 /* Check for problems with the catch list and specbind stack */ | |
| 149 #define ERROR_CHECK_CATCH | |
| 150 /* Check for insufficient use of call_trapping_problems(), particularly | |
| 151 due to glyph-related changes causing eval or QUIT within redisplay */ | |
| 152 #define ERROR_CHECK_TRAPPING_PROBLEMS | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
153 #endif /* ERROR_CHECK_STRUCTURES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
154 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
155 #define INLINE_ERROR_CHECK_ARGS , const char *__file__, int __line__ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
156 #define INLINE_ERROR_CHECK_CALL , __FILE__, __LINE__ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
157 #define DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
158 #define DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
159 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
160 /* For assertions in inline header functions which will report the file and |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
161 line of the calling function */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
162 #define inline_assert(assertion) assert_at_line (assertion, __file__, __line__) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
163 #define disabled_inline_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
164 disabled_assert_at_line (assertion, __file__, __line__) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
165 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
166 #ifdef ERROR_CHECK_TEXT |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
167 #define text_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
168 #define text_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
169 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
170 #define inline_text_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
171 #define INLINE_TEXT_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
172 #define INLINE_TEXT_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
173 #define text_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
174 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
175 #else /* not ERROR_CHECK_TEXT */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
176 #define text_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
177 #define text_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
178 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
179 #define inline_text_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
180 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
181 #define INLINE_TEXT_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
182 #define INLINE_TEXT_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
183 #define text_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
184 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
185 #endif /* ERROR_CHECK_TEXT */ |
| 853 | 186 |
| 1318 | 187 #ifdef ERROR_CHECK_TYPES |
| 188 #define type_checking_assert(assertion) assert (assertion) | |
| 189 #define type_checking_assert_at_line(assertion, file, line) \ | |
| 190 assert_at_line (assertion, file, line) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
191 #define inline_type_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
192 #define INLINE_TYPE_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
193 #define INLINE_TYPE_CHECK_CALL INLINE_ERROR_CHECK_CALL |
| 1318 | 194 #define type_checking_assert_with_message(assertion, msg) \ |
| 195 assert_with_message (assertion, msg) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
196 #else /* not ERROR_CHECK_TYPES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
197 #define type_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
198 #define type_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
199 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
200 #define inline_type_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
201 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
202 #define INLINE_TYPE_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
203 #define INLINE_TYPE_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
204 #define type_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
205 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
206 #endif /* ERROR_CHECK_TYPES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
207 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
208 #ifdef ERROR_CHECK_STRUCTURES |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
209 #define structure_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
210 #define structure_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
211 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
212 #define inline_structure_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
213 #define INLINE_STRUCTURE_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
214 #define INLINE_STRUCTURE_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
215 #define structure_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
216 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
217 #else /* not ERROR_CHECK_STRUCTURES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
218 #define structure_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
219 #define structure_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
220 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
221 #define inline_structure_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
222 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
223 #define INLINE_STRUCTURE_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
224 #define INLINE_STRUCTURE_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
225 #define structure_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
226 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
227 #endif /* ERROR_CHECK_STRUCTURES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
228 |
| 1318 | 229 #ifdef ERROR_CHECK_GC |
| 230 #define gc_checking_assert(assertion) assert (assertion) | |
| 231 #define gc_checking_assert_at_line(assertion, file, line) \ | |
| 232 assert_at_line (assertion, file, line) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
233 #define inline_gc_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
234 #define INLINE_GC_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
235 #define INLINE_GC_CHECK_CALL INLINE_ERROR_CHECK_CALL |
| 1318 | 236 #define gc_checking_assert_with_message(assertion, msg) \ |
| 237 assert_with_message (assertion, msg) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
238 #else /* not ERROR_CHECK_GC */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
239 #define gc_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
240 #define gc_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
241 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
242 #define inline_gc_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
243 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
244 #define INLINE_GC_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
245 #define INLINE_GC_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
246 #define gc_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
247 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
248 #endif /* ERROR_CHECK_GC */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
249 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
250 #ifdef ERROR_CHECK_DISPLAY |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
251 #define display_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
252 #define display_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
253 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
254 #define inline_display_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
255 #define INLINE_DISPLAY_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
256 #define INLINE_DISPLAY_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
257 #define display_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
258 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
259 #else /* not ERROR_CHECK_DISPLAY */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
260 #define display_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
261 #define display_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
262 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
263 #define inline_display_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
264 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
265 #define INLINE_DISPLAY_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
266 #define INLINE_DISPLAY_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
267 #define display_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
268 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
269 #endif /* ERROR_CHECK_DISPLAY */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
270 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
271 #ifdef ERROR_CHECK_GLYPHS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
272 #define glyph_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
273 #define glyph_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
274 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
275 #define inline_glyph_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
276 #define INLINE_GLYPH_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
277 #define INLINE_GLYPH_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
278 #define glyph_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
279 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
280 #else /* not ERROR_CHECK_GLYPHS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
281 #define glyph_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
282 #define glyph_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
283 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
284 #define inline_glyph_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
285 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
286 #define INLINE_GLYPH_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
287 #define INLINE_GLYPH_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
288 #define glyph_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
289 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
290 #endif /* ERROR_CHECK_GLYPHS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
291 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
292 #ifdef ERROR_CHECK_EXTENTS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
293 #define extent_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
294 #define extent_checking_assert_at_line(assertion, file, line) \ |
| 1318 | 295 assert_at_line (assertion, file, line) |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
296 #define inline_extent_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
297 #define INLINE_EXTENT_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
298 #define INLINE_EXTENT_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
299 #define extent_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
300 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
301 #else /* not ERROR_CHECK_EXTENTS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
302 #define extent_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
303 #define extent_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
304 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
305 #define inline_extent_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
306 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
307 #define INLINE_EXTENT_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
308 #define INLINE_EXTENT_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
309 #define extent_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
310 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
311 #endif /* ERROR_CHECK_EXTENTS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
312 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
313 #ifdef ERROR_CHECK_MALLOC |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
314 #define malloc_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
315 #define malloc_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
316 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
317 #define inline_malloc_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
318 #define INLINE_MALLOC_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
319 #define INLINE_MALLOC_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
320 #define malloc_checking_assert_with_message(assertion, msg) \ |
| 1318 | 321 assert_with_message (assertion, msg) |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
322 #else /* not ERROR_CHECK_MALLOC */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
323 #define malloc_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
324 #define malloc_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
325 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
326 #define inline_malloc_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
327 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
328 #define INLINE_MALLOC_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
329 #define INLINE_MALLOC_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
330 #define malloc_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
331 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
332 #endif /* ERROR_CHECK_MALLOC */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
333 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
334 #ifdef ERROR_CHECK_BYTE_CODE |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
335 #define byte_code_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
336 #define byte_code_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
337 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
338 #define inline_byte_code_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
339 #define INLINE_BYTE_CODE_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
340 #define INLINE_BYTE_CODE_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
341 #define byte_code_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
342 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
343 #else /* not ERROR_CHECK_BYTE_CODE */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
344 #define byte_code_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
345 #define byte_code_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
346 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
347 #define inline_byte_code_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
348 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
349 #define INLINE_BYTE_CODE_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
350 #define INLINE_BYTE_CODE_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
351 #define byte_code_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
352 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
353 #endif /* ERROR_CHECK_BYTE_CODE */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
354 |
| 1318 | 355 #ifdef ERROR_CHECK_TRAPPING_PROBLEMS |
| 356 #define trapping_problems_checking_assert(assertion) assert (assertion) | |
| 357 #define trapping_problems_checking_assert_at_line(assertion, file, line) \ | |
| 358 assert_at_line (assertion, file, line) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
359 #define inline_trapping_problems_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
360 #define INLINE_TRAPPING_PROBLEMS_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
361 #define INLINE_TRAPPING_PROBLEMS_CHECK_CALL INLINE_ERROR_CHECK_CALL |
| 1318 | 362 #define trapping_problems_checking_assert_with_message(assertion, msg) \ |
| 363 assert_with_message (assertion, msg) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
364 #else /* not ERROR_CHECK_TRAPPING_PROBLEMS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
365 #define trapping_problems_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
366 #define trapping_problems_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
367 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
368 #define inline_trapping_problems_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
369 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
370 #define INLINE_TRAPPING_PROBLEMS_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
371 #define INLINE_TRAPPING_PROBLEMS_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
372 #define trapping_problems_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
373 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
374 #endif /* ERROR_CHECK_TRAPPING_PROBLEMS */ |
| 1318 | 375 |
| 2367 | 376 /************************************************************************/ |
| 377 /** Definitions of basic types **/ | |
| 378 /************************************************************************/ | |
| 379 | |
| 380 /* ------------- generic 8/16/32/64/128-bit integral types ------------ */ | |
| 647 | 381 |
| 826 | 382 #if SIZEOF_SHORT == 2 |
| 383 #define INT_16_BIT short | |
| 384 #define UINT_16_BIT unsigned short | |
| 385 #elif SIZEOF_INT == 2 | |
| 386 /* Bwa ha ha. As if XEmacs could actually support such systems. */ | |
| 387 #define INT_16_BIT int | |
| 388 #define UINT_16_BIT unsigned int | |
| 389 #else | |
| 390 #error Unable to find a 16-bit integral type | |
| 391 #endif | |
| 392 | |
| 393 #if SIZEOF_INT == 4 | |
| 394 #define INT_32_BIT int | |
| 395 #define UINT_32_BIT unsigned int | |
| 396 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##U | |
| 397 #elif SIZEOF_LONG == 4 | |
| 398 /* Bwa ha ha again. */ | |
| 399 #define INT_32_BIT long | |
| 400 #define UINT_32_BIT unsigned long | |
| 401 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##UL | |
| 402 #elif SIZEOF_SHORT == 4 | |
| 403 /* And again. */ | |
| 404 #define INT_32_BIT short | |
| 405 #define UINT_32_BIT unsigned short | |
| 406 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##U | |
| 1429 | 407 #elif 1 /* Unable to find a 32-bit integral type! */ |
| 826 | 408 #error What kind of strange-ass system are you running on? |
| 409 #endif | |
| 410 | |
| 411 #if SIZEOF_LONG == 8 | |
| 412 #define INT_64_BIT long | |
| 413 #define UINT_64_BIT unsigned long | |
| 414 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##UL | |
| 415 #elif SIZEOF_LONG_LONG == 8 | |
| 416 #define INT_64_BIT long long | |
| 417 #define UINT_64_BIT unsigned long long | |
| 418 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##ULL | |
|
4682
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
419 #elif defined(WIN32_ANY) |
|
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
420 #define INT_64_BIT __int64 |
|
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
421 #define UINT_64_BIT unsigned __int64 |
|
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
422 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##UI64 |
| 826 | 423 /* No error otherwise; just leave undefined */ |
| 424 #endif | |
| 425 | |
| 426 #if SIZEOF_LONG_LONG == 16 | |
| 427 #define INT_128_BIT long long | |
| 428 #define UINT_128_BIT unsigned long long | |
| 429 #define MAKE_128_BIT_UNSIGNED_CONSTANT(num) num##ULL | |
| 430 /* No error otherwise; just leave undefined */ | |
| 431 #endif | |
| 432 | |
| 433 /* #### Fill this in for other systems */ | |
| 434 #if defined (INT_64_BIT) && !(defined (i386) || defined (__i386__)) | |
| 435 #define EFFICIENT_INT_64_BIT INT_64_BIT | |
| 436 #define EFFICIENT_UINT_64_BIT UINT_64_BIT | |
| 437 #endif | |
| 438 | |
| 439 #if defined (INT_128_BIT) | |
| 440 #define EFFICIENT_INT_128_BIT INT_128_BIT | |
| 441 #define EFFICIENT_UINT_128_BIT UINT_128_BIT | |
| 442 #endif | |
| 443 | |
| 2367 | 444 #ifdef HAVE_INTTYPES_H |
| 445 #include <inttypes.h> | |
| 446 #elif defined (HAVE_INTPTR_T_IN_SYS_TYPES_H) | |
| 447 /* included elsewhere */ | |
| 448 #elif SIZEOF_VOID_P == SIZEOF_INT | |
| 449 typedef int intptr_t; | |
| 450 typedef unsigned int uintptr_t; | |
| 451 #elif SIZEOF_VOID_P == SIZEOF_LONG | |
| 452 typedef long intptr_t; | |
| 453 typedef unsigned long uintptr_t; | |
| 454 #elif defined (SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG | |
| 455 typedef long long intptr_t; | |
| 456 typedef unsigned long long uintptr_t; | |
| 457 #else | |
| 458 /* Just pray. May break, may not. */ | |
| 459 typedef long intptr_t; | |
| 460 typedef unsigned long uintptr_t; | |
| 461 #endif | |
| 462 | |
| 3988 | 463 #if SIZEOF_VOID_P == 8 |
| 464 #define DEADBEEF_CONSTANT 0xCAFEBABEDEADBEEF | |
| 465 #elif SIZEOF_VOID_P == 4 | |
| 466 #define DEADBEEF_CONSTANT 0xDEADBEEF | |
| 467 #else | |
| 468 #error "What size are your pointers, really?" | |
| 469 #endif /* SIZEOF_VOID_P == 8 */ | |
| 470 | |
| 2367 | 471 /* ---------------------- definition of EMACS_INT --------------------- */ |
| 472 | |
| 473 /* EMACS_INT is the underlying integral type into which a Lisp_Object must fit. | |
| 474 In particular, it must be large enough to contain a pointer. | |
| 475 config.h can override this, e.g. to use `long long' for bigger lisp ints. | |
| 476 | |
| 477 #### In point of fact, it would NOT be a good idea for config.h to mess | |
| 478 with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT | |
| 479 is the size of a pointer. */ | |
| 480 | |
| 481 #ifndef SIZEOF_EMACS_INT | |
| 482 # define SIZEOF_EMACS_INT SIZEOF_VOID_P | |
| 483 #endif | |
| 484 | |
| 485 #ifndef EMACS_INT | |
| 486 # if SIZEOF_EMACS_INT == SIZEOF_LONG | |
| 487 # define EMACS_INT long | |
| 488 # elif SIZEOF_EMACS_INT == SIZEOF_INT | |
| 489 # define EMACS_INT int | |
| 490 # elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG | |
| 491 # define EMACS_INT long long | |
| 492 # else | |
| 493 # error Unable to determine suitable type for EMACS_INT | |
| 494 # endif | |
| 495 #endif | |
| 496 | |
| 497 #ifndef EMACS_UINT | |
| 498 # define EMACS_UINT unsigned EMACS_INT | |
| 499 #endif | |
| 500 | |
| 501 #define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR) | |
| 502 | |
| 503 /* -------------------------- basic byte typedefs --------------------- */ | |
| 504 | |
| 505 /* The definitions we put here and in the next section use typedefs to | |
| 506 attribute specific meaning to types that by themselves are pretty | |
| 507 general. | |
| 508 | |
| 509 REMEMBER! These typedefs are purely for documentation purposes; from | |
| 647 | 510 the C code's perspective, they are exactly equivalent to `char *', |
| 511 `unsigned char *', etc., so you can freely use them with library | |
| 2367 | 512 functions declared as such. |
| 513 | |
| 514 (See also "Byte/Character Types" in text.c) | |
| 515 | |
| 516 The basic semantics for `char': | |
| 517 | |
| 518 a) [Ibyte] pointer to internally-formatted text | |
| 519 b) [Extbyte] pointer to text in some external format, which can be | |
| 520 defined as all formats other than the internal one | |
| 521 c) [Ascbyte] pure ASCII text | |
| 522 d) [Binbyte] binary data that is not meant to be interpreted as text | |
| 523 e) [Rawbyte] general data in memory, where we don't care about whether | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
524 it's text or binary; often used when computing memory- |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
525 based/byte-based offsets of pointers |
| 2367 | 526 f) [Boolbyte] a zero or a one |
| 527 g) [Bitbyte] a byte used for bit fields | |
| 528 h) [Chbyte] null-semantics `char *'; used when casting an argument to | |
| 529 an external API where the the other types may not be | |
| 530 appropriate | |
| 531 | |
| 532 | |
| 533 Prefixing codes: | |
| 534 | |
| 535 C = plain char, when the base type is unsigned | |
| 536 U = unsigned | |
| 537 S = signed | |
| 538 | |
| 539 Ideally, XEmacs code should NEVER directly use `char' or any type | |
| 540 derived from it. This is for Mule-cleanliness. If you find yourself | |
| 541 wanting or needing to use `char' and one of the above six semantics does | |
| 542 not apply, add a new type of semantics; don't use `char' directly. | |
| 543 | |
| 544 See text.c under "Byte Types", and following sections. | |
| 545 */ | |
| 647 | 546 |
| 547 /* The data representing the text in a buffer is logically a set | |
| 867 | 548 of Ibytes, declared as follows. */ |
| 549 | |
| 550 typedef unsigned char Ibyte; | |
| 647 | 551 |
| 552 /* The following should be used when you are working with internal data | |
| 553 but for whatever reason need to have it declared a "char *". Examples | |
| 554 are function arguments whose values are most commonly literal strings, | |
| 555 or where you have to apply a stdlib string function to internal data. | |
| 556 | |
| 2367 | 557 In general, you should avoid this where possible and use Ascbyte if the |
| 558 text is just ASCII (e.g. string literals) or otherwise Ibyte, for | |
| 559 consistency. For example, the new Mule workspace contains Ibyte | |
| 560 versions of the stdlib string functions. */ | |
| 867 | 561 |
| 562 typedef char CIbyte; | |
| 647 | 563 |
| 564 /* The data representing a string in "external" format (binary or any | |
| 565 external encoding) is logically a set of Extbytes, declared as | |
| 566 follows. Extbyte is guaranteed to be just a char, so for example | |
| 567 strlen (Extbyte *) is OK. Extbyte is only a documentation device | |
| 568 for referring to external text. */ | |
| 569 | |
| 570 typedef char Extbyte; | |
| 771 | 571 typedef unsigned char UExtbyte; |
| 647 | 572 |
| 2367 | 573 #define EXTTEXT_ZTERM_SIZE (sizeof (Extbyte)) |
| 647 | 574 |
| 575 /* A byte in a string in entirely US-ASCII format: (Nothing outside | |
| 576 the range 00 - 7F) */ | |
| 577 | |
| 2367 | 578 typedef char Ascbyte; |
| 579 typedef unsigned char UAscbyte; | |
| 580 | |
| 581 /* A generic memory pointer, no text or binary semantics assumed. | |
| 582 In general, there should be no manipulation of the memory pointed to | |
| 583 by these pointers other than just copying it around. */ | |
| 584 | |
| 585 typedef unsigned char Rawbyte; | |
| 586 typedef char CRawbyte; | |
| 587 | |
| 588 /* A byte in a string in binary (not meant as text) format: */ | |
| 589 | |
| 590 typedef unsigned char Binbyte; | |
| 591 typedef char CBinbyte; | |
| 592 typedef signed char SBinbyte; | |
| 593 | |
| 594 /* A byte used to represent a boolean value: 0 or 1. | |
| 595 Normally use plain Boolint, and only use Boolbyte to save space. */ | |
| 596 | |
| 597 typedef char Boolbyte; | |
| 598 | |
| 599 /* A byte composed of bitfields. Hardly ever used. */ | |
| 600 | |
| 601 typedef unsigned char Bitbyte; | |
| 602 | |
| 603 /* A no-semantics `char'. Used (pretty-much) ONLY for casting arguments to | |
| 604 functions accepting a `char *', `unsigned char *', etc. where the other | |
| 605 types don't exactly apply and what you are logically concerned with is | |
| 606 the type of the function's argument and not its semantics. | |
| 607 | |
| 608 DO NOT DO NOT DO NOT DO NOT use this as a sloppy replacement for one of | |
| 609 the other types. If you're not using this as part of casting an | |
| 610 argument to a function call, and you're not Ben Wing, you're using it | |
| 611 wrong. Go find another one of the types. */ | |
| 612 | |
| 613 typedef char Chbyte; | |
| 614 typedef unsigned char UChbyte; | |
| 615 typedef signed char SChbyte; | |
| 616 | |
| 617 /* ------------------------ other text-related typedefs ------------------- */ | |
| 647 | 618 |
| 826 | 619 /* To the user, a buffer is made up of characters. In the non-Mule world, |
| 867 | 620 characters and Ibytes are equivalent, restricted to the range 0 - 255. |
| 3498 | 621 In the Mule world, many more characters are possible (21 bits worth, |
| 867 | 622 more or less), and a character requires (typically) 1 to 4 Ibytes for |
| 826 | 623 its representation in a buffer or string. Note that the representation |
| 624 of a character by itself, in a variable, is very different from its | |
| 625 representation in a string of text (in a buffer or Lisp string). | |
| 626 | |
| 627 Under Mule, text can be represented in more than one way. The "default" | |
| 628 format is variable-width (1 to 4 bytes) and compatible with ASCII -- | |
| 629 ASCII chars are stored in one byte, as themselves, and all other chars | |
| 630 use only high bytes. The default format is currently the only format | |
| 631 used for text stored anywhere but in a buffer. In a buffer, other | |
| 632 formats -- fixed-width formats (1, 2, or 4 bytes) -- are possible, for | |
| 633 speed. | |
| 634 | |
| 635 See text.c/text.h for a detailed discussion of all of this. */ | |
| 636 | |
| 637 /* A character, as represented on its own. */ | |
| 647 | 638 |
| 867 | 639 typedef int Ichar; |
| 647 | 640 |
| 826 | 641 /* The "raw value" of a character as stored in the buffer. In the default |
| 642 format, this is just the same as the character. In fixed-width formats, | |
| 643 this is the actual value in the buffer, which will be limited to the | |
| 644 range as established by the format. This is used when searching for a | |
| 645 character in a buffer -- it's faster to convert the character to the raw | |
| 646 value and look for that, than repeatedly convert each raw value in the | |
| 647 buffer into a character. */ | |
| 648 | |
| 867 | 649 typedef int Raw_Ichar; |
| 826 | 650 |
| 2367 | 651 /* Internal text as a series of textual units (8-bit bytes in the old |
| 652 "Mule" encoding -- still the standard internal encoding -- and in UTF-8, | |
| 653 but 16-bit bytes in UTF-16 and 32-bit bytes in UTF-32). See text.c. */ | |
| 654 | |
| 655 #ifdef UTF16_IBYTE_FORMAT | |
| 656 #define NON_ASCII_INTERNAL_FORMAT | |
| 657 typedef unsigned short Itext; | |
| 658 #else | |
| 659 typedef Ibyte Itext; | |
| 660 #endif | |
| 661 typedef EMACS_INT Textcount; | |
| 662 | |
| 663 #define ITEXT_SIZE (sizeof (Itext)) | |
| 664 /* Use this to emphasize that we are adding space for the zero-terminator */ | |
| 665 #define ITEXT_ZTERM_SIZE ITEXT_SIZE | |
| 666 | |
| 667 /* Wexttext is wchar_t on WIN32_NATIVE (and perhaps other systems that | |
| 668 support wchar_t's in library functions), and Extbyte otherwise. This is | |
| 669 used whenever we have to do any sort of manipulation of | |
| 670 externally-encoded strings -- generally a very bad idea, and unsafe, but | |
| 671 in some cases we have no choice (especially at startup, and esp. prior | |
| 672 to pdump, where we haven't loaded the Unicode tables necessary for | |
| 673 conversion under Windows). On platforms where the external encoding may | |
| 674 be Unicode (i.e. Windows), we always do our manipulations in Unicode, | |
| 675 converting to and from multibyte if necessary -- otherwise we'd have to | |
| 676 conditionalize on Unicode vs. multibyte all over the place, which is | |
| 677 just a nightmare. */ | |
| 678 #ifdef WIN32_NATIVE | |
| 679 #define WEXTTEXT_IS_WIDE | |
| 680 typedef wchar_t Wexttext; | |
| 681 #else | |
| 682 typedef Extbyte Wexttext; | |
| 683 #endif | |
| 826 | 684 |
| 685 #if !defined (__cplusplus) || !defined (CPLUSPLUS_INTEGRAL_CLASSES_NOT_YET) | |
| 686 | |
| 687 /* Counts of bytes or chars */ | |
| 688 | |
| 689 typedef EMACS_INT Bytecount; | |
| 690 typedef EMACS_INT Charcount; | |
| 691 | |
| 647 | 692 /* Different ways of referring to a position in a buffer. We use |
| 693 the typedefs in preference to 'EMACS_INT' to make it clearer what | |
| 826 | 694 sort of position is being used. See text.c for a description |
| 695 of the different positions. | |
| 696 | |
| 697 Note that buffer positions are 1-based, and there's a gap in the middle | |
| 698 of a buffer; that's why we have separate typedefs. For Lisp strings and | |
| 699 other strings of text, we just use Bytecount and Charcount. */ | |
| 800 | 700 |
| 665 | 701 typedef EMACS_INT Charbpos; |
| 702 typedef EMACS_INT Bytebpos; | |
| 703 typedef EMACS_INT Membpos; | |
| 647 | 704 |
| 826 | 705 /* Different ways of referring to a position that can be either in a buffer |
| 706 or string; used when passing around an object that can be either a | |
| 707 buffer or string, and an associated position. Conceptually, they | |
| 708 resolve as follows: | |
| 709 | |
| 710 Typedef Buffer String | |
| 711 ------------------------------------------------------ | |
| 712 Charxpos Charbpos Charcount | |
| 713 Bytexpos Bytebpos Bytecount | |
| 714 Memxpos Membpos Bytecount | |
| 715 | |
| 716 */ | |
| 717 | |
| 814 | 718 typedef EMACS_INT Charxpos; |
| 719 typedef EMACS_INT Bytexpos; | |
| 720 typedef EMACS_INT Memxpos; | |
| 721 | |
| 722 #else /* __cplusplus */ | |
| 723 | |
| 724 /* Implement strong type-checking of the above integral types by declaring | |
| 725 them to be classes and using operator overloading. Unfortunately this | |
| 726 is a huge pain in the ass because C++ doesn't strongly distinguish | |
| 727 "bool" and "size_t" from int. The problem is especially bad with "bool" | |
| 2956 | 728 -- if you want to be able to say `if (len--)' where len is e.g. a |
| 814 | 729 Bytecount, you need to declare a conversion operator to bool(); and |
| 730 since bool is just an alias for int, you suddenly get tons and tons of | |
| 731 ambiguities, which need to be resolved by lots of laborious declarations | |
| 732 for every single possible type combination. Hence the multitude of | |
| 733 declarations in DECLARE_INTCLASS_ARITH_COMPARE(). The bool/int | |
| 734 equivalence also means that we have to forcibly block the combinations | |
| 735 we don't want by creating overloaded versions of them and declaring them | |
| 736 private. */ | |
| 737 | |
| 738 class Bytecount; | |
| 739 class Bytebpos; | |
| 740 class Bytexpos; | |
| 741 class Charcount; | |
| 742 class Charbpos; | |
| 743 class Charxpos; | |
| 744 class Membpos; | |
| 745 class Memxpos; | |
| 746 | |
| 747 /* Declare the arithmetic and comparison operations for an integral class, | |
| 748 i.e. one of the above classes. If this is a "position" class, where the | |
| 749 difference between two positions is a different class (a "count" class), | |
| 750 then use POSCL for the position class and COUNTCL for the count class. | |
| 751 If this is a simple class, where all operations yield the same class, | |
| 752 substitute the same class for POSCL and COUNTCL. */ | |
| 753 | |
| 754 #define DECLARE_INTCLASS_ARITH_COMPARE(poscl, countcl) \ | |
| 755 poscl operator += (const countcl& l) { data += l.data; return *this; } \ | |
| 756 poscl operator -= (const countcl& l) { data -= l.data; return *this; } \ | |
| 757 poscl operator + (const countcl& l) const { return poscl (data + l.data); } \ | |
| 758 poscl operator - (const countcl& l) const { return poscl (data - l.data); } \ | |
| 759 poscl operator += (const int& l) { data += l; return *this; } \ | |
| 760 poscl operator -= (const int& l) { data -= l; return *this; } \ | |
| 761 poscl operator + (const int& l) const { return poscl (data + l); } \ | |
| 762 poscl operator - (const int& l) const { return poscl (data - l); } \ | |
| 763 poscl operator += (const unsigned int& l) { data += l; return *this; } \ | |
| 764 poscl operator -= (const unsigned int& l) { data -= l; return *this; } \ | |
| 765 poscl operator + (const unsigned int& l) const \ | |
| 766 { return poscl (data + l); } \ | |
| 767 poscl operator - (const unsigned int& l) const \ | |
| 768 { return poscl (data - l); } \ | |
| 769 poscl operator += (const long& l) { data += l; return *this; } \ | |
| 770 poscl operator -= (const long& l) { data -= l; return *this; } \ | |
| 771 poscl operator + (const long& l) const { return poscl (data + l); } \ | |
| 772 poscl operator - (const long& l) const { return poscl (data - l); } \ | |
| 773 poscl operator += (const unsigned long& l) { data += l; return *this; } \ | |
| 774 poscl operator -= (const unsigned long& l) { data -= l; return *this; } \ | |
| 775 poscl operator + (const unsigned long& l) const \ | |
| 776 { return poscl (data + l); } \ | |
| 777 poscl operator - (const unsigned long& l) const \ | |
| 778 { return poscl (data - l); } \ | |
| 779 poscl operator += (const short& l) { data += l; return *this; } \ | |
| 780 poscl operator -= (const short& l) { data -= l; return *this; } \ | |
| 781 poscl operator + (const short& l) const { return poscl (data + l); } \ | |
| 782 poscl operator - (const short& l) const { return poscl (data - l); } \ | |
| 783 poscl operator += (const unsigned short& l) { data += l; return *this; } \ | |
| 784 poscl operator -= (const unsigned short& l) { data -= l; return *this; } \ | |
| 785 poscl operator + (const unsigned short& l) const \ | |
| 786 { return poscl (data + l); } \ | |
| 787 poscl operator - (const unsigned short& l) const \ | |
| 788 { return poscl (data - l); } \ | |
| 789 \ | |
| 790 poscl operator *= (const countcl& l) { data *= l.data; return *this; } \ | |
| 791 poscl operator /= (const countcl& l) { data /= l.data; return *this; } \ | |
| 792 poscl operator * (const countcl& l) const { return poscl (data * l.data); } \ | |
| 793 poscl operator / (const countcl& l) const { return poscl (data / l.data); } \ | |
| 794 poscl operator *= (const int& l) { data *= l; return *this; } \ | |
| 795 poscl operator /= (const int& l) { data /= l; return *this; } \ | |
| 796 poscl operator * (const int& l) const { return poscl (data * l); } \ | |
| 797 poscl operator / (const int& l) const { return poscl (data / l); } \ | |
| 798 poscl operator *= (const unsigned int& l) { data *= l; return *this; } \ | |
| 799 poscl operator /= (const unsigned int& l) { data /= l; return *this; } \ | |
| 800 poscl operator * (const unsigned int& l) const { return poscl (data * l); } \ | |
| 801 poscl operator / (const unsigned int& l) const { return poscl (data / l); } \ | |
| 802 poscl operator *= (const long& l) { data *= l; return *this; } \ | |
| 803 poscl operator /= (const long& l) { data /= l; return *this; } \ | |
| 804 poscl operator * (const long& l) const { return poscl (data * l); } \ | |
| 805 poscl operator / (const long& l) const { return poscl (data / l); } \ | |
| 806 poscl operator *= (const unsigned long& l) { data *= l; return *this; } \ | |
| 807 poscl operator /= (const unsigned long& l) { data /= l; return *this; } \ | |
| 808 poscl operator * (const unsigned long& l) const \ | |
| 809 { return poscl (data * l); } \ | |
| 810 poscl operator / (const unsigned long& l) const \ | |
| 811 { return poscl (data / l); } \ | |
| 812 poscl operator *= (const short& l) { data *= l; return *this; } \ | |
| 813 poscl operator /= (const short& l) { data /= l; return *this; } \ | |
| 814 poscl operator * (const short& l) const { return poscl (data * l); } \ | |
| 815 poscl operator / (const short& l) const { return poscl (data / l); } \ | |
| 816 poscl operator *= (const unsigned short& l) { data *= l; return *this; } \ | |
| 817 poscl operator /= (const unsigned short& l) { data /= l; return *this; } \ | |
| 818 poscl operator * (const unsigned short& l) const \ | |
| 819 { return poscl (data * l); } \ | |
| 820 poscl operator / (const unsigned short& l) const \ | |
| 821 { return poscl (data / l); } \ | |
| 822 \ | |
| 823 poscl operator &= (const countcl& l) { data &= l.data; return *this; } \ | |
| 824 poscl operator |= (const countcl& l) { data |= l.data; return *this; } \ | |
| 825 poscl operator & (const countcl& l) const { return poscl (data & l.data); } \ | |
| 826 poscl operator | (const countcl& l) const { return poscl (data | l.data); } \ | |
| 827 poscl operator &= (const int& l) { data &= l; return *this; } \ | |
| 828 poscl operator |= (const int& l) { data |= l; return *this; } \ | |
| 829 poscl operator & (const int& l) const { return poscl (data & l); } \ | |
| 830 poscl operator | (const int& l) const { return poscl (data | l); } \ | |
| 831 poscl operator &= (const unsigned int& l) { data &= l; return *this; } \ | |
| 832 poscl operator |= (const unsigned int& l) { data |= l; return *this; } \ | |
| 833 poscl operator & (const unsigned int& l) const { return poscl (data & l); } \ | |
| 834 poscl operator | (const unsigned int& l) const { return poscl (data | l); } \ | |
| 835 poscl operator &= (const long& l) { data &= l; return *this; } \ | |
| 836 poscl operator |= (const long& l) { data |= l; return *this; } \ | |
| 837 poscl operator & (const long& l) const { return poscl (data & l); } \ | |
| 838 poscl operator | (const long& l) const { return poscl (data | l); } \ | |
| 839 poscl operator &= (const unsigned long& l) { data &= l; return *this; } \ | |
| 840 poscl operator |= (const unsigned long& l) { data |= l; return *this; } \ | |
| 841 poscl operator & (const unsigned long& l) const \ | |
| 842 { return poscl (data & l); } \ | |
| 843 poscl operator | (const unsigned long& l) const \ | |
| 844 { return poscl (data | l); } \ | |
| 845 poscl operator &= (const short& l) { data &= l; return *this; } \ | |
| 846 poscl operator |= (const short& l) { data |= l; return *this; } \ | |
| 847 poscl operator & (const short& l) const { return poscl (data & l); } \ | |
| 848 poscl operator | (const short& l) const { return poscl (data | l); } \ | |
| 849 poscl operator &= (const unsigned short& l) { data &= l; return *this; } \ | |
| 850 poscl operator |= (const unsigned short& l) { data |= l; return *this; } \ | |
| 851 poscl operator & (const unsigned short& l) const \ | |
| 852 { return poscl (data & l); } \ | |
| 853 poscl operator | (const unsigned short& l) const \ | |
| 854 { return poscl (data | l); } \ | |
| 855 \ | |
| 856 poscl operator - () { return poscl (-data); } \ | |
| 857 poscl operator-- () { data--; return *this; } \ | |
| 858 poscl operator-- (int) { data--; return poscl (data + 1); } \ | |
| 859 poscl operator++ () { data++; return *this; } \ | |
| 860 poscl operator++ (int) { data++; return poscl (data - 1); } \ | |
| 861 \ | |
| 862 bool operator < (const poscl& l) const { return data < l.data; } \ | |
| 863 bool operator <= (const poscl& l) const { return data <= l.data; } \ | |
| 864 bool operator > (const poscl& l) const { return data > l.data; } \ | |
| 865 bool operator >= (const poscl& l) const { return data >= l.data; } \ | |
| 866 bool operator == (const poscl& l) const { return data == l.data; } \ | |
| 867 bool operator != (const poscl& l) const { return data != l.data; } \ | |
| 868 bool operator < (const int& l) const { return data < (EMACS_INT) l; } \ | |
| 869 bool operator <= (const int& l) const { return data <= (EMACS_INT) l; } \ | |
| 870 bool operator > (const int& l) const { return data > (EMACS_INT) l; } \ | |
| 871 bool operator >= (const int& l) const { return data >= (EMACS_INT) l; } \ | |
| 872 bool operator == (const int& l) const { return data == (EMACS_INT) l; } \ | |
| 873 bool operator != (const int& l) const { return data != (EMACS_INT) l; } \ | |
| 874 bool operator < (const unsigned int& l) const \ | |
| 875 { return data < (EMACS_INT) l; } \ | |
| 876 bool operator <= (const unsigned int& l) const \ | |
| 877 { return data <= (EMACS_INT) l; } \ | |
| 878 bool operator > (const unsigned int& l) const \ | |
| 879 { return data > (EMACS_INT) l; } \ | |
| 880 bool operator >= (const unsigned int& l) const \ | |
| 881 { return data >= (EMACS_INT) l; } \ | |
| 882 bool operator == (const unsigned int& l) const \ | |
| 883 { return data == (EMACS_INT) l; } \ | |
| 884 bool operator != (const unsigned int& l) const \ | |
| 885 { return data != (EMACS_INT) l; } \ | |
| 886 bool operator < (const long& l) const { return data < (EMACS_INT) l; } \ | |
| 887 bool operator <= (const long& l) const { return data <= (EMACS_INT) l; } \ | |
| 888 bool operator > (const long& l) const { return data > (EMACS_INT) l; } \ | |
| 889 bool operator >= (const long& l) const { return data >= (EMACS_INT) l; } \ | |
| 890 bool operator == (const long& l) const { return data == (EMACS_INT) l; } \ | |
| 891 bool operator != (const long& l) const { return data != (EMACS_INT) l; } \ | |
| 892 bool operator < (const unsigned long& l) const \ | |
| 893 { return data < (EMACS_INT) l; } \ | |
| 894 bool operator <= (const unsigned long& l) const \ | |
| 895 { return data <= (EMACS_INT) l; } \ | |
| 896 bool operator > (const unsigned long& l) const \ | |
| 897 { return data > (EMACS_INT) l; } \ | |
| 898 bool operator >= (const unsigned long& l) const \ | |
| 899 { return data >= (EMACS_INT) l; } \ | |
| 900 bool operator == (const unsigned long& l) const \ | |
| 901 { return data == (EMACS_INT) l; } \ | |
| 902 bool operator != (const unsigned long& l) const \ | |
| 903 { return data != (EMACS_INT) l; } \ | |
| 904 bool operator < (const short& l) const { return data < (EMACS_INT) l; } \ | |
| 905 bool operator <= (const short& l) const { return data <= (EMACS_INT) l; } \ | |
| 906 bool operator > (const short& l) const { return data > (EMACS_INT) l; } \ | |
| 907 bool operator >= (const short& l) const { return data >= (EMACS_INT) l; } \ | |
| 908 bool operator == (const short& l) const { return data == (EMACS_INT) l; } \ | |
| 909 bool operator != (const short& l) const { return data != (EMACS_INT) l; } \ | |
| 910 bool operator < (const unsigned short& l) const \ | |
| 911 { return data < (EMACS_INT) l; } \ | |
| 912 bool operator <= (const unsigned short& l) const \ | |
| 913 { return data <= (EMACS_INT) l; } \ | |
| 914 bool operator > (const unsigned short& l) const \ | |
| 915 { return data > (EMACS_INT) l; } \ | |
| 916 bool operator >= (const unsigned short& l) const \ | |
| 917 { return data >= (EMACS_INT) l; } \ | |
| 918 bool operator == (const unsigned short& l) const \ | |
| 919 { return data == (EMACS_INT) l; } \ | |
| 920 bool operator != (const unsigned short& l) const \ | |
| 921 { return data != (EMACS_INT) l; } \ | |
| 922 bool operator ! () const { return !data; } | |
| 923 | |
| 924 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 925 between class GOOD and class BAD. Meant to go inside the private | |
| 926 section of class GOOD. */ | |
| 927 | |
| 928 #define DECLARE_BAD_INTCLASS_ARITH_COMPARE(good, bad) \ | |
| 929 good operator += (const bad& l) { return badret; } \ | |
| 930 good operator -= (const bad& l) { return badret; } \ | |
| 931 good operator *= (const bad& l) { return badret; } \ | |
| 932 good operator /= (const bad& l) { return badret; } \ | |
| 933 good operator + (const bad& l) { return badret; } \ | |
| 934 good operator - (const bad& l) { return badret; } \ | |
| 935 good operator * (const bad& l) { return badret; } \ | |
| 936 good operator / (const bad& l) { return badret; } \ | |
| 937 \ | |
| 938 bool operator < (const bad& l) { return 0; } \ | |
| 939 bool operator <= (const bad& l) { return 0; } \ | |
| 940 bool operator > (const bad& l) { return 0; } \ | |
| 941 bool operator >= (const bad& l) { return 0; } \ | |
| 942 bool operator == (const bad& l) { return 0; } \ | |
| 943 bool operator != (const bad& l) { return 0; } | |
| 944 | |
| 945 /* Declare the "bad" or disallowed arithmetic operations between class GOOD | |
| 946 and another of the same class, for a position class. Meant to go inside | |
| 947 the private section of class GOOD. */ | |
| 948 | |
| 949 #define DECLARE_BAD_POS_CLASS_ARITH(good) \ | |
| 950 good operator += (const good& l) { return badret; } \ | |
| 951 good operator -= (const good& l) { return badret; } \ | |
| 952 good operator *= (const good& l) { return badret; } \ | |
| 953 good operator /= (const good& l) { return badret; } \ | |
| 954 good operator + (const good& l) { return badret; } \ | |
| 955 good operator * (const good& l) { return badret; } \ | |
| 956 good operator / (const good& l) { return badret; } | |
| 957 | |
| 958 /* Basic declaration at the top of all integral classes. Don't call | |
| 959 directly, use one of the more specific versions below. */ | |
| 960 | |
| 961 #define DECLARE_INTCLASS(cl) \ | |
| 962 public: \ | |
| 963 EMACS_INT data; \ | |
| 964 cl () { data = 0xCDCDCDCD; } \ | |
| 965 cl (int i) { data = i; } \ | |
| 966 cl (unsigned int i) { data = i; } \ | |
| 967 cl (long i) { data = i; } \ | |
| 968 cl (unsigned long i) { data = i; } \ | |
| 969 cl (short i) { data = i; } \ | |
| 970 cl (unsigned short i) { data = i; } \ | |
| 971 operator EMACS_INT () const { return data; } | |
| 972 | |
| 973 /* Basic declaration at the top of all count classes. */ | |
| 974 | |
| 975 #define DECLARE_COUNT_CLASS(cl) \ | |
| 976 DECLARE_INTCLASS (cl) \ | |
| 977 DECLARE_INTCLASS_ARITH_COMPARE (cl, cl) \ | |
| 978 private: \ | |
| 979 static cl badret; | |
| 980 | |
| 981 /* Basic declaration at the bottom of the prelude of all position classes. | |
| 982 Don't call directly. */ | |
| 983 | |
| 984 #define DECLARE_POS_CLASS_SECOND_HALF(cl, countcl) \ | |
| 985 DECLARE_INTCLASS_ARITH_COMPARE (cl, countcl) \ | |
| 986 countcl operator - (const cl& l) const { return countcl (data - l.data); } \ | |
| 987 private: \ | |
| 988 static cl badret; \ | |
| 989 DECLARE_BAD_POS_INTCLASS_ARITH (cl) | |
| 990 | |
| 991 /* Basic declaration at the top of all buffer position classes. */ | |
| 992 | |
| 993 #define DECLARE_BPOS_CLASS(cl, countcl) \ | |
| 994 DECLARE_INTCLASS (cl) \ | |
| 995 DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) | |
| 996 | |
| 997 /* Basic declaration at the top of all X-position classes (that can refer | |
| 998 to buffers or strings). CL1 and CL2 are the equivalent more specific | |
| 1318 | 999 classes referring only to buffers or strings, respectively. */ |
| 814 | 1000 |
| 1001 #define DECLARE_XPOS_CLASS(cl, countcl, cl1, cl2) \ | |
| 1002 DECLARE_INTCLASS (cl) \ | |
| 1003 cl (const cl1& x) { data = x.data; } \ | |
| 1004 cl (const cl2& x) { data = x.data; } \ | |
| 1005 operator cl1 () const { return cl1 (data); } \ | |
| 1006 operator cl2 () const { return cl2 (data); } \ | |
| 1007 DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) | |
| 1008 | |
| 1009 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1010 between class CHARCL (a character class) and various non-character | |
| 1011 classes. Meant to go inside the private section of class GOOD. */ | |
| 1012 | |
| 1013 #define DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE(charcl) \ | |
| 1014 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytecount) \ | |
| 1015 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytebpos) \ | |
| 1016 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytexpos) \ | |
| 1017 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Membpos) \ | |
| 1018 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Memxpos) | |
| 1019 | |
| 1020 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1021 between class BYTECL (a byte class) and various non-byte classes. | |
| 1022 Meant to go inside the private section of class GOOD. */ | |
| 1023 | |
| 1024 #define DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE(bytecl) \ | |
| 1025 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ | |
| 1026 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ | |
| 1027 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ | |
| 1028 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Membpos) \ | |
| 1029 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Memxpos) | |
| 1030 | |
| 1031 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1032 between class BYTECL (a mem class) and various non-mem classes. | |
| 1033 Meant to go inside the private section of class GOOD. */ | |
| 1034 | |
| 1035 #define DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE(bytecl) \ | |
| 1036 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ | |
| 1037 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ | |
| 1038 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ | |
| 1039 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytebpos) \ | |
| 1040 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytexpos) | |
| 1041 | |
| 1042 class Charcount | |
| 1043 { | |
| 1044 DECLARE_COUNT_CLASS (Charcount) | |
| 1045 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charcount) | |
| 1046 }; | |
| 1047 | |
| 1048 class Charbpos | |
| 1049 { | |
| 1050 DECLARE_BPOS_CLASS (Charbpos, Charcount) | |
| 1051 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charbpos) | |
| 1052 }; | |
| 1053 | |
| 1054 class Charxpos | |
| 1055 { | |
| 1056 DECLARE_XPOS_CLASS (Charxpos, Charcount, Charbpos, Charcount) | |
| 1057 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charxpos) | |
| 1058 }; | |
| 1059 | |
| 1060 class Bytecount | |
| 1061 { | |
| 1062 DECLARE_COUNT_CLASS (Bytecount) | |
| 1063 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytecount) | |
| 1064 }; | |
| 1065 | |
| 1066 class Bytebpos | |
| 1067 { | |
| 1068 DECLARE_BPOS_CLASS (Bytebpos, Bytecount) | |
| 1069 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytebpos) | |
| 1070 }; | |
| 1071 | |
| 1072 class Bytexpos | |
| 1073 { | |
| 1074 DECLARE_XPOS_CLASS (Bytexpos, Bytecount, Bytebpos, Bytecount) | |
| 1075 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytexpos) | |
| 1076 }; | |
| 1077 | |
| 1078 class Membpos | |
| 1079 { | |
| 1080 DECLARE_BPOS_CLASS (Membpos, Bytecount) | |
| 1081 DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Membpos) | |
| 1082 }; | |
| 1083 | |
| 1084 class Memxpos | |
| 1085 { | |
| 1086 DECLARE_XPOS_CLASS (Memxpos, Bytecount, Membpos, Bytecount) | |
| 1087 DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Memxpos) | |
| 1088 }; | |
| 1089 | |
| 826 | 1090 #define DECLARE_POINTER_TYPE_ARITH_COUNT(pointer, countcl) \ |
| 1091 inline pointer operator += (const pointer & x, const countcl& y) \ | |
| 1092 { x += y.data; return x; } \ | |
| 1093 inline pointer operator -= (const pointer & x, const countcl& y) \ | |
| 1094 { x -= y.data; return x; } \ | |
| 1095 inline pointer operator + (const pointer x, const countcl& y) \ | |
| 1096 { return x + y.data; } \ | |
| 1097 inline pointer operator - (const pointer x, const countcl& y) \ | |
| 814 | 1098 { return x - y.data; } |
| 1099 | |
| 1100 #define DECLARE_INTEGRAL_TYPE_ARITH_COUNT(integral, countcl) \ | |
| 1101 inline integral operator += (integral & x, const countcl& y) \ | |
| 1102 { x += y.data; return x; } \ | |
| 1103 inline integral operator -= (integral & x, const countcl& y) \ | |
| 1104 { x -= y.data; return x; } \ | |
| 1105 inline countcl operator + (integral x, const countcl& y) \ | |
| 1106 { return countcl (x + y.data); } \ | |
| 1107 inline countcl operator - (integral x, const countcl& y) \ | |
| 1108 { return countcl (x - y.data); } | |
| 1109 | |
| 1110 #define DECLARE_INTEGRAL_TYPE_COMPARE(integral, cl) \ | |
| 1111 inline bool operator < (integral x, const cl& y) \ | |
| 1112 { return (EMACS_INT) x < y.data; } \ | |
| 1113 inline bool operator <= (integral x, const cl& y) \ | |
| 1114 { return (EMACS_INT) x <= y.data; } \ | |
| 1115 inline bool operator > (integral x, const cl& y) \ | |
| 1116 { return (EMACS_INT) x > y.data; } \ | |
| 1117 inline bool operator >= (integral x, const cl& y) \ | |
| 1118 { return (EMACS_INT) x >= y.data; } \ | |
| 1119 inline bool operator == (integral x, const cl& y) \ | |
| 1120 { return (EMACS_INT) x == y.data; } \ | |
| 1121 inline bool operator != (integral x, const cl& y) \ | |
| 1122 { return (EMACS_INT) x != y.data; } | |
| 1123 | |
| 1124 #if 0 | |
| 1125 /* Unfortunately C++ doesn't let you overload the ?: operator, so we have | |
| 1126 to manually deal with ambiguities using casting */ | |
| 1127 #define DECLARE_INTEGRAL_TYPE_TRISTATE(integral, cl) \ | |
| 1128 inline cl operator ?: (bool b, integral x, const cl& y) \ | |
| 1129 { return b ? cl (x) : y; } \ | |
| 1130 inline cl operator ?: (bool b, const cl& x, integral y) \ | |
| 1131 { return b ? x : cl (y); } | |
| 1132 #endif /* 0 */ | |
| 1133 | |
| 867 | 1134 /* DECLARE_POINTER_TYPE_ARITH_COUNT (const Ibyte *, Bytecount); |
| 826 | 1135 DECLARE_POINTER_TYPE_ARITH_COUNT (const Extbyte *, Bytecount); */ |
| 867 | 1136 DECLARE_POINTER_TYPE_ARITH_COUNT (Ibyte *, Bytecount); |
| 814 | 1137 DECLARE_POINTER_TYPE_ARITH_COUNT (Extbyte *, Bytecount); |
| 1138 | |
| 1139 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Bytecount); | |
| 1140 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Charcount); | |
| 1141 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Bytecount); | |
| 1142 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Charcount); | |
| 1143 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Bytecount); | |
| 1144 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Charcount); | |
| 1145 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Bytecount); | |
| 1146 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Charcount); | |
| 1147 | |
| 1148 DECLARE_INTEGRAL_TYPE_COMPARE (int, Bytecount); | |
| 1149 DECLARE_INTEGRAL_TYPE_COMPARE (int, Charcount); | |
| 1150 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Bytecount); | |
| 1151 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Charcount); | |
| 1152 DECLARE_INTEGRAL_TYPE_COMPARE (long, Bytecount); | |
| 1153 DECLARE_INTEGRAL_TYPE_COMPARE (long, Charcount); | |
| 1154 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Bytecount); | |
| 1155 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Charcount); | |
| 1156 | |
| 1157 #if 0 /* doesn't work */ | |
| 867 | 1158 inline Bytecount operator - (const Ibyte *x, const Ibyte *y) \ |
| 814 | 1159 { return Bytecount (x - y); } |
| 1160 #endif | |
| 1161 | |
| 1162 #endif /* __cplusplus */ | |
| 1163 | |
| 665 | 1164 /* Counts of elements */ |
| 1165 typedef EMACS_INT Elemcount; | |
| 1166 /* Hash codes */ | |
| 1167 typedef unsigned long Hashcode; | |
| 2367 | 1168 /* Booleans */ |
| 1169 typedef int Boolint; | |
| 771 | 1170 |
| 793 | 1171 /* ------------------------ basic compiler defines ------------------- */ |
| 428 | 1172 |
| 1743 | 1173 #include "compiler.h" |
| 1632 | 1174 |
| 793 | 1175 /* ------------------------ alignment definitions ------------------- */ |
| 1176 | |
| 454 | 1177 /* No type has a greater alignment requirement than max_align_t. |
| 1178 (except perhaps for types we don't use, like long double) */ | |
| 1179 typedef union | |
| 1180 { | |
| 1181 struct { long l; } l; | |
| 1182 struct { void *p; } p; | |
| 1183 struct { void (*f)(void); } f; | |
| 1184 struct { double d; } d; | |
| 1185 } max_align_t; | |
| 1186 | |
| 771 | 1187 /* ALIGNOF returns the required alignment of a type -- i.e. a value such |
| 1188 that data of this type must begin at a memory address which is a | |
| 1189 multiple of that value. For simple types, this is often the same size | |
| 1190 as the type itself. */ | |
| 1191 | |
| 428 | 1192 #ifndef ALIGNOF |
| 1193 # if defined (__GNUC__) && (__GNUC__ >= 2) | |
| 454 | 1194 /* gcc has an extension that gives us exactly what we want. */ |
| 1195 # define ALIGNOF(type) __alignof__ (type) | |
| 1196 # elif ! defined (__cplusplus) | |
| 1197 /* The following is mostly portable, except that: | |
| 1198 - it doesn't work for inside out declarations like void (*) (void). | |
| 1199 (so just call ALIGNOF with a typedef'ed name) | |
| 1200 - it doesn't work with C++. The C++ committee has decided, | |
| 1201 in its infinite wisdom, that: | |
| 1202 "Types must be declared in declarations, not in expressions." */ | |
| 1203 # define ALIGNOF(type) offsetof (struct { char c; type member; }, member) | |
| 428 | 1204 # else |
| 456 | 1205 /* C++ is annoying, but it has a big bag of tricks. |
| 1206 The following doesn't have the "inside out" declaration bug C does. */ | |
| 458 | 1207 template<typename T> struct alignment_trick { char c; T member; }; |
| 456 | 1208 # define ALIGNOF(type) offsetof (alignment_trick<type>, member) |
| 428 | 1209 # endif |
| 454 | 1210 #endif /* ALIGNOF */ |
| 428 | 1211 |
| 771 | 1212 /* ALIGN_SIZE returns the smallest size greater than or equal to LEN which |
| 1213 is a multiple of UNIT. This can be used to assure that data that | |
| 1214 follows a block of the returned size is of correct alignment for a type | |
| 1215 whose alignment (as returned by ALIGNOF) is UNIT (provided that the | |
| 1216 block itself is correctly aligned for this type; memory returned by | |
| 1217 malloc() is guaranteed to be correctly aligned for all types). */ | |
| 1218 | |
| 428 | 1219 #define ALIGN_SIZE(len, unit) \ |
| 1220 ((((len) + (unit) - 1) / (unit)) * (unit)) | |
| 1221 | |
| 826 | 1222 /* ALIGN_FOR_TYPE returns the smallest size greater than or equal to LEN |
| 1223 which is aligned for the given type. This can be used to assure that | |
| 1224 data that follows a block of the returned size is of correct alignment | |
| 1225 for the type (provided that the block itself is correctly aligned for | |
| 1226 this type; memory returned by malloc() is guaranteed to be correctly | |
| 1227 aligned for all types). */ | |
| 1228 | |
| 1229 #define ALIGN_FOR_TYPE(len, type) ALIGN_SIZE (len, ALIGNOF (type)) | |
| 1230 | |
| 771 | 1231 /* MAX_ALIGN_SIZE returns the smallest size greater than or equal to LEN |
| 1232 which guarantees that data following a block of such size is correctly | |
| 1233 aligned for all types (provided that the block itself is so aligned, | |
| 1234 which is the case for memory returned by malloc()). */ | |
| 1235 | |
| 826 | 1236 #define MAX_ALIGN_SIZE(len) ALIGN_FOR_TYPE (len, max_align_t) |
| 1237 | |
| 1238 /* ALIGN_PTR returns the smallest pointer >= PTR which is aligned for | |
| 1239 data of TYPE. */ | |
| 1240 #define ALIGN_PTR(ptr, type) ((void *) ALIGN_FOR_TYPE ((size_t) (ptr), type)) | |
| 428 | 1241 |
| 1743 | 1242 BEGIN_C_DECLS |
| 1650 | 1243 |
| 793 | 1244 /* ------------------------ assertions ------------------- */ |
| 428 | 1245 |
| 1246 /* We define assert iff USE_ASSERTIONS or DEBUG_XEMACS is defined. | |
| 1247 Otherwise we define it to be empty. Quantify has shown that the | |
| 1248 time the assert checks take is measurable so let's not include them | |
| 771 | 1249 in production binaries. |
| 1250 | |
| 788 | 1251 If ASSERTIONS_DONT_ABORT defined, we will continue after assertion |
| 1252 failures. | |
| 1253 | |
| 1254 assert_at_line() is used for asserts inside of inline functions called | |
| 1255 from error-checking macros. If we're not tricky, we just get the file | |
| 1256 and line of the inline function, which is not very useful. */ | |
| 428 | 1257 |
| 1258 /* Highly dubious kludge */ | |
| 1259 /* (thanks, Jamie, I feel better now -- ben) */ | |
| 2367 | 1260 MODULE_API void assert_failed (const Ascbyte *, int, const Ascbyte *); |
| 2535 | 1261 #define ABORT() (assert_failed (__FILE__, __LINE__, "ABORT()")) |
| 1262 | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1263 /* This used to be ((void) (0)) but that triggers lots of unused variable |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1264 warnings. It's pointless to force all that code to be rewritten, with |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1265 added ifdefs. Any reasonable compiler will eliminate an expression with |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1266 no effects. We keep this abstracted out like this in case we want to |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1267 change it in the future. */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1268 #define disabled_assert(x) ((void) (x)) |
| 4932 | 1269 #define disabled_assert_with_message(x, msg) ((void) msg, disabled_assert (x)) |
| 1270 #define disabled_assert_at_line(x, file, line) \ | |
| 1271 ((void) file, (void) line, disabled_assert (x)) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1272 |
| 2535 | 1273 #ifdef USE_ASSERTIONS |
| 428 | 1274 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x)) |
| 853 | 1275 # define assert_with_message(x, msg) \ |
| 1276 ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, msg)) | |
| 788 | 1277 # define assert_at_line(x, file, line) \ |
| 1278 ((x) ? (void) 0 : assert_failed (file, line, #x)) | |
| 428 | 1279 #else |
| 2956 | 1280 /* This used to be ((void) (0)) but that triggers lots of unused variable |
| 1281 warnings. It's pointless to force all that code to be rewritten, with | |
| 1282 added ifdefs. Any reasonable compiler will eliminate an expression with | |
| 1283 no effects. */ | |
| 4932 | 1284 # define assert(x) disabled_assert (x) |
| 1285 # define assert_with_message(x, msg) disabled_assert_with_message (x, msg) | |
| 1286 # define assert_at_line(x, file, line) disabled_assert_at_line (x, file, line) | |
| 428 | 1287 #endif |
| 1288 | |
| 2367 | 1289 /************************************************************************/ |
| 1290 /** Memory allocation **/ | |
| 1291 /************************************************************************/ | |
| 853 | 1292 |
| 793 | 1293 /* ------------------------ simple memory allocation ------------------- */ |
| 1294 | |
| 2367 | 1295 /* Basic memory allocation and freeing functions */ |
| 1296 void malloc_warning (const Ascbyte *); | |
| 1743 | 1297 MODULE_API void *xmalloc (Bytecount size) ATTRIBUTE_MALLOC; |
| 1298 MODULE_API void *xmalloc_and_zero (Bytecount size) ATTRIBUTE_MALLOC; | |
| 1299 MODULE_API void *xrealloc (void *, Bytecount size) ATTRIBUTE_MALLOC; | |
| 2367 | 1300 MODULE_API Chbyte *xstrdup (const Chbyte *) ATTRIBUTE_MALLOC; |
| 1301 | |
| 1302 /* Basic free function */ | |
| 1303 | |
| 1304 MODULE_API void xfree_1 (void *); | |
| 1305 #ifdef ERROR_CHECK_MALLOC | |
| 1306 /* This used to use a temporary variable, which both avoided the multiple | |
| 1307 evaluation and obviated the need for the TYPE argument. But that triggered | |
| 1308 complaints under strict aliasing. #### There should be a better way. */ | |
| 1309 #define xfree(lvalue, type) do \ | |
| 1310 { \ | |
| 1311 xfree_1 (lvalue); \ | |
| 3988 | 1312 VOIDP_CAST (lvalue) = (void *) DEADBEEF_CONSTANT; \ |
| 2367 | 1313 } while (0) |
| 1314 #else | |
| 1315 #define xfree(lvalue,type) xfree_1 (lvalue) | |
| 1316 #endif /* ERROR_CHECK_MALLOC */ | |
| 1317 | |
| 1318 /* ------------------------ stack allocation -------------------------- */ | |
| 1319 | |
| 1320 /* Allocating excessively large blocks on the stack can cause crashes. | |
| 851 | 1321 We provide MALLOC_OR_ALLOCA() below for places where it's likely that |
| 1322 large amounts will be allocated; it mallocs the block if it's too big. | |
| 1323 Unfortunately, that requires a call to unbind_to() at the end of the | |
| 1324 function, and it's not feasible to rewrite all calls to alloca() this | |
| 1325 way. | |
| 1326 | |
| 1327 Instead, we use the portable C alloca() substitute in alloca.c above a | |
| 1328 certain size. This actually uses malloc(), but checks the current stack | |
| 1329 pointer to see if data from previous alloca() calls needs to be freed. | |
| 1330 However, this can lead to large heap sizes -- especially since cleanup | |
| 1331 can only happen in a parent function, and will never happen if (as will | |
| 1332 often be the case) it's the same function in the same place in the code | |
| 1333 that keeps tripping the alloca() limit. | |
| 1334 | |
| 1335 So we set up a system to periodically force cleanup. Currently we | |
| 1336 do cleanup: | |
| 1337 | |
| 1338 -- Only when there's C alloca() data, and then | |
| 1339 -- Every stack alloca() or allocation of Lisp data, every call to | |
| 1340 next_event_internal() [typically near the top of the stack], | |
| 1341 or every 10th funcall | |
| 1342 | |
| 1343 This should not be a big penalty because | |
| 1344 | |
| 1345 (a) If there are few C alloca() chunks, checking them will be fast | |
| 1346 (b) If not, we've allocated a huge amount of heap space (remember, each | |
| 1347 chunk represents > 256K of heap), and we really want them gone | |
| 1348 */ | |
| 1349 | |
| 1350 /* We use a larger maximum when the choice is alloca() vs. the C alloca() | |
| 1351 substitute than when the choice is vs. malloc(), because in the former | |
| 1352 case, our alternative choice is less palatable because the memory may | |
| 1353 not be freed for awhile. */ | |
| 1354 | |
| 1355 #define MAX_ALLOCA_VS_C_ALLOCA 262144 | |
| 1356 #define MAX_ALLOCA_VS_MALLOC 65536 | |
| 1357 | |
| 1358 #define MAX_FUNCALLS_BETWEEN_ALLOCA_CLEANUP 10 | |
| 1359 | |
| 1632 | 1360 extern MODULE_API Bytecount __temp_alloca_size__; |
| 851 | 1361 extern Bytecount funcall_alloca_count; |
| 1362 | |
| 1333 | 1363 #ifdef ERROR_CHECK_MALLOC |
| 1632 | 1364 extern MODULE_API int regex_malloc_disallowed; |
| 1333 | 1365 #define REGEX_MALLOC_CHECK() assert (!regex_malloc_disallowed) |
| 1366 #else | |
| 1367 #define REGEX_MALLOC_CHECK() ((void) 0) | |
| 1368 #endif | |
| 1369 | |
| 851 | 1370 /* Do stack or heap alloca() depending on size. |
| 1371 | |
| 1372 NOTE: The use of a global temporary like this is unsafe if ALLOCA() occurs | |
| 1373 twice anywhere in the same expression; but that seems highly unlikely. The | |
| 1374 alternative is to force all callers to declare a local temporary if the | |
| 1375 expression has side effects -- something easy to forget. */ | |
| 1376 | |
| 1377 #define ALLOCA(size) \ | |
| 1333 | 1378 (REGEX_MALLOC_CHECK (), \ |
| 1379 __temp_alloca_size__ = (size), \ | |
| 851 | 1380 __temp_alloca_size__ > MAX_ALLOCA_VS_C_ALLOCA ? \ |
| 1381 xemacs_c_alloca (__temp_alloca_size__) : \ | |
| 1382 (need_to_check_c_alloca ? xemacs_c_alloca (0) : 0, \ | |
| 1383 alloca (__temp_alloca_size__))) | |
| 1384 | |
| 1318 | 1385 /* Version of ALLOCA() that is guaranteed to work inside of function calls |
| 1386 (i.e., we call the C alloca if regular alloca() is broken inside of | |
| 1387 function calls). */ | |
| 1388 #ifdef BROKEN_ALLOCA_IN_FUNCTION_CALLS | |
| 1389 #define ALLOCA_FUNCALL_OK(size) xemacs_c_alloca (size) | |
| 1390 #else | |
| 1391 #define ALLOCA_FUNCALL_OK(size) ALLOCA (size) | |
| 1392 #endif | |
| 1393 | |
| 2367 | 1394 MODULE_API void *xemacs_c_alloca (unsigned int size) ATTRIBUTE_MALLOC; |
| 1395 | |
| 1396 MODULE_API int record_unwind_protect_freeing (void *ptr); | |
| 1397 | |
| 1398 DECLARE_INLINE_HEADER ( | |
| 1399 void * | |
| 1400 xmalloc_and_record_unwind (Bytecount size) | |
| 1401 ) | |
| 1402 { | |
| 1403 void *ptr = xmalloc (size); | |
| 1404 record_unwind_protect_freeing (ptr); | |
| 1405 return ptr; | |
| 1406 } | |
| 1407 | |
| 851 | 1408 /* WARNING: If you use this, you must unbind_to() at the end of your |
| 1409 function! */ | |
| 1410 | |
| 1411 #define MALLOC_OR_ALLOCA(size) \ | |
| 1333 | 1412 (REGEX_MALLOC_CHECK (), \ |
| 1413 __temp_alloca_size__ = (size), \ | |
| 851 | 1414 __temp_alloca_size__ > MAX_ALLOCA_VS_MALLOC ? \ |
| 1415 xmalloc_and_record_unwind (__temp_alloca_size__) : \ | |
| 1416 (need_to_check_c_alloca ? xemacs_c_alloca (0) : 0, \ | |
| 1417 alloca (__temp_alloca_size__))) | |
| 793 | 1418 |
| 2367 | 1419 /* -------------- convenience functions for memory allocation ------------- */ |
| 1420 | |
| 1421 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0]))) | |
| 1422 #define xnew(type) ((type *) xmalloc (sizeof (type))) | |
| 1423 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type))) | |
| 1424 #define xnew_and_zero(type) ((type *) xmalloc_and_zero (sizeof (type))) | |
| 1425 #define xzero(lvalue) ((void) memset (&(lvalue), '\0', sizeof (lvalue))) | |
| 1426 #define xnew_array_and_zero(type, len) ((type *) xmalloc_and_zero ((len) * sizeof (type))) | |
| 1427 | |
| 1428 #define alloca_new(type) ((type *) ALLOCA (sizeof (type))) | |
| 1429 #define alloca_array(type, len) ((type *) ALLOCA ((len) * sizeof (type))) | |
| 1430 | |
| 1431 #define alloca_itexts(num) alloca_array (Itext, num) | |
| 1432 #define alloca_ibytes(num) alloca_array (Ibyte, num) | |
| 1433 #define alloca_extbytes(num) alloca_array (Extbyte, num) | |
| 1434 #define alloca_rawbytes(num) alloca_array (Rawbyte, num) | |
| 1435 #define alloca_binbytes(num) alloca_array (Binbyte, num) | |
| 1436 #define alloca_ascbytes(num) alloca_array (Ascbyte, num) | |
| 1437 #define xmalloc_itexts(num) xnew_array (Itext, num) | |
| 1438 #define xnew_ibytes(num) xnew_array (Ibyte, num) | |
| 1439 #define xnew_extbytes(num) xnew_array (Extbyte, num) | |
| 1440 #define xnew_rawbytes(num) xnew_array (Rawbyte, num) | |
| 1441 #define xnew_binbytes(num) xnew_array (Binbyte, num) | |
| 1442 #define xnew_ascbytes(num) xnew_array (Ascbyte, num) | |
| 1443 | |
| 1444 /* Make an alloca'd copy of a Ibyte * */ | |
| 1445 #define IBYTE_STRING_TO_ALLOCA(p, lval) \ | |
| 1446 do { \ | |
| 1447 Ibyte **_bsta_ = (Ibyte **) &(lval); \ | |
| 1448 const Ibyte *_bsta_2 = (p); \ | |
| 1449 Bytecount _bsta_3 = qxestrlen (_bsta_2); \ | |
| 1450 *_bsta_ = alloca_ibytes (1 + _bsta_3); \ | |
| 1451 memcpy (*_bsta_, _bsta_2, 1 + _bsta_3); \ | |
| 1452 } while (0) | |
| 1453 | |
| 1454 /* ----------------- convenience functions for reallocation --------------- */ | |
| 1455 | |
| 1456 #define XREALLOC_ARRAY(ptr, type, len) \ | |
| 1457 ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type)))) | |
| 1458 | |
| 793 | 1459 /* also generally useful if you want to avoid arbitrary size limits |
| 1460 but don't need a full dynamic array. Assumes that BASEVAR points | |
| 1461 to a malloced array of TYPE objects (or possibly a NULL pointer, | |
| 1462 if SIZEVAR is 0), with the total size stored in SIZEVAR. This | |
| 1463 macro will realloc BASEVAR as necessary so that it can hold at | |
| 1464 least NEEDED_SIZE objects. The reallocing is done by doubling, | |
| 1465 which ensures constant amortized time per element. */ | |
| 1466 #define DO_REALLOC(basevar, sizevar, needed_size, type) do { \ | |
| 1467 Bytecount do_realloc_needed_size = (needed_size); \ | |
| 1333 | 1468 REGEX_MALLOC_CHECK (); \ |
| 793 | 1469 if ((sizevar) < do_realloc_needed_size) \ |
| 1470 { \ | |
| 1471 if ((sizevar) < 32) \ | |
| 1472 (sizevar) = 32; \ | |
| 1473 while ((sizevar) < do_realloc_needed_size) \ | |
| 1474 (sizevar) *= 2; \ | |
| 1475 XREALLOC_ARRAY (basevar, type, (sizevar)); \ | |
| 1476 } \ | |
| 1477 } while (0) | |
| 1478 | |
| 2367 | 1479 /************************************************************************/ |
| 1480 /** Definitions of more complex types **/ | |
| 1481 /************************************************************************/ | |
| 428 | 1482 |
| 647 | 1483 /* Note that the simplest typedefs are near the top of this file. */ |
| 1484 | |
| 428 | 1485 /* We put typedefs here so that prototype declarations don't choke. |
| 1486 Note that we don't actually declare the structures here (except | |
| 1487 maybe for simple structures like Dynarrs); that keeps them private | |
| 1488 to the routines that actually use them. */ | |
| 1489 | |
| 771 | 1490 /* ------------------------------- */ |
| 1491 /* Error_Behavior typedefs */ | |
| 1492 /* ------------------------------- */ | |
| 1493 | |
| 800 | 1494 #ifndef ERROR_CHECK_TYPES |
| 771 | 1495 |
| 1496 typedef enum error_behavior | |
| 428 | 1497 { |
| 771 | 1498 ERROR_ME, |
| 1499 ERROR_ME_NOT, | |
| 793 | 1500 ERROR_ME_WARN, |
| 1501 ERROR_ME_DEBUG_WARN | |
| 771 | 1502 } Error_Behavior; |
| 1503 | |
| 1504 #define ERRB_EQ(a, b) ((a) == (b)) | |
| 1505 | |
| 1506 #else | |
| 1507 | |
| 1508 /* By defining it like this, we provide strict type-checking | |
| 1509 for code that lazily uses ints. */ | |
| 1510 | |
| 1511 typedef struct _error_behavior_struct_ | |
| 428 | 1512 { |
| 771 | 1513 int really_unlikely_name_to_have_accidentally_in_a_non_errb_structure; |
| 1514 } Error_Behavior; | |
| 1515 | |
| 1516 extern Error_Behavior ERROR_ME; | |
| 1517 extern Error_Behavior ERROR_ME_NOT; | |
| 1518 extern Error_Behavior ERROR_ME_WARN; | |
| 793 | 1519 extern Error_Behavior ERROR_ME_DEBUG_WARN; |
| 771 | 1520 |
| 1521 #define ERRB_EQ(a, b) \ | |
| 1522 ((a).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure == \ | |
| 1523 (b).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure) | |
| 1524 | |
| 1525 #endif | |
| 1526 | |
| 1527 /* ------------------------------- */ | |
| 1528 /* Empty structures and typedefs */ | |
| 1529 /* ------------------------------- */ | |
| 428 | 1530 |
| 1531 struct buffer; /* "buffer.h" */ | |
| 1532 struct console; /* "console.h" */ | |
| 1533 struct device; /* "device.h" */ | |
| 1534 struct extent_fragment; | |
| 1535 struct extent; | |
| 1536 struct frame; /* "frame.h" */ | |
| 1537 struct window; /* "window.h" */ | |
| 771 | 1538 struct utimbuf; /* "systime.h" or <utime.h> */ |
| 428 | 1539 struct display_line; |
| 1540 struct display_glyph_area; | |
| 1541 struct display_box; | |
| 1542 struct redisplay_info; | |
| 1543 struct window_mirror; | |
| 1544 struct scrollbar_instance; | |
| 1545 struct font_metric_info; | |
| 1546 struct face_cachel; | |
| 1547 struct console_type_entry; | |
| 1548 | |
| 771 | 1549 /* This is shared by process.h, events.h and others in future. |
| 1550 See events.h for description */ | |
| 4123 | 1551 typedef unsigned EMACS_INT USID; |
| 771 | 1552 typedef int face_index; |
| 1553 typedef int glyph_index; | |
| 1726 | 1554 typedef struct lstream Lstream; /* lstream.h */ |
| 872 | 1555 typedef struct extent *EXTENT; /* extents-impl.h */ |
| 771 | 1556 typedef struct Lisp_Event Lisp_Event; /* "events.h" */ |
| 872 | 1557 typedef struct Lisp_Face Lisp_Face; /* "faces-impl.h" */ |
| 771 | 1558 typedef struct Lisp_Process Lisp_Process; /* "procimpl.h" */ |
| 872 | 1559 typedef struct Lisp_Color_Instance Lisp_Color_Instance; /* objects-impl.h */ |
| 1560 typedef struct Lisp_Font_Instance Lisp_Font_Instance; /* objects-impl.h */ | |
| 1726 | 1561 typedef struct Lisp_Image_Instance Lisp_Image_Instance; /* glyphs.h */ |
| 771 | 1562 typedef struct Lisp_Gui_Item Lisp_Gui_Item; |
| 1563 | |
| 1564 /* ------------------------------- */ | |
| 1565 /* enum typedefs */ | |
| 1566 /* ------------------------------- */ | |
| 1567 | |
| 428 | 1568 enum run_hooks_condition |
| 1569 { | |
| 1570 RUN_HOOKS_TO_COMPLETION, | |
| 1571 RUN_HOOKS_UNTIL_SUCCESS, | |
| 1572 RUN_HOOKS_UNTIL_FAILURE | |
| 1573 }; | |
| 1574 | |
| 1575 #ifdef HAVE_TOOLBARS | |
| 1576 enum toolbar_pos | |
| 1577 { | |
| 1578 TOP_TOOLBAR, | |
| 1579 BOTTOM_TOOLBAR, | |
| 1580 LEFT_TOOLBAR, | |
| 1581 RIGHT_TOOLBAR | |
| 1582 }; | |
| 1583 #endif | |
| 1584 | |
| 1585 enum edge_style | |
| 1586 { | |
| 1587 EDGE_ETCHED_IN, | |
| 1588 EDGE_ETCHED_OUT, | |
| 1589 EDGE_BEVEL_IN, | |
| 1590 EDGE_BEVEL_OUT | |
| 1591 }; | |
| 1592 | |
| 1593 enum munge_me_out_the_door | |
| 1594 { | |
| 1595 MUNGE_ME_FUNCTION_KEY, | |
| 1596 MUNGE_ME_KEY_TRANSLATION | |
| 1597 }; | |
| 1598 | |
| 771 | 1599 /* ------------------------------- */ |
| 1600 /* misc */ | |
| 1601 /* ------------------------------- */ | |
| 1602 | |
| 1603 #ifdef MEMORY_USAGE_STATS | |
| 1604 | |
| 1605 /* This structure is used to keep statistics on the amount of memory | |
| 1606 in use. | |
| 1607 | |
| 1608 WAS_REQUESTED stores the actual amount of memory that was requested | |
| 1609 of the allocation function. The *_OVERHEAD fields store the | |
| 1610 additional amount of memory that was grabbed by the functions to | |
| 1611 facilitate allocation, reallocation, etc. MALLOC_OVERHEAD is for | |
| 1612 memory allocated with malloc(); DYNARR_OVERHEAD is for dynamic | |
| 1613 arrays; GAP_OVERHEAD is for gap arrays. Note that for (e.g.) | |
| 1614 dynamic arrays, there is both MALLOC_OVERHEAD and DYNARR_OVERHEAD | |
| 1615 memory: The dynamic array allocates memory above and beyond what | |
| 1616 was asked of it, and when it in turns allocates memory using | |
| 1617 malloc(), malloc() allocates memory beyond what it was asked | |
| 1618 to allocate. | |
| 1619 | |
| 1620 Functions that accept a structure of this sort do not initialize | |
| 1621 the fields to 0, and add any existing values to whatever was there | |
| 1622 before; this way, you can get a cumulative effect. */ | |
| 1623 | |
| 1624 struct overhead_stats | |
| 1625 { | |
| 1626 int was_requested; | |
| 1627 int malloc_overhead; | |
| 1628 int dynarr_overhead; | |
| 1629 int gap_overhead; | |
| 1630 }; | |
| 1631 | |
| 1632 #endif /* MEMORY_USAGE_STATS */ | |
| 1633 | |
| 428 | 1634 |
| 1635 /************************************************************************/ | |
| 1636 /* Definition of Lisp_Object data type */ | |
| 1637 /************************************************************************/ | |
| 1638 | |
| 1639 /* Define the fundamental Lisp data structures */ | |
| 1640 | |
| 1641 /* This is the set of Lisp data types */ | |
| 1642 | |
| 1643 enum Lisp_Type | |
| 1644 { | |
| 1645 Lisp_Type_Record, | |
| 1646 Lisp_Type_Int_Even, | |
| 1647 Lisp_Type_Char, | |
| 1648 Lisp_Type_Int_Odd | |
| 1649 }; | |
| 1650 | |
| 1651 #define POINTER_TYPE_P(type) ((type) == Lisp_Type_Record) | |
| 1652 | |
| 1653 /* Overridden by m/next.h */ | |
| 1654 #ifndef ASSERT_VALID_POINTER | |
| 1655 # define ASSERT_VALID_POINTER(pnt) (assert ((((EMACS_UINT) pnt) & 3) == 0)) | |
| 1656 #endif | |
| 1657 | |
| 1658 #define GCMARKBITS 0 | |
| 1659 #define GCTYPEBITS 2 | |
| 1660 #define GCBITS 2 | |
| 1661 #define INT_GCBITS 1 | |
| 1662 | |
| 1663 #define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS) | |
| 1664 #define VALBITS (BITS_PER_EMACS_INT - GCBITS) | |
| 542 | 1665 #define EMACS_INT_MAX ((EMACS_INT) ((1UL << (INT_VALBITS - 1)) -1UL)) |
| 442 | 1666 #define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1) |
| 802 | 1667 /* WARNING: evaluates its arg twice. */ |
| 1668 #define NUMBER_FITS_IN_AN_EMACS_INT(num) \ | |
| 1669 ((num) <= EMACS_INT_MAX && (num) >= EMACS_INT_MIN) | |
| 428 | 1670 |
| 1671 #ifdef USE_UNION_TYPE | |
| 1672 # include "lisp-union.h" | |
| 1673 #else /* !USE_UNION_TYPE */ | |
| 1674 # include "lisp-disunion.h" | |
| 1675 #endif /* !USE_UNION_TYPE */ | |
| 1676 | |
| 1677 #define XPNTR(x) ((void *) XPNTRVAL(x)) | |
| 1678 | |
| 1679 /* Close your eyes now lest you vomit or spontaneously combust ... */ | |
| 1680 | |
| 1681 #define HACKEQ_UNSAFE(obj1, obj2) \ | |
| 1682 (EQ (obj1, obj2) || (!POINTER_TYPE_P (XTYPE (obj1)) \ | |
| 1683 && !POINTER_TYPE_P (XTYPE (obj2)) \ | |
| 1684 && XCHAR_OR_INT (obj1) == XCHAR_OR_INT (obj2))) | |
| 1685 | |
| 1686 #ifdef DEBUG_XEMACS | |
| 1632 | 1687 extern MODULE_API int debug_issue_ebola_notices; |
| 1688 MODULE_API int eq_with_ebola_notice (Lisp_Object, Lisp_Object); | |
| 428 | 1689 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) \ |
| 1690 (debug_issue_ebola_notices ? eq_with_ebola_notice (obj1, obj2) \ | |
| 1691 : EQ (obj1, obj2)) | |
| 1692 #else | |
| 1693 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) EQ (obj1, obj2) | |
| 1694 #endif | |
| 1695 | |
| 1696 /* OK, you can open them again */ | |
| 1697 | |
| 1743 | 1698 END_C_DECLS |
| 1650 | 1699 |
| 428 | 1700 /************************************************************************/ |
| 442 | 1701 /** Definitions of basic Lisp objects **/ |
| 428 | 1702 /************************************************************************/ |
| 1703 | |
| 1704 #include "lrecord.h" | |
| 1705 | |
| 1743 | 1706 BEGIN_C_DECLS |
| 1650 | 1707 |
| 3293 | 1708 /* ------------------------ dynamic arrays ------------------- */ |
| 1709 | |
| 3092 | 1710 #ifdef NEW_GC |
| 1711 #ifdef ERROR_CHECK_STRUCTURES | |
| 1712 #define Dynarr_declare(type) \ | |
| 1713 struct lrecord_header header; \ | |
| 1714 type *base; \ | |
| 1715 const struct lrecord_implementation *lisp_imp; \ | |
| 1716 int locked; \ | |
| 1717 int elsize; \ | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1718 int len; \ |
| 3092 | 1719 int largest; \ |
| 1720 int max | |
| 1721 #else | |
| 1722 #define Dynarr_declare(type) \ | |
| 1723 struct lrecord_header header; \ | |
| 1724 type *base; \ | |
| 1725 const struct lrecord_implementation *lisp_imp; \ | |
| 1726 int elsize; \ | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1727 int len; \ |
| 3092 | 1728 int largest; \ |
| 1729 int max | |
| 1730 #endif /* ERROR_CHECK_STRUCTURES */ | |
| 3293 | 1731 #else /* not NEW_GC */ |
| 1732 #ifdef ERROR_CHECK_STRUCTURES | |
| 1733 #define Dynarr_declare(type) \ | |
| 1734 struct lrecord_header header; \ | |
| 1735 type *base; \ | |
| 1736 int locked; \ | |
| 1737 int elsize; \ | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1738 int len; \ |
| 3293 | 1739 int largest; \ |
| 1740 int max | |
| 1741 #else | |
| 1742 #define Dynarr_declare(type) \ | |
| 1743 struct lrecord_header header; \ | |
| 1744 type *base; \ | |
| 1745 int elsize; \ | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1746 int len; \ |
| 3293 | 1747 int largest; \ |
| 1748 int max | |
| 1749 #endif /* ERROR_CHECK_STRUCTURES */ | |
| 1750 #endif /* not NEW_GC */ | |
| 3092 | 1751 |
| 1752 typedef struct dynarr | |
| 1753 { | |
| 1754 Dynarr_declare (void); | |
| 1755 } Dynarr; | |
| 1756 | |
| 1757 MODULE_API void *Dynarr_newf (int elsize); | |
| 1758 MODULE_API void Dynarr_resize (void *dy, Elemcount size); | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1759 MODULE_API void Dynarr_insert_many (void *d, const void *el, int len, |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1760 int start); |
| 3092 | 1761 MODULE_API void Dynarr_delete_many (void *d, int start, int len); |
| 1762 MODULE_API void Dynarr_free (void *d); | |
| 1763 | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1764 #ifdef ERROR_CHECK_TYPES |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1765 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1766 int |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1767 Dynarr_verify_pos_at (void *d, int pos, const Ascbyte *file, int line) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1768 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1769 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1770 Dynarr *dy = (Dynarr *) d; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1771 /* We use `largest', not `len', because the redisplay code often |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1772 accesses stuff between len and largest. */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1773 assert_at_line (pos >= 0 && pos < dy->largest, file, line); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1774 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1775 } |
|
4929
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1776 |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1777 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1778 int |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1779 Dynarr_verify_pos_atp (void *d, int pos, const Ascbyte *file, int line) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1780 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1781 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1782 Dynarr *dy = (Dynarr *) d; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1783 /* We use `largest', not `len', because the redisplay code often |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1784 accesses stuff between len and largest. */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1785 /* Code will often do something like ... |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1786 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1787 val = make_bit_vector_from_byte_vector (Dynarr_atp (dyn, 0), |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1788 Dynarr_length (dyn)); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1789 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1790 which works fine when the Dynarr_length is non-zero, but when zero, |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1791 the result of Dynarr_atp() not only points past the end of the |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1792 allocated array, but the array may not have ever been allocated and |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1793 hence the return value is NULL. But the length of 0 causes the |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1794 pointer to never get checked. These can occur throughout the code |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1795 so we put in a special check. */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1796 if (pos == 0 && dy->len == 0) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1797 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1798 /* #### It's vaguely possible that some code could legitimately want to |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1799 retrieve a pointer to the position just past the end of dynarr memory. |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1800 This could happen with Dynarr_atp() but not Dynarr_at(). If so, it |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1801 will trigger this assert(). In such cases, it should be obvious that |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1802 the code wants to do this; rather than relaxing the assert, we should |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1803 probably create a new macro Dynarr_atp_allow_end() which is like |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1804 Dynarr_atp() but which allows for pointing at invalid addresses -- we |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1805 really want to check for cases of accessing just past the end of |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1806 memory, which is a likely off-by-one problem to occur and will usually |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1807 not trigger a protection fault (instead, you'll just get random |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1808 behavior, possibly overwriting other memory, which is bad). */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1809 assert_at_line (pos >= 0 && pos < dy->largest, file, line); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1810 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1811 } |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1812 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1813 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1814 int |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1815 Dynarr_verify_pos_atp_allow_end (void *d, int pos, const Ascbyte *file, |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1816 int line) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1817 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1818 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1819 Dynarr *dy = (Dynarr *) d; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1820 /* We use `largest', not `len', because the redisplay code often |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1821 accesses stuff between len and largest. |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1822 We also allow referencing the very end, past the end of allocated |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1823 legitimately space. See comments in Dynarr_verify_pos_atp.()*/ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1824 assert_at_line (pos >= 0 && pos <= dy->largest, file, line); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1825 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1826 } |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1827 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1828 #else |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1829 #define Dynarr_verify_pos_at(d, pos, file, line) (pos) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1830 #define Dynarr_verify_pos_atp(d, pos, file, line) (pos) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1831 #define Dynarr_verify_pos_atp_allow_end(d, pos, file, line) (pos) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1832 #endif /* ERROR_CHECK_TYPES */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1833 |
| 3293 | 1834 #ifdef NEW_GC |
| 3092 | 1835 MODULE_API void *Dynarr_lisp_newf (int elsize, |
| 1836 const struct lrecord_implementation | |
| 1837 *dynarr_imp, | |
| 1838 const struct lrecord_implementation *imp); | |
| 1839 | |
| 1840 #define Dynarr_lisp_new(type, dynarr_imp, imp) \ | |
| 1841 ((type##_dynarr *) Dynarr_lisp_newf (sizeof (type), dynarr_imp, imp)) | |
| 1842 #define Dynarr_lisp_new2(dynarr_type, type, dynarr_imp, imp) \ | |
| 1843 ((dynarr_type *) Dynarr_lisp_newf (sizeof (type)), dynarr_imp, imp) | |
| 3293 | 1844 #endif /* NEW_GC */ |
| 3092 | 1845 #define Dynarr_new(type) ((type##_dynarr *) Dynarr_newf (sizeof (type))) |
| 1846 #define Dynarr_new2(dynarr_type, type) \ | |
| 1847 ((dynarr_type *) Dynarr_newf (sizeof (type))) | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1848 |
|
4929
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1849 #ifdef ERROR_CHECK_TYPES_GCC_NOT_BROKEN |
|
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1850 /* Enabling this leads to crashes in Cygwin 1.7, gcc 3.4.4 */ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1851 #define Dynarr_at(d, pos) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1852 ((d)->base[Dynarr_verify_pos_at (d, pos, __FILE__, __LINE__)]) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1853 #define Dynarr_atp_allow_end(d, pos) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1854 (&((d)->base[Dynarr_verify_pos_atp_allow_end (d, pos, __FILE__, __LINE__)])) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1855 #define Dynarr_atp(d, pos) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1856 (&((d)->base[Dynarr_verify_pos_atp (d, pos, __FILE__, __LINE__)])) |
|
4929
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1857 #else |
|
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1858 #define Dynarr_at(d, pos) ((d)->base[pos]) |
|
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1859 #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos)) |
|
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1860 #define Dynarr_atp_allow_end(d, pos) Dynarr_atp (d, pos) |
|
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1861 #endif |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1862 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1863 /* Old #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos)) */ |
| 3092 | 1864 #define Dynarr_begin(d) Dynarr_atp (d, 0) |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1865 #define Dynarr_lastp(d) Dynarr_atp (d, Dynarr_length (d) - 1) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1866 #define Dynarr_past_lastp(d) Dynarr_atp_allow_end (d, Dynarr_length (d)) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1867 #define Dynarr_sizeof(d) ((d)->len * (d)->elsize) |
| 3092 | 1868 |
| 1869 #ifdef ERROR_CHECK_STRUCTURES | |
| 1870 DECLARE_INLINE_HEADER ( | |
| 1871 Dynarr * | |
| 1872 Dynarr_verify_1 (void *d, const Ascbyte *file, int line) | |
| 1873 ) | |
| 1874 { | |
| 1875 Dynarr *dy = (Dynarr *) d; | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1876 assert_at_line (dy->len >= 0 && dy->len <= dy->largest && |
| 3092 | 1877 dy->largest <= dy->max, file, line); |
| 1878 return dy; | |
| 1879 } | |
| 1880 | |
| 1881 DECLARE_INLINE_HEADER ( | |
| 1882 Dynarr * | |
| 1883 Dynarr_verify_mod_1 (void *d, const Ascbyte *file, int line) | |
| 1884 ) | |
| 1885 { | |
| 1886 Dynarr *dy = (Dynarr *) d; | |
| 1887 assert_at_line (!dy->locked, file, line); | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1888 assert_at_line (dy->len >= 0 && dy->len <= dy->largest && |
| 3092 | 1889 dy->largest <= dy->max, file, line); |
| 1890 return dy; | |
| 1891 } | |
| 1892 | |
| 1893 #define Dynarr_verify(d) Dynarr_verify_1 (d, __FILE__, __LINE__) | |
| 1894 #define Dynarr_verify_mod(d) Dynarr_verify_mod_1 (d, __FILE__, __LINE__) | |
| 1895 #define Dynarr_lock(d) (Dynarr_verify_mod (d)->locked = 1) | |
| 1896 #define Dynarr_unlock(d) ((d)->locked = 0) | |
| 1897 #else | |
| 1898 #define Dynarr_verify(d) (d) | |
| 1899 #define Dynarr_verify_mod(d) (d) | |
| 1900 #define Dynarr_lock(d) | |
| 1901 #define Dynarr_unlock(d) | |
| 1902 #endif /* ERROR_CHECK_STRUCTURES */ | |
| 1903 | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1904 #define Dynarr_length(d) (Dynarr_verify (d)->len) |
| 3092 | 1905 #define Dynarr_largest(d) (Dynarr_verify (d)->largest) |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1906 #define Dynarr_reset(d) (Dynarr_verify_mod (d)->len = 0) |
| 3092 | 1907 #define Dynarr_insert_many_at_start(d, el, len) \ |
| 1908 Dynarr_insert_many (d, el, len, 0) | |
| 1909 #define Dynarr_add_literal_string(d, s) Dynarr_add_many (d, s, sizeof (s) - 1) | |
| 1910 #define Dynarr_add_lisp_string(d, s, codesys) \ | |
| 1911 do { \ | |
| 1912 Lisp_Object dyna_ls_s = (s); \ | |
| 1913 Lisp_Object dyna_ls_cs = (codesys); \ | |
| 1914 Extbyte *dyna_ls_eb; \ | |
| 1915 Bytecount dyna_ls_bc; \ | |
| 1916 \ | |
| 1917 LISP_STRING_TO_SIZED_EXTERNAL (dyna_ls_s, dyna_ls_eb, \ | |
| 1918 dyna_ls_bc, dyna_ls_cs); \ | |
| 1919 Dynarr_add_many (d, dyna_ls_eb, dyna_ls_bc); \ | |
| 1920 } while (0) | |
| 1921 | |
| 3293 | 1922 #ifdef NEW_GC |
| 3092 | 1923 #define Dynarr_add(d, el) \ |
| 1924 do { \ | |
| 3319 | 1925 const struct lrecord_implementation *imp = (d)->lisp_imp; \ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1926 if (Dynarr_verify_mod (d)->len >= (d)->max) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1927 Dynarr_resize ((d), (d)->len+1); \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1928 ((d)->base)[(d)->len] = (el); \ |
| 3092 | 1929 \ |
| 3319 | 1930 if (imp) \ |
| 3092 | 1931 set_lheader_implementation \ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1932 ((struct lrecord_header *)&(((d)->base)[(d)->len]), imp); \ |
| 3092 | 1933 \ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1934 (d)->len++; \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1935 if ((d)->len > (d)->largest) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1936 (d)->largest = (d)->len; \ |
| 3092 | 1937 } while (0) |
| 3293 | 1938 #else /* not NEW_GC */ |
| 3092 | 1939 #define Dynarr_add(d, el) ( \ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1940 Dynarr_verify_mod (d)->len >= (d)->max ? Dynarr_resize ((d), (d)->len+1) : \ |
| 3092 | 1941 (void) 0, \ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1942 ((d)->base)[(d)->len++] = (el), \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1943 (d)->len > (d)->largest ? (d)->largest = (d)->len : (int) 0) |
| 3293 | 1944 #endif /* not NEW_GC */ |
| 3092 | 1945 |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1946 /* Add LEN contiguous elements to a Dynarr */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1947 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1948 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1949 void |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1950 Dynarr_add_many (void *d, const void *el, int len) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1951 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1952 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1953 /* This duplicates Dynarr_insert_many to some extent; but since it is |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1954 called so often, it seemed useful to remove the unnecessary stuff |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1955 from that function and to make it inline */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1956 Dynarr *dy = (Dynarr *) Dynarr_verify (d); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1957 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1958 if (dy->len + len > dy->max) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1959 Dynarr_resize (dy, dy->len + len); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1960 /* Some functions call us with a value of 0 to mean "reserve space but |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1961 don't write into it" */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1962 if (el) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1963 memcpy ((char *) dy->base + dy->len*dy->elsize, el, len*dy->elsize); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1964 dy->len += len; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1965 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1966 if (dy->len > dy->largest) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1967 dy->largest = dy->len; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1968 } |
| 3092 | 1969 |
| 1970 /* The following defines will get you into real trouble if you aren't | |
| 1971 careful. But they can save a lot of execution time when used wisely. */ | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1972 #define Dynarr_increment(d) (Dynarr_verify_mod (d)->len++) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1973 #define Dynarr_set_size(d, n) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1974 do { \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1975 Bytecount _dss_n = (n); \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1976 structure_checking_assert (_dss_n >= 0 && _dss_n <= (d)->largest); \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1977 Dynarr_verify_mod (d)->len = _dss_n; \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1978 } while (0) |
| 3092 | 1979 |
| 1980 #define Dynarr_pop(d) \ | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1981 (assert ((d)->len > 0), Dynarr_verify_mod (d)->len--, \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1982 Dynarr_at (d, (d)->len)) |
| 3092 | 1983 #define Dynarr_delete(d, i) Dynarr_delete_many (d, i, 1) |
| 1984 #define Dynarr_delete_by_pointer(d, p) \ | |
| 1985 Dynarr_delete_many (d, (p) - ((d)->base), 1) | |
| 1986 | |
| 1987 #define Dynarr_delete_object(d, el) \ | |
| 1988 do \ | |
| 1989 { \ | |
| 1990 REGISTER int i; \ | |
| 1991 for (i = Dynarr_length (d) - 1; i >= 0; i--) \ | |
| 1992 { \ | |
| 1993 if (el == Dynarr_at (d, i)) \ | |
| 1994 Dynarr_delete_many (d, i, 1); \ | |
| 1995 } \ | |
| 1996 } while (0) | |
| 1997 | |
| 1998 #ifdef MEMORY_USAGE_STATS | |
| 1999 struct overhead_stats; | |
| 2000 Bytecount Dynarr_memory_usage (void *d, struct overhead_stats *stats); | |
| 2001 #endif | |
| 2002 | |
| 2003 void *stack_like_malloc (Bytecount size); | |
| 2004 void stack_like_free (void *val); | |
| 2005 | |
| 2006 /* ------------------------------- */ | |
| 2007 /* Dynarr typedefs */ | |
| 2008 /* ------------------------------- */ | |
| 2009 | |
| 2010 /* Dynarr typedefs -- basic types first */ | |
| 2011 | |
| 2012 typedef struct | |
| 2013 { | |
| 2014 Dynarr_declare (Ibyte); | |
| 2015 } Ibyte_dynarr; | |
| 2016 | |
| 2017 typedef struct | |
| 2018 { | |
| 2019 Dynarr_declare (Extbyte); | |
| 2020 } Extbyte_dynarr; | |
| 2021 | |
| 2022 typedef struct | |
| 2023 { | |
| 2024 Dynarr_declare (Ichar); | |
| 2025 } Ichar_dynarr; | |
| 2026 | |
| 2027 typedef struct | |
| 2028 { | |
| 2029 Dynarr_declare (char); | |
| 2030 } char_dynarr; | |
| 2031 | |
| 2032 typedef struct | |
| 2033 { | |
| 2034 Dynarr_declare (char *); | |
| 2035 } char_ptr_dynarr; | |
| 2036 | |
| 2037 typedef unsigned char unsigned_char; | |
| 2038 typedef struct | |
| 2039 { | |
| 2040 Dynarr_declare (unsigned char); | |
| 2041 } unsigned_char_dynarr; | |
| 2042 | |
| 2043 typedef unsigned long unsigned_long; | |
| 2044 typedef struct | |
| 2045 { | |
| 2046 Dynarr_declare (unsigned long); | |
| 2047 } unsigned_long_dynarr; | |
| 2048 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2049 typedef const Ascbyte *const_Ascbyte_ptr; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2050 typedef struct |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2051 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2052 Dynarr_declare (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2053 } const_Ascbyte_ptr_dynarr; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2054 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2055 extern const struct sized_memory_description const_Ascbyte_ptr_description; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2056 extern const struct sized_memory_description const_Ascbyte_ptr_dynarr_description; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2057 |
| 3092 | 2058 typedef struct |
| 2059 { | |
| 2060 Dynarr_declare (int); | |
| 2061 } int_dynarr; | |
| 2062 | |
| 2063 typedef struct | |
| 2064 { | |
| 2065 Dynarr_declare (Charbpos); | |
| 2066 } Charbpos_dynarr; | |
| 2067 | |
| 2068 typedef struct | |
| 2069 { | |
| 2070 Dynarr_declare (Bytebpos); | |
| 2071 } Bytebpos_dynarr; | |
| 2072 | |
| 2073 typedef struct | |
| 2074 { | |
| 2075 Dynarr_declare (Charcount); | |
| 2076 } Charcount_dynarr; | |
| 2077 | |
| 2078 typedef struct | |
| 2079 { | |
| 2080 Dynarr_declare (Bytecount); | |
| 2081 } Bytecount_dynarr; | |
| 2082 | |
| 2083 /* Dynarr typedefs -- more complex types */ | |
| 2084 | |
| 2085 typedef struct | |
| 2086 { | |
| 2087 Dynarr_declare (struct face_cachel); | |
| 2088 } face_cachel_dynarr; | |
| 2089 | |
| 3293 | 2090 #ifdef NEW_GC |
| 3092 | 2091 DECLARE_LRECORD (face_cachel_dynarr, face_cachel_dynarr); |
| 2092 #define XFACE_CACHEL_DYNARR(x) \ | |
| 2093 XRECORD (x, face_cachel_dynarr, face_cachel_dynarr) | |
| 2094 #define wrap_face_cachel_dynarr(p) wrap_record (p, face_cachel_dynarr) | |
| 2095 #define FACE_CACHEL_DYNARRP(x) RECORDP (x, face_cachel_dynarr) | |
| 2096 #define CHECK_FACE_CACHEL_DYNARR(x) CHECK_RECORD (x, face_cachel_dynarr) | |
| 2097 #define CONCHECK_FACE_CACHEL_DYNARR(x) CONCHECK_RECORD (x, face_cachel_dynarr) | |
| 3293 | 2098 #endif /* NEW_GC */ |
| 3092 | 2099 |
| 2100 typedef struct | |
| 2101 { | |
| 2102 Dynarr_declare (struct glyph_cachel); | |
| 2103 } glyph_cachel_dynarr; | |
| 2104 | |
| 3293 | 2105 #ifdef NEW_GC |
| 3092 | 2106 DECLARE_LRECORD (glyph_cachel_dynarr, glyph_cachel_dynarr); |
| 2107 #define XGLYPH_CACHEL_DYNARR(x) \ | |
| 2108 XRECORD (x, glyph_cachel_dynarr, glyph_cachel_dynarr) | |
| 2109 #define wrap_glyph_cachel_dynarr(p) wrap_record (p, glyph_cachel_dynarr) | |
| 2110 #define GLYPH_CACHEL_DYNARRP(x) RECORDP (x, glyph_cachel_dynarr) | |
| 2111 #define CHECK_GLYPH_CACHEL_DYNARR(x) CHECK_RECORD (x, glyph_cachel_dynarr) | |
| 2112 #define CONCHECK_GLYPH_CACHEL_DYNARR(x) \ | |
| 2113 CONCHECK_RECORD (x, glyph_cachel_dynarr) | |
| 3293 | 2114 #endif /* NEW_GC */ |
| 3092 | 2115 |
| 2116 typedef struct | |
| 2117 { | |
| 2118 Dynarr_declare (struct console_type_entry); | |
| 2119 } console_type_entry_dynarr; | |
| 2120 | |
| 2121 /* WARNING WARNING WARNING. You must ensure on your own that proper | |
| 2122 GC protection is provided for the elements in this array. */ | |
| 2123 typedef struct | |
| 2124 { | |
| 2125 Dynarr_declare (Lisp_Object); | |
| 2126 } Lisp_Object_dynarr; | |
| 2127 | |
| 2128 typedef struct | |
| 2129 { | |
| 2130 Dynarr_declare (Lisp_Object *); | |
| 2131 } Lisp_Object_ptr_dynarr; | |
| 2132 | |
| 442 | 2133 /*------------------------------ unbound -------------------------------*/ |
| 428 | 2134 |
| 2135 /* Qunbound is a special Lisp_Object (actually of type | |
| 2136 symbol-value-forward), that can never be visible to | |
| 2137 the Lisp caller and thus can be used in the C code | |
| 2138 to mean "no such value". */ | |
| 2139 | |
| 2140 #define UNBOUNDP(val) EQ (val, Qunbound) | |
| 2141 | |
| 771 | 2142 /* Evaluate expr, return it if it's not Qunbound. */ |
| 2143 #define RETURN_IF_NOT_UNBOUND(expr) do \ | |
| 2144 { \ | |
| 2145 Lisp_Object ret_nunb_val = (expr); \ | |
| 2146 if (!UNBOUNDP (ret_nunb_val)) \ | |
| 2147 RETURN_SANS_WARNINGS ret_nunb_val; \ | |
| 2148 } while (0) | |
| 2149 | |
| 442 | 2150 /*------------------------------- cons ---------------------------------*/ |
| 428 | 2151 |
| 2152 /* In a cons, the markbit of the car is the gc mark bit */ | |
| 2153 | |
| 2154 struct Lisp_Cons | |
| 2155 { | |
| 2156 struct lrecord_header lheader; | |
| 853 | 2157 Lisp_Object car_, cdr_; |
| 428 | 2158 }; |
| 2159 typedef struct Lisp_Cons Lisp_Cons; | |
| 2160 | |
| 2161 #if 0 /* FSFmacs */ | |
| 2162 /* Like a cons, but records info on where the text lives that it was read from */ | |
| 2163 /* This is not really in use now */ | |
| 2164 | |
| 2165 struct Lisp_Buffer_Cons | |
| 2166 { | |
| 2167 Lisp_Object car, cdr; | |
| 2168 struct buffer *buffer; | |
| 665 | 2169 int charbpos; |
| 428 | 2170 }; |
| 2171 #endif | |
| 2172 | |
| 1632 | 2173 DECLARE_MODULE_API_LRECORD (cons, Lisp_Cons); |
| 428 | 2174 #define XCONS(x) XRECORD (x, cons, Lisp_Cons) |
| 617 | 2175 #define wrap_cons(p) wrap_record (p, cons) |
| 428 | 2176 #define CONSP(x) RECORDP (x, cons) |
| 2177 #define CHECK_CONS(x) CHECK_RECORD (x, cons) | |
| 2178 #define CONCHECK_CONS(x) CONCHECK_RECORD (x, cons) | |
| 2179 | |
| 3263 | 2180 #ifdef NEW_GC |
| 2720 | 2181 #define CONS_MARKED_P(c) MARKED_P (&((c)->lheader)) |
| 2182 #define MARK_CONS(c) MARK (&((c)->lheader)) | |
| 3263 | 2183 #else /* not NEW_GC */ |
| 428 | 2184 #define CONS_MARKED_P(c) MARKED_RECORD_HEADER_P(&((c)->lheader)) |
| 2185 #define MARK_CONS(c) MARK_RECORD_HEADER (&((c)->lheader)) | |
| 3263 | 2186 #endif /* not NEW_GC */ |
| 428 | 2187 |
| 1632 | 2188 extern MODULE_API Lisp_Object Qnil; |
| 428 | 2189 |
| 2190 #define NILP(x) EQ (x, Qnil) | |
| 853 | 2191 #define cons_car(a) ((a)->car_) |
| 2192 #define cons_cdr(a) ((a)->cdr_) | |
| 2193 #define XCAR(a) (XCONS (a)->car_) | |
| 2194 #define XCDR(a) (XCONS (a)->cdr_) | |
| 1318 | 2195 #define XCADR(a) (XCAR (XCDR (a))) |
| 2196 #define XCDDR(a) (XCDR (XCDR (a))) | |
| 2197 #define XCADDR(a) (XCAR (XCDDR (a))) | |
| 2198 #define XCDDDR(a) (XCDR (XCDDR (a))) | |
| 2199 #define XCADDDR(a) (XCAR (XCDDDR (a))) | |
| 2200 #define XCDDDDR(a) (XCDR (XCDDDR (a))) | |
| 2201 #define XCADDDDR(a) (XCAR (XCDDDDR (a))) | |
| 2202 #define XCDDDDDR(a) (XCDR (XCDDDDR (a))) | |
| 2203 #define XCADDDDDR(a) (XCAR (XCDDDDDR (a))) | |
| 2204 #define XCDDDDDDR(a) (XCDR (XCDDDDDR (a))) | |
| 2205 #define X1ST(a) XCAR (a) | |
| 2206 #define X2ND(a) XCADR (a) | |
| 2207 #define X3RD(a) XCADDR (a) | |
| 2208 #define X4TH(a) XCADDDR (a) | |
| 2209 #define X5TH(a) XCADDDDR (a) | |
| 2210 #define X6TH(a) XCADDDDDR (a) | |
| 2211 | |
| 853 | 2212 #define XSETCAR(a, b) (XCONS (a)->car_ = (b)) |
| 2213 #define XSETCDR(a, b) (XCONS (a)->cdr_ = (b)) | |
| 428 | 2214 #define LISTP(x) (CONSP(x) || NILP(x)) |
| 2215 | |
| 2216 #define CHECK_LIST(x) do { \ | |
| 2217 if (!LISTP (x)) \ | |
| 2218 dead_wrong_type_argument (Qlistp, x); \ | |
| 2219 } while (0) | |
| 2220 | |
| 2221 #define CONCHECK_LIST(x) do { \ | |
| 2222 if (!LISTP (x)) \ | |
| 2223 x = wrong_type_argument (Qlistp, x); \ | |
| 2224 } while (0) | |
| 2225 | |
| 442 | 2226 /*---------------------- list traversal macros -------------------------*/ |
| 2227 | |
| 2228 /* Note: These macros are for traversing through a list in some format, | |
| 2229 and executing code that you specify on each member of the list. | |
| 2230 | |
| 2231 There are two kinds of macros, those requiring surrounding braces, and | |
| 2232 those not requiring this. Which type of macro will be indicated. | |
| 2233 The general format for using a brace-requiring macro is | |
| 2234 | |
| 2235 { | |
| 2236 LIST_LOOP_3 (elt, list, tail) | |
| 2237 execute_code_here; | |
| 2238 } | |
| 2239 | |
| 2240 or | |
| 2241 | |
| 2242 { | |
| 2243 LIST_LOOP_3 (elt, list, tail) | |
| 2244 { | |
| 2245 execute_code_here; | |
| 2246 } | |
| 2247 } | |
| 2248 | |
| 2249 You can put variable declarations between the brace and beginning of | |
| 2250 macro, but NOTHING ELSE. | |
| 2251 | |
| 2252 The brace-requiring macros typically declare themselves any arguments | |
| 2253 that are initialized and iterated by the macros. If for some reason | |
| 2254 you need to declare these arguments yourself (e.g. to do something on | |
| 2255 them before the iteration starts, use the _NO_DECLARE versions of the | |
| 2256 macros.) | |
| 2257 */ | |
| 2258 | |
| 2259 /* There are two basic kinds of macros: those that handle "internal" lists | |
| 2260 that are known to be correctly structured (i.e. first element is a cons | |
| 2261 or nil, and the car of each cons is also a cons or nil, and there are | |
| 2262 no circularities), and those that handle "external" lists, where the | |
| 2263 list may have any sort of invalid formation. This is reflected in | |
| 2264 the names: those with "EXTERNAL_" work with external lists, and those | |
| 2265 without this prefix work with internal lists. The internal-list | |
| 2266 macros will hit an assertion failure if the structure is ill-formed; | |
| 2267 the external-list macros will signal an error in this case, either a | |
| 2268 malformed-list error or a circular-list error. | |
| 2269 */ | |
| 2270 | |
| 2367 | 2271 /* LIST_LOOP is a simple, old-fashioned macro. It doesn't require brace |
| 2272 surrounding, and iterates through a list, which may or may not known to | |
| 2273 be syntactically correct. It accepts two args, TAIL (set progressively | |
| 2274 to each cons starting with the first), and LIST, the list to iterate | |
| 2275 over. TAIL needs to be defined by the caller. | |
| 442 | 2276 |
| 2277 In each iteration, you can retrieve the current list item using XCAR | |
| 2278 (tail), or destructively modify the list using XSETCAR (tail, | |
| 2279 ...). */ | |
| 2280 | |
| 428 | 2281 #define LIST_LOOP(tail, list) \ |
| 2282 for (tail = list; \ | |
| 2283 !NILP (tail); \ | |
| 2284 tail = XCDR (tail)) | |
| 2285 | |
| 442 | 2286 /* The following macros are the "core" macros for list traversal. |
| 2287 | |
| 2288 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2289 | |
| 2290 LIST_LOOP_2 and EXTERNAL_LIST_LOOP_2 are the standard, most-often used | |
| 2291 macros. They take two arguments, an element variable ELT and the list | |
| 2292 LIST. ELT is automatically declared, and set to each element in turn | |
| 2293 from LIST. | |
| 2294 | |
| 2295 LIST_LOOP_3 and EXTERNAL_LIST_LOOP_3 are the same, but they have a third | |
| 2296 argument TAIL, another automatically-declared variable. At each iteration, | |
| 2297 this one points to the cons cell for which ELT is the car. | |
| 2298 | |
| 2299 EXTERNAL_LIST_LOOP_4 is like EXTERNAL_LIST_LOOP_3 but takes an additional | |
| 2300 LEN argument, again automatically declared, which counts the number of | |
| 2301 iterations gone by. It is 0 during the first iteration. | |
| 2302 | |
| 2303 EXTERNAL_LIST_LOOP_4_NO_DECLARE is like EXTERNAL_LIST_LOOP_4 but none | |
| 2304 of the variables are automatically declared, and so you need to declare | |
| 2305 them yourself. (ELT and TAIL are Lisp_Objects, and LEN is an EMACS_INT.) | |
| 2306 */ | |
| 2307 | |
| 2308 #define LIST_LOOP_2(elt, list) \ | |
| 2309 LIST_LOOP_3(elt, list, unused_tail_##elt) | |
| 2310 | |
| 2311 #define LIST_LOOP_3(elt, list, tail) \ | |
| 2312 Lisp_Object elt, tail; \ | |
| 2313 for (tail = list; \ | |
| 2314 NILP (tail) ? \ | |
| 2315 0 : (elt = XCAR (tail), 1); \ | |
| 2316 tail = XCDR (tail)) | |
| 428 | 2317 |
| 2318 /* The following macros are for traversing lisp lists. | |
| 2319 Signal an error if LIST is not properly acyclic and nil-terminated. | |
| 2320 | |
| 2321 Use tortoise/hare algorithm to check for cycles, but only if it | |
| 2322 looks like the list is getting too long. Not only is the hare | |
| 2323 faster than the tortoise; it even gets a head start! */ | |
| 2324 | |
| 2325 /* Optimized and safe macros for looping over external lists. */ | |
| 2326 #define CIRCULAR_LIST_SUSPICION_LENGTH 1024 | |
| 2327 | |
| 2328 #define EXTERNAL_LIST_LOOP_1(list) \ | |
| 2329 Lisp_Object ELL1_elt, ELL1_hare, ELL1_tortoise; \ | |
| 442 | 2330 EMACS_INT ELL1_len; \ |
| 2331 PRIVATE_EXTERNAL_LIST_LOOP_6 (ELL1_elt, list, ELL1_len, ELL1_hare, \ | |
| 428 | 2332 ELL1_tortoise, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2333 | |
| 2334 #define EXTERNAL_LIST_LOOP_2(elt, list) \ | |
| 442 | 2335 Lisp_Object elt, hare_##elt, tortoise_##elt; \ |
| 2336 EMACS_INT len_##elt; \ | |
| 2337 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ | |
| 428 | 2338 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2339 | |
| 2367 | 2340 |
| 2341 #define GC_EXTERNAL_LIST_LOOP_2(elt, list) \ | |
| 2342 do { \ | |
| 2343 XGCDECL3 (elt); \ | |
| 2344 Lisp_Object elt, hare_##elt, tortoise_##elt; \ | |
| 2345 EMACS_INT len_##elt; \ | |
| 2346 XGCPRO3 (elt, elt, hare_##elt, tortoise_##elt); \ | |
| 2347 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ | |
| 2348 tortoise_##elt, \ | |
| 2349 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2350 | |
| 2351 #define END_GC_EXTERNAL_LIST_LOOP(elt) \ | |
| 2352 XUNGCPRO (elt); \ | |
| 2353 } \ | |
| 2354 while (0) | |
| 2355 | |
| 428 | 2356 #define EXTERNAL_LIST_LOOP_3(elt, list, tail) \ |
| 442 | 2357 Lisp_Object elt, tail, tortoise_##elt; \ |
| 2358 EMACS_INT len_##elt; \ | |
| 2359 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, tail, \ | |
| 2360 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2361 | |
| 2362 #define EXTERNAL_LIST_LOOP_4_NO_DECLARE(elt, list, tail, len) \ | |
| 428 | 2363 Lisp_Object tortoise_##elt; \ |
| 442 | 2364 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail, \ |
| 428 | 2365 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2366 | |
| 2367 #define EXTERNAL_LIST_LOOP_4(elt, list, tail, len) \ | |
| 442 | 2368 Lisp_Object elt, tail, tortoise_##elt; \ |
| 2369 EMACS_INT len; \ | |
| 2370 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail, \ | |
| 428 | 2371 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2372 | |
| 2373 | |
| 444 | 2374 #define PRIVATE_EXTERNAL_LIST_LOOP_6(elt, list, len, hare, \ |
| 2375 tortoise, suspicion_length) \ | |
| 2376 for (tortoise = hare = list, len = 0; \ | |
| 2377 \ | |
| 2378 (CONSP (hare) ? ((elt = XCAR (hare)), 1) : \ | |
| 2379 (NILP (hare) ? 0 : \ | |
| 2380 (signal_malformed_list_error (list), 0))); \ | |
| 2381 \ | |
| 2382 hare = XCDR (hare), \ | |
| 2383 (void) \ | |
| 2384 ((++len > suspicion_length) \ | |
| 2385 && \ | |
| 2386 ((((len & 1) != 0) && (tortoise = XCDR (tortoise), 0)), \ | |
| 2387 (EQ (hare, tortoise) && (signal_circular_list_error (list), 0))))) | |
| 428 | 2388 |
| 442 | 2389 /* GET_LIST_LENGTH and GET_EXTERNAL_LIST_LENGTH: |
| 2390 | |
| 2391 These two macros return the length of LIST (either an internal or external | |
| 2392 list, according to which macro is used), stored into LEN (which must | |
| 2393 be declared by the caller). Circularities are trapped in external lists | |
| 2394 (and cause errors). Neither macro need be declared inside brackets. */ | |
| 2395 | |
| 2396 #define GET_LIST_LENGTH(list, len) do { \ | |
| 2397 Lisp_Object GLL_tail; \ | |
| 2398 for (GLL_tail = list, len = 0; \ | |
| 2399 !NILP (GLL_tail); \ | |
| 2400 GLL_tail = XCDR (GLL_tail), ++len) \ | |
| 2401 DO_NOTHING; \ | |
| 2402 } while (0) | |
| 2403 | |
| 2404 #define GET_EXTERNAL_LIST_LENGTH(list, len) \ | |
| 2405 do { \ | |
| 2406 Lisp_Object GELL_elt, GELL_tail; \ | |
| 2407 EXTERNAL_LIST_LOOP_4_NO_DECLARE (GELL_elt, list, GELL_tail, len) \ | |
| 2408 ; \ | |
| 2409 } while (0) | |
| 2410 | |
| 2411 /* For a list that's known to be in valid list format, where we may | |
| 2412 be deleting the current element out of the list -- | |
| 2500 | 2413 will ABORT() if the list is not in valid format */ |
| 442 | 2414 #define LIST_LOOP_DELETING(consvar, nextconsvar, list) \ |
| 2415 for (consvar = list; \ | |
| 2416 !NILP (consvar) ? (nextconsvar = XCDR (consvar), 1) :0; \ | |
| 2417 consvar = nextconsvar) | |
| 2418 | |
| 2419 /* LIST_LOOP_DELETE_IF and EXTERNAL_LIST_LOOP_DELETE_IF: | |
| 2420 | |
| 2421 These two macros delete all elements of LIST (either an internal or | |
| 2422 external list, according to which macro is used) satisfying | |
| 2423 CONDITION, a C expression referring to variable ELT. ELT is | |
| 2424 automatically declared. Circularities are trapped in external | |
| 2425 lists (and cause errors). Neither macro need be declared inside | |
| 2426 brackets. */ | |
| 2427 | |
| 2428 #define LIST_LOOP_DELETE_IF(elt, list, condition) do { \ | |
| 2429 /* Do not use ##list when creating new variables because \ | |
| 2430 that may not be just a variable name. */ \ | |
| 2431 Lisp_Object prev_tail_##elt = Qnil; \ | |
| 2432 LIST_LOOP_3 (elt, list, tail_##elt) \ | |
| 2433 { \ | |
| 2434 if (condition) \ | |
| 2435 { \ | |
| 2436 if (NILP (prev_tail_##elt)) \ | |
| 2437 list = XCDR (tail_##elt); \ | |
| 2438 else \ | |
| 2439 XCDR (prev_tail_##elt) = XCDR (tail_##elt); \ | |
| 2440 } \ | |
| 2441 else \ | |
| 2442 prev_tail_##elt = tail_##elt; \ | |
| 2443 } \ | |
| 2444 } while (0) | |
| 2445 | |
| 2446 #define EXTERNAL_LIST_LOOP_DELETE_IF(elt, list, condition) do { \ | |
| 2447 Lisp_Object prev_tail_##elt = Qnil; \ | |
| 2448 EXTERNAL_LIST_LOOP_4 (elt, list, tail_##elt, len_##elt) \ | |
| 2449 { \ | |
| 2450 if (condition) \ | |
| 2451 { \ | |
| 2452 if (NILP (prev_tail_##elt)) \ | |
| 2453 list = XCDR (tail_##elt); \ | |
| 2454 else \ | |
| 2455 XCDR (prev_tail_##elt) = XCDR (tail_##elt); \ | |
| 2456 /* Keep tortoise from ever passing hare. */ \ | |
| 2457 len_##elt = 0; \ | |
| 2458 } \ | |
| 2459 else \ | |
| 2460 prev_tail_##elt = tail_##elt; \ | |
| 2461 } \ | |
| 2462 } while (0) | |
| 2463 | |
| 2464 | |
| 1204 | 2465 /* Macros for looping over internal alists. |
| 2466 | |
| 2467 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2468 | |
| 2469 ALIST_LOOP_3 loops over an alist, at each iteration setting CAR and CDR | |
| 2470 to the car and cdr of the acons. CAR and CDR are automatically | |
| 2471 declared. | |
| 2472 | |
| 2473 ALIST_LOOP_4 is similar to ALIST_LOOP_3 but contains an additional | |
| 2474 variable ACONS at the beginning for access to the acons itself.All of | |
| 2475 the variables ACONS, CAR and CDR are automatically declared. | |
| 2476 */ | |
| 2477 | |
| 2478 #define ALIST_LOOP_3(car, cdr, alist) \ | |
| 2479 Lisp_Object _al3_acons_##car, car, cdr, _al3_tail_##car; \ | |
| 2480 for (_al3_tail_##car = alist; \ | |
| 2481 NILP (_al3_tail_##car) ? \ | |
| 2482 0 : (_al3_acons_##car = XCAR (_al3_tail_##car), \ | |
| 2483 car = XCAR (_al3_acons_##car), \ | |
| 2484 cdr = XCDR (_al3_acons_##car), 1); \ | |
| 2485 _al3_tail_##car = XCDR (_al3_tail_##car)) | |
| 2486 | |
| 2487 #define ALIST_LOOP_4(acons, car, cdr, list) \ | |
| 2488 Lisp_Object acons, car, cdr, _al4_tail_##car; \ | |
| 2489 for (_al4_tail_##car = list; \ | |
| 2490 NILP (_al4_tail_##car) ? \ | |
| 2491 0 : (elt = XCAR (_al4_tail_##car), car = XCAR (elt), \ | |
| 2492 cdr = XCDR (elt), 1); \ | |
| 2493 _al4_tail_##car = XCDR (tail)) | |
| 2494 | |
| 442 | 2495 /* Macros for looping over external alists. |
| 2496 | |
| 2497 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2498 | |
| 2499 EXTERNAL_ALIST_LOOP_4 is similar to EXTERNAL_LIST_LOOP_2, but it | |
| 2500 assumes the elements are aconses (the elements in an alist) and | |
| 2501 sets two additional argument variables ELT_CAR and ELT_CDR to the | |
| 2502 car and cdr of the acons. All of the variables ELT, ELT_CAR and | |
| 2503 ELT_CDR are automatically declared. | |
| 2504 | |
| 2505 EXTERNAL_ALIST_LOOP_5 adds a TAIL argument to EXTERNAL_ALIST_LOOP_4, | |
| 2506 just like EXTERNAL_LIST_LOOP_3 does, and again TAIL is automatically | |
| 2507 declared. | |
| 2508 | |
| 2509 EXTERNAL_ALIST_LOOP_6 adds a LEN argument to EXTERNAL_ALIST_LOOP_5, | |
| 2510 just like EXTERNAL_LIST_LOOP_4 does, and again LEN is automatically | |
| 2511 declared. | |
| 2512 | |
| 2513 EXTERNAL_ALIST_LOOP_6_NO_DECLARE does not declare any of its arguments, | |
| 2514 just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these must be declared | |
| 2515 manually. | |
| 2516 */ | |
| 428 | 2517 |
| 2518 /* Optimized and safe macros for looping over external alists. */ | |
| 2519 #define EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, list) \ | |
| 442 | 2520 Lisp_Object elt, elt_car, elt_cdr; \ |
| 428 | 2521 Lisp_Object hare_##elt, tortoise_##elt; \ |
| 2522 EMACS_INT len_##elt; \ | |
| 442 | 2523 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2524 len_##elt, hare_##elt, tortoise_##elt, \ |
| 2525 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2526 | |
| 2527 #define EXTERNAL_ALIST_LOOP_5(elt, elt_car, elt_cdr, list, tail) \ | |
| 442 | 2528 Lisp_Object elt, elt_car, elt_cdr, tail; \ |
| 428 | 2529 Lisp_Object tortoise_##elt; \ |
| 2530 EMACS_INT len_##elt; \ | |
| 442 | 2531 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2532 len_##elt, tail, tortoise_##elt, \ |
| 2533 CIRCULAR_LIST_SUSPICION_LENGTH) \ | |
| 2534 | |
| 2535 #define EXTERNAL_ALIST_LOOP_6(elt, elt_car, elt_cdr, list, tail, len) \ | |
| 442 | 2536 Lisp_Object elt, elt_car, elt_cdr, tail; \ |
| 2537 EMACS_INT len; \ | |
| 428 | 2538 Lisp_Object tortoise_##elt; \ |
| 442 | 2539 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2540 len, tail, tortoise_##elt, \ |
| 2541 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2542 | |
| 442 | 2543 #define EXTERNAL_ALIST_LOOP_6_NO_DECLARE(elt, elt_car, elt_cdr, list, \ |
| 2544 tail, len) \ | |
| 2545 Lisp_Object tortoise_##elt; \ | |
| 2546 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ | |
| 2547 len, tail, tortoise_##elt, \ | |
| 2548 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2549 | |
| 2550 | |
| 2551 #define PRIVATE_EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list, len, \ | |
| 2552 hare, tortoise, suspicion_length) \ | |
| 2553 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, hare, tortoise, \ | |
| 2554 suspicion_length) \ | |
| 428 | 2555 if (CONSP (elt) ? (elt_car = XCAR (elt), elt_cdr = XCDR (elt), 0) :1) \ |
| 2556 continue; \ | |
| 2557 else | |
| 2558 | |
| 442 | 2559 /* Macros for looping over external property lists. |
| 2560 | |
| 2561 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2562 | |
| 2563 EXTERNAL_PROPERTY_LIST_LOOP_3 maps over an external list assumed to | |
| 2564 be a property list, consisting of alternating pairs of keys | |
| 2565 (typically symbols or keywords) and values. Each iteration | |
| 2566 processes one such pair out of LIST, assigning the two elements to | |
| 2567 KEY and VALUE respectively. Malformed lists and circularities are | |
| 2568 trapped as usual, and in addition, property lists with an odd number | |
| 2569 of elements also signal an error. | |
| 2570 | |
| 2571 EXTERNAL_PROPERTY_LIST_LOOP_4 adds a TAIL argument to | |
| 2572 EXTERNAL_PROPERTY_LIST_LOOP_3, just like EXTERNAL_LIST_LOOP_3 does, | |
| 2573 and again TAIL is automatically declared. | |
| 2574 | |
| 2575 EXTERNAL_PROPERTY_LIST_LOOP_5 adds a LEN argument to | |
| 2576 EXTERNAL_PROPERTY_LIST_LOOP_4, just like EXTERNAL_LIST_LOOP_4 does, | |
| 2577 and again LEN is automatically declared. Note that in this case, | |
| 2578 LEN counts the iterations, NOT the total number of list elements | |
| 2579 processed, which is 2 * LEN. | |
| 2580 | |
| 2581 EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE does not declare any of its | |
| 2582 arguments, just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these | |
| 2583 must be declared manually. */ | |
| 428 | 2584 |
| 2585 /* Optimized and safe macros for looping over external property lists. */ | |
| 2586 #define EXTERNAL_PROPERTY_LIST_LOOP_3(key, value, list) \ | |
| 2587 Lisp_Object key, value, hare_##key, tortoise_##key; \ | |
| 442 | 2588 EMACS_INT len_##key; \ |
| 428 | 2589 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, hare_##key, \ |
| 2590 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2591 | |
| 2592 #define EXTERNAL_PROPERTY_LIST_LOOP_4(key, value, list, tail) \ | |
| 2593 Lisp_Object key, value, tail, tortoise_##key; \ | |
| 442 | 2594 EMACS_INT len_##key; \ |
| 428 | 2595 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, tail, \ |
| 2596 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2597 | |
| 2598 #define EXTERNAL_PROPERTY_LIST_LOOP_5(key, value, list, tail, len) \ | |
| 2599 Lisp_Object key, value, tail, tortoise_##key; \ | |
| 2600 EMACS_INT len; \ | |
| 2601 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail, \ | |
| 2602 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2603 | |
| 442 | 2604 #define EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE(key, value, list, \ |
| 2605 tail, len) \ | |
| 2606 Lisp_Object tortoise_##key; \ | |
| 2607 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail, \ | |
| 2608 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2609 | |
| 428 | 2610 |
| 2611 #define EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len, hare, \ | |
| 2612 tortoise, suspicion_length) \ | |
| 2613 for (tortoise = hare = list, len = 0; \ | |
| 2614 \ | |
| 2615 ((CONSP (hare) && \ | |
| 2616 (key = XCAR (hare), \ | |
| 2617 hare = XCDR (hare), \ | |
| 442 | 2618 (CONSP (hare) ? 1 : \ |
| 2619 (signal_malformed_property_list_error (list), 0)))) ? \ | |
| 428 | 2620 (value = XCAR (hare), 1) : \ |
| 2621 (NILP (hare) ? 0 : \ | |
| 2622 (signal_malformed_property_list_error (list), 0))); \ | |
| 2623 \ | |
| 2624 hare = XCDR (hare), \ | |
| 2625 ((++len < suspicion_length) ? \ | |
| 2626 ((void) 0) : \ | |
| 2627 (((len & 1) ? \ | |
| 2628 ((void) (tortoise = XCDR (XCDR (tortoise)))) : \ | |
| 2629 ((void) 0)) \ | |
| 2630 , \ | |
| 2631 (EQ (hare, tortoise) ? \ | |
| 2632 ((void) signal_circular_property_list_error (list)) : \ | |
| 2633 ((void) 0))))) | |
| 2634 | |
| 2421 | 2635 #define PRIVATE_PROPERTY_LIST_LOOP_4(tail, key, value, plist) \ |
| 2636 for (tail = plist; \ | |
| 2637 NILP (tail) ? 0 : \ | |
| 2638 (key = XCAR (tail), tail = XCDR (tail), \ | |
| 2639 value = XCAR (tail), tail = XCDR (tail), 1); \ | |
| 428 | 2640 ) |
| 2641 | |
| 2421 | 2642 #define PROPERTY_LIST_LOOP_3(key, value, plist) \ |
| 2643 Lisp_Object key, value, tail_##key; \ | |
| 2644 PRIVATE_PROPERTY_LIST_LOOP_4 (tail_##key, key, value, plist) | |
| 2645 | |
| 2646 #define GC_PROPERTY_LIST_LOOP_3(key, value, plist) \ | |
| 2647 do { \ | |
| 2648 XGCDECL3 (key); \ | |
| 2649 Lisp_Object key, value, tail_##key; \ | |
| 2650 XGCPRO3 (key, key, value, tail_##key); \ | |
| 2651 PRIVATE_PROPERTY_LIST_LOOP_4 (tail_##key, key, value, plist) | |
| 2652 | |
| 2653 #define END_GC_PROPERTY_LIST_LOOP(key) \ | |
| 2654 XUNGCPRO (key); \ | |
| 2655 } \ | |
| 2656 while (0) | |
| 2657 | |
| 428 | 2658 /* Return 1 if LIST is properly acyclic and nil-terminated, else 0. */ |
| 826 | 2659 DECLARE_INLINE_HEADER ( |
| 2660 int | |
| 428 | 2661 TRUE_LIST_P (Lisp_Object object) |
| 826 | 2662 ) |
| 428 | 2663 { |
| 2664 Lisp_Object hare, tortoise; | |
| 2665 EMACS_INT len; | |
| 2666 | |
| 2667 for (hare = tortoise = object, len = 0; | |
| 2668 CONSP (hare); | |
| 2669 hare = XCDR (hare), len++) | |
| 2670 { | |
| 2671 if (len < CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2672 continue; | |
| 2673 | |
| 2674 if (len & 1) | |
| 2675 tortoise = XCDR (tortoise); | |
| 2676 else if (EQ (hare, tortoise)) | |
| 2677 return 0; | |
| 2678 } | |
| 2679 | |
| 2680 return NILP (hare); | |
| 2681 } | |
| 2682 | |
| 2683 /* Signal an error if LIST is not properly acyclic and nil-terminated. */ | |
| 2684 #define CHECK_TRUE_LIST(list) do { \ | |
| 2685 Lisp_Object CTL_list = (list); \ | |
| 2686 Lisp_Object CTL_hare, CTL_tortoise; \ | |
| 436 | 2687 EMACS_INT CTL_len; \ |
| 428 | 2688 \ |
| 2689 for (CTL_hare = CTL_tortoise = CTL_list, CTL_len = 0; \ | |
| 2690 CONSP (CTL_hare); \ | |
| 2691 CTL_hare = XCDR (CTL_hare), CTL_len++) \ | |
| 2692 { \ | |
| 2693 if (CTL_len < CIRCULAR_LIST_SUSPICION_LENGTH) \ | |
| 2694 continue; \ | |
| 2695 \ | |
| 2696 if (CTL_len & 1) \ | |
| 2697 CTL_tortoise = XCDR (CTL_tortoise); \ | |
| 2698 else if (EQ (CTL_hare, CTL_tortoise)) \ | |
| 2699 Fsignal (Qcircular_list, list1 (CTL_list)); \ | |
| 2700 } \ | |
| 2701 \ | |
| 2702 if (! NILP (CTL_hare)) \ | |
| 2703 signal_malformed_list_error (CTL_list); \ | |
| 2704 } while (0) | |
| 2705 | |
| 442 | 2706 /*------------------------------ string --------------------------------*/ |
| 428 | 2707 |
| 3092 | 2708 #ifdef NEW_GC |
| 2709 struct Lisp_String_Direct_Data | |
| 2710 { | |
| 2711 struct lrecord_header header; | |
| 2712 Bytecount size; | |
| 2713 Ibyte data[1]; | |
| 2714 }; | |
| 2715 typedef struct Lisp_String_Direct_Data Lisp_String_Direct_Data; | |
| 2716 | |
| 2717 DECLARE_MODULE_API_LRECORD (string_direct_data, Lisp_String_Direct_Data); | |
| 2718 #define XSTRING_DIRECT_DATA(x) \ | |
| 2719 XRECORD (x, string_direct_data, Lisp_String_Direct_Data) | |
| 2720 #define wrap_string_direct_data(p) wrap_record (p, string_direct_data) | |
| 2721 #define STRING_DIRECT_DATAP(x) RECORDP (x, string_direct_data) | |
| 2722 #define CHECK_STRING_DIRECT_DATA(x) CHECK_RECORD (x, string_direct_data) | |
| 2723 #define CONCHECK_STRING_DIRECT_DATA(x) CONCHECK_RECORD (x, string_direct_data) | |
| 2724 | |
| 2725 #define XSTRING_DIRECT_DATA_SIZE(x) XSTRING_DIRECT_DATA (x)->size | |
| 2726 #define XSTRING_DIRECT_DATA_DATA(x) XSTRING_DIRECT_DATA (x)->data | |
| 2727 | |
| 2728 | |
| 2729 struct Lisp_String_Indirect_Data | |
| 2730 { | |
| 2731 struct lrecord_header header; | |
| 2732 Bytecount size; | |
| 2733 Ibyte *data; | |
| 2734 }; | |
| 2735 typedef struct Lisp_String_Indirect_Data Lisp_String_Indirect_Data; | |
| 2736 | |
| 2737 DECLARE_MODULE_API_LRECORD (string_indirect_data, Lisp_String_Indirect_Data); | |
| 2738 #define XSTRING_INDIRECT_DATA(x) \ | |
| 2739 XRECORD (x, string_indirect_data, Lisp_String_Indirect_Data) | |
| 2740 #define wrap_string_indirect_data(p) wrap_record (p, string_indirect_data) | |
| 2741 #define STRING_INDIRECT_DATAP(x) RECORDP (x, string_indirect_data) | |
| 2742 #define CHECK_STRING_INDIRECT_DATA(x) CHECK_RECORD (x, string_indirect_data) | |
| 2743 #define CONCHECK_STRING_INDIRECT_DATA(x) \ | |
| 2744 CONCHECK_RECORD (x, string_indirect_data) | |
| 2745 | |
| 2746 #define XSTRING_INDIRECT_DATA_SIZE(x) XSTRING_INDIRECT_DATA (x)->size | |
| 2747 #define XSTRING_INDIRECT_DATA_DATA(x) XSTRING_INDIRECT_DATA (x)->data | |
| 2748 | |
| 2749 | |
| 2750 #define XSTRING_DATA_SIZE(s) ((s)->indirect)? \ | |
| 2751 XSTRING_INDIRECT_DATA_SIZE ((s)->data_object): \ | |
| 2752 XSTRING_DIRECT_DATA_SIZE ((s)->data_object) | |
| 2753 #define XSTRING_DATA_DATA(s) ((s)->indirect)? \ | |
| 2754 XSTRING_INDIRECT_DATA_DATA ((s)->data_object): \ | |
| 2755 XSTRING_DIRECT_DATA_DATA ((s)->data_object) | |
| 2756 | |
| 2757 #define XSET_STRING_DATA_SIZE(s, len) \ | |
| 2758 if ((s)->indirect) \ | |
| 2759 XSTRING_INDIRECT_DATA_SIZE ((s)->data_object) = len; \ | |
| 2760 else \ | |
| 2761 XSTRING_DIRECT_DATA_SIZE ((s)->data_object) = len | |
| 2762 #define XSET_STRING_DATA_DATA(s, ptr) \ | |
| 2763 if ((s)->indirect) \ | |
| 2764 XSTRING_INDIRECT_DATA_DATA ((s)->data_object) = ptr; \ | |
| 2765 else \ | |
| 2766 XSTRING_DIRECT_DATA_DATA ((s)->data_object) = ptr | |
| 2767 #endif /* NEW_GC */ | |
| 2768 | |
| 428 | 2769 struct Lisp_String |
| 2770 { | |
| 771 | 2771 union |
| 2772 { | |
| 2773 struct lrecord_header lheader; | |
| 2774 struct | |
| 2775 { | |
| 2776 /* WARNING: Everything before ascii_begin must agree exactly with | |
| 2777 struct lrecord_header */ | |
| 2778 unsigned int type :8; | |
| 3263 | 2779 #ifdef NEW_GC |
| 2720 | 2780 unsigned int lisp_readonly :1; |
| 2781 unsigned int free :1; | |
| 2782 /* Number of chars at beginning of string that are one byte in length | |
| 2783 (byte_ascii_p) */ | |
| 2784 unsigned int ascii_begin :22; | |
| 3263 | 2785 #else /* not NEW_GC */ |
| 771 | 2786 unsigned int mark :1; |
| 2787 unsigned int c_readonly :1; | |
| 2788 unsigned int lisp_readonly :1; | |
| 2789 /* Number of chars at beginning of string that are one byte in length | |
| 826 | 2790 (byte_ascii_p) */ |
| 771 | 2791 unsigned int ascii_begin :21; |
| 3263 | 2792 #endif /* not NEW_GC */ |
| 771 | 2793 } v; |
| 2794 } u; | |
| 3092 | 2795 #ifdef NEW_GC |
| 2796 int indirect; | |
| 2797 Lisp_Object data_object; | |
| 2798 #else /* not NEW_GC */ | |
| 793 | 2799 Bytecount size_; |
| 867 | 2800 Ibyte *data_; |
| 3092 | 2801 #endif /* not NEW_GC */ |
| 428 | 2802 Lisp_Object plist; |
| 2803 }; | |
| 2804 typedef struct Lisp_String Lisp_String; | |
| 2805 | |
| 3263 | 2806 #ifdef NEW_GC |
| 3063 | 2807 #define MAX_STRING_ASCII_BEGIN ((1 << 22) - 1) |
| 3263 | 2808 #else /* not NEW_GC */ |
| 851 | 2809 #define MAX_STRING_ASCII_BEGIN ((1 << 21) - 1) |
| 3263 | 2810 #endif /* not NEW_GC */ |
| 771 | 2811 |
| 1632 | 2812 DECLARE_MODULE_API_LRECORD (string, Lisp_String); |
| 428 | 2813 #define XSTRING(x) XRECORD (x, string, Lisp_String) |
| 617 | 2814 #define wrap_string(p) wrap_record (p, string) |
| 428 | 2815 #define STRINGP(x) RECORDP (x, string) |
| 2816 #define CHECK_STRING(x) CHECK_RECORD (x, string) | |
| 2817 #define CONCHECK_STRING(x) CONCHECK_RECORD (x, string) | |
| 2818 | |
| 826 | 2819 /* Most basic macros for strings -- basically just accessing or setting |
| 2820 fields -- are here. Everything else is in text.h, since they depend on | |
| 2821 stuff there. */ | |
| 428 | 2822 |
| 793 | 2823 /* Operations on Lisp_String *'s; only ones left */ |
| 3092 | 2824 #ifdef NEW_GC |
| 3304 | 2825 #define set_lispstringp_direct(s) ((s)->indirect = 0) |
| 3092 | 2826 #define set_lispstringp_indirect(s) ((s)->indirect = 1) |
| 2827 #define set_lispstringp_length(s, len) XSET_STRING_DATA_SIZE (s, len) | |
| 2828 #define set_lispstringp_data(s, ptr) XSET_STRING_DATA_DATA (s, ptr) | |
| 2829 #else /* not NEW_GC */ | |
| 826 | 2830 #define set_lispstringp_length(s, len) ((void) ((s)->size_ = (len))) |
| 2831 #define set_lispstringp_data(s, ptr) ((void) ((s)->data_ = (ptr))) | |
| 3092 | 2832 #endif /* not NEW_GC */ |
| 826 | 2833 |
| 2834 /* Operations on strings as Lisp_Objects. Don't manipulate Lisp_String *'s | |
| 2835 in any new code. */ | |
| 3092 | 2836 #ifdef NEW_GC |
| 2837 #define STRING_DATA_OBJECT(s) ((s)->data_object) | |
| 2838 #define XSTRING_DATA_OBJECT(s) (STRING_DATA_OBJECT (XSTRING (s))) | |
| 2839 #define XSTRING_LENGTH(s) (XSTRING_DATA_SIZE (XSTRING (s))) | |
| 2840 #else /* not NEW_GC */ | |
| 793 | 2841 #define XSTRING_LENGTH(s) (XSTRING (s)->size_) |
| 3092 | 2842 #endif /* not NEW_GC */ |
| 793 | 2843 #define XSTRING_PLIST(s) (XSTRING (s)->plist) |
| 3092 | 2844 #ifdef NEW_GC |
| 2845 #define XSTRING_DATA(s) (XSTRING_DATA_DATA (XSTRING (s))) | |
| 2846 #else /* not NEW_GC */ | |
| 793 | 2847 #define XSTRING_DATA(s) (XSTRING (s)->data_ + 0) |
| 3092 | 2848 #endif /* not NEW_GC */ |
| 793 | 2849 #define XSTRING_ASCII_BEGIN(s) (XSTRING (s)->u.v.ascii_begin + 0) |
| 826 | 2850 #define XSET_STRING_LENGTH(s, ptr) set_lispstringp_length (XSTRING (s), ptr) |
| 2851 #define XSET_STRING_DATA(s, ptr) set_lispstringp_data (XSTRING (s), ptr) | |
| 771 | 2852 /* WARNING: If you modify an existing string, you must call |
| 2853 bump_string_modiff() afterwards. */ | |
| 793 | 2854 #define XSET_STRING_ASCII_BEGIN(s, val) \ |
| 2855 ((void) (XSTRING (s)->u.v.ascii_begin = (val))) | |
| 826 | 2856 #define XSTRING_FORMAT(s) FORMAT_DEFAULT |
| 428 | 2857 |
| 456 | 2858 /* Return the true aligned size of a struct whose last member is a |
| 2859 variable-length array field. (this is known as the "struct hack") */ | |
| 2860 /* Implementation: in practice, structtype and fieldtype usually have | |
| 2861 the same alignment, but we can't be sure. We need to use | |
| 2862 ALIGN_SIZE to be absolutely sure of getting the correct alignment. | |
| 2863 To help the compiler's optimizer, we use a ternary expression that | |
| 2864 only a very stupid compiler would fail to correctly simplify. */ | |
| 2865 #define FLEXIBLE_ARRAY_STRUCT_SIZEOF(structtype, \ | |
| 2866 fieldtype, \ | |
| 2867 fieldname, \ | |
| 2868 array_length) \ | |
| 2869 (ALIGNOF (structtype) == ALIGNOF (fieldtype) \ | |
| 2870 ? (offsetof (structtype, fieldname) + \ | |
| 2871 (offsetof (structtype, fieldname[1]) - \ | |
| 2872 offsetof (structtype, fieldname[0])) * \ | |
| 2873 (array_length)) \ | |
| 826 | 2874 : (ALIGN_FOR_TYPE \ |
| 456 | 2875 ((offsetof (structtype, fieldname) + \ |
| 2876 (offsetof (structtype, fieldname[1]) - \ | |
| 2877 offsetof (structtype, fieldname[0])) * \ | |
| 2878 (array_length)), \ | |
| 826 | 2879 structtype))) |
| 442 | 2880 |
| 2881 /*------------------------------ vector --------------------------------*/ | |
| 428 | 2882 |
| 2883 struct Lisp_Vector | |
| 2884 { | |
| 3017 | 2885 struct LCRECORD_HEADER header; |
| 428 | 2886 long size; |
| 2887 Lisp_Object contents[1]; | |
| 2888 }; | |
| 2889 typedef struct Lisp_Vector Lisp_Vector; | |
| 2890 | |
| 2891 DECLARE_LRECORD (vector, Lisp_Vector); | |
| 2892 #define XVECTOR(x) XRECORD (x, vector, Lisp_Vector) | |
| 617 | 2893 #define wrap_vector(p) wrap_record (p, vector) |
| 428 | 2894 #define VECTORP(x) RECORDP (x, vector) |
| 2895 #define CHECK_VECTOR(x) CHECK_RECORD (x, vector) | |
| 2896 #define CONCHECK_VECTOR(x) CONCHECK_RECORD (x, vector) | |
| 2897 | |
| 2898 #define vector_length(v) ((v)->size) | |
| 2899 #define XVECTOR_LENGTH(s) vector_length (XVECTOR (s)) | |
| 2900 #define vector_data(v) ((v)->contents) | |
| 2901 #define XVECTOR_DATA(s) vector_data (XVECTOR (s)) | |
| 2902 | |
| 442 | 2903 /*---------------------------- bit vectors -----------------------------*/ |
| 428 | 2904 |
| 2905 #if (LONGBITS < 16) | |
| 2906 #error What the hell?! | |
| 2907 #elif (LONGBITS < 32) | |
| 2908 # define LONGBITS_LOG2 4 | |
| 2909 # define LONGBITS_POWER_OF_2 16 | |
| 2910 #elif (LONGBITS < 64) | |
| 2911 # define LONGBITS_LOG2 5 | |
| 2912 # define LONGBITS_POWER_OF_2 32 | |
| 2913 #elif (LONGBITS < 128) | |
| 2914 # define LONGBITS_LOG2 6 | |
| 2915 # define LONGBITS_POWER_OF_2 64 | |
| 2916 #else | |
| 2917 #error You really have 128-bit integers?! | |
| 2918 #endif | |
| 2919 | |
| 2920 struct Lisp_Bit_Vector | |
| 2921 { | |
| 3017 | 2922 struct LCRECORD_HEADER lheader; |
| 665 | 2923 Elemcount size; |
| 428 | 2924 unsigned long bits[1]; |
| 2925 }; | |
| 2926 typedef struct Lisp_Bit_Vector Lisp_Bit_Vector; | |
| 2927 | |
| 2928 DECLARE_LRECORD (bit_vector, Lisp_Bit_Vector); | |
| 2929 #define XBIT_VECTOR(x) XRECORD (x, bit_vector, Lisp_Bit_Vector) | |
| 617 | 2930 #define wrap_bit_vector(p) wrap_record (p, bit_vector) |
| 428 | 2931 #define BIT_VECTORP(x) RECORDP (x, bit_vector) |
| 2932 #define CHECK_BIT_VECTOR(x) CHECK_RECORD (x, bit_vector) | |
| 2933 #define CONCHECK_BIT_VECTOR(x) CONCHECK_RECORD (x, bit_vector) | |
| 2934 | |
| 2935 #define BITP(x) (INTP (x) && (XINT (x) == 0 || XINT (x) == 1)) | |
| 2936 | |
| 2937 #define CHECK_BIT(x) do { \ | |
| 2938 if (!BITP (x)) \ | |
| 2939 dead_wrong_type_argument (Qbitp, x);\ | |
| 2940 } while (0) | |
| 2941 | |
| 2942 #define CONCHECK_BIT(x) do { \ | |
| 2943 if (!BITP (x)) \ | |
| 2944 x = wrong_type_argument (Qbitp, x); \ | |
| 2945 } while (0) | |
| 2946 | |
| 2947 #define bit_vector_length(v) ((v)->size) | |
| 2948 | |
| 826 | 2949 DECLARE_INLINE_HEADER ( |
| 2950 int | |
| 665 | 2951 bit_vector_bit (Lisp_Bit_Vector *v, Elemcount n) |
| 826 | 2952 ) |
| 428 | 2953 { |
| 2954 return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1))) | |
| 2955 & 1); | |
| 2956 } | |
| 2957 | |
| 826 | 2958 DECLARE_INLINE_HEADER ( |
| 2959 void | |
| 665 | 2960 set_bit_vector_bit (Lisp_Bit_Vector *v, Elemcount n, int value) |
| 826 | 2961 ) |
| 428 | 2962 { |
| 2963 if (value) | |
| 2964 v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1))); | |
| 2965 else | |
| 2966 v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1))); | |
| 2967 } | |
| 2968 | |
| 2969 /* Number of longs required to hold LEN bits */ | |
| 2970 #define BIT_VECTOR_LONG_STORAGE(len) \ | |
| 2971 (((len) + LONGBITS_POWER_OF_2 - 1) >> LONGBITS_LOG2) | |
| 2972 | |
| 3659 | 2973 /* For when we want to include a bit vector in another structure, and we |
| 2974 know it's of a fixed size. */ | |
| 2975 #define DECLARE_INLINE_LISP_BIT_VECTOR(numbits) struct { \ | |
| 2976 struct LCRECORD_HEADER lheader; \ | |
| 2977 Elemcount size; \ | |
| 2978 unsigned long bits[BIT_VECTOR_LONG_STORAGE(numbits)]; \ | |
| 2979 } | |
| 853 | 2980 |
| 442 | 2981 /*------------------------------ symbol --------------------------------*/ |
| 428 | 2982 |
| 440 | 2983 typedef struct Lisp_Symbol Lisp_Symbol; |
| 428 | 2984 struct Lisp_Symbol |
| 2985 { | |
| 2986 struct lrecord_header lheader; | |
| 2987 /* next symbol in this obarray bucket */ | |
| 440 | 2988 Lisp_Symbol *next; |
| 793 | 2989 Lisp_Object name; |
| 428 | 2990 Lisp_Object value; |
| 2991 Lisp_Object function; | |
| 2992 Lisp_Object plist; | |
| 2993 }; | |
| 2994 | |
| 2995 #define SYMBOL_IS_KEYWORD(sym) \ | |
| 826 | 2996 ((string_byte (symbol_name (XSYMBOL (sym)), 0) == ':') \ |
| 428 | 2997 && EQ (sym, oblookup (Vobarray, \ |
| 793 | 2998 XSTRING_DATA (symbol_name (XSYMBOL (sym))), \ |
| 2999 XSTRING_LENGTH (symbol_name (XSYMBOL (sym)))))) | |
| 428 | 3000 #define KEYWORDP(obj) (SYMBOLP (obj) && SYMBOL_IS_KEYWORD (obj)) |
| 3001 | |
| 1632 | 3002 DECLARE_MODULE_API_LRECORD (symbol, Lisp_Symbol); |
| 428 | 3003 #define XSYMBOL(x) XRECORD (x, symbol, Lisp_Symbol) |
| 617 | 3004 #define wrap_symbol(p) wrap_record (p, symbol) |
| 428 | 3005 #define SYMBOLP(x) RECORDP (x, symbol) |
| 3006 #define CHECK_SYMBOL(x) CHECK_RECORD (x, symbol) | |
| 3007 #define CONCHECK_SYMBOL(x) CONCHECK_RECORD (x, symbol) | |
| 3008 | |
| 3009 #define symbol_next(s) ((s)->next) | |
| 3010 #define symbol_name(s) ((s)->name) | |
| 3011 #define symbol_value(s) ((s)->value) | |
| 3012 #define symbol_function(s) ((s)->function) | |
| 3013 #define symbol_plist(s) ((s)->plist) | |
| 3014 | |
| 793 | 3015 #define XSYMBOL_NEXT(s) (XSYMBOL (s)->next) |
| 3016 #define XSYMBOL_NAME(s) (XSYMBOL (s)->name) | |
| 3017 #define XSYMBOL_VALUE(s) (XSYMBOL (s)->value) | |
| 3018 #define XSYMBOL_FUNCTION(s) (XSYMBOL (s)->function) | |
| 3019 #define XSYMBOL_PLIST(s) (XSYMBOL (s)->plist) | |
| 3020 | |
| 3021 | |
| 442 | 3022 /*------------------------------- subr ---------------------------------*/ |
| 428 | 3023 |
| 853 | 3024 /* A function that takes no arguments and returns a Lisp_Object. |
| 3025 We could define such types for n arguments, if needed. */ | |
| 428 | 3026 typedef Lisp_Object (*lisp_fn_t) (void); |
| 3027 | |
| 3028 struct Lisp_Subr | |
| 3029 { | |
| 3030 struct lrecord_header lheader; | |
| 442 | 3031 short min_args; |
| 3032 short max_args; | |
| 3379 | 3033 /* #### We should make these const Ascbyte * or const Ibyte *, not const |
| 3034 char *. */ | |
| 442 | 3035 const char *prompt; |
| 3036 const char *doc; | |
| 3037 const char *name; | |
| 428 | 3038 lisp_fn_t subr_fn; |
| 3039 }; | |
| 3040 typedef struct Lisp_Subr Lisp_Subr; | |
| 3041 | |
| 3042 DECLARE_LRECORD (subr, Lisp_Subr); | |
| 3043 #define XSUBR(x) XRECORD (x, subr, Lisp_Subr) | |
| 617 | 3044 #define wrap_subr(p) wrap_record (p, subr) |
| 428 | 3045 #define SUBRP(x) RECORDP (x, subr) |
| 3046 #define CHECK_SUBR(x) CHECK_RECORD (x, subr) | |
| 3047 #define CONCHECK_SUBR(x) CONCHECK_RECORD (x, subr) | |
| 3048 | |
| 436 | 3049 #define subr_function(subr) ((subr)->subr_fn) |
| 3050 #define SUBR_FUNCTION(subr,max_args) \ | |
| 3051 ((Lisp_Object (*) (EXFUN_##max_args)) (subr)->subr_fn) | |
| 3052 #define subr_name(subr) ((subr)->name) | |
| 428 | 3053 |
| 442 | 3054 /*------------------------------ marker --------------------------------*/ |
| 3055 | |
| 428 | 3056 |
| 440 | 3057 typedef struct Lisp_Marker Lisp_Marker; |
| 428 | 3058 struct Lisp_Marker |
| 3059 { | |
| 3060 struct lrecord_header lheader; | |
| 440 | 3061 Lisp_Marker *next; |
| 3062 Lisp_Marker *prev; | |
| 428 | 3063 struct buffer *buffer; |
| 665 | 3064 Membpos membpos; |
| 428 | 3065 char insertion_type; |
| 3066 }; | |
| 3067 | |
| 1632 | 3068 DECLARE_MODULE_API_LRECORD (marker, Lisp_Marker); |
| 428 | 3069 #define XMARKER(x) XRECORD (x, marker, Lisp_Marker) |
| 617 | 3070 #define wrap_marker(p) wrap_record (p, marker) |
| 428 | 3071 #define MARKERP(x) RECORDP (x, marker) |
| 3072 #define CHECK_MARKER(x) CHECK_RECORD (x, marker) | |
| 3073 #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker) | |
| 3074 | |
| 3075 /* The second check was looking for GCed markers still in use */ | |
| 2500 | 3076 /* if (INTP (XMARKER (x)->lheader.next.v)) ABORT (); */ |
| 428 | 3077 |
| 3078 #define marker_next(m) ((m)->next) | |
| 3079 #define marker_prev(m) ((m)->prev) | |
| 3080 | |
| 3063 | 3081 /*-------------------basic int (no connection to char)------------------*/ |
| 3082 | |
| 3083 #define ZEROP(x) EQ (x, Qzero) | |
| 428 | 3084 |
| 800 | 3085 #ifdef ERROR_CHECK_TYPES |
| 428 | 3086 |
| 3063 | 3087 #define XINT(x) XINT_1 (x, __FILE__, __LINE__) |
| 3088 | |
| 3089 DECLARE_INLINE_HEADER ( | |
| 3090 EMACS_INT | |
| 3091 XINT_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3092 ) | |
| 3093 { | |
| 3094 assert_at_line (INTP (obj), file, line); | |
| 3095 return XREALINT (obj); | |
| 3096 } | |
| 3097 | |
| 3098 #else /* no error checking */ | |
| 3099 | |
| 3100 #define XINT(obj) XREALINT (obj) | |
| 3101 | |
| 3102 #endif /* no error checking */ | |
| 3103 | |
| 3104 #define CHECK_INT(x) do { \ | |
| 3105 if (!INTP (x)) \ | |
| 3106 dead_wrong_type_argument (Qintegerp, x); \ | |
| 3107 } while (0) | |
| 3108 | |
| 3109 #define CONCHECK_INT(x) do { \ | |
| 3110 if (!INTP (x)) \ | |
| 3111 x = wrong_type_argument (Qintegerp, x); \ | |
| 3112 } while (0) | |
| 3113 | |
| 3114 #define NATNUMP(x) (INTP (x) && XINT (x) >= 0) | |
| 3115 | |
| 3116 #define CHECK_NATNUM(x) do { \ | |
| 3117 if (!NATNUMP (x)) \ | |
| 3118 dead_wrong_type_argument (Qnatnump, x); \ | |
| 3119 } while (0) | |
| 3120 | |
| 3121 #define CONCHECK_NATNUM(x) do { \ | |
| 3122 if (!NATNUMP (x)) \ | |
| 3123 x = wrong_type_argument (Qnatnump, x); \ | |
| 3124 } while (0) | |
| 3125 | |
| 3126 /*------------------------------- char ---------------------------------*/ | |
| 3127 | |
| 3128 /* NOTE: There are basic functions for converting between a character and | |
| 3129 the string representation of a character in text.h, as well as lots of | |
| 3130 other character-related stuff. There are other functions/macros for | |
| 3131 working with Ichars in charset.h, for retrieving the charset of an | |
| 3132 Ichar, the length of an Ichar when converted to text, etc. | |
| 3133 */ | |
| 3134 | |
| 3135 #ifdef MULE | |
| 3136 | |
| 3137 MODULE_API int non_ascii_valid_ichar_p (Ichar ch); | |
| 3138 | |
| 3139 /* Return whether the given Ichar is valid. | |
| 3140 */ | |
| 3141 | |
| 3142 DECLARE_INLINE_HEADER ( | |
| 3143 int | |
| 3144 valid_ichar_p (Ichar ch) | |
| 3145 ) | |
| 3146 { | |
| 3147 return (! (ch & ~0xFF)) || non_ascii_valid_ichar_p (ch); | |
| 3148 } | |
| 3149 | |
| 3150 #else /* not MULE */ | |
| 3151 | |
| 3152 /* This works when CH is negative, and correctly returns non-zero only when CH | |
| 3153 is in the range [0, 255], inclusive. */ | |
| 3154 #define valid_ichar_p(ch) (! (ch & ~0xFF)) | |
| 3155 | |
| 3156 #endif /* not MULE */ | |
| 3157 | |
| 3158 #ifdef ERROR_CHECK_TYPES | |
| 3159 | |
| 3160 DECLARE_INLINE_HEADER ( | |
| 3161 int | |
| 3162 CHARP_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3163 ) | |
| 3164 { | |
| 3165 if (XTYPE (obj) != Lisp_Type_Char) | |
| 3166 return 0; | |
| 3167 assert_at_line (valid_ichar_p (XCHARVAL (obj)), file, line); | |
| 3168 return 1; | |
| 3169 } | |
| 3170 | |
| 3171 #define CHARP(x) CHARP_1 (x, __FILE__, __LINE__) | |
| 3172 | |
| 826 | 3173 DECLARE_INLINE_HEADER ( |
| 867 | 3174 Ichar |
| 2367 | 3175 XCHAR_1 (Lisp_Object obj, const Ascbyte *file, int line) |
| 826 | 3176 ) |
| 428 | 3177 { |
| 3063 | 3178 Ichar ch; |
| 788 | 3179 assert_at_line (CHARP (obj), file, line); |
| 3063 | 3180 ch = XCHARVAL (obj); |
| 3181 assert_at_line (valid_ichar_p (ch), file, line); | |
| 3182 return ch; | |
| 428 | 3183 } |
| 3184 | |
| 788 | 3185 #define XCHAR(x) XCHAR_1 (x, __FILE__, __LINE__) |
| 3186 | |
| 3063 | 3187 #else /* not ERROR_CHECK_TYPES */ |
| 3188 | |
| 3189 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char) | |
| 3190 #define XCHAR(x) ((Ichar) XCHARVAL (x)) | |
| 3191 | |
| 3192 #endif /* (else) not ERROR_CHECK_TYPES */ | |
| 3193 | |
| 3194 #define CONCHECK_CHAR(x) do { \ | |
| 3195 if (!CHARP (x)) \ | |
| 3196 x = wrong_type_argument (Qcharacterp, x); \ | |
| 3197 } while (0) | |
| 3198 | |
| 3199 #define CHECK_CHAR(x) do { \ | |
| 3200 if (!CHARP (x)) \ | |
| 3201 dead_wrong_type_argument (Qcharacterp, x); \ | |
| 3202 } while (0) | |
| 3203 | |
| 3204 | |
| 3205 DECLARE_INLINE_HEADER ( | |
| 3206 Lisp_Object | |
| 3207 make_char (Ichar val) | |
| 3208 ) | |
| 3209 { | |
| 3210 type_checking_assert (valid_ichar_p (val)); | |
| 3211 /* This is defined in lisp-union.h or lisp-disunion.h */ | |
| 3212 return make_char_1 (val); | |
| 3213 } | |
| 3214 | |
| 3215 /*------------------------- int-char connection ------------------------*/ | |
| 3216 | |
| 3217 #ifdef ERROR_CHECK_TYPES | |
| 3218 | |
| 3219 #define XCHAR_OR_INT(x) XCHAR_OR_INT_1 (x, __FILE__, __LINE__) | |
| 3220 | |
| 3221 DECLARE_INLINE_HEADER ( | |
| 3222 EMACS_INT | |
| 3223 XCHAR_OR_INT_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3224 ) | |
| 3225 { | |
| 3226 assert_at_line (INTP (obj) || CHARP (obj), file, line); | |
| 3227 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3228 } | |
| 3229 | |
| 788 | 3230 #else /* no error checking */ |
| 3231 | |
| 4134 | 3232 /* obj is multiply eval'ed and not an lvalue; use an inline function instead |
| 3233 of a macro. */ | |
| 3234 DECLARE_INLINE_HEADER ( | |
| 3235 EMACS_INT | |
| 3236 XCHAR_OR_INT (Lisp_Object obj) | |
| 3237 ) | |
| 3238 { | |
| 3239 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3240 } | |
| 788 | 3241 |
| 3242 #endif /* no error checking */ | |
| 428 | 3243 |
| 3063 | 3244 /* True of X is an integer whose value is the valid integral equivalent of a |
| 3245 character. */ | |
| 3246 | |
| 3247 #define CHAR_INTP(x) (INTP (x) && valid_ichar_p (XINT (x))) | |
| 3248 | |
| 3249 /* True of X is a character or an integral value that can be converted into a | |
| 3250 character. */ | |
| 3251 #define CHAR_OR_CHAR_INTP(x) (CHARP (x) || CHAR_INTP (x)) | |
| 3252 | |
| 3253 DECLARE_INLINE_HEADER ( | |
| 3254 Ichar | |
| 3255 XCHAR_OR_CHAR_INT (Lisp_Object obj) | |
| 3256 ) | |
| 3257 { | |
| 3258 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3259 } | |
| 3260 | |
| 3261 /* Signal an error if CH is not a valid character or integer Lisp_Object. | |
| 3262 If CH is an integer Lisp_Object, convert it to a character Lisp_Object, | |
| 3263 but merely by repackaging, without performing tests for char validity. | |
| 3264 */ | |
| 3265 | |
| 3266 #define CHECK_CHAR_COERCE_INT(x) do { \ | |
| 3267 if (CHARP (x)) \ | |
| 3268 ; \ | |
| 3269 else if (CHAR_INTP (x)) \ | |
| 3270 x = make_char (XINT (x)); \ | |
| 3271 else \ | |
| 3272 x = wrong_type_argument (Qcharacterp, x); \ | |
| 3273 } while (0) | |
| 3274 | |
| 3275 /* next three always continuable because they coerce their arguments. */ | |
| 3276 #define CHECK_INT_COERCE_CHAR(x) do { \ | |
| 3277 if (INTP (x)) \ | |
| 3278 ; \ | |
| 3279 else if (CHARP (x)) \ | |
| 3280 x = make_int (XCHAR (x)); \ | |
| 3281 else \ | |
| 3282 x = wrong_type_argument (Qinteger_or_char_p, x); \ | |
| 3283 } while (0) | |
| 3284 | |
| 3285 #define CHECK_INT_COERCE_MARKER(x) do { \ | |
| 3286 if (INTP (x)) \ | |
| 3287 ; \ | |
| 3288 else if (MARKERP (x)) \ | |
| 3289 x = make_int (marker_position (x)); \ | |
| 3290 else \ | |
| 3291 x = wrong_type_argument (Qinteger_or_marker_p, x); \ | |
| 3292 } while (0) | |
| 3293 | |
| 3294 #define CHECK_INT_COERCE_CHAR_OR_MARKER(x) do { \ | |
| 3295 if (INTP (x)) \ | |
| 3296 ; \ | |
| 3297 else if (CHARP (x)) \ | |
| 3298 x = make_int (XCHAR (x)); \ | |
| 3299 else if (MARKERP (x)) \ | |
| 3300 x = make_int (marker_position (x)); \ | |
| 3301 else \ | |
| 3302 x = wrong_type_argument (Qinteger_char_or_marker_p, x); \ | |
| 3303 } while (0) | |
| 428 | 3304 |
| 442 | 3305 /*------------------------------ float ---------------------------------*/ |
| 428 | 3306 |
| 3307 /* Note: the 'unused_next_' field exists only to ensure that the | |
| 3308 `next' pointer fits within the structure, for the purposes of the | |
| 3309 free list. This makes a difference in the unlikely case of | |
| 3310 sizeof(double) being smaller than sizeof(void *). */ | |
| 3311 | |
| 3312 struct Lisp_Float | |
| 3313 { | |
| 3314 struct lrecord_header lheader; | |
| 3315 union { double d; struct Lisp_Float *unused_next_; } data; | |
| 3316 }; | |
| 3317 typedef struct Lisp_Float Lisp_Float; | |
| 3318 | |
| 3319 DECLARE_LRECORD (float, Lisp_Float); | |
| 3320 #define XFLOAT(x) XRECORD (x, float, Lisp_Float) | |
| 617 | 3321 #define wrap_float(p) wrap_record (p, float) |
| 428 | 3322 #define FLOATP(x) RECORDP (x, float) |
| 3323 #define CHECK_FLOAT(x) CHECK_RECORD (x, float) | |
| 3324 #define CONCHECK_FLOAT(x) CONCHECK_RECORD (x, float) | |
| 3325 | |
| 3326 #define float_data(f) ((f)->data.d) | |
| 3327 #define XFLOAT_DATA(x) float_data (XFLOAT (x)) | |
| 3328 | |
| 3329 #define XFLOATINT(n) extract_float (n) | |
| 3330 | |
| 3331 #define CHECK_INT_OR_FLOAT(x) do { \ | |
| 3332 if (!INT_OR_FLOATP (x)) \ | |
| 3333 dead_wrong_type_argument (Qnumberp, x); \ | |
| 3334 } while (0) | |
| 3335 | |
| 3336 #define CONCHECK_INT_OR_FLOAT(x) do { \ | |
| 3337 if (!INT_OR_FLOATP (x)) \ | |
| 3338 x = wrong_type_argument (Qnumberp, x); \ | |
| 3339 } while (0) | |
| 3340 | |
| 3341 # define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x)) | |
| 3342 | |
| 442 | 3343 /*--------------------------- readonly objects -------------------------*/ |
| 440 | 3344 |
| 3263 | 3345 #ifndef NEW_GC |
| 428 | 3346 #define CHECK_C_WRITEABLE(obj) \ |
| 3347 do { if (c_readonly (obj)) c_write_error (obj); } while (0) | |
| 3348 | |
| 2720 | 3349 #define C_READONLY(obj) (C_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj))) |
| 3263 | 3350 #endif /* not NEW_GC */ |
| 2720 | 3351 |
| 428 | 3352 #define CHECK_LISP_WRITEABLE(obj) \ |
| 3353 do { if (lisp_readonly (obj)) lisp_write_error (obj); } while (0) | |
| 3354 | |
| 3355 #define LISP_READONLY(obj) (LISP_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj))) | |
| 3356 | |
| 980 | 3357 /*----------------------------- structures ----------------------------*/ |
| 428 | 3358 |
| 3359 typedef struct structure_keyword_entry structure_keyword_entry; | |
| 3360 struct structure_keyword_entry | |
| 3361 { | |
| 3362 Lisp_Object keyword; | |
| 3363 int (*validate) (Lisp_Object keyword, Lisp_Object value, | |
| 578 | 3364 Error_Behavior errb); |
| 428 | 3365 }; |
| 3366 | |
| 3367 typedef struct | |
| 3368 { | |
| 3369 Dynarr_declare (structure_keyword_entry); | |
| 3370 } structure_keyword_entry_dynarr; | |
| 3371 | |
| 3372 typedef struct structure_type structure_type; | |
| 3373 struct structure_type | |
| 3374 { | |
| 3375 Lisp_Object type; | |
| 3376 structure_keyword_entry_dynarr *keywords; | |
| 578 | 3377 int (*validate) (Lisp_Object data, Error_Behavior errb); |
| 428 | 3378 Lisp_Object (*instantiate) (Lisp_Object data); |
| 3379 }; | |
| 3380 | |
| 3381 typedef struct | |
| 3382 { | |
| 3383 Dynarr_declare (structure_type); | |
| 3384 } structure_type_dynarr; | |
| 3385 | |
| 3386 struct structure_type *define_structure_type (Lisp_Object type, | |
| 3387 int (*validate) | |
| 3388 (Lisp_Object data, | |
| 578 | 3389 Error_Behavior errb), |
| 428 | 3390 Lisp_Object (*instantiate) |
| 3391 (Lisp_Object data)); | |
| 3392 void define_structure_type_keyword (struct structure_type *st, | |
| 3393 Lisp_Object keyword, | |
| 3394 int (*validate) (Lisp_Object keyword, | |
| 3395 Lisp_Object value, | |
| 578 | 3396 Error_Behavior errb)); |
| 428 | 3397 |
| 858 | 3398 /*---------------------------- weak boxes ------------------------------*/ |
| 3399 | |
| 3400 struct weak_box | |
| 3401 { | |
| 3017 | 3402 struct LCRECORD_HEADER header; |
| 858 | 3403 Lisp_Object value; |
| 3404 | |
| 3405 Lisp_Object next_weak_box; /* don't mark through this! */ | |
| 3406 }; | |
| 3407 | |
| 3408 void prune_weak_boxes (void); | |
| 3409 Lisp_Object make_weak_box (Lisp_Object value); | |
| 3410 Lisp_Object weak_box_ref (Lisp_Object value); | |
| 3411 | |
| 3412 DECLARE_LRECORD (weak_box, struct weak_box); | |
| 3413 #define XWEAK_BOX(x) XRECORD (x, weak_box, struct weak_box) | |
| 3414 #define XSET_WEAK_BOX(x, v) (XWEAK_BOX (x)->value = (v)) | |
| 3415 #define wrap_weak_box(p) wrap_record (p, weak_box) | |
| 3416 #define WEAK_BOXP(x) RECORDP (x, weak_box) | |
| 3417 #define CHECK_WEAK_BOX(x) CHECK_RECORD (x, weak_box) | |
| 3418 #define CONCHECK_WEAK_BOX(x) CONCHECK_RECORD (x, weak_box) | |
| 3419 | |
| 888 | 3420 /*--------------------------- ephemerons ----------------------------*/ |
| 3421 | |
| 3422 struct ephemeron | |
| 3423 { | |
| 3017 | 3424 struct LCRECORD_HEADER header; |
| 888 | 3425 |
| 3426 Lisp_Object key; | |
| 3427 | |
| 3428 /* This field holds a pair. The cdr of this cons points to the next | |
| 3429 ephemeron in Vall_ephemerons. The car points to another pair | |
| 3430 whose car is the value and whose cdr is the finalizer. | |
| 3431 | |
| 3432 This representation makes it very easy to unlink an ephemeron | |
| 3433 from Vall_ephemerons and chain it into | |
| 3434 Vall_ephemerons_to_finalize. */ | |
| 3435 | |
| 3436 Lisp_Object cons_chain; | |
| 3437 | |
| 3438 Lisp_Object value; | |
| 3439 }; | |
| 3440 | |
| 3441 void prune_ephemerons (void); | |
| 3442 Lisp_Object ephemeron_value(Lisp_Object ephi); | |
| 1590 | 3443 void init_marking_ephemerons(void); |
| 3444 int continue_marking_ephemerons(void); | |
| 888 | 3445 int finish_marking_ephemerons(void); |
| 3446 Lisp_Object zap_finalize_list(void); | |
| 3447 Lisp_Object make_ephemeron(Lisp_Object key, Lisp_Object value, Lisp_Object finalizer); | |
| 3448 | |
| 3449 DECLARE_LRECORD(ephemeron, struct ephemeron); | |
| 3450 #define XEPHEMERON(x) XRECORD (x, ephemeron, struct ephemeron) | |
| 3451 #define XEPHEMERON_REF(x) (XEPHEMERON (x)->value) | |
| 3452 #define XEPHEMERON_NEXT(x) (XCDR (XEPHEMERON(x)->cons_chain)) | |
| 3453 #define XEPHEMERON_FINALIZER(x) (XCDR (XCAR (XEPHEMERON (x)->cons_chain))) | |
| 3454 #define XSET_EPHEMERON_NEXT(x, n) (XSETCDR (XEPHEMERON(x)->cons_chain, n)) | |
| 3455 #define XSET_EPHEMERON_VALUE(x, v) (XEPHEMERON(x)->value = (v)) | |
| 3456 #define XSET_EPHEMERON_KEY(x, k) (XEPHEMERON(x)->key = (k)) | |
| 3457 #define wrap_ephemeron(p) wrap_record (p, ephemeron) | |
| 3458 #define EPHEMERONP(x) RECORDP (x, ephemeron) | |
| 3459 #define CHECK_EPHEMERON(x) CHECK_RECORD (x, ephemeron) | |
| 3460 #define CONCHECK_EPHEMERON(x) CONCHECK_RECORD (x, ephemeron) | |
| 3461 | |
| 858 | 3462 |
| 442 | 3463 /*---------------------------- weak lists ------------------------------*/ |
| 428 | 3464 |
| 3465 enum weak_list_type | |
| 3466 { | |
| 3467 /* element disappears if it's unmarked. */ | |
| 3468 WEAK_LIST_SIMPLE, | |
| 3469 /* element disappears if it's a cons and either its car or | |
| 3470 cdr is unmarked. */ | |
| 3471 WEAK_LIST_ASSOC, | |
| 3472 /* element disappears if it's a cons and its car is unmarked. */ | |
| 3473 WEAK_LIST_KEY_ASSOC, | |
| 3474 /* element disappears if it's a cons and its cdr is unmarked. */ | |
| 442 | 3475 WEAK_LIST_VALUE_ASSOC, |
| 3476 /* element disappears if it's a cons and neither its car nor | |
| 3477 its cdr is marked. */ | |
| 3478 WEAK_LIST_FULL_ASSOC | |
| 428 | 3479 }; |
| 3480 | |
| 3481 struct weak_list | |
| 3482 { | |
| 3017 | 3483 struct LCRECORD_HEADER header; |
| 428 | 3484 Lisp_Object list; /* don't mark through this! */ |
| 3485 enum weak_list_type type; | |
| 3486 Lisp_Object next_weak; /* don't mark through this! */ | |
| 3487 }; | |
| 3488 | |
| 3489 DECLARE_LRECORD (weak_list, struct weak_list); | |
| 3490 #define XWEAK_LIST(x) XRECORD (x, weak_list, struct weak_list) | |
| 617 | 3491 #define wrap_weak_list(p) wrap_record (p, weak_list) |
| 428 | 3492 #define WEAK_LISTP(x) RECORDP (x, weak_list) |
| 3493 #define CHECK_WEAK_LIST(x) CHECK_RECORD (x, weak_list) | |
| 3494 #define CONCHECK_WEAK_LIST(x) CONCHECK_RECORD (x, weak_list) | |
| 3495 | |
| 3496 #define weak_list_list(w) ((w)->list) | |
| 3497 #define XWEAK_LIST_LIST(w) (XWEAK_LIST (w)->list) | |
| 3498 | |
| 3499 Lisp_Object make_weak_list (enum weak_list_type type); | |
| 3500 /* The following two are only called by the garbage collector */ | |
| 3501 int finish_marking_weak_lists (void); | |
| 3502 void prune_weak_lists (void); | |
| 3503 | |
| 1743 | 3504 END_C_DECLS |
| 428 | 3505 |
| 3506 /************************************************************************/ | |
| 771 | 3507 /* Definitions related to the format of text and of characters */ |
| 3508 /************************************************************************/ | |
| 3509 | |
| 3510 /* Note: | |
| 3511 | |
| 3512 "internally formatted text" and the term "internal format" in | |
| 3513 general are likely to refer to the format of text in buffers and | |
| 3514 strings; "externally formatted text" and the term "external format" | |
| 3515 refer to any text format used in the O.S. or elsewhere outside of | |
| 3516 XEmacs. The format of text and of a character are related and | |
| 3517 there must be a one-to-one relationship (hopefully through a | |
| 3518 relatively simple algorithmic means of conversion) between a string | |
| 3519 of text and an equivalent array of characters, but the conversion | |
| 3520 between the two is NOT necessarily trivial. | |
| 3521 | |
| 3522 In a non-Mule XEmacs, allowed characters are numbered 0 through | |
| 3523 255, where no fixed meaning is assigned to them, but (when | |
| 3524 representing text, rather than bytes in a binary file) in practice | |
| 3525 the lower half represents ASCII and the upper half some other 8-bit | |
| 3526 character set (chosen by setting the font, case tables, syntax | |
| 3527 tables, etc. appropriately for the character set through ad-hoc | |
| 3528 means such as the `iso-8859-1' file and the | |
| 3529 `standard-display-european' function). | |
| 3530 | |
| 3531 #### Finish this. | |
| 3532 | |
| 3533 */ | |
| 3534 #include "text.h" | |
| 3535 | |
| 3536 | |
| 3537 /************************************************************************/ | |
| 428 | 3538 /* Definitions of primitive Lisp functions and variables */ |
| 3539 /************************************************************************/ | |
| 3540 | |
| 3541 | |
| 3542 /* DEFUN - Define a built-in Lisp-visible C function or `subr'. | |
| 3543 `lname' should be the name to give the function in Lisp, | |
| 3544 as a null-terminated C string. | |
| 3545 `Fname' should be the C equivalent of `lname', using only characters | |
| 3546 valid in a C identifier, with an "F" prepended. | |
| 3547 The name of the C constant structure that records information | |
| 3548 on this function for internal use is "S" concatenated with Fname. | |
| 3549 `min_args' should be a number, the minimum number of arguments allowed. | |
| 3550 `max_args' should be a number, the maximum number of arguments allowed, | |
| 3551 or else MANY or UNEVALLED. | |
| 3552 MANY means pass a vector of evaluated arguments, | |
| 3553 in the form of an integer number-of-arguments | |
| 3554 followed by the address of a vector of Lisp_Objects | |
| 3555 which contains the argument values. | |
| 3556 UNEVALLED means pass the list of unevaluated arguments. | |
| 3557 `prompt' says how to read arguments for an interactive call. | |
| 3558 See the doc string for `interactive'. | |
| 3559 A null string means call interactively with no arguments. | |
| 3560 `arglist' are the comma-separated arguments (always Lisp_Objects) for | |
| 3561 the function. | |
| 3562 The docstring for the function is placed as a "C" comment between | |
| 3563 the prompt and the `args' argument. make-docfile reads the | |
| 3564 comment and creates the DOC file from it. | |
| 3565 */ | |
| 3566 | |
| 3567 #define EXFUN_0 void | |
| 3568 #define EXFUN_1 Lisp_Object | |
| 3569 #define EXFUN_2 Lisp_Object,Lisp_Object | |
| 3570 #define EXFUN_3 Lisp_Object,Lisp_Object,Lisp_Object | |
| 3571 #define EXFUN_4 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object | |
| 3572 #define EXFUN_5 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object | |
| 3573 #define EXFUN_6 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3574 Lisp_Object | |
| 3575 #define EXFUN_7 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3576 Lisp_Object,Lisp_Object | |
| 3577 #define EXFUN_8 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3578 Lisp_Object,Lisp_Object,Lisp_Object | |
| 3579 #define EXFUN_MANY int, Lisp_Object* | |
| 3580 #define EXFUN_UNEVALLED Lisp_Object | |
| 3581 #define EXFUN(sym, max_args) Lisp_Object sym (EXFUN_##max_args) | |
| 2268 | 3582 #define EXFUN_NORETURN(sym, max_args) \ |
| 3583 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, sym (EXFUN_##max_args)) | |
| 428 | 3584 |
| 3585 #define SUBR_MAX_ARGS 8 | |
| 3586 #define MANY -2 | |
| 3587 #define UNEVALLED -1 | |
| 3588 | |
| 3589 /* Can't be const, because then subr->doc is read-only and | |
| 3590 Snarf_documentation chokes */ | |
| 3591 | |
| 3263 | 3592 #ifdef NEW_GC |
| 2720 | 3593 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3594 Lisp_Object Fname (EXFUN_##max_args); \ | |
| 3595 static struct Lisp_Subr MC_ALLOC_S##Fname = \ | |
| 3596 { \ | |
| 3597 { /* struct lrecord_header */ \ | |
| 3598 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3599 1, /* lisp_readonly bit */ \ | |
| 3600 0, /* free */ \ | |
| 3601 0 /* uid */ \ | |
| 3602 }, \ | |
| 3603 min_args, \ | |
| 3604 max_args, \ | |
| 3605 prompt, \ | |
| 3606 0, /* doc string */ \ | |
| 3607 lname, \ | |
| 3608 (lisp_fn_t) Fname \ | |
| 3609 }; \ | |
| 2814 | 3610 static struct Lisp_Subr *S##Fname; \ |
| 2720 | 3611 Lisp_Object Fname (DEFUN_##max_args arglist) |
| 3612 | |
| 3613 #define DEFUN_NORETURN(lname, Fname, min_args, max_args, prompt, arglist) \ | |
| 3614 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, Fname (EXFUN_##max_args)); \ | |
| 3615 static struct Lisp_Subr MC_ALLOC_S##Fname = \ | |
| 3616 { \ | |
| 3617 { /* struct lrecord_header */ \ | |
| 3618 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3619 1, /* lisp_readonly bit */ \ | |
| 3620 0, /* free */ \ | |
| 3621 0 /* uid */ \ | |
| 3622 }, \ | |
| 3623 min_args, \ | |
| 3624 max_args, \ | |
| 3625 prompt, \ | |
| 3626 0, /* doc string */ \ | |
| 3627 lname, \ | |
| 3628 (lisp_fn_t) Fname \ | |
| 3629 }; \ | |
| 2814 | 3630 static struct Lisp_Subr *S##Fname; \ |
| 2720 | 3631 DOESNT_RETURN_TYPE (Lisp_Object) Fname (DEFUN_##max_args arglist) |
| 2834 | 3632 #define GET_DEFUN_LISP_OBJECT(Fname) \ |
| 3633 wrap_subr (S##Fname); | |
| 3263 | 3634 #else /* not NEW_GC */ |
| 428 | 3635 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3636 Lisp_Object Fname (EXFUN_##max_args); \ | |
| 442 | 3637 static struct Lisp_Subr S##Fname = \ |
| 3638 { \ | |
| 3639 { /* struct lrecord_header */ \ | |
| 3640 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3641 1, /* mark bit */ \ | |
| 3642 1, /* c_readonly bit */ \ | |
| 1111 | 3643 1, /* lisp_readonly bit */ \ |
| 3644 0 /* unused */ \ | |
| 442 | 3645 }, \ |
| 3646 min_args, \ | |
| 3647 max_args, \ | |
| 3648 prompt, \ | |
| 3649 0, /* doc string */ \ | |
| 3650 lname, \ | |
| 3651 (lisp_fn_t) Fname \ | |
| 3652 }; \ | |
| 428 | 3653 Lisp_Object Fname (DEFUN_##max_args arglist) |
| 3654 | |
| 2268 | 3655 #define DEFUN_NORETURN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3656 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, Fname (EXFUN_##max_args)); \ | |
| 3657 static struct Lisp_Subr S##Fname = \ | |
| 3658 { \ | |
| 3659 { /* struct lrecord_header */ \ | |
| 3660 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3661 1, /* mark bit */ \ | |
| 3662 1, /* c_readonly bit */ \ | |
| 3663 1, /* lisp_readonly bit */ \ | |
| 3664 0 /* unused */ \ | |
| 3665 }, \ | |
| 3666 min_args, \ | |
| 3667 max_args, \ | |
| 3668 prompt, \ | |
| 3669 0, /* doc string */ \ | |
| 3670 lname, \ | |
| 3671 (lisp_fn_t) Fname \ | |
| 3672 }; \ | |
| 3673 DOESNT_RETURN_TYPE (Lisp_Object) Fname (DEFUN_##max_args arglist) | |
| 2834 | 3674 #define GET_DEFUN_LISP_OBJECT(Fname) \ |
| 3675 wrap_subr (&S##Fname); | |
| 3263 | 3676 #endif /* not NEW_GC */ |
| 2268 | 3677 |
| 428 | 3678 /* Heavy ANSI C preprocessor hackery to get DEFUN to declare a |
| 3679 prototype that matches max_args, and add the obligatory | |
| 3680 `Lisp_Object' type declaration to the formal C arguments. */ | |
| 3681 | |
| 3682 #define DEFUN_MANY(named_int, named_Lisp_Object) named_int, named_Lisp_Object | |
| 3683 #define DEFUN_UNEVALLED(args) Lisp_Object args | |
| 3684 #define DEFUN_0() void | |
| 3685 #define DEFUN_1(a) Lisp_Object a | |
| 3686 #define DEFUN_2(a,b) DEFUN_1(a), Lisp_Object b | |
| 3687 #define DEFUN_3(a,b,c) DEFUN_2(a,b), Lisp_Object c | |
| 3688 #define DEFUN_4(a,b,c,d) DEFUN_3(a,b,c), Lisp_Object d | |
| 3689 #define DEFUN_5(a,b,c,d,e) DEFUN_4(a,b,c,d), Lisp_Object e | |
| 3690 #define DEFUN_6(a,b,c,d,e,f) DEFUN_5(a,b,c,d,e), Lisp_Object f | |
| 3691 #define DEFUN_7(a,b,c,d,e,f,g) DEFUN_6(a,b,c,d,e,f), Lisp_Object g | |
| 3692 #define DEFUN_8(a,b,c,d,e,f,g,h) DEFUN_7(a,b,c,d,e,f,g),Lisp_Object h | |
| 3693 | |
| 3694 /* WARNING: If you add defines here for higher values of max_args, | |
| 3695 make sure to also fix the clauses in PRIMITIVE_FUNCALL(), | |
| 3696 and change the define of SUBR_MAX_ARGS above. */ | |
| 3697 | |
| 3698 #include "symeval.h" | |
| 3699 | |
| 1743 | 3700 BEGIN_C_DECLS |
| 1650 | 3701 |
| 428 | 3702 /* `specpdl' is the special binding/unwind-protect stack. |
| 3703 | |
| 3704 Knuth says (see the Jargon File): | |
| 3705 At MIT, `pdl' [abbreviation for `Push Down List'] used to | |
| 3706 be a more common synonym for `stack'. | |
| 3707 Everywhere else `stack' seems to be the preferred term. | |
| 3708 | |
| 3709 specpdl_depth is the current depth of `specpdl'. | |
| 771 | 3710 Save this for use later as arg to `unbind_to_1'. */ |
| 1632 | 3711 extern MODULE_API int specpdl_depth_counter; |
| 428 | 3712 #define specpdl_depth() specpdl_depth_counter |
| 3713 | |
| 442 | 3714 |
| 3715 #define CHECK_FUNCTION(fun) do { \ | |
| 3716 while (NILP (Ffunctionp (fun))) \ | |
| 3717 signal_invalid_function_error (fun); \ | |
| 3718 } while (0) | |
| 3719 | |
| 428 | 3720 |
| 3721 /************************************************************************/ | |
| 3722 /* Checking for QUIT */ | |
| 3723 /************************************************************************/ | |
| 3724 | |
| 1123 | 3725 /* NOTE NOTE NOTE: Invoking QUIT can cause random Lisp code to be executed! |
| 3726 This can happen in numerous ways. For example, on many platforms, QUIT | |
| 3727 needs to drain the event queue to see whether there's a C-g in the works. | |
| 3728 A side effect of this is that, if there's a menu-press event, menu filters | |
| 3729 (i.e. Lisp code) will be invoked. Lisp code could also happen if there's | |
| 3730 an asynchronous timeout, or if the debugger is invoked as a result of | |
| 3731 debug-on-quit and the user returns by hitting `r', etc. etc. | |
| 3732 | |
| 3733 However, GC CANNOT HAPPEN. It is forbidden everywhere within the QUIT- | |
| 3734 processing code, because most callers cannot tolerate GC during QUIT | |
| 3735 since it's just too prevalent. */ | |
| 3736 | |
| 853 | 3737 /* The exact workings of this mechanism are described in detail in signal.c. */ |
| 3738 | |
| 428 | 3739 /* Asynchronous events set something_happened, and then are processed |
| 3740 within the QUIT macro. At this point, we are guaranteed to not be in | |
| 3741 any sensitive code. */ | |
| 3742 | |
| 1632 | 3743 extern MODULE_API volatile int something_happened; |
| 3744 extern MODULE_API int dont_check_for_quit; | |
| 3745 MODULE_API void check_what_happened (void); | |
| 3746 | |
| 3747 extern MODULE_API volatile int quit_check_signal_happened; | |
| 428 | 3748 extern volatile int quit_check_signal_tick_count; |
| 1632 | 3749 MODULE_API void check_quit (void); |
| 3750 | |
| 3751 MODULE_API void signal_quit (void); | |
| 428 | 3752 |
| 853 | 3753 int begin_dont_check_for_quit (void); |
| 3754 int begin_do_check_for_quit (void); | |
| 3755 | |
| 3756 /* Nonzero if the values of `quit-flag' and `inhibit-quit' indicate | |
| 3757 that a quit should be signalled. */ | |
| 771 | 3758 #define QUIT_FLAG_SAYS_SHOULD_QUIT \ |
| 3759 (!NILP (Vquit_flag) && \ | |
| 3760 (NILP (Vinhibit_quit) \ | |
| 3761 || (EQ (Vquit_flag, Qcritical) && !dont_check_for_quit))) | |
| 3762 | |
| 853 | 3763 /* Nonzero if ought to quit now. This is the "efficient" version, which |
| 3764 respects the flags set to indicate whether the full quit check should | |
| 3765 be done. Therefore it may be inaccurate (i.e. lagging reality), esp. | |
| 3766 when poll for quit is used. | |
| 3767 | |
| 3768 This is defined for code that wants to allow quitting, but needs to | |
| 3769 do some cleanup if that happens. (You could always register the cleanup | |
| 3770 code using record_unwind_protect(), but sometimes it makes more sense | |
| 3771 to do it using QUITP.) To use this macro, just call it at the | |
| 3772 appropriate time, and if its value is non-zero, do your cleanup code | |
| 3773 and then call QUIT. | |
| 3774 | |
| 3775 A different version (below) is used for the actual QUIT macro. */ | |
| 428 | 3776 #define QUITP \ |
| 853 | 3777 ((quit_check_signal_happened ? check_quit () : (void) 0), \ |
| 771 | 3778 QUIT_FLAG_SAYS_SHOULD_QUIT) |
| 428 | 3779 |
| 853 | 3780 /* This is the version actually called by QUIT. The difference |
| 3781 between it and QUITP is that it also has side effects in that it | |
| 3782 will handle anything else that has recently signalled itself | |
| 3783 asynchronously and wants to be handled now. Currently this | |
| 3784 includes executing asynchronous timeouts that may have been set | |
| 3785 from Lisp or from the poll-for-quit or poll-for-sigchld | |
| 3786 timers. (#### It seems that, to be slightly more accurate, we | |
| 3787 should also process poll-for-quit timers in the above version. | |
| 3788 However, this mechanism is inherently approximate, so it really | |
| 3789 doesn't matter much.) In the future, it might also include doing a | |
| 3790 thread context switch. Callers of QUITP generally don't except | |
| 1123 | 3791 random side effects to happen (#### unfortunately, random side effects |
| 3792 can happen anyway, e.g. through menu filters -- see comment above), | |
| 3793 so we have this different version. */ | |
| 428 | 3794 #define INTERNAL_QUITP \ |
| 853 | 3795 ((something_happened ? check_what_happened () : (void) 0), \ |
| 771 | 3796 QUIT_FLAG_SAYS_SHOULD_QUIT) |
| 428 | 3797 |
| 3798 /* Check quit-flag and quit if it is non-nil. Also do any other things | |
| 853 | 3799 that are triggered by asynchronous events and might want to be |
| 3800 handled. */ | |
| 428 | 3801 #define QUIT do { if (INTERNAL_QUITP) signal_quit (); } while (0) |
| 3802 | |
| 3803 | |
| 3804 /************************************************************************/ | |
| 3805 /* hashing */ | |
| 3806 /************************************************************************/ | |
| 3807 | |
| 3808 /* #### for a 64-bit machine, we should substitute a prime just over 2^32 */ | |
| 3809 #define GOOD_HASH 65599 /* prime number just over 2^16; Dragon book, p. 435 */ | |
| 3810 #define HASH2(a,b) (GOOD_HASH * (a) + (b)) | |
| 3811 #define HASH3(a,b,c) (GOOD_HASH * HASH2 (a,b) + (c)) | |
| 3812 #define HASH4(a,b,c,d) (GOOD_HASH * HASH3 (a,b,c) + (d)) | |
| 3813 #define HASH5(a,b,c,d,e) (GOOD_HASH * HASH4 (a,b,c,d) + (e)) | |
| 3814 #define HASH6(a,b,c,d,e,f) (GOOD_HASH * HASH5 (a,b,c,d,e) + (f)) | |
| 3815 #define HASH7(a,b,c,d,e,f,g) (GOOD_HASH * HASH6 (a,b,c,d,e,f) + (g)) | |
| 3816 #define HASH8(a,b,c,d,e,f,g,h) (GOOD_HASH * HASH7 (a,b,c,d,e,f,g) + (h)) | |
| 3817 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i)) | |
| 3818 | |
| 3819 #define LISP_HASH(obj) ((unsigned long) LISP_TO_VOID (obj)) | |
| 2516 | 3820 Hashcode memory_hash (const void *xv, Bytecount size); |
| 3821 Hashcode internal_hash (Lisp_Object obj, int depth); | |
| 3822 Hashcode internal_array_hash (Lisp_Object *arr, int size, int depth); | |
| 428 | 3823 |
| 3824 | |
| 3825 /************************************************************************/ | |
| 3826 /* String translation */ | |
| 3827 /************************************************************************/ | |
| 3828 | |
| 771 | 3829 /* When support for message translation exists, GETTEXT() translates a |
| 3830 string from English into the language defined by | |
| 3831 `current-language-environment'. This is done by looking the string | |
| 3832 up in a large predefined table; if no translation is found, the | |
| 3833 original string is returned, and the failure is possibly logged so | |
| 3834 that the translation can later be entered into the table. | |
| 3835 | |
| 3836 In addition to this, there is a mechanism to snarf message strings | |
| 3837 out of the source code so that they can be entered into the tables. | |
| 3838 This is what make-msgfile.lex does. | |
| 3839 | |
| 3840 Handling `format' strings is more difficult: The format string | |
| 3841 should get translated, but not under all circumstances. When the | |
| 3842 format string is a Lisp string, what should happen is that | |
| 3843 Fformat() should format the untranslated args[0] and return that, | |
| 3844 and also call Fgettext() on args[0] and, if that is different, | |
| 3845 format it and store it in the `string-translatable' property of the | |
| 3846 returned string. See Fgettext(). | |
| 3847 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3848 The variations IGETTEXT, CIGETTEXT and ASCGETTEXT operate on |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3849 Ibyte *, CIbyte *, and Ascbyte * strings, respectively. The |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3850 ASCGETTEXT version has an assert check to verify that its string |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3851 really is pure-ASCII. Plain GETTEXT is defined as ASCGETTEXT, and |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3852 so works the same way. (There are no versions that work for Extbyte *. |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3853 Translate to internal format before working on it.) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3854 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3855 There are similar functions for building a Lisp string from a C |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3856 string and translating in the process. They again come in three |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3857 variants: build_msg_istring(), build_msg_cistring(), and |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3858 build_msg_ascstring(). Again, build_msg_ascstring() asserts that |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3859 its text is pure-ASCII, and build_msg_string() is the same as |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3860 build_msg_ascstring(). |
| 771 | 3861 */ |
| 3862 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3863 /* Return value NOT Ascbyte, because the result in general will have been |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3864 translated into a foreign language. */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3865 DECLARE_INLINE_HEADER (const CIbyte *ASCGETTEXT (const Ascbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3866 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3867 ASSERT_ASCTEXT_ASCII (s); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3868 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3869 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3870 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3871 DECLARE_INLINE_HEADER (const Ibyte *IGETTEXT (const Ibyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3872 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3873 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3874 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3875 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3876 DECLARE_INLINE_HEADER (const CIbyte *CIGETTEXT (const CIbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3877 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3878 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3879 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3880 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3881 DECLARE_INLINE_HEADER (Lisp_Object LISP_GETTEXT (Lisp_Object s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3882 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3883 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3884 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3885 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3886 #define GETTEXT ASCGETTEXT |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3887 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3888 MODULE_API Lisp_Object build_msg_istring (const Ibyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3889 MODULE_API Lisp_Object build_msg_cistring (const CIbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3890 MODULE_API Lisp_Object build_msg_ascstring (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3891 #define build_msg_string build_msg_ascstring |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3892 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3893 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3894 /* DEFER_GETTEXT() and variants are used to identify strings which are not |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3895 meant to be translated immediately, but instead at some later time. |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3896 This is used in strings that are stored somewhere at dump or |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3897 initialization time, at a time when the current language environment is |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3898 not set. It is the duty of the user of the string to call GETTEXT or |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3899 some variant at the appropriate time. DEFER_GETTTEXT() serves only as a |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3900 marker that the string is translatable, and will as a result be snarfed |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3901 during message snarfing (see above). |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3902 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3903 build_defer_string() and variants are the deferred equivalents of |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3904 build_msg_string() and variants. Similarly to DEFER_GETTEXT(), they |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3905 don't actually do any translation, but serve as place markers for |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3906 message snarfing. However, they may do something more than just build |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3907 a Lisp string -- in particular, they may store a string property |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3908 indicating that the string is translatable (see discussion above about |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3909 this property). |
| 428 | 3910 */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3911 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3912 DECLARE_INLINE_HEADER (const Ascbyte *DEFER_ASCGETTEXT (const Ascbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3913 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3914 ASSERT_ASCTEXT_ASCII (s); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3915 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3916 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3917 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3918 DECLARE_INLINE_HEADER (const Ibyte *DEFER_IGETTEXT (const Ibyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3919 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3920 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3921 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3922 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3923 DECLARE_INLINE_HEADER (const CIbyte *DEFER_CIGETTEXT (const CIbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3924 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3925 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3926 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3927 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3928 #define DEFER_GETTEXT DEFER_ASCGETTEXT |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3929 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3930 MODULE_API Lisp_Object build_defer_istring (const Ibyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3931 MODULE_API Lisp_Object build_defer_cistring (const CIbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3932 MODULE_API Lisp_Object build_defer_ascstring (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3933 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3934 #define build_defer_string build_defer_ascstring |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3935 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3936 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3937 void write_msg_istring (Lisp_Object stream, const Ibyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3938 void write_msg_cistring (Lisp_Object stream, const CIbyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3939 void write_msg_ascstring (Lisp_Object stream, const Ascbyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3940 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3941 #define write_msg_string write_msg_ascstring |
| 428 | 3942 |
| 3943 | |
| 3944 /************************************************************************/ | |
| 3945 /* Garbage collection / GC-protection */ | |
| 3946 /************************************************************************/ | |
| 3947 | |
| 3948 /* Structure for recording stack slots that need marking */ | |
| 3949 | |
| 3950 /* This is a chain of structures, each of which points at a Lisp_Object | |
| 3951 variable whose value should be marked in garbage collection. | |
| 3952 Normally every link of the chain is an automatic variable of a function, | |
| 3953 and its `val' points to some argument or local variable of the function. | |
| 3954 On exit to the function, the chain is set back to the value it had on | |
| 3955 entry. This way, no link remains in the chain when the stack frame | |
| 3956 containing the link disappears. | |
| 3957 | |
| 3958 Every function that can call Feval must protect in this fashion all | |
| 3959 Lisp_Object variables whose contents will be used again. */ | |
| 3960 | |
| 1632 | 3961 extern MODULE_API struct gcpro *gcprolist; |
| 428 | 3962 |
| 1743 | 3963 END_C_DECLS |
| 1650 | 3964 |
| 1204 | 3965 /* #### Catching insufficient gcpro: |
| 3966 | |
| 3967 The C++ code below catches GCPRO without UNGCPRO or vice-versa. | |
| 3968 Catching cases where there's no GCPRO or UNGCPRO but should be, however, | |
| 3969 is much harder, but could be done: | |
| 3970 | |
| 3971 1. Lisp_Object becomes a real object. Its creator and destructor need to | |
| 3972 figure out whether the object is on the stack (by looking at the range | |
| 3973 that `this' is within), and if so, add the pointer to a list of all | |
| 3974 stack-based Lisp_Objects. | |
| 3975 | |
| 3976 2. The assignment method needs to do reference-counting on actual Lisp | |
| 3977 objects -- in particular, we need to know if there are any references | |
| 3978 to a Lisp object that are *NOT* from stack-based Lisp_Objects. | |
| 3979 | |
| 3980 3. When we get to a point in the code where we might garbage collect -- | |
| 3981 i.e. Ffuncall(), Feval(), or Fgarbage_collect() is called -- we look | |
| 3982 at our list of stack-based Lisp_Objects, and if there are any that | |
| 3983 point to Lisp objects with no non-stack references, see if there are | |
| 3984 any gcpros pointing to the object, and if not, set a flag indicating | |
| 3985 that the object is "destroyed". (Don't abort yet because the function | |
| 3986 might not use the object any more.) | |
| 3987 | |
| 3988 4. When we detag a pointer using XFOO(), abort if its "destroyed" flag | |
| 3989 is set. | |
| 3990 | |
| 3991 --ben | |
| 3992 */ | |
| 3993 | |
| 428 | 3994 struct gcpro |
| 3995 { | |
| 3996 struct gcpro *next; | |
| 771 | 3997 const Lisp_Object *var; /* Address of first protected variable */ |
| 428 | 3998 int nvars; /* Number of consecutive protected variables */ |
| 1204 | 3999 #if defined (__cplusplus) && defined (ERROR_CHECK_GC) |
| 4000 /* Try to catch GCPRO without UNGCPRO, or vice-versa. G++ complains (at | |
| 4001 least with sufficient numbers of warnings enabled, i.e. -Weffc++) if a | |
| 4002 copy constructor or assignment operator is not defined. */ | |
| 4003 gcpro () : next (0), var (0), nvars (0) { } | |
| 4004 gcpro (const gcpro& g) : next (g.next), var (g.var), nvars (g.nvars) { } | |
| 4005 gcpro& operator= (const gcpro& g) { next = g.next; var = g.var; | |
| 4006 nvars = g.nvars; | |
| 4007 return *this;} | |
| 4008 ~gcpro () { assert (!next); } | |
| 4009 #endif /* defined (__cplusplus) && defined (ERROR_CHECK_GC) */ | |
| 428 | 4010 }; |
| 4011 | |
| 4012 /* Normally, you declare variables gcpro1, gcpro2, ... and use the | |
| 4013 GCPROn() macros. However, if you need to have nested gcpro's, | |
| 4014 declare ngcpro1, ngcpro2, ... and use NGCPROn(). If you need | |
| 4015 to nest another level, use nngcpro1, nngcpro2, ... and use | |
| 4016 NNGCPROn(). If you need to nest yet another level, create | |
| 4017 the appropriate macros. */ | |
| 4018 | |
| 1123 | 4019 /* NOTE: About comments like "This function does not GC": These are there to |
| 4020 try to track whether GCPROing is necessary. Strictly speaking, some | |
| 4021 functions that say this might actually GC, but only when it is never | |
| 4022 possible to return (more specifically, in the process of signalling an | |
| 4023 error, the debugger may be invoked, and could GC). For GCPRO purposes, | |
| 4024 you only have to worry about functions that can GC and then return. | |
| 4025 The QUIT macro cannot GC any more, although this wasn't true at some point, | |
| 4026 and so some "This function can GC" comments may be inaccurate. | |
| 4027 */ | |
| 4028 | |
| 1743 | 4029 BEGIN_C_DECLS |
| 1650 | 4030 |
| 2367 | 4031 #define XGCDECL1(x) struct gcpro x##cpro1 |
| 4032 #define XGCDECL2(x) struct gcpro x##cpro1, x##cpro2 | |
| 4033 #define XGCDECL3(x) struct gcpro x##cpro1, x##cpro2, x##cpro3 | |
| 4034 #define XGCDECL4(x) struct gcpro x##cpro1, x##cpro2, x##cpro3, x##cpro4 | |
| 4035 #define XGCDECL5(x) struct gcpro x##cpro1, x##cpro2, x##cpro3, x##cpro4, x##cpro5 | |
| 4036 | |
| 428 | 4037 #ifdef DEBUG_GCPRO |
| 4038 | |
| 2367 | 4039 MODULE_API void debug_gcpro1 (Ascbyte *, int, struct gcpro *, Lisp_Object *); |
| 4040 MODULE_API void debug_gcpro2 (Ascbyte *, int, struct gcpro *, struct gcpro *, | |
| 1632 | 4041 Lisp_Object *, Lisp_Object *); |
| 2367 | 4042 MODULE_API void debug_gcpro3 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4043 struct gcpro *, Lisp_Object *, Lisp_Object *, |
| 4044 Lisp_Object *); | |
| 2367 | 4045 MODULE_API void debug_gcpro4 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4046 struct gcpro *, struct gcpro *, Lisp_Object *, |
| 4047 Lisp_Object *, Lisp_Object *, Lisp_Object *); | |
| 2367 | 4048 MODULE_API void debug_gcpro5 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4049 struct gcpro *, struct gcpro *, struct gcpro *, |
| 4050 Lisp_Object *, Lisp_Object *, Lisp_Object *, | |
| 4051 Lisp_Object *, Lisp_Object *); | |
| 2367 | 4052 MODULE_API void debug_ungcpro(Ascbyte *, int, struct gcpro *); |
| 4053 | |
| 4054 #define XGCPRO1(x,v) \ | |
| 4055 debug_gcpro1 (__FILE__, __LINE__,&x##cpro1,&v) | |
| 4056 #define XGCPRO2(x,v1,v2) \ | |
| 4057 debug_gcpro2 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&v1,&v2) | |
| 4058 #define XGCPRO3(x,v1,v2,v3) \ | |
| 4059 debug_gcpro3 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4060 &v1,&v2,&v3) | |
| 4061 #define XGCPRO4(x,v1,v2,v3,v4) \ | |
| 4062 debug_gcpro4 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4063 &x##cpro4, \ | |
| 428 | 4064 &v1,&v2,&v3,&v4) |
| 2367 | 4065 #define XGCPRO5(x,v1,v2,v3,v4,v5) \ |
| 4066 debug_gcpro5 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4067 &x##cpro4,&x##cpro5, \ | |
| 428 | 4068 &v1,&v2,&v3,&v4,&v5) |
| 2367 | 4069 #define XUNGCPRO(x) \ |
| 4070 debug_ungcpro(__FILE__, __LINE__,&x##cpro1) | |
| 428 | 4071 |
| 4072 #else /* ! DEBUG_GCPRO */ | |
| 4073 | |
| 2367 | 4074 #define XGCPRO1(x, var1) ((void) ( \ |
| 4075 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4076 gcprolist = &x##cpro1 )) | |
| 4077 | |
| 4078 #define XGCPRO2(x, var1, var2) ((void) ( \ | |
| 4079 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4080 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4081 gcprolist = &x##cpro2 )) | |
| 4082 | |
| 4083 #define XGCPRO3(x, var1, var2, var3) ((void) ( \ | |
| 4084 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4085 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4086 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4087 gcprolist = &x##cpro3 )) | |
| 4088 | |
| 4089 #define XGCPRO4(x, var1, var2, var3, var4) ((void) ( \ | |
| 4090 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4091 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4092 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4093 x##cpro4.next = &x##cpro3, x##cpro4.var = &var4, x##cpro4.nvars = 1, \ | |
| 4094 gcprolist = &x##cpro4 )) | |
| 4095 | |
| 4096 #define XGCPRO5(x, var1, var2, var3, var4, var5) ((void) ( \ | |
| 4097 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4098 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4099 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4100 x##cpro4.next = &x##cpro3, x##cpro4.var = &var4, x##cpro4.nvars = 1, \ | |
| 4101 x##cpro5.next = &x##cpro4, x##cpro5.var = &var5, x##cpro5.nvars = 1, \ | |
| 4102 gcprolist = &x##cpro5 )) | |
| 4103 | |
| 4104 #define XGCPRO1_ARRAY(x, array, n) ((void) ( \ | |
| 4105 x##cpro1.next = gcprolist, x##cpro1.var = array, x##cpro1.nvars = n, \ | |
| 4106 gcprolist = &x##cpro1 )) | |
| 4107 | |
| 4108 #define XGCPRO2_ARRAY(x, array1, n1, array2, n2) ((void) ( \ | |
| 4109 x##cpro1.next = gcprolist, x##cpro1.var = array1, x##cpro1.nvars = n1, \ | |
| 4110 x##cpro2.next = &x##cpro1, x##cpro2.var = array2, x##cpro2.nvars = n2, \ | |
| 4111 gcprolist = &x##cpro2 )) | |
| 4112 | |
| 4113 #define XGCPRO3_ARRAY(x, array1, n1, array2, n2, array3, n3) ((void) ( \ | |
| 4114 x##cpro1.next = gcprolist, x##cpro1.var = array1, x##cpro1.nvars = n1, \ | |
| 4115 x##cpro2.next = &x##cpro1, x##cpro2.var = array2, x##cpro2.nvars = n2, \ | |
| 4116 x##cpro3.next = &x##cpro2, x##cpro3.var = array3, x##cpro3.nvars = n3, \ | |
| 4117 gcprolist = &x##cpro3 )) | |
| 853 | 4118 |
| 1204 | 4119 #if defined (__cplusplus) && defined (ERROR_CHECK_GC) |
| 4120 /* We need to reset each gcpro to avoid triggering the assert() in | |
| 4121 ~gcpro(). This happens in UNGCPRO and longjmp(). */ | |
| 4122 #define UNWIND_GCPRO_TO(val) \ | |
| 4123 do \ | |
| 4124 { \ | |
| 4125 struct gcpro *__gcpro_stop = (val); \ | |
| 4126 /* Try to catch UNGCPRO without GCPRO. We arrange for there to be a \ | |
| 4127 sentinel at the end of the gcprolist, so it should never be NULL. */ \ | |
| 4128 assert (__gcpro_stop); \ | |
| 4129 while (gcprolist != __gcpro_stop) \ | |
| 4130 { \ | |
| 4131 struct gcpro *__gcpro_next = gcprolist->next; \ | |
| 4132 gcprolist->next = 0; \ | |
| 4133 gcprolist = __gcpro_next; \ | |
| 4134 assert (gcprolist); \ | |
| 4135 } \ | |
| 4136 } while (0) | |
| 4137 #else | |
| 4138 #define UNWIND_GCPRO_TO(val) (gcprolist = (val)) | |
| 4139 #endif /* defined (__cplusplus) && defined (ERROR_CHECK_GC) */ | |
| 4140 | |
| 2367 | 4141 #define XUNGCPRO(x) UNWIND_GCPRO_TO (x##cpro1.next) |
| 428 | 4142 |
| 4143 #endif /* ! DEBUG_GCPRO */ | |
| 4144 | |
| 2367 | 4145 #define GCDECL1 XGCDECL1 (g) |
| 4146 #define GCDECL2 XGCDECL2 (g) | |
| 4147 #define GCDECL3 XGCDECL3 (g) | |
| 4148 #define GCDECL4 XGCDECL4 (g) | |
| 4149 #define GCDECL5 XGCDECL5 (g) | |
| 4150 | |
| 4151 #define GCPRO1(a) XGCPRO1 (g,a) | |
| 4152 #define GCPRO2(a,b) XGCPRO2 (g,a,b) | |
| 4153 #define GCPRO3(a,b,c) XGCPRO3 (g,a,b,c) | |
| 4154 #define GCPRO4(a,b,c,d) XGCPRO4 (g,a,b,c,d) | |
| 4155 #define GCPRO5(a,b,c,d,e) XGCPRO5 (g,a,b,c,d,e) | |
| 4156 | |
| 4157 #define GCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(g,a1,n1) | |
| 4158 #define GCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (g,a1,n1,a2,n2) | |
| 4159 #define GCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (g,a1,n1,a2,n2,a3,n3) | |
| 4160 | |
| 4161 #define UNGCPRO XUNGCPRO (g) | |
| 4162 | |
| 4163 #define NGCDECL1 XGCDECL1 (ng) | |
| 4164 #define NGCDECL2 XGCDECL2 (ng) | |
| 4165 #define NGCDECL3 XGCDECL3 (ng) | |
| 4166 #define NGCDECL4 XGCDECL4 (ng) | |
| 4167 #define NGCDECL5 XGCDECL5 (ng) | |
| 4168 | |
| 4169 #define NGCPRO1(a) XGCPRO1 (ng,a) | |
| 4170 #define NGCPRO2(a,b) XGCPRO2 (ng,a,b) | |
| 4171 #define NGCPRO3(a,b,c) XGCPRO3 (ng,a,b,c) | |
| 4172 #define NGCPRO4(a,b,c,d) XGCPRO4 (ng,a,b,c,d) | |
| 4173 #define NGCPRO5(a,b,c,d,e) XGCPRO5 (ng,a,b,c,d,e) | |
| 4174 | |
| 4175 #define NGCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(ng,a1,n1) | |
| 4176 #define NGCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (ng,a1,n1,a2,n2) | |
| 4177 #define NGCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (ng,a1,n1,a2,n2,a3,n3) | |
| 4178 | |
| 4179 #define NUNGCPRO XUNGCPRO (ng) | |
| 4180 | |
| 4181 #define NNGCDECL1 XGCDECL1 (nng) | |
| 4182 #define NNGCDECL2 XGCDECL2 (nng) | |
| 4183 #define NNGCDECL3 XGCDECL3 (nng) | |
| 4184 #define NNGCDECL4 XGCDECL4 (nng) | |
| 4185 #define NNGCDECL5 XGCDECL5 (nng) | |
| 4186 | |
| 4187 #define NNGCPRO1(a) XGCPRO1 (nng,a) | |
| 4188 #define NNGCPRO2(a,b) XGCPRO2 (nng,a,b) | |
| 4189 #define NNGCPRO3(a,b,c) XGCPRO3 (nng,a,b,c) | |
| 4190 #define NNGCPRO4(a,b,c,d) XGCPRO4 (nng,a,b,c,d) | |
| 4191 #define NNGCPRO5(a,b,c,d,e) XGCPRO5 (nng,a,b,c,d,e) | |
| 4192 | |
| 4193 #define NNGCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(nng,a1,n1) | |
| 4194 #define NNGCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (nng,a1,n1,a2,n2) | |
| 4195 #define NNGCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (nng,a1,n1,a2,n2,a3,n3) | |
| 4196 | |
| 4197 #define NNUNGCPRO XUNGCPRO (nng) | |
| 4198 | |
| 428 | 4199 /* Evaluate expr, UNGCPRO, and then return the value of expr. */ |
| 4200 #define RETURN_UNGCPRO(expr) do \ | |
| 4201 { \ | |
| 4202 Lisp_Object ret_ungc_val = (expr); \ | |
| 4203 UNGCPRO; \ | |
| 4204 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4205 } while (0) | |
| 4206 | |
| 4207 /* Evaluate expr, NUNGCPRO, UNGCPRO, and then return the value of expr. */ | |
| 4208 #define RETURN_NUNGCPRO(expr) do \ | |
| 4209 { \ | |
| 4210 Lisp_Object ret_ungc_val = (expr); \ | |
| 4211 NUNGCPRO; \ | |
| 4212 UNGCPRO; \ | |
| 4213 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4214 } while (0) | |
| 4215 | |
| 4216 /* Evaluate expr, NNUNGCPRO, NUNGCPRO, UNGCPRO, and then return the | |
| 4217 value of expr. */ | |
| 4218 #define RETURN_NNUNGCPRO(expr) do \ | |
| 4219 { \ | |
| 4220 Lisp_Object ret_ungc_val = (expr); \ | |
| 4221 NNUNGCPRO; \ | |
| 4222 NUNGCPRO; \ | |
| 4223 UNGCPRO; \ | |
| 4224 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4225 } while (0) | |
| 4226 | |
| 452 | 4227 extern Lisp_Object_ptr_dynarr *staticpros; |
| 3092 | 4228 extern Lisp_Object_ptr_dynarr *staticpros_nodump; |
| 771 | 4229 #ifdef DEBUG_XEMACS |
| 4230 | |
| 4231 /* Help debug crashes gc-marking a staticpro'ed object. */ | |
| 4232 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4233 MODULE_API void staticpro_1 (Lisp_Object *, const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4234 MODULE_API void staticpro_nodump_1 (Lisp_Object *, const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4235 #define staticpro(ptr) staticpro_1 (ptr, #ptr) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4236 #define staticpro_nodump(ptr) staticpro_nodump_1 (ptr, #ptr) |
| 771 | 4237 |
| 996 | 4238 #ifdef HAVE_SHLIB |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4239 MODULE_API void unstaticpro_nodump_1 (Lisp_Object *, const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4240 #define unstaticpro_nodump(ptr) unstaticpro_nodump_1 (ptr, #ptr) |
| 996 | 4241 #endif |
| 4242 | |
| 771 | 4243 #else |
| 611 | 4244 |
| 428 | 4245 /* Call staticpro (&var) to protect static variable `var'. */ |
| 1632 | 4246 MODULE_API void staticpro (Lisp_Object *); |
| 428 | 4247 |
| 4248 /* Call staticpro_nodump (&var) to protect static variable `var'. */ | |
| 4249 /* var will not be saved at dump time */ | |
| 1632 | 4250 MODULE_API void staticpro_nodump (Lisp_Object *); |
| 428 | 4251 |
| 996 | 4252 #ifdef HAVE_SHLIB |
| 4253 /* Call unstaticpro_nodump (&var) to stop protecting static variable `var'. */ | |
| 1632 | 4254 MODULE_API void unstaticpro_nodump (Lisp_Object *); |
| 996 | 4255 #endif |
| 4256 | |
| 771 | 4257 #endif |
| 4258 | |
| 3263 | 4259 #ifdef NEW_GC |
| 2720 | 4260 extern Lisp_Object_dynarr *mcpros; |
| 4261 #ifdef DEBUG_XEMACS | |
| 4262 /* Help debug crashes gc-marking a mcpro'ed object. */ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4263 MODULE_API void mcpro_1 (Lisp_Object, const Ascbyte *); |
| 2720 | 4264 #define mcpro(ptr) mcpro_1 (ptr, #ptr) |
| 4265 #else /* not DEBUG_XEMACS */ | |
| 4266 /* Call mcpro (&var) to protect mc variable `var'. */ | |
| 4267 MODULE_API void mcpro (Lisp_Object); | |
| 4268 #endif /* not DEBUG_XEMACS */ | |
| 3263 | 4269 #endif /* NEW_GC */ |
| 2720 | 4270 |
| 771 | 4271 void register_post_gc_action (void (*fun) (void *), void *arg); |
| 4272 int begin_gc_forbidden (void); | |
| 4273 void end_gc_forbidden (int count); | |
| 1957 | 4274 extern int gc_currently_forbidden; |
| 771 | 4275 |
| 1743 | 4276 END_C_DECLS |
| 1650 | 4277 |
| 771 | 4278 |
| 4279 /************************************************************************/ | |
| 4280 /* Misc definitions */ | |
| 4281 /************************************************************************/ | |
| 442 | 4282 |
| 4283 /************************************************************************/ | |
| 1983 | 4284 /* Other numeric types */ |
| 4285 /************************************************************************/ | |
| 4286 #ifdef WITH_NUMBER_TYPES | |
| 4287 #include "number.h" | |
| 1986 | 4288 #else |
| 4289 #define make_integer(x) make_int(x) | |
| 1983 | 4290 #endif |
| 4291 | |
| 4292 | |
| 4293 /************************************************************************/ | |
| 442 | 4294 /* prototypes */ |
| 4295 /************************************************************************/ | |
| 4296 | |
| 4297 /* NOTE: Prototypes should go HERE, not in various header files, unless | |
| 4298 they specifically reference a type that's not defined in lisp.h. | |
| 4299 (And even then, you might consider adding the type to lisp.h.) | |
| 4300 | |
| 4301 The idea is that header files typically contain the innards of objects, | |
| 4302 and we want to minimize the number of "dependencies" of one file on | |
| 4303 the specifics of such objects. Putting prototypes here minimizes the | |
| 4304 number of header files that need to be included -- good for a number | |
| 4305 of reasons. --ben */ | |
| 4306 | |
| 4307 /*--------------- prototypes for various public c functions ------------*/ | |
| 4308 | |
| 4309 /* Prototypes for all init/syms_of/vars_of initialization functions. */ | |
| 4310 #include "symsinit.h" | |
| 4311 | |
| 1743 | 4312 BEGIN_C_DECLS |
| 1650 | 4313 |
| 826 | 4314 /* Defined in abbrev.c */ |
| 1632 | 4315 MODULE_API EXFUN (Fexpand_abbrev, 0); |
| 826 | 4316 |
| 428 | 4317 /* Defined in alloc.c */ |
| 1632 | 4318 MODULE_API EXFUN (Fcons, 2); |
| 4319 MODULE_API EXFUN (Flist, MANY); | |
| 826 | 4320 EXFUN (Fmake_byte_code, MANY); |
| 1632 | 4321 MODULE_API EXFUN (Fmake_list, 2); |
| 4322 MODULE_API EXFUN (Fmake_string, 2); | |
| 4323 MODULE_API EXFUN (Fmake_symbol, 1); | |
| 4324 MODULE_API EXFUN (Fmake_vector, 2); | |
| 4325 MODULE_API EXFUN (Fvector, MANY); | |
| 826 | 4326 |
| 3263 | 4327 #ifndef NEW_GC |
| 428 | 4328 void release_breathing_space (void); |
| 3263 | 4329 #endif /* not NEW_GC */ |
| 428 | 4330 Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object); |
| 1632 | 4331 MODULE_API Lisp_Object make_vector (Elemcount, Lisp_Object); |
| 4332 MODULE_API Lisp_Object vector1 (Lisp_Object); | |
| 4333 MODULE_API Lisp_Object vector2 (Lisp_Object, Lisp_Object); | |
| 4334 MODULE_API Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 665 | 4335 Lisp_Object make_bit_vector (Elemcount, Lisp_Object); |
| 4336 Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, Elemcount); | |
| 428 | 4337 Lisp_Object noseeum_make_marker (void); |
| 3092 | 4338 #ifndef NEW_GC |
| 428 | 4339 void garbage_collect_1 (void); |
| 3092 | 4340 #endif /* not NEW_GC */ |
| 1632 | 4341 MODULE_API Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object); |
| 4342 MODULE_API Lisp_Object cons3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4343 MODULE_API Lisp_Object list1 (Lisp_Object); | |
| 4344 MODULE_API Lisp_Object list2 (Lisp_Object, Lisp_Object); | |
| 4345 MODULE_API Lisp_Object list3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4346 MODULE_API Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4347 Lisp_Object); | |
| 4348 MODULE_API Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4349 Lisp_Object); | |
| 4350 MODULE_API Lisp_Object list6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4351 Lisp_Object, Lisp_Object); | |
| 428 | 4352 DECLARE_DOESNT_RETURN (memory_full (void)); |
| 4353 void disksave_object_finalization (void); | |
| 4354 extern int purify_flag; | |
| 3092 | 4355 #ifndef NEW_GC |
| 428 | 4356 extern EMACS_INT gc_generation_number[1]; |
| 3092 | 4357 #endif /* not NEW_GC */ |
| 428 | 4358 int c_readonly (Lisp_Object); |
| 4359 int lisp_readonly (Lisp_Object); | |
| 1632 | 4360 MODULE_API void copy_lisp_object (Lisp_Object dst, Lisp_Object src); |
| 4361 MODULE_API Lisp_Object build_intstring (const Ibyte *); | |
| 4362 MODULE_API Lisp_Object build_string (const CIbyte *); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4363 MODULE_API Lisp_Object build_ascstring (const Ascbyte *); |
| 1632 | 4364 MODULE_API Lisp_Object build_ext_string (const Extbyte *, Lisp_Object); |
| 4365 MODULE_API Lisp_Object make_string (const Ibyte *, Bytecount); | |
| 4366 MODULE_API Lisp_Object make_ext_string (const Extbyte *, EMACS_INT, Lisp_Object); | |
| 771 | 4367 void init_string_ascii_begin (Lisp_Object string); |
| 428 | 4368 Lisp_Object make_uninit_string (Bytecount); |
| 1632 | 4369 MODULE_API Lisp_Object make_float (double); |
| 867 | 4370 Lisp_Object make_string_nocopy (const Ibyte *, Bytecount); |
| 853 | 4371 void free_cons (Lisp_Object); |
| 428 | 4372 void free_list (Lisp_Object); |
| 4373 void free_alist (Lisp_Object); | |
| 1204 | 4374 void free_marker (Lisp_Object); |
| 428 | 4375 int object_dead_p (Lisp_Object); |
| 4376 void mark_object (Lisp_Object obj); | |
| 3092 | 4377 #ifndef NEW_GC |
| 1598 | 4378 #ifdef USE_KKCC |
| 2645 | 4379 #ifdef DEBUG_XEMACS |
| 4380 void kkcc_gc_stack_push_lisp_object_1 (Lisp_Object obj, int level, int pos); | |
| 4381 #define kkcc_gc_stack_push_lisp_object(obj, level, pos) \ | |
| 4382 kkcc_gc_stack_push_lisp_object_1 (obj, level, pos) | |
| 4383 void kkcc_backtrace (void); | |
| 4384 #else | |
| 4385 void kkcc_gc_stack_push_lisp_object_1 (Lisp_Object obj); | |
| 4386 #define kkcc_gc_stack_push_lisp_object(obj, level, pos) \ | |
| 4387 kkcc_gc_stack_push_lisp_object_1 (obj) | |
| 4388 #define kkcc_backtrace() | |
| 4389 #endif | |
| 1598 | 4390 #endif /* USE_KKCC */ |
| 3092 | 4391 #endif /* not NEW_GC */ |
| 428 | 4392 int marked_p (Lisp_Object obj); |
| 851 | 4393 extern int funcall_allocation_flag; |
| 814 | 4394 extern int need_to_garbage_collect; |
| 1632 | 4395 extern MODULE_API int need_to_check_c_alloca; |
| 888 | 4396 extern int need_to_signal_post_gc; |
| 1333 | 4397 extern Lisp_Object Qpost_gc_hook, Qgarbage_collecting; |
| 851 | 4398 void recompute_funcall_allocation_flag (void); |
| 428 | 4399 |
| 4400 #ifdef MEMORY_USAGE_STATS | |
| 665 | 4401 Bytecount malloced_storage_size (void *, Bytecount, struct overhead_stats *); |
| 4402 Bytecount fixed_type_block_overhead (Bytecount); | |
| 428 | 4403 #endif |
| 1204 | 4404 |
| 4405 #ifdef EVENT_DATA_AS_OBJECTS | |
| 4406 Lisp_Object make_key_data (void); | |
| 4407 Lisp_Object make_button_data (void); | |
| 4408 Lisp_Object make_motion_data (void); | |
| 4409 Lisp_Object make_process_data (void); | |
| 4410 Lisp_Object make_timeout_data (void); | |
| 4411 Lisp_Object make_magic_data (void); | |
| 4412 Lisp_Object make_magic_eval_data (void); | |
| 4413 Lisp_Object make_eval_data (void); | |
| 4414 Lisp_Object make_misc_user_data (void); | |
| 4415 void free_key_data (Lisp_Object); | |
| 4416 void free_button_data (Lisp_Object); | |
| 4417 void free_motion_data (Lisp_Object); | |
| 4418 void free_process_data (Lisp_Object); | |
| 4419 void free_timeout_data (Lisp_Object); | |
| 4420 void free_magic_data (Lisp_Object); | |
| 4421 void free_magic_eval_data (Lisp_Object); | |
| 4422 void free_eval_data (Lisp_Object); | |
| 4423 void free_misc_user_data (Lisp_Object); | |
| 4424 #endif /* EVENT_DATA_AS_OBJECTS */ | |
| 934 | 4425 |
| 428 | 4426 /* Defined in buffer.c */ |
| 4427 Lisp_Object get_truename_buffer (Lisp_Object); | |
| 4428 void switch_to_buffer (Lisp_Object, Lisp_Object); | |
| 4429 extern int find_file_compare_truenames; | |
| 4430 extern int find_file_use_truenames; | |
| 867 | 4431 Ibyte *get_initial_directory (Ibyte *pathname, Bytecount size); |
| 771 | 4432 void set_buffer_internal (struct buffer *b); |
| 4433 struct buffer *decode_buffer (Lisp_Object buffer, int allow_string); | |
| 4434 | |
| 4435 void record_buffer (Lisp_Object buf); | |
| 4436 Lisp_Object get_buffer (Lisp_Object name, | |
| 4437 int error_if_deleted_or_does_not_exist); | |
| 4438 int map_over_sharing_buffers (struct buffer *buf, | |
| 4439 int (*mapfun) (struct buffer *buf, | |
| 4440 void *closure), | |
| 4441 void *closure); | |
| 1204 | 4442 void cleanup_buffer_undo_lists (void); |
| 771 | 4443 |
| 4444 extern struct buffer *current_buffer; | |
| 4445 | |
| 4446 extern void init_initial_directory (void); /* initialize initial_directory */ | |
| 4447 | |
| 4448 EXFUN (Fbuffer_disable_undo, 1); | |
| 1632 | 4449 MODULE_API EXFUN (Fbuffer_modified_p, 1); |
| 4450 MODULE_API EXFUN (Fbuffer_name, 1); | |
| 4451 MODULE_API EXFUN (Fcurrent_buffer, 0); | |
| 771 | 4452 EXFUN (Ferase_buffer, 1); |
| 4453 EXFUN (Fget_buffer, 1); | |
| 4454 EXFUN (Fget_buffer_create, 1); | |
| 4455 EXFUN (Fget_file_buffer, 1); | |
| 1632 | 4456 MODULE_API EXFUN (Fkill_buffer, 1); |
| 771 | 4457 EXFUN (Fother_buffer, 3); |
| 4458 EXFUN (Frecord_buffer, 1); | |
| 1632 | 4459 MODULE_API EXFUN (Fset_buffer, 1); |
| 771 | 4460 EXFUN (Fset_buffer_modified_p, 2); |
| 4461 | |
| 4462 extern Lisp_Object QSscratch, Qafter_change_function, Qafter_change_functions; | |
| 4463 extern Lisp_Object Qbefore_change_function, Qbefore_change_functions; | |
| 4464 extern Lisp_Object Qbuffer_or_string_p, Qdefault_directory, Qfirst_change_hook; | |
| 4465 extern Lisp_Object Qpermanent_local, Vafter_change_function; | |
| 4466 extern Lisp_Object Vafter_change_functions, Vbefore_change_function; | |
| 4467 extern Lisp_Object Vbefore_change_functions, Vbuffer_alist, Vbuffer_defaults; | |
| 4468 extern Lisp_Object Vinhibit_read_only, Vtransient_mark_mode; | |
| 428 | 4469 |
| 563 | 4470 /* Defined in bytecode.c */ |
| 826 | 4471 EXFUN (Fbyte_code, 3); |
| 4472 | |
| 593 | 4473 DECLARE_DOESNT_RETURN (invalid_byte_code |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4474 (const Ascbyte *reason, Lisp_Object frob)); |
| 563 | 4475 |
| 4932 | 4476 extern Lisp_Object Qbyte_code, Qinvalid_byte_code; |
| 4477 | |
| 826 | 4478 /* Defined in callint.c */ |
| 4479 EXFUN (Fcall_interactively, 3); | |
| 4480 EXFUN (Fprefix_numeric_value, 1); | |
| 4481 | |
| 4482 /* Defined in casefiddle.c */ | |
| 4483 EXFUN (Fdowncase, 2); | |
| 4484 EXFUN (Fupcase, 2); | |
| 4485 EXFUN (Fupcase_initials, 2); | |
| 4486 EXFUN (Fupcase_initials_region, 3); | |
| 4487 EXFUN (Fupcase_region, 3); | |
| 4488 | |
| 4489 /* Defined in casetab.c */ | |
| 4490 EXFUN (Fset_standard_case_table, 1); | |
| 4491 | |
| 4492 /* Defined in chartab.c */ | |
| 4493 EXFUN (Freset_char_table, 1); | |
| 4494 | |
| 4495 /* Defined in cmds.c */ | |
| 4496 EXFUN (Fbeginning_of_line, 2); | |
| 4497 EXFUN (Fend_of_line, 2); | |
| 4498 EXFUN (Fforward_char, 2); | |
| 4499 EXFUN (Fforward_line, 2); | |
| 4500 | |
| 428 | 4501 /* Defined in data.c */ |
| 826 | 4502 EXFUN (Fadd1, 1); |
| 4503 EXFUN (Faref, 2); | |
| 4504 EXFUN (Faset, 3); | |
| 4505 EXFUN (Fcar, 1); | |
| 4506 EXFUN (Fcar_safe, 1); | |
| 4507 EXFUN (Fcdr, 1); | |
| 919 | 4508 EXFUN (Fcdr_safe, 1); |
| 826 | 4509 EXFUN (Fgeq, MANY); |
| 4510 EXFUN (Fgtr, MANY); | |
| 4511 EXFUN (Findirect_function, 1); | |
| 4512 EXFUN (Fleq, MANY); | |
| 4513 EXFUN (Flistp, 1); | |
| 4514 EXFUN (Flss, MANY); | |
| 4515 EXFUN (Fmax, MANY); | |
| 4516 EXFUN (Fmin, MANY); | |
| 4517 EXFUN (Fminus, MANY); | |
| 4518 EXFUN (Fnumber_to_string, 1); | |
| 4519 EXFUN (Fplus, MANY); | |
| 4520 EXFUN (Fquo, MANY); | |
| 4521 EXFUN (Frem, 2); | |
| 4522 EXFUN (Fsetcar, 2); | |
| 4523 EXFUN (Fsetcdr, 2); | |
| 4524 EXFUN (Fsub1, 1); | |
| 4525 EXFUN (Fsubr_max_args, 1); | |
| 4526 EXFUN (Fsubr_min_args, 1); | |
| 4527 EXFUN (Ftimes, MANY); | |
| 4528 | |
| 428 | 4529 DECLARE_DOESNT_RETURN (c_write_error (Lisp_Object)); |
| 4530 DECLARE_DOESNT_RETURN (lisp_write_error (Lisp_Object)); | |
| 4531 DECLARE_DOESNT_RETURN (args_out_of_range (Lisp_Object, Lisp_Object)); | |
| 4532 DECLARE_DOESNT_RETURN (args_out_of_range_3 (Lisp_Object, Lisp_Object, | |
| 4533 Lisp_Object)); | |
| 1632 | 4534 MODULE_API Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object); |
| 4535 MODULE_API | |
| 428 | 4536 DECLARE_DOESNT_RETURN (dead_wrong_type_argument (Lisp_Object, Lisp_Object)); |
| 4537 void check_int_range (EMACS_INT, EMACS_INT, EMACS_INT); | |
| 4538 | |
| 771 | 4539 EXFUN (Fint_to_char, 1); |
| 4540 EXFUN (Fchar_to_int, 1); | |
| 4541 | |
| 428 | 4542 enum arith_comparison { |
| 4543 arith_equal, | |
| 4544 arith_notequal, | |
| 4545 arith_less, | |
| 4546 arith_grtr, | |
| 4547 arith_less_or_equal, | |
| 4548 arith_grtr_or_equal }; | |
| 4549 Lisp_Object arithcompare (Lisp_Object, Lisp_Object, enum arith_comparison); | |
| 4550 | |
| 707 | 4551 /* Do NOT use word_to_lisp or wasteful_word_to_lisp to decode time_t's |
| 4552 unless you KNOW arg is non-negative. They cannot return negative | |
| 4553 values! Use make_time. */ | |
| 428 | 4554 Lisp_Object word_to_lisp (unsigned int); |
| 4555 unsigned int lisp_to_word (Lisp_Object); | |
| 4556 | |
| 4932 | 4557 extern Lisp_Object Qarrayp, Qbitp, Qchar_or_string_p, Qcharacterp, |
| 4558 Qerror_conditions, Qerror_message, Qinteger_char_or_marker_p, | |
| 4559 Qinteger_or_char_p, Qinteger_or_marker_p, Qlambda, Qlistp, Qnatnump, | |
| 4560 Qnonnegativep, Qnumber_char_or_marker_p, Qnumberp, Qquote, Qtrue_list_p; | |
| 4561 extern MODULE_API Lisp_Object Qintegerp; | |
| 4562 | |
| 4563 extern Lisp_Object Qarith_error, Qbeginning_of_buffer, Qbuffer_read_only, | |
| 4564 Qcircular_list, Qcircular_property_list, Qconversion_error, | |
| 4565 Qcyclic_variable_indirection, Qdomain_error, Qediting_error, | |
| 4566 Qend_of_buffer, Qend_of_file, Qerror, Qfile_error, Qinternal_error, | |
| 4567 Qinvalid_change, Qinvalid_constant, Qinvalid_function, Qinvalid_operation, | |
| 4568 Qinvalid_read_syntax, Qinvalid_state, Qio_error, Qlist_formation_error, | |
| 4569 Qmalformed_list, Qmalformed_property_list, Qno_catch, Qout_of_memory, | |
| 4570 Qoverflow_error, Qprinting_unreadable_object, Qquit, Qrange_error, | |
| 4571 Qsetting_constant, Qsingularity_error, Qstack_overflow, | |
| 4572 Qstructure_formation_error, Qtext_conversion_error, Qunderflow_error, | |
| 4573 Qvoid_function, Qvoid_variable, Qwrong_number_of_arguments, | |
| 4574 Qwrong_type_argument; | |
| 4575 extern MODULE_API Lisp_Object Qinvalid_argument, Qsyntax_error; | |
| 4576 | |
| 428 | 4577 /* Defined in dired.c */ |
| 867 | 4578 Lisp_Object make_directory_hash_table (const Ibyte *); |
| 428 | 4579 Lisp_Object wasteful_word_to_lisp (unsigned int); |
| 4580 | |
| 4581 /* Defined in doc.c */ | |
| 826 | 4582 EXFUN (Fsubstitute_command_keys, 1); |
| 4583 | |
| 814 | 4584 Lisp_Object unparesseuxify_doc_string (int fd, EMACS_INT position, |
| 867 | 4585 Ibyte *name_nonreloc, |
| 814 | 4586 Lisp_Object name_reloc, |
| 4587 int standard_doc_file); | |
| 428 | 4588 Lisp_Object read_doc_string (Lisp_Object); |
| 4589 | |
| 4590 /* Defined in doprnt.c */ | |
| 867 | 4591 Bytecount emacs_doprnt_va (Lisp_Object stream, const Ibyte *format_nonreloc, |
| 771 | 4592 Bytecount format_length, Lisp_Object format_reloc, |
| 4593 va_list vargs); | |
| 867 | 4594 Bytecount emacs_doprnt (Lisp_Object stream, const Ibyte *format_nonreloc, |
| 771 | 4595 Bytecount format_length, Lisp_Object format_reloc, |
| 4596 int nargs, const Lisp_Object *largs, ...); | |
| 867 | 4597 Lisp_Object emacs_vsprintf_string_lisp (const CIbyte *format_nonreloc, |
| 771 | 4598 Lisp_Object format_reloc, int nargs, |
| 4599 const Lisp_Object *largs); | |
| 867 | 4600 Lisp_Object emacs_sprintf_string_lisp (const CIbyte *format_nonreloc, |
| 771 | 4601 Lisp_Object format_reloc, int nargs, ...); |
| 867 | 4602 Ibyte *emacs_vsprintf_malloc_lisp (const CIbyte *format_nonreloc, |
| 771 | 4603 Lisp_Object format_reloc, int nargs, |
| 4604 const Lisp_Object *largs, | |
| 4605 Bytecount *len_out); | |
| 867 | 4606 Ibyte *emacs_sprintf_malloc_lisp (Bytecount *len_out, |
| 4607 const CIbyte *format_nonreloc, | |
| 771 | 4608 Lisp_Object format_reloc, int nargs, ...); |
| 867 | 4609 Lisp_Object emacs_vsprintf_string (const CIbyte *format, va_list vargs); |
| 4610 Lisp_Object emacs_sprintf_string (const CIbyte *format, ...) | |
| 771 | 4611 PRINTF_ARGS (1, 2); |
| 867 | 4612 Ibyte *emacs_vsprintf_malloc (const CIbyte *format, va_list vargs, |
| 771 | 4613 Bytecount *len_out); |
| 867 | 4614 Ibyte *emacs_sprintf_malloc (Bytecount *len_out, const CIbyte *format, ...) |
| 771 | 4615 PRINTF_ARGS (2, 3); |
| 867 | 4616 Bytecount emacs_vsprintf (Ibyte *output, const CIbyte *format, |
| 771 | 4617 va_list vargs); |
| 867 | 4618 Bytecount emacs_sprintf (Ibyte *output, const CIbyte *format, ...) |
| 771 | 4619 PRINTF_ARGS (2, 3); |
| 4620 | |
| 428 | 4621 |
| 4622 /* Defined in editfns.c */ | |
| 826 | 4623 EXFUN (Fbobp, 1); |
| 4624 EXFUN (Fbolp, 1); | |
| 4625 EXFUN (Fbuffer_substring, 3); | |
| 4626 EXFUN (Fchar_after, 2); | |
| 4627 EXFUN (Fchar_to_string, 1); | |
| 4628 EXFUN (Fdelete_region, 3); | |
| 4629 EXFUN (Feobp, 1); | |
| 4630 EXFUN (Feolp, 1); | |
| 4631 EXFUN (Ffollowing_char, 1); | |
| 4632 EXFUN (Fformat, MANY); | |
| 4633 EXFUN (Fgoto_char, 2); | |
| 4634 EXFUN (Finsert, MANY); | |
| 4635 EXFUN (Finsert_buffer_substring, 3); | |
| 4636 EXFUN (Finsert_char, 4); | |
| 4637 EXFUN (Fnarrow_to_region, 3); | |
| 4638 EXFUN (Fpoint, 1); | |
| 4639 EXFUN (Fpoint_marker, 2); | |
| 4640 EXFUN (Fpoint_max, 1); | |
| 4641 EXFUN (Fpoint_min, 1); | |
| 4642 EXFUN (Fpreceding_char, 1); | |
| 4643 EXFUN (Fsystem_name, 0); | |
| 4644 EXFUN (Fuser_home_directory, 0); | |
| 4645 EXFUN (Fuser_login_name, 1); | |
| 4646 EXFUN (Fwiden, 1); | |
| 4647 | |
| 428 | 4648 void uncache_home_directory (void); |
| 867 | 4649 Ibyte *get_home_directory (void); |
| 4650 Ibyte *user_login_name (uid_t *); | |
| 428 | 4651 void buffer_insert1 (struct buffer *, Lisp_Object); |
| 665 | 4652 Lisp_Object make_string_from_buffer (struct buffer *, Charbpos, Charcount); |
| 4653 Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Charbpos, Charcount); | |
| 707 | 4654 Lisp_Object make_time (time_t); |
| 428 | 4655 Lisp_Object save_excursion_save (void); |
| 844 | 4656 Lisp_Object save_restriction_save (struct buffer *buf); |
| 428 | 4657 Lisp_Object save_excursion_restore (Lisp_Object); |
| 4658 Lisp_Object save_restriction_restore (Lisp_Object); | |
| 771 | 4659 void widen_buffer (struct buffer *b, int no_clip); |
| 4660 int beginning_of_line_p (struct buffer *b, Charbpos pt); | |
| 428 | 4661 |
| 4662 /* Defined in emacsfns.c */ | |
| 4663 Lisp_Object save_current_buffer_restore (Lisp_Object); | |
| 4664 | |
| 4665 /* Defined in emacs.c */ | |
| 2268 | 4666 EXFUN_NORETURN (Fkill_emacs, 1); |
| 826 | 4667 EXFUN (Frunning_temacs_p, 0); |
| 1123 | 4668 EXFUN (Fforce_debugging_signal, 1); |
| 826 | 4669 |
| 428 | 4670 SIGTYPE fatal_error_signal (int); |
| 2367 | 4671 Lisp_Object make_arg_list (int, Wexttext **); |
| 4672 void make_argc_argv (Lisp_Object, int *, Wexttext ***); | |
| 4673 void free_argc_argv (Wexttext **); | |
| 771 | 4674 Lisp_Object split_external_path (const Extbyte *path); |
| 867 | 4675 Lisp_Object split_env_path (const CIbyte *evarname, const Ibyte *default_); |
| 771 | 4676 |
| 428 | 4677 /* Nonzero means don't do interactive redisplay and don't change tty modes */ |
| 442 | 4678 extern int noninteractive, noninteractive1; |
| 2367 | 4679 extern int inhibit_non_essential_conversion_operations; |
| 428 | 4680 extern int preparing_for_armageddon; |
| 458 | 4681 extern Fixnum emacs_priority; |
| 428 | 4682 extern int suppress_early_error_handler_backtrace; |
| 771 | 4683 void debug_break (void); |
| 4854 | 4684 int debug_can_access_memory (const void *ptr, Bytecount len); |
| 2210 | 4685 DECLARE_DOESNT_RETURN (really_abort (void)); |
| 776 | 4686 void zero_out_command_line_status_vars (void); |
| 428 | 4687 |
| 826 | 4688 /* Defined in emodules.c */ |
| 996 | 4689 #ifdef HAVE_SHLIB |
| 826 | 4690 EXFUN (Flist_modules, 0); |
| 4691 EXFUN (Fload_module, 3); | |
| 996 | 4692 extern int unloading_module; |
| 4693 #endif | |
| 826 | 4694 |
| 428 | 4695 /* Defined in eval.c */ |
| 1706 | 4696 MODULE_API EXFUN (Fapply, MANY); |
| 826 | 4697 EXFUN (Fbacktrace, 2); |
| 4698 EXFUN (Fcommand_execute, 3); | |
| 4699 EXFUN (Fcommandp, 1); | |
|
4744
17f7e9191c0b
Rationalise duplicated functionality, #'custom-quote, #'quote-maybe.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4690
diff
changeset
|
4700 EXFUN (Fquote_maybe, 1); |
| 1706 | 4701 MODULE_API EXFUN (Feval, 1); |
| 4702 MODULE_API EXFUN (Ffuncall, MANY); | |
| 826 | 4703 EXFUN (Ffunctionp, 1); |
| 4704 EXFUN (Finteractive_p, 0); | |
| 4705 EXFUN (Fprogn, UNEVALLED); | |
| 1706 | 4706 MODULE_API EXFUN (Fsignal, 2); |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4707 MODULE_API EXFUN_NORETURN (Fthrow, UNEVALLED); |
| 1706 | 4708 MODULE_API EXFUN (Fcall_with_condition_handler, MANY); |
| 853 | 4709 EXFUN (Ffunction_max_args, 1); |
| 4710 EXFUN (Ffunction_min_args, 1); | |
| 826 | 4711 |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4712 MODULE_API DECLARE_DOESNT_RETURN (throw_or_bomb_out (Lisp_Object, |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4713 Lisp_Object, int, |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4714 Lisp_Object, Lisp_Object)); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4715 |
| 1632 | 4716 MODULE_API DECLARE_DOESNT_RETURN (signal_error_1 (Lisp_Object, Lisp_Object)); |
| 563 | 4717 void maybe_signal_error_1 (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 4718 Error_Behavior); |
| 563 | 4719 Lisp_Object maybe_signal_continuable_error_1 (Lisp_Object, Lisp_Object, |
| 578 | 4720 Lisp_Object, Error_Behavior); |
| 1743 | 4721 MODULE_API DECLARE_DOESNT_RETURN (signal_ferror (Lisp_Object, const CIbyte *, |
| 4722 ...)) PRINTF_ARGS(2, 3); | |
| 578 | 4723 void maybe_signal_ferror (Lisp_Object, Lisp_Object, Error_Behavior, |
| 867 | 4724 const CIbyte *, ...) PRINTF_ARGS (4, 5); |
| 4725 Lisp_Object signal_continuable_ferror (Lisp_Object, const CIbyte *, ...) | |
| 442 | 4726 PRINTF_ARGS (2, 3); |
| 563 | 4727 Lisp_Object maybe_signal_continuable_ferror (Lisp_Object, Lisp_Object, |
| 578 | 4728 Error_Behavior, |
| 867 | 4729 const CIbyte *, ...) |
| 442 | 4730 PRINTF_ARGS (4, 5); |
| 563 | 4731 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4732 Lisp_Object build_error_data (const Ascbyte *reason, Lisp_Object frob); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4733 DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const Ascbyte *, |
| 563 | 4734 Lisp_Object)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4735 void maybe_signal_error (Lisp_Object, const Ascbyte *, Lisp_Object, |
| 578 | 4736 Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4737 Lisp_Object signal_continuable_error (Lisp_Object, const Ascbyte *, |
| 563 | 4738 Lisp_Object); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4739 Lisp_Object maybe_signal_continuable_error (Lisp_Object, const Ascbyte *, |
| 563 | 4740 Lisp_Object, |
| 578 | 4741 Lisp_Object, Error_Behavior); |
| 1743 | 4742 DECLARE_DOESNT_RETURN (signal_ferror_with_frob (Lisp_Object, Lisp_Object, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4743 const Ascbyte *, ...)) |
| 1743 | 4744 PRINTF_ARGS(3, 4); |
| 563 | 4745 void maybe_signal_ferror_with_frob (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 4746 Error_Behavior, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4747 const Ascbyte *, ...) PRINTF_ARGS (5, 6); |
| 563 | 4748 Lisp_Object signal_continuable_ferror_with_frob (Lisp_Object, Lisp_Object, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4749 const Ascbyte *, |
| 563 | 4750 ...) PRINTF_ARGS (3, 4); |
| 4751 Lisp_Object maybe_signal_continuable_ferror_with_frob (Lisp_Object, | |
| 4752 Lisp_Object, | |
| 4753 Lisp_Object, | |
| 578 | 4754 Error_Behavior, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4755 const Ascbyte *, ...) |
| 442 | 4756 PRINTF_ARGS (5, 6); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4757 DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 4758 Lisp_Object, Lisp_Object)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4759 void maybe_signal_error_2 (Lisp_Object, const Ascbyte *, Lisp_Object, |
| 578 | 4760 Lisp_Object, Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4761 Lisp_Object signal_continuable_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 4762 Lisp_Object, Lisp_Object); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4763 Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 4764 Lisp_Object, Lisp_Object, |
| 4765 Lisp_Object, | |
| 578 | 4766 Error_Behavior); |
| 563 | 4767 |
| 4768 | |
| 1927 | 4769 MODULE_API DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object)); |
| 4770 MODULE_API DECLARE_DOESNT_RETURN (signal_malformed_property_list_error | |
| 4771 (Lisp_Object)); | |
| 4772 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object)); | |
| 4773 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_property_list_error | |
| 4774 (Lisp_Object)); | |
| 436 | 4775 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4776 DECLARE_DOESNT_RETURN (syntax_error (const Ascbyte *reason, |
| 609 | 4777 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4778 DECLARE_DOESNT_RETURN (syntax_error_2 (const Ascbyte *reason, |
| 609 | 4779 Lisp_Object frob1, |
| 442 | 4780 Lisp_Object frob2)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4781 void maybe_syntax_error (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4782 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4783 DECLARE_DOESNT_RETURN (sferror (const Ascbyte *reason, Lisp_Object frob)); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4784 DECLARE_DOESNT_RETURN (sferror_2 (const Ascbyte *reason, Lisp_Object frob1, |
| 563 | 4785 Lisp_Object frob2)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4786 void maybe_sferror (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4787 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4788 MODULE_API DECLARE_DOESNT_RETURN (invalid_argument (const Ascbyte *reason, |
| 1632 | 4789 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4790 MODULE_API DECLARE_DOESNT_RETURN (invalid_argument_2 (const Ascbyte *reason, |
| 1632 | 4791 Lisp_Object frob1, |
| 4792 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4793 void maybe_invalid_argument (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4794 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4795 MODULE_API DECLARE_DOESNT_RETURN (invalid_operation (const Ascbyte *reason, |
| 1632 | 4796 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4797 MODULE_API DECLARE_DOESNT_RETURN (invalid_operation_2 (const Ascbyte *reason, |
| 1632 | 4798 Lisp_Object frob1, |
| 4799 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4800 MODULE_API void maybe_invalid_operation (const Ascbyte *, Lisp_Object, |
| 1632 | 4801 Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4802 DECLARE_DOESNT_RETURN (invalid_state (const Ascbyte *reason, |
| 563 | 4803 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4804 DECLARE_DOESNT_RETURN (invalid_state_2 (const Ascbyte *reason, |
| 563 | 4805 Lisp_Object frob1, |
| 4806 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4807 void maybe_invalid_state (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 609 | 4808 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4809 DECLARE_DOESNT_RETURN (invalid_change (const Ascbyte *reason, |
| 563 | 4810 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4811 DECLARE_DOESNT_RETURN (invalid_change_2 (const Ascbyte *reason, |
| 563 | 4812 Lisp_Object frob1, |
| 4813 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4814 void maybe_invalid_change (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 609 | 4815 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4816 MODULE_API DECLARE_DOESNT_RETURN (invalid_constant (const Ascbyte *reason, |
| 1632 | 4817 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4818 DECLARE_DOESNT_RETURN (invalid_constant_2 (const Ascbyte *reason, |
| 563 | 4819 Lisp_Object frob1, |
| 4820 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4821 void maybe_invalid_constant (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4822 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4823 DECLARE_DOESNT_RETURN (wtaerror (const Ascbyte *reason, Lisp_Object frob)); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4824 MODULE_API DECLARE_DOESNT_RETURN (out_of_memory (const Ascbyte *reason, |
| 1632 | 4825 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4826 DECLARE_DOESNT_RETURN (stack_overflow (const Ascbyte *reason, |
| 442 | 4827 Lisp_Object frob)); |
| 4828 | |
| 436 | 4829 Lisp_Object signal_void_function_error (Lisp_Object); |
| 4830 Lisp_Object signal_invalid_function_error (Lisp_Object); | |
| 4831 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int); | |
| 4832 | |
| 428 | 4833 Lisp_Object run_hook_with_args_in_buffer (struct buffer *, int, Lisp_Object *, |
| 4834 enum run_hooks_condition); | |
| 4835 Lisp_Object run_hook_with_args (int, Lisp_Object *, enum run_hooks_condition); | |
| 4836 void va_run_hook_with_args (Lisp_Object, int, ...); | |
| 4837 void va_run_hook_with_args_in_buffer (struct buffer *, Lisp_Object, int, ...); | |
| 4838 Lisp_Object run_hook (Lisp_Object); | |
| 1706 | 4839 MODULE_API Lisp_Object apply1 (Lisp_Object, Lisp_Object); |
| 4840 MODULE_API Lisp_Object call0 (Lisp_Object); | |
| 4841 MODULE_API Lisp_Object call1 (Lisp_Object, Lisp_Object); | |
| 4842 MODULE_API Lisp_Object call2 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4843 MODULE_API Lisp_Object call3 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4844 Lisp_Object); | |
| 4845 MODULE_API Lisp_Object call4 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4846 Lisp_Object, Lisp_Object); | |
| 4847 MODULE_API Lisp_Object call5 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4848 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4849 MODULE_API Lisp_Object call6 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4850 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4851 Lisp_Object); | |
| 4852 MODULE_API Lisp_Object call7 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4853 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4854 Lisp_Object, Lisp_Object); | |
| 4855 MODULE_API Lisp_Object call8 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4856 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4857 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 428 | 4858 Lisp_Object call0_in_buffer (struct buffer *, Lisp_Object); |
| 4859 Lisp_Object call1_in_buffer (struct buffer *, Lisp_Object, Lisp_Object); | |
| 4860 Lisp_Object call2_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4861 Lisp_Object); | |
| 4862 Lisp_Object call3_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4863 Lisp_Object, Lisp_Object); | |
| 4864 Lisp_Object call4_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4865 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4866 Lisp_Object call5_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4867 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4868 Lisp_Object); | |
| 4869 Lisp_Object call6_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4870 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4871 Lisp_Object, Lisp_Object); | |
| 4872 Lisp_Object eval_in_buffer (struct buffer *, Lisp_Object); | |
| 853 | 4873 |
| 4874 struct call_trapping_problems_result | |
| 4875 { | |
| 4876 int caught_error, caught_throw; | |
| 4877 Lisp_Object error_conditions, data; | |
| 4878 Lisp_Object backtrace; | |
| 4879 Lisp_Object thrown_tag; | |
| 4880 Lisp_Object thrown_value; | |
| 4881 }; | |
| 4882 | |
| 4883 #define NO_INHIBIT_ERRORS (1<<0) | |
| 4884 #define NO_INHIBIT_THROWS (1<<1) | |
| 4885 #define INTERNAL_INHIBIT_ERRORS (1<<0) | |
| 4886 #define INTERNAL_INHIBIT_THROWS (1<<1) | |
| 4887 #define INHIBIT_WARNING_ISSUE (1<<2) | |
| 4888 #define ISSUE_WARNINGS_AT_DEBUG_LEVEL (1<<3) | |
| 4889 #define INHIBIT_QUIT (1<<4) | |
| 4890 #define UNINHIBIT_QUIT (1<<5) | |
| 4891 #define INHIBIT_GC (1<<6) | |
| 4892 #define INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION (1<<7) | |
| 4893 #define INHIBIT_EXISTING_CODING_SYSTEM_DELETION (1<<8) | |
| 4894 #define INHIBIT_EXISTING_CHARSET_DELETION (1<<9) | |
| 4895 #define INHIBIT_PERMANENT_DISPLAY_OBJECT_CREATION (1<<10) | |
| 4896 #define INHIBIT_CODING_SYSTEM_CREATION (1<<11) | |
| 4897 #define INHIBIT_CHARSET_CREATION (1<<12) | |
| 4898 #define INHIBIT_EXISTING_BUFFER_TEXT_MODIFICATION (1<<13) | |
| 4899 #define INHIBIT_ANY_CHANGE_AFFECTING_REDISPLAY (1<<14) | |
| 4900 #define INHIBIT_ENTERING_DEBUGGER (1<<15) | |
| 4901 #define CALL_WITH_SUSPENDED_ERRORS (1<<16) | |
| 1333 | 4902 #define POSTPONE_WARNING_ISSUE (1<<17) |
| 853 | 4903 |
| 4904 enum check_allowed_operation | |
| 4905 { | |
| 4906 OPERATION_DELETE_OBJECT, | |
| 4907 OPERATION_CREATE_OBJECT, | |
| 4908 OPERATION_MODIFY_BUFFER_TEXT, | |
| 1429 | 4909 OPERATION_MODIFY_OBJECT_PROPERTY |
| 853 | 4910 }; |
| 4911 | |
| 4912 int get_inhibit_flags (void); | |
| 4913 void check_allowed_operation (int what, Lisp_Object obj, Lisp_Object prop); | |
| 4914 void note_object_created (Lisp_Object obj); | |
| 4915 void note_object_deleted (Lisp_Object obj); | |
| 4916 Lisp_Object call_with_condition_handler (Lisp_Object (*handler) (Lisp_Object, | |
| 4917 Lisp_Object, | |
| 4918 Lisp_Object), | |
| 4919 Lisp_Object handler_arg, | |
| 4920 Lisp_Object (*fun) (Lisp_Object), | |
| 4921 Lisp_Object arg); | |
| 1318 | 4922 int set_trapping_problems_flags (int flags); |
| 853 | 4923 Lisp_Object call_trapping_problems (Lisp_Object warning_class, |
| 2367 | 4924 const Ascbyte *warning_string, |
| 853 | 4925 int flags, |
| 4926 struct call_trapping_problems_result | |
| 4927 *problem, | |
| 4928 Lisp_Object (*fun) (void *), | |
| 4929 void *arg); | |
| 4930 Lisp_Object va_call_trapping_problems (Lisp_Object warning_class, | |
| 2367 | 4931 const Ascbyte *warning_string, |
| 853 | 4932 int flags, |
| 4933 struct call_trapping_problems_result | |
| 4934 *problem, | |
| 4935 lisp_fn_t fun, int nargs, ...); | |
| 2367 | 4936 Lisp_Object call0_trapping_problems (const Ascbyte *, Lisp_Object, int); |
| 4937 Lisp_Object call1_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, | |
| 853 | 4938 int); |
| 2367 | 4939 Lisp_Object call2_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4940 Lisp_Object, int); |
| 2367 | 4941 Lisp_Object call3_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4942 Lisp_Object, Lisp_Object, int); |
| 2367 | 4943 Lisp_Object call4_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4944 Lisp_Object, Lisp_Object, Lisp_Object, |
| 4945 int); | |
| 2367 | 4946 Lisp_Object call5_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4947 Lisp_Object, Lisp_Object, Lisp_Object, |
| 4948 Lisp_Object, int); | |
| 2367 | 4949 Lisp_Object eval_in_buffer_trapping_problems (const Ascbyte *, struct buffer *, |
| 853 | 4950 Lisp_Object, int); |
| 1333 | 4951 Lisp_Object run_hook_trapping_problems (Lisp_Object, Lisp_Object, int); |
| 4952 Lisp_Object safe_run_hook_trapping_problems (Lisp_Object, Lisp_Object, int); | |
| 4953 Lisp_Object run_hook_with_args_in_buffer_trapping_problems (Lisp_Object, | |
| 4954 struct buffer *, | |
| 4955 int nargs, | |
| 853 | 4956 Lisp_Object *args, |
| 4957 enum | |
| 4958 run_hooks_condition | |
| 4959 cond, int flags); | |
| 1333 | 4960 Lisp_Object run_hook_with_args_trapping_problems (Lisp_Object, |
| 853 | 4961 int nargs, |
| 4962 Lisp_Object *args, | |
| 4963 enum run_hooks_condition | |
| 4964 cond, | |
| 4965 int flags); | |
| 1333 | 4966 Lisp_Object va_run_hook_with_args_trapping_problems (Lisp_Object, |
| 853 | 4967 Lisp_Object hook_var, |
| 4968 int nargs, ...); | |
| 1333 | 4969 Lisp_Object va_run_hook_with_args_in_buffer_trapping_problems (Lisp_Object, |
| 4970 struct buffer *, | |
| 4971 Lisp_Object, | |
| 853 | 4972 int nargs, ...); |
| 4973 Lisp_Object call_with_suspended_errors (lisp_fn_t, Lisp_Object, | |
| 4974 Lisp_Object, | |
| 578 | 4975 Error_Behavior, int, ...); |
| 428 | 4976 /* C Code should be using internal_catch, record_unwind_p, condition_case_1 */ |
| 1318 | 4977 int proper_redisplay_wrapping_in_place (void); |
| 428 | 4978 Lisp_Object internal_catch (Lisp_Object, Lisp_Object (*) (Lisp_Object), |
| 853 | 4979 Lisp_Object, int * volatile, |
| 2532 | 4980 Lisp_Object * volatile, |
| 853 | 4981 Lisp_Object * volatile); |
| 428 | 4982 Lisp_Object condition_case_1 (Lisp_Object, |
| 4983 Lisp_Object (*) (Lisp_Object), | |
| 4984 Lisp_Object, | |
| 4985 Lisp_Object (*) (Lisp_Object, Lisp_Object), | |
| 4986 Lisp_Object); | |
| 4987 Lisp_Object condition_case_3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 1632 | 4988 MODULE_API Lisp_Object unbind_to_1 (int, Lisp_Object); |
| 771 | 4989 #define unbind_to(obj) unbind_to_1 (obj, Qnil) |
| 428 | 4990 void specbind (Lisp_Object, Lisp_Object); |
| 1632 | 4991 MODULE_API int record_unwind_protect (Lisp_Object (*) (Lisp_Object), |
| 4992 Lisp_Object); | |
| 771 | 4993 int record_unwind_protect_freeing_dynarr (void *ptr); |
| 1333 | 4994 int record_unwind_protect_restoring_int (int *addr, int val); |
| 802 | 4995 int internal_bind_int (int *addr, int newval); |
| 4996 int internal_bind_lisp_object (Lisp_Object *addr, Lisp_Object newval); | |
| 970 | 4997 void do_autoload (Lisp_Object, Lisp_Object); /* GCPROs both arguments */ |
| 428 | 4998 Lisp_Object un_autoload (Lisp_Object); |
| 4999 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5000 MODULE_API void warn_when_safe (Lisp_Object, Lisp_Object, const Ascbyte *, |
| 1632 | 5001 ...) PRINTF_ARGS (3, 4); |
| 1292 | 5002 extern int backtrace_with_internal_sections; |
| 428 | 5003 |
|
4841
3465c3161fea
when `debug', abort when lisp error during loadup
Ben Wing <ben@xemacs.org>
parents:
4805
diff
changeset
|
5004 extern Lisp_Object Vdebug_on_error; |
| 1315 | 5005 extern Lisp_Object Vstack_trace_on_error; |
| 428 | 5006 |
| 5007 /* Defined in event-stream.c */ | |
| 826 | 5008 EXFUN (Faccept_process_output, 3); |
| 5009 EXFUN (Fadd_timeout, 4); | |
| 5010 EXFUN (Fdisable_timeout, 1); | |
| 5011 EXFUN (Fdiscard_input, 0); | |
| 5012 EXFUN (Fdispatch_event, 1); | |
| 5013 EXFUN (Fenqueue_eval_event, 2); | |
| 5014 EXFUN (Fnext_event, 2); | |
| 5015 EXFUN (Fread_key_sequence, 3); | |
| 5016 EXFUN (Fsit_for, 2); | |
| 5017 EXFUN (Fsleep_for, 1); | |
| 5018 | |
| 428 | 5019 void wait_delaying_user_input (int (*) (void *), void *); |
| 1268 | 5020 int detect_input_pending (int how_many); |
| 428 | 5021 void reset_this_command_keys (Lisp_Object, int); |
| 5022 Lisp_Object enqueue_misc_user_event (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5023 Lisp_Object enqueue_misc_user_event_pos (Lisp_Object, Lisp_Object, | |
| 5024 Lisp_Object, int, int, int, int); | |
| 442 | 5025 extern int modifier_keys_are_sticky; |
| 428 | 5026 |
| 5027 /* Defined in event-Xt.c */ | |
| 5028 void signal_special_Xt_user_event (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5029 | |
| 5030 | |
| 5031 /* Defined in events.c */ | |
| 826 | 5032 EXFUN (Fcopy_event, 2); |
| 2862 | 5033 EXFUN (Fevent_to_character, 4); |
| 826 | 5034 |
| 428 | 5035 void clear_event_resource (void); |
| 5036 Lisp_Object allocate_event (void); | |
| 5037 | |
| 771 | 5038 EXFUN (Fevent_x_pixel, 1); |
| 5039 EXFUN (Fevent_y_pixel, 1); | |
| 5040 | |
| 5041 | |
| 5042 /* Defined in file-coding.c */ | |
| 5043 EXFUN (Fcoding_category_list, 0); | |
| 5044 EXFUN (Fcoding_category_system, 1); | |
| 5045 EXFUN (Fcoding_priority_list, 0); | |
| 5046 EXFUN (Fcoding_system_description, 1); | |
| 5047 EXFUN (Fcoding_system_documentation, 1); | |
| 5048 EXFUN (Fcoding_system_list, 1); | |
| 5049 EXFUN (Fcoding_system_name, 1); | |
| 5050 EXFUN (Fcoding_system_p, 1); | |
| 5051 EXFUN (Fcoding_system_property, 2); | |
| 5052 EXFUN (Fcoding_system_type, 1); | |
| 5053 EXFUN (Fcopy_coding_system, 2); | |
| 5054 EXFUN (Fdecode_big5_char, 1); | |
| 5055 EXFUN (Fdecode_coding_region, 4); | |
| 5056 EXFUN (Fdecode_shift_jis_char, 1); | |
| 5057 EXFUN (Fdefine_coding_system_alias, 2); | |
| 5058 EXFUN (Fdetect_coding_region, 3); | |
| 5059 EXFUN (Fdefault_encoding_detection_enabled_p, 0); | |
| 5060 EXFUN (Fencode_big5_char, 1); | |
| 5061 EXFUN (Fencode_coding_region, 4); | |
| 5062 EXFUN (Fencode_shift_jis_char, 1); | |
| 5063 EXFUN (Ffind_coding_system, 1); | |
| 5064 EXFUN (Fget_coding_system, 1); | |
|
4690
257b468bf2ca
Move the #'query-coding-region implementation to C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4682
diff
changeset
|
5065 EXFUN (Fmake_coding_system_internal, 4); |
| 771 | 5066 EXFUN (Fset_coding_category_system, 2); |
| 5067 EXFUN (Fset_coding_priority_list, 1); | |
| 5068 EXFUN (Fsubsidiary_coding_system, 2); | |
| 5069 | |
| 5070 extern Lisp_Object Qshift_jis, Qiso2022, Qbig5, Qccl; | |
| 5071 extern Lisp_Object Qcharset_g0; | |
| 5072 extern Lisp_Object Qcharset_g1, Qcharset_g2, Qcharset_g3, Qcoding_system_error; | |
| 5073 extern Lisp_Object Qcoding_systemp, Qcr, Qcrlf, Qdecode, Qencode; | |
| 5074 extern Lisp_Object Qeol_cr, Qeol_crlf, Qeol_lf, Qeol_type, Qescape_quoted; | |
| 5075 extern Lisp_Object Qforce_g0_on_output, Qforce_g1_on_output; | |
| 5076 extern Lisp_Object Qforce_g2_on_output, Qforce_g3_on_output; | |
| 5077 extern Lisp_Object Qinput_charset_conversion, Qlf, Qlock_shift; | |
| 5078 extern Lisp_Object Qmnemonic, Qno_ascii_cntl, Qno_ascii_eol; | |
| 5079 extern Lisp_Object Qno_conversion, Qraw_text; | |
| 5080 extern Lisp_Object Qno_iso6429, Qoutput_charset_conversion; | |
| 5081 extern Lisp_Object Qpost_read_conversion, Qpre_write_conversion, Qseven; | |
| 5082 extern Lisp_Object Qshort, Vcoding_system_for_read; | |
| 5083 extern Lisp_Object Vcoding_system_for_write; | |
| 5084 extern Lisp_Object Vfile_name_coding_system, Vkeyboard_coding_system; | |
| 5085 extern Lisp_Object Vterminal_coding_system; | |
| 5086 extern Lisp_Object Qcanonicalize_after_coding; | |
| 5087 int coding_system_is_for_text_file (Lisp_Object coding_system); | |
| 5088 Lisp_Object find_coding_system_for_text_file (Lisp_Object name, int eol_wrap); | |
| 1632 | 5089 MODULE_API Lisp_Object get_coding_system_for_text_file (Lisp_Object name, |
| 5090 int eol_wrap); | |
| 771 | 5091 int coding_system_is_binary (Lisp_Object coding_system); |
| 5092 | |
| 5093 | |
| 428 | 5094 /* Defined in fileio.c */ |
| 826 | 5095 EXFUN (Fdirectory_file_name, 1); |
| 5096 EXFUN (Fdo_auto_save, 2); | |
| 5097 EXFUN (Fexpand_file_name, 2); | |
| 5098 EXFUN (Ffile_accessible_directory_p, 1); | |
| 5099 EXFUN (Ffile_directory_p, 1); | |
| 5100 EXFUN (Ffile_executable_p, 1); | |
| 5101 EXFUN (Ffile_exists_p, 1); | |
| 5102 EXFUN (Ffile_name_absolute_p, 1); | |
| 5103 EXFUN (Ffile_name_as_directory, 1); | |
| 5104 EXFUN (Ffile_name_directory, 1); | |
| 5105 EXFUN (Ffile_name_nondirectory, 1); | |
| 5106 EXFUN (Ffile_readable_p, 1); | |
| 5107 EXFUN (Ffile_symlink_p, 1); | |
| 5108 EXFUN (Ffile_truename, 2); | |
| 5109 EXFUN (Ffind_file_name_handler, 2); | |
| 5110 EXFUN (Finsert_file_contents_internal, 7); | |
| 5111 EXFUN (Fmake_temp_name, 1); | |
| 5112 EXFUN (Fsubstitute_in_file_name, 1); | |
| 5113 EXFUN (Funhandled_file_name_directory, 1); | |
| 5114 EXFUN (Fverify_visited_file_modtime, 1); | |
| 5115 | |
| 428 | 5116 void record_auto_save (void); |
| 5117 void force_auto_save_soon (void); | |
| 563 | 5118 DECLARE_DOESNT_RETURN (report_error_with_errno (Lisp_Object errtype, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5119 const Ascbyte *reason, |
| 563 | 5120 Lisp_Object data)); |
| 5121 DECLARE_DOESNT_RETURN (report_file_type_error (Lisp_Object errtype, | |
| 5122 Lisp_Object oserrmess, | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5123 const Ascbyte *reason, |
| 563 | 5124 Lisp_Object data)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5125 DECLARE_DOESNT_RETURN (report_file_error (const Ascbyte *, Lisp_Object)); |
| 428 | 5126 Lisp_Object lisp_strerror (int); |
| 5127 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object); | |
| 5128 int internal_delete_file (Lisp_Object); | |
| 2526 | 5129 Ibyte *find_end_of_directory_component (const Ibyte *path, |
| 5130 Bytecount len); | |
| 428 | 5131 |
| 5132 /* Defined in filelock.c */ | |
| 826 | 5133 EXFUN (Funlock_buffer, 0); |
| 5134 | |
| 428 | 5135 void lock_file (Lisp_Object); |
| 5136 void unlock_file (Lisp_Object); | |
| 5137 void unlock_all_files (void); | |
| 5138 void unlock_buffer (struct buffer *); | |
| 5139 | |
| 5140 /* Defined in floatfns.c */ | |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4677
diff
changeset
|
5141 EXFUN (Ftruncate, 2); |
| 826 | 5142 |
| 428 | 5143 double extract_float (Lisp_Object); |
| 5144 | |
| 5145 /* Defined in fns.c */ | |
| 1632 | 5146 MODULE_API EXFUN (Fappend, MANY); |
| 826 | 5147 EXFUN (Fassoc, 2); |
| 5148 EXFUN (Fassq, 2); | |
| 5149 EXFUN (Fcanonicalize_lax_plist, 2); | |
| 5150 EXFUN (Fcanonicalize_plist, 2); | |
| 5151 EXFUN (Fcheck_valid_plist, 1); | |
| 5152 EXFUN (Fconcat, MANY); | |
| 5153 EXFUN (Fcopy_alist, 1); | |
| 5154 EXFUN (Fcopy_list, 1); | |
| 5155 EXFUN (Fcopy_sequence, 1); | |
| 5156 EXFUN (Fcopy_tree, 2); | |
| 5157 EXFUN (Fdelete, 2); | |
| 5158 EXFUN (Fdelq, 2); | |
| 5159 EXFUN (Fdestructive_alist_to_plist, 1); | |
| 5160 EXFUN (Felt, 2); | |
| 1632 | 5161 MODULE_API EXFUN (Fequal, 2); |
| 5162 MODULE_API EXFUN (Fget, 3); | |
| 826 | 5163 EXFUN (Flast, 2); |
| 5164 EXFUN (Flax_plist_get, 3); | |
| 5165 EXFUN (Flax_plist_remprop, 2); | |
| 1632 | 5166 MODULE_API EXFUN (Flength, 1); |
| 826 | 5167 EXFUN (Fmapcar, 2); |
| 5168 EXFUN (Fmember, 2); | |
| 5169 EXFUN (Fmemq, 2); | |
| 5170 EXFUN (Fnconc, MANY); | |
| 1632 | 5171 MODULE_API EXFUN (Fnreverse, 1); |
| 826 | 5172 EXFUN (Fnthcdr, 2); |
| 5173 EXFUN (Fold_assq, 2); | |
| 5174 EXFUN (Fold_equal, 2); | |
| 5175 EXFUN (Fold_member, 2); | |
| 5176 EXFUN (Fold_memq, 2); | |
| 5177 EXFUN (Fplist_get, 3); | |
| 5178 EXFUN (Fplist_member, 2); | |
| 5179 EXFUN (Fplist_put, 3); | |
| 1632 | 5180 MODULE_API EXFUN (Fprovide, 1); |
| 5181 MODULE_API EXFUN (Fput, 3); | |
| 826 | 5182 EXFUN (Frassq, 2); |
| 5183 EXFUN (Fremassq, 2); | |
| 5184 EXFUN (Freplace_list, 2); | |
| 1632 | 5185 MODULE_API EXFUN (Freverse, 1); |
| 1268 | 5186 EXFUN (Fsafe_length, 1); |
| 826 | 5187 EXFUN (Fsort, 2); |
| 5188 EXFUN (Fstring_equal, 2); | |
| 5189 EXFUN (Fstring_lessp, 2); | |
| 5190 EXFUN (Fsubstring, 3); | |
| 5191 EXFUN (Fvalid_plist_p, 1); | |
| 5192 | |
| 428 | 5193 Lisp_Object list_sort (Lisp_Object, Lisp_Object, |
| 5194 int (*) (Lisp_Object, Lisp_Object, Lisp_Object)); | |
| 5195 Lisp_Object merge (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5196 | |
| 5197 void bump_string_modiff (Lisp_Object); | |
| 5198 Lisp_Object memq_no_quit (Lisp_Object, Lisp_Object); | |
| 5199 Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object); | |
| 5200 Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object); | |
| 5201 Lisp_Object rassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5202 Lisp_Object delq_no_quit (Lisp_Object, Lisp_Object); | |
| 5203 Lisp_Object delq_no_quit_and_free_cons (Lisp_Object, Lisp_Object); | |
| 5204 Lisp_Object remassoc_no_quit (Lisp_Object, Lisp_Object); | |
| 5205 Lisp_Object remassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5206 Lisp_Object remrassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5207 | |
| 5208 int plists_differ (Lisp_Object, Lisp_Object, int, int, int); | |
| 5209 Lisp_Object internal_plist_get (Lisp_Object, Lisp_Object); | |
| 5210 void internal_plist_put (Lisp_Object *, Lisp_Object, Lisp_Object); | |
| 5211 int internal_remprop (Lisp_Object *, Lisp_Object); | |
| 5212 Lisp_Object external_plist_get (Lisp_Object *, Lisp_Object, | |
| 578 | 5213 int, Error_Behavior); |
| 428 | 5214 void external_plist_put (Lisp_Object *, Lisp_Object, |
| 578 | 5215 Lisp_Object, int, Error_Behavior); |
| 5216 int external_remprop (Lisp_Object *, Lisp_Object, int, Error_Behavior); | |
| 853 | 5217 int internal_equal_trapping_problems (Lisp_Object warning_class, |
| 2367 | 5218 const Ascbyte *warning_string, |
| 853 | 5219 int flags, |
| 5220 struct call_trapping_problems_result *p, | |
| 5221 int retval, | |
| 5222 Lisp_Object obj1, Lisp_Object obj2, | |
| 5223 int depth); | |
| 428 | 5224 int internal_equal (Lisp_Object, Lisp_Object, int); |
| 801 | 5225 int internal_equalp (Lisp_Object obj1, Lisp_Object obj2, int depth); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5226 Lisp_Object MODULE_API concat2 (Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5227 Lisp_Object MODULE_API concat3 (Lisp_Object, Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5228 Lisp_Object MODULE_API vconcat2 (Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5229 Lisp_Object MODULE_API vconcat3 (Lisp_Object, Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5230 Lisp_Object MODULE_API nconc2 (Lisp_Object, Lisp_Object); |
| 428 | 5231 Lisp_Object bytecode_nconc2 (Lisp_Object *); |
| 442 | 5232 void check_losing_bytecode (const char *, Lisp_Object); |
| 428 | 5233 |
| 771 | 5234 Lisp_Object add_suffix_to_symbol (Lisp_Object symbol, |
| 2367 | 5235 const Ascbyte *ascii_string); |
| 5236 Lisp_Object add_prefix_to_symbol (const Ascbyte *ascii_string, | |
| 771 | 5237 Lisp_Object symbol); |
| 5238 | |
| 826 | 5239 /* Defined in free-hook.c */ |
| 5240 EXFUN (Freally_free, 1); | |
| 5241 | |
| 428 | 5242 /* Defined in glyphs.c */ |
| 826 | 5243 EXFUN (Fmake_glyph_internal, 1); |
| 5244 | |
| 578 | 5245 Error_Behavior decode_error_behavior_flag (Lisp_Object); |
| 5246 Lisp_Object encode_error_behavior_flag (Error_Behavior); | |
| 428 | 5247 |
| 563 | 5248 /* Defined in glyphs-shared.c */ |
| 5249 void shared_resource_validate (Lisp_Object instantiator); | |
| 5250 Lisp_Object shared_resource_normalize (Lisp_Object inst, | |
| 5251 Lisp_Object console_type, | |
| 5252 Lisp_Object dest_mask, | |
| 5253 Lisp_Object tag); | |
| 5254 extern Lisp_Object Q_resource_type, Q_resource_id; | |
| 5255 | |
| 5256 /* Defined in gui.c */ | |
| 2367 | 5257 DECLARE_DOESNT_RETURN (gui_error (const Ascbyte *reason, |
| 563 | 5258 Lisp_Object frob)); |
| 2367 | 5259 DECLARE_DOESNT_RETURN (gui_error_2 (const Ascbyte *reason, |
| 569 | 5260 Lisp_Object frob0, Lisp_Object frob1)); |
| 428 | 5261 /* Defined in indent.c */ |
| 826 | 5262 EXFUN (Findent_to, 3); |
| 5263 EXFUN (Fvertical_motion, 3); | |
| 5264 | |
| 5265 int byte_spaces_at_point (struct buffer *, Bytebpos); | |
| 665 | 5266 int column_at_point (struct buffer *, Charbpos, int); |
| 793 | 5267 int string_column_at_point (Lisp_Object, Charbpos, int); |
| 428 | 5268 int current_column (struct buffer *); |
| 5269 void invalidate_current_column (void); | |
| 665 | 5270 Charbpos vmotion (struct window *, Charbpos, int, int *); |
| 5271 Charbpos vmotion_pixels (Lisp_Object, Charbpos, int, int, int *); | |
| 428 | 5272 |
| 771 | 5273 /* Defined in insdel.c */ |
| 5274 void set_buffer_point (struct buffer *buf, Charbpos pos, Bytebpos bipos); | |
| 5275 | |
| 826 | 5276 /* Defined in intl.c */ |
| 5277 EXFUN (Fgettext, 1); | |
| 5278 | |
| 428 | 5279 /* Defined in keymap.c */ |
| 826 | 5280 EXFUN (Fdefine_key, 3); |
| 5281 EXFUN (Fkey_description, 1); | |
| 5282 EXFUN (Flookup_key, 3); | |
| 5283 EXFUN (Fmake_sparse_keymap, 1); | |
| 5284 | |
| 793 | 5285 void where_is_to_char (Lisp_Object, Eistring *); |
| 428 | 5286 |
| 5287 /* Defined in lread.c */ | |
| 826 | 5288 EXFUN (Fread, 1); |
| 5289 | |
| 428 | 5290 void ebolify_bytecode_constants (Lisp_Object); |
| 5291 void close_load_descs (void); | |
| 5292 int locate_file (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, int); | |
| 5293 EXFUN (Flocate_file_clear_hashing, 1); | |
| 442 | 5294 int isfloat_string (const char *); |
| 1983 | 5295 #ifdef HAVE_RATIO |
| 5296 int isratio_string (const char *); | |
| 5297 #endif | |
| 428 | 5298 |
| 5299 /* Well, I've decided to enable this. -- ben */ | |
| 5300 /* And I've decided to make it work right. -- sb */ | |
| 5301 #define LOADHIST | |
| 5302 /* Define the following symbol to enable load history of dumped files */ | |
| 5303 #define LOADHIST_DUMPED | |
| 5304 /* Define the following symbol to enable load history of C source */ | |
| 5305 #define LOADHIST_BUILTIN | |
| 5306 | |
| 5307 #ifdef LOADHIST /* this is just a stupid idea */ | |
| 5308 #define LOADHIST_ATTACH(x) \ | |
| 5309 do { if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); } \ | |
| 5310 while (0) | |
| 5311 #else /*! LOADHIST */ | |
| 5312 # define LOADHIST_ATTACH(x) | |
| 5313 #endif /*! LOADHIST */ | |
| 5314 | |
| 826 | 5315 /* Defined in macros.c */ |
| 5316 EXFUN (Fexecute_kbd_macro, 2); | |
| 5317 | |
| 428 | 5318 /* Defined in marker.c */ |
| 826 | 5319 EXFUN (Fcopy_marker, 2); |
| 5320 EXFUN (Fmake_marker, 0); | |
| 5321 EXFUN (Fmarker_buffer, 1); | |
| 5322 EXFUN (Fmarker_position, 1); | |
| 5323 EXFUN (Fset_marker, 3); | |
| 5324 EXFUN (Fset_marker_insertion_type, 2); | |
| 5325 | |
| 5326 Bytebpos byte_marker_position (Lisp_Object); | |
| 665 | 5327 Charbpos marker_position (Lisp_Object); |
| 826 | 5328 void set_byte_marker_position (Lisp_Object, Bytebpos); |
| 665 | 5329 void set_marker_position (Lisp_Object, Charbpos); |
| 428 | 5330 void unchain_marker (Lisp_Object); |
| 5331 Lisp_Object noseeum_copy_marker (Lisp_Object, Lisp_Object); | |
| 5332 Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5333 #ifdef MEMORY_USAGE_STATS | |
| 5334 int compute_buffer_marker_usage (struct buffer *, struct overhead_stats *); | |
| 5335 #endif | |
| 771 | 5336 void init_buffer_markers (struct buffer *b); |
| 5337 void uninit_buffer_markers (struct buffer *b); | |
| 428 | 5338 |
| 5339 /* Defined in minibuf.c */ | |
| 5340 extern int minibuf_level; | |
| 867 | 5341 Charcount scmp_1 (const Ibyte *, const Ibyte *, Charcount, int); |
| 428 | 5342 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case) |
| 5343 extern int completion_ignore_case; | |
| 867 | 5344 int regexp_ignore_completion_p (const Ibyte *, Lisp_Object, |
| 428 | 5345 Bytecount, Bytecount); |
| 5346 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int); | |
| 5347 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int); | |
| 867 | 5348 void echo_area_append (struct frame *, const Ibyte *, Lisp_Object, |
| 428 | 5349 Bytecount, Bytecount, Lisp_Object); |
| 867 | 5350 void echo_area_message (struct frame *, const Ibyte *, Lisp_Object, |
| 428 | 5351 Bytecount, Bytecount, Lisp_Object); |
| 5352 Lisp_Object echo_area_status (struct frame *); | |
| 5353 int echo_area_active (struct frame *); | |
| 5354 Lisp_Object echo_area_contents (struct frame *); | |
| 867 | 5355 void message_internal (const Ibyte *, Lisp_Object, Bytecount, Bytecount); |
| 5356 void message_append_internal (const Ibyte *, Lisp_Object, | |
| 428 | 5357 Bytecount, Bytecount); |
| 1632 | 5358 MODULE_API void message (const char *, ...) PRINTF_ARGS (1, 2); |
| 442 | 5359 void message_append (const char *, ...) PRINTF_ARGS (1, 2); |
| 5360 void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2); | |
| 428 | 5361 void clear_message (void); |
| 5362 | |
| 771 | 5363 /* Defined in mule-charset.c */ |
| 826 | 5364 EXFUN (Fmake_charset, 3); |
| 5365 | |
| 771 | 5366 extern Lisp_Object Ql2r, Qr2l; |
| 5367 | |
| 428 | 5368 /* Defined in print.c */ |
| 826 | 5369 EXFUN (Fdisplay_error, 2); |
| 5370 EXFUN (Ferror_message_string, 1); | |
| 5371 EXFUN (Fprin1, 2); | |
| 5372 EXFUN (Fprin1_to_string, 2); | |
| 5373 EXFUN (Fprinc, 2); | |
| 5374 EXFUN (Fprint, 2); | |
| 5375 | |
|
4394
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4355
diff
changeset
|
5376 Lisp_Object prin1_to_string (Lisp_Object, int); |
| 771 | 5377 |
| 5378 /* Lower-level ways to output data: */ | |
| 3085 | 5379 void default_object_printer (Lisp_Object, Lisp_Object, int); |
| 771 | 5380 void print_internal (Lisp_Object, Lisp_Object, int); |
| 428 | 5381 void debug_print (Lisp_Object); |
| 1204 | 5382 void debug_p4 (Lisp_Object obj); |
| 5383 void debug_p3 (Lisp_Object obj); | |
| 5384 void debug_short_backtrace (int); | |
| 5385 void debug_backtrace (void); | |
| 428 | 5386 /* NOTE: Do not call this with the data of a Lisp_String. Use princ. |
| 5387 * Note: stream should be defaulted before calling | |
| 5388 * (eg Qnil means stdout, not Vstandard_output, etc) */ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5389 MODULE_API void write_istring (Lisp_Object stream, const Ibyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5390 /* Same goes for this function. */ |
| 1632 | 5391 MODULE_API void write_c_string (Lisp_Object stream, const CIbyte *str); |
| 771 | 5392 /* Same goes for this function. */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5393 MODULE_API void write_ascstring (Lisp_Object stream, const Ascbyte *str); |
| 428 | 5394 /* Same goes for this function. */ |
| 867 | 5395 void write_string_1 (Lisp_Object stream, const Ibyte *str, Bytecount size); |
| 826 | 5396 void write_eistring (Lisp_Object stream, const Eistring *ei); |
| 771 | 5397 |
| 5398 /* Higher-level (printf-style) ways to output data: */ | |
| 1632 | 5399 MODULE_API void write_fmt_string (Lisp_Object stream, const CIbyte *fmt, ...); |
| 5400 MODULE_API void write_fmt_string_lisp (Lisp_Object stream, const CIbyte *fmt, | |
| 5401 int nargs, ...); | |
| 867 | 5402 void stderr_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); |
| 5403 void stderr_out_lisp (const CIbyte *, int nargs, ...); | |
| 5404 void stdout_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); | |
| 1346 | 5405 void external_out (int dest, const CIbyte *fmt, ...) PRINTF_ARGS (2, 3); |
| 867 | 5406 void debug_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); |
| 1743 | 5407 DECLARE_DOESNT_RETURN (fatal (const CIbyte *, ...)) PRINTF_ARGS(1, 2); |
| 771 | 5408 |
| 5409 /* Internal functions: */ | |
| 1261 | 5410 Lisp_Object canonicalize_printcharfun (Lisp_Object printcharfun); |
| 771 | 5411 void temp_output_buffer_setup (Lisp_Object); |
| 5412 void temp_output_buffer_show (Lisp_Object, Lisp_Object); | |
| 428 | 5413 void print_cons (Lisp_Object, Lisp_Object, int); |
| 5414 void print_vector (Lisp_Object, Lisp_Object, int); | |
| 5415 void print_string (Lisp_Object, Lisp_Object, int); | |
| 771 | 5416 void print_symbol (Lisp_Object, Lisp_Object, int); |
| 5417 void print_float (Lisp_Object, Lisp_Object, int); | |
| 603 | 5418 /* The number of bytes required to store the decimal printed |
| 5419 representation of an integral type. Add a few bytes for truncation, | |
| 5420 optional sign prefix, and null byte terminator. | |
| 614 | 5421 2.40824 == log (256) / log (10). |
| 5422 | |
| 5423 We don't use floating point since Sun cc (buggily?) cannot use | |
| 5424 floating point computations to define a compile-time integral | |
| 5425 constant. */ | |
| 603 | 5426 #define DECIMAL_PRINT_SIZE(integral_type) \ |
| 614 | 5427 (((2410824 * sizeof (integral_type)) / 1000000) + 3) |
| 577 | 5428 void long_to_string (char *, long); |
|
4329
d9eb5ea14f65
Provide %b in #'format; use it for converting between ints and bit vectors.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4134
diff
changeset
|
5429 void ulong_to_bit_string (char *, unsigned long); |
| 428 | 5430 extern int print_escape_newlines; |
| 1632 | 5431 extern MODULE_API int print_readably; |
|
4880
ae81a2c00f4f
try harder to avoid crashing when debug-printing
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
5432 extern int in_debug_print; |
| 428 | 5433 Lisp_Object internal_with_output_to_temp_buffer (Lisp_Object, |
| 5434 Lisp_Object (*) (Lisp_Object), | |
| 5435 Lisp_Object, Lisp_Object); | |
| 5436 void float_to_string (char *, double); | |
| 5437 void internal_object_printer (Lisp_Object, Lisp_Object, int); | |
| 4846 | 5438 MODULE_API DECLARE_DOESNT_RETURN (printing_unreadable_object (const CIbyte *, |
| 5439 ...)) | |
| 5440 PRINTF_ARGS (1, 2); | |
| 5441 DECLARE_DOESNT_RETURN (printing_unreadable_lcrecord (Lisp_Object obj, | |
| 5442 const Ibyte *name)); | |
| 428 | 5443 |
| 5444 /* Defined in rangetab.c */ | |
| 826 | 5445 EXFUN (Fclear_range_table, 1); |
| 5446 EXFUN (Fget_range_table, 3); | |
| 2421 | 5447 EXFUN (Fmake_range_table, 1); |
| 826 | 5448 EXFUN (Fput_range_table, 4); |
|
4690
257b468bf2ca
Move the #'query-coding-region implementation to C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4682
diff
changeset
|
5449 EXFUN (Fcopy_range_table, 1); |
| 826 | 5450 |
| 2421 | 5451 extern Lisp_Object Qstart_closed_end_open; |
| 5452 extern Lisp_Object Qstart_open_end_open; | |
| 5453 extern Lisp_Object Qstart_closed_end_closed; | |
| 5454 extern Lisp_Object Qstart_open_end_closed; | |
| 5455 | |
| 428 | 5456 void put_range_table (Lisp_Object, EMACS_INT, EMACS_INT, Lisp_Object); |
| 5457 int unified_range_table_bytes_needed (Lisp_Object); | |
| 5458 int unified_range_table_bytes_used (void *); | |
| 5459 void unified_range_table_copy_data (Lisp_Object, void *); | |
| 5460 Lisp_Object unified_range_table_lookup (void *, EMACS_INT, Lisp_Object); | |
| 5461 int unified_range_table_nentries (void *); | |
| 5462 void unified_range_table_get_range (void *, int, EMACS_INT *, EMACS_INT *, | |
| 5463 Lisp_Object *); | |
| 5464 | |
| 5465 /* Defined in search.c */ | |
| 826 | 5466 EXFUN (Fmatch_beginning, 1); |
| 5467 EXFUN (Fmatch_end, 1); | |
| 5468 EXFUN (Fskip_chars_backward, 3); | |
| 5469 EXFUN (Fskip_chars_forward, 3); | |
| 5470 EXFUN (Fstring_match, 4); | |
| 5471 | |
| 428 | 5472 struct re_pattern_buffer; |
| 5473 struct re_registers; | |
| 867 | 5474 Charbpos scan_buffer (struct buffer *, Ichar, Charbpos, Charbpos, EMACS_INT, |
| 826 | 5475 EMACS_INT *, int); |
| 665 | 5476 Charbpos find_next_newline (struct buffer *, Charbpos, int); |
| 5477 Charbpos find_next_newline_no_quit (struct buffer *, Charbpos, int); | |
| 826 | 5478 Bytebpos byte_find_next_newline_no_quit (struct buffer *, Bytebpos, int); |
| 867 | 5479 Bytecount byte_find_next_ichar_in_string (Lisp_Object, Ichar, Bytecount, |
| 826 | 5480 EMACS_INT); |
| 665 | 5481 Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos, int); |
| 826 | 5482 struct re_pattern_buffer *compile_pattern (Lisp_Object pattern, |
| 5483 struct re_registers *regp, | |
| 5484 Lisp_Object translate, | |
| 5485 Lisp_Object searchobj, | |
| 5486 struct buffer *searchbuf, | |
| 5487 int posix, Error_Behavior errb); | |
| 867 | 5488 Bytecount fast_string_match (Lisp_Object, const Ibyte *, |
| 428 | 5489 Lisp_Object, Bytecount, |
| 578 | 5490 Bytecount, int, Error_Behavior, int); |
| 428 | 5491 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object); |
| 507 | 5492 extern Fixnum warn_about_possibly_incompatible_back_references; |
| 502 | 5493 |
| 428 | 5494 |
| 5495 /* Defined in signal.c */ | |
| 5496 void init_interrupts_late (void); | |
| 5497 | |
| 5498 /* Defined in sound.c */ | |
| 826 | 5499 EXFUN (Fding, 3); |
| 5500 | |
| 428 | 5501 void init_device_sound (struct device *); |
| 2367 | 5502 DECLARE_DOESNT_RETURN (report_sound_error (const Ascbyte *, Lisp_Object)); |
| 428 | 5503 |
| 5504 /* Defined in specifier.c */ | |
| 826 | 5505 EXFUN (Fadd_spec_to_specifier, 5); |
| 5506 EXFUN (Fspecifier_spec_list, 4); | |
| 5507 | |
| 428 | 5508 Lisp_Object specifier_instance (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 5509 Error_Behavior, int, int, Lisp_Object); |
| 428 | 5510 Lisp_Object specifier_instance_no_quit (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 5511 Error_Behavior, int, Lisp_Object); |
| 428 | 5512 |
| 5513 /* Defined in symbols.c */ | |
| 826 | 5514 EXFUN (Fboundp, 1); |
| 5515 EXFUN (Fbuilt_in_variable_type, 1); | |
| 5516 EXFUN (Fdefault_boundp, 1); | |
| 5517 EXFUN (Fdefault_value, 1); | |
| 5518 EXFUN (Ffboundp, 1); | |
| 5519 EXFUN (Ffset, 2); | |
| 5520 EXFUN (Fintern, 2); | |
|
4355
a2af1ff1761f
Provide a DEFAULT argument in #'intern-soft.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4329
diff
changeset
|
5521 EXFUN (Fintern_soft, 3); |
| 826 | 5522 EXFUN (Fkill_local_variable, 1); |
| 5523 EXFUN (Fset, 2); | |
| 5524 EXFUN (Fset_default, 2); | |
| 5525 EXFUN (Fsymbol_function, 1); | |
| 5526 EXFUN (Fsymbol_name, 1); | |
| 5527 EXFUN (Fsymbol_plist, 1); | |
| 5528 EXFUN (Fsymbol_value, 1); | |
| 5529 | |
| 867 | 5530 unsigned int hash_string (const Ibyte *, Bytecount); |
| 5531 Lisp_Object intern_int (const Ibyte *str); | |
| 1632 | 5532 MODULE_API Lisp_Object intern (const CIbyte *str); |
| 867 | 5533 Lisp_Object intern_converting_underscores_to_dashes (const CIbyte *str); |
| 5534 Lisp_Object oblookup (Lisp_Object, const Ibyte *, Bytecount); | |
| 428 | 5535 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *); |
| 5536 Lisp_Object indirect_function (Lisp_Object, int); | |
| 5537 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object); | |
| 5538 void kill_buffer_local_variables (struct buffer *); | |
| 5539 int symbol_value_buffer_local_info (Lisp_Object, struct buffer *); | |
| 5540 Lisp_Object find_symbol_value (Lisp_Object); | |
| 5541 Lisp_Object find_symbol_value_quickly (Lisp_Object, int); | |
| 5542 Lisp_Object top_level_value (Lisp_Object); | |
| 5543 void reject_constant_symbols (Lisp_Object sym, Lisp_Object newval, | |
| 5544 int function_p, | |
| 5545 Lisp_Object follow_past_lisp_magic); | |
| 5546 | |
| 5547 /* Defined in syntax.c */ | |
| 665 | 5548 Charbpos scan_words (struct buffer *, Charbpos, int); |
| 826 | 5549 EXFUN (Fchar_syntax, 2); |
| 5550 EXFUN (Fforward_word, 2); | |
| 5551 extern Lisp_Object Vstandard_syntax_table; | |
| 3250 | 5552 void signal_syntax_cache_extent_changed (EXTENT extent); |
| 5553 void signal_syntax_cache_extent_adjust (struct buffer *buf); | |
| 826 | 5554 void init_buffer_syntax_cache (struct buffer *buf); |
| 5555 void mark_buffer_syntax_cache (struct buffer *buf); | |
| 5556 void uninit_buffer_syntax_cache (struct buffer *buf); | |
| 5557 extern Lisp_Object Qsyntax_table; | |
| 428 | 5558 |
| 771 | 5559 /* Defined in sysdep.c */ |
| 5560 long get_random (void); | |
| 5561 void seed_random (long arg); | |
| 5562 | |
| 5563 /* Defined in text.c */ | |
| 867 | 5564 void find_charsets_in_ibyte_string (unsigned char *charsets, |
| 5565 const Ibyte *str, | |
| 771 | 5566 Bytecount len); |
| 867 | 5567 void find_charsets_in_ichar_string (unsigned char *charsets, |
| 5568 const Ichar *str, | |
| 771 | 5569 Charcount len); |
| 867 | 5570 int ibyte_string_displayed_columns (const Ibyte *str, Bytecount len); |
| 5571 int ichar_string_displayed_columns (const Ichar *str, Charcount len); | |
| 5572 Charcount ibyte_string_nonascii_chars (const Ibyte *str, Bytecount len); | |
| 5573 void convert_ibyte_string_into_ichar_dynarr (const Ibyte *str, | |
| 771 | 5574 Bytecount len, |
| 867 | 5575 Ichar_dynarr *dyn); |
| 5576 Charcount convert_ibyte_string_into_ichar_string (const Ibyte *str, | |
| 771 | 5577 Bytecount len, |
| 867 | 5578 Ichar *arr); |
| 5579 void convert_ichar_string_into_ibyte_dynarr (Ichar *arr, int nels, | |
| 5580 Ibyte_dynarr *dyn); | |
| 5581 Ibyte *convert_ichar_string_into_malloced_string (Ichar *arr, int nels, | |
| 771 | 5582 Bytecount *len_out); |
| 867 | 5583 Bytecount copy_text_between_formats (const Ibyte *src, Bytecount srclen, |
| 826 | 5584 Internal_Format srcfmt, |
| 5585 Lisp_Object srcobj, | |
| 867 | 5586 Ibyte *dst, Bytecount dstlen, |
| 826 | 5587 Internal_Format dstfmt, |
| 5588 Lisp_Object dstobj, | |
| 5589 Bytecount *src_used); | |
| 5590 Bytecount copy_buffer_text_out (struct buffer *buf, Bytebpos pos, | |
| 867 | 5591 Bytecount len, Ibyte *dst, Bytecount dstlen, |
| 826 | 5592 Internal_Format dstfmt, Lisp_Object dstobj, |
| 5593 Bytecount *src_used); | |
| 771 | 5594 |
| 5595 /* flags for get_buffer_pos_char(), get_buffer_range_char(), etc. */ | |
| 5596 /* At most one of GB_COERCE_RANGE and GB_NO_ERROR_IF_BAD should be | |
| 5597 specified. At most one of GB_NEGATIVE_FROM_END and GB_NO_ERROR_IF_BAD | |
| 5598 should be specified. */ | |
| 5599 | |
| 5600 #define GB_ALLOW_PAST_ACCESSIBLE (1 << 0) | |
| 5601 #define GB_ALLOW_NIL (1 << 1) | |
| 5602 #define GB_CHECK_ORDER (1 << 2) | |
| 5603 #define GB_COERCE_RANGE (1 << 3) | |
| 5604 #define GB_NO_ERROR_IF_BAD (1 << 4) | |
| 5605 #define GB_NEGATIVE_FROM_END (1 << 5) | |
| 5606 #define GB_HISTORICAL_STRING_BEHAVIOR (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL) | |
| 5607 | |
| 5608 Charbpos get_buffer_pos_char (struct buffer *b, Lisp_Object pos, | |
| 5609 unsigned int flags); | |
| 5610 Bytebpos get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, | |
| 5611 unsigned int flags); | |
| 5612 void get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to, | |
| 5613 Charbpos *from_out, Charbpos *to_out, | |
| 5614 unsigned int flags); | |
| 5615 void get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to, | |
| 5616 Bytebpos *from_out, Bytebpos *to_out, | |
| 5617 unsigned int flags); | |
| 5618 Charcount get_string_pos_char (Lisp_Object string, Lisp_Object pos, | |
| 5619 unsigned int flags); | |
| 5620 Bytecount get_string_pos_byte (Lisp_Object string, Lisp_Object pos, | |
| 5621 unsigned int flags); | |
| 5622 void get_string_range_char (Lisp_Object string, Lisp_Object from, | |
| 5623 Lisp_Object to, Charcount *from_out, | |
| 5624 Charcount *to_out, unsigned int flags); | |
| 5625 void get_string_range_byte (Lisp_Object string, Lisp_Object from, | |
| 5626 Lisp_Object to, Bytecount *from_out, | |
| 5627 Bytecount *to_out, unsigned int flags); | |
| 826 | 5628 Charxpos get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos, |
| 5629 unsigned int flags); | |
| 5630 Bytexpos get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos, | |
| 5631 unsigned int flags); | |
| 771 | 5632 void get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from, |
| 826 | 5633 Lisp_Object to, Charxpos *from_out, |
| 5634 Charxpos *to_out, unsigned int flags); | |
| 771 | 5635 void get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from, |
| 826 | 5636 Lisp_Object to, Bytexpos *from_out, |
| 5637 Bytexpos *to_out, unsigned int flags); | |
| 5638 Charxpos buffer_or_string_accessible_begin_char (Lisp_Object object); | |
| 5639 Charxpos buffer_or_string_accessible_end_char (Lisp_Object object); | |
| 5640 Bytexpos buffer_or_string_accessible_begin_byte (Lisp_Object object); | |
| 5641 Bytexpos buffer_or_string_accessible_end_byte (Lisp_Object object); | |
| 5642 Charxpos buffer_or_string_absolute_begin_char (Lisp_Object object); | |
| 5643 Charxpos buffer_or_string_absolute_end_char (Lisp_Object object); | |
| 5644 Bytexpos buffer_or_string_absolute_begin_byte (Lisp_Object object); | |
| 5645 Bytexpos buffer_or_string_absolute_end_byte (Lisp_Object object); | |
| 5646 Charbpos charbpos_clip_to_bounds (Charbpos lower, Charbpos num, | |
| 5647 Charbpos upper); | |
| 5648 Bytebpos bytebpos_clip_to_bounds (Bytebpos lower, Bytebpos num, | |
| 5649 Bytebpos upper); | |
| 5650 Charxpos charxpos_clip_to_bounds (Charxpos lower, Charxpos num, | |
| 5651 Charxpos upper); | |
| 5652 Bytexpos bytexpos_clip_to_bounds (Bytexpos lower, Bytexpos num, | |
| 5653 Bytexpos upper); | |
| 5654 Charxpos buffer_or_string_clip_to_accessible_char (Lisp_Object object, | |
| 5655 Charxpos pos); | |
| 5656 Bytexpos buffer_or_string_clip_to_accessible_byte (Lisp_Object object, | |
| 5657 Bytexpos pos); | |
| 5658 Charxpos buffer_or_string_clip_to_absolute_char (Lisp_Object object, | |
| 5659 Charxpos pos); | |
| 5660 Bytexpos buffer_or_string_clip_to_absolute_byte (Lisp_Object object, | |
| 5661 Bytexpos pos); | |
| 5662 | |
| 771 | 5663 |
| 5664 #ifdef ENABLE_COMPOSITE_CHARS | |
| 5665 | |
| 867 | 5666 Ichar lookup_composite_char (Ibyte *str, int len); |
| 5667 Lisp_Object composite_char_string (Ichar ch); | |
| 771 | 5668 #endif /* ENABLE_COMPOSITE_CHARS */ |
| 5669 | |
| 5670 EXFUN (Ffind_charset, 1); | |
| 5671 EXFUN (Fget_charset, 1); | |
| 5672 EXFUN (Fcharset_list, 0); | |
| 5673 | |
| 5674 extern Lisp_Object Vcharset_ascii; | |
| 5675 extern Lisp_Object Vcharset_control_1; | |
| 5676 extern Lisp_Object Vcharset_latin_iso8859_1; | |
| 5677 extern Lisp_Object Vcharset_latin_iso8859_2; | |
| 5678 extern Lisp_Object Vcharset_latin_iso8859_3; | |
| 5679 extern Lisp_Object Vcharset_latin_iso8859_4; | |
| 5680 extern Lisp_Object Vcharset_thai_tis620; | |
| 5681 extern Lisp_Object Vcharset_greek_iso8859_7; | |
|
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4744
diff
changeset
|
5682 extern Lisp_Object Vcharset_arabic_iso8859_6; |
| 771 | 5683 extern Lisp_Object Vcharset_hebrew_iso8859_8; |
| 5684 extern Lisp_Object Vcharset_katakana_jisx0201; | |
| 5685 extern Lisp_Object Vcharset_latin_jisx0201; | |
| 5686 extern Lisp_Object Vcharset_cyrillic_iso8859_5; | |
| 5687 extern Lisp_Object Vcharset_latin_iso8859_9; | |
| 3094 | 5688 extern Lisp_Object Vcharset_latin_iso8859_15; |
| 771 | 5689 extern Lisp_Object Vcharset_japanese_jisx0208_1978; |
| 5690 extern Lisp_Object Vcharset_chinese_gb2312; | |
| 5691 extern Lisp_Object Vcharset_japanese_jisx0208; | |
| 5692 extern Lisp_Object Vcharset_korean_ksc5601; | |
| 5693 extern Lisp_Object Vcharset_japanese_jisx0212; | |
| 5694 extern Lisp_Object Vcharset_chinese_cns11643_1; | |
| 5695 extern Lisp_Object Vcharset_chinese_cns11643_2; | |
| 5696 extern Lisp_Object Vcharset_chinese_big5_1; | |
| 5697 extern Lisp_Object Vcharset_chinese_big5_2; | |
| 5698 extern Lisp_Object Vcharset_composite; | |
| 5699 | |
| 867 | 5700 Ichar Lstream_get_ichar_1 (Lstream *stream, int first_char); |
| 5701 int Lstream_fput_ichar (Lstream *stream, Ichar ch); | |
| 5702 void Lstream_funget_ichar (Lstream *stream, Ichar ch); | |
| 5703 | |
| 5704 DECLARE_INLINE_HEADER (Ibyte *qxestrdup (const Ibyte *s)) | |
| 771 | 5705 { |
| 2367 | 5706 return (Ibyte *) xstrdup ((const Chbyte *) s); |
| 771 | 5707 } |
| 5708 | |
| 867 | 5709 DECLARE_INLINE_HEADER (Bytecount qxestrlen (const Ibyte *s)) |
| 771 | 5710 { |
| 2367 | 5711 return strlen ((const Chbyte *) s); |
| 771 | 5712 } |
| 5713 | |
| 867 | 5714 DECLARE_INLINE_HEADER (Charcount qxestrcharlen (const Ibyte *s)) |
| 771 | 5715 { |
| 5716 return bytecount_to_charcount (s, qxestrlen (s)); | |
| 5717 } | |
| 5718 | |
| 867 | 5719 DECLARE_INLINE_HEADER (int qxestrcmp (const Ibyte *s1, |
| 5720 const Ibyte *s2)) | |
| 771 | 5721 { |
| 2367 | 5722 return strcmp ((const Chbyte *) s1, (const Chbyte *) s2); |
| 771 | 5723 } |
| 5724 | |
| 2367 | 5725 DECLARE_INLINE_HEADER (int qxestrcmp_ascii (const Ibyte *s1, |
| 5726 const Ascbyte *s2)) | |
| 771 | 5727 { |
| 2367 | 5728 return strcmp ((const Chbyte *) s1, s2); |
| 771 | 5729 } |
| 5730 | |
| 867 | 5731 DECLARE_INLINE_HEADER (int qxestrncmp (const Ibyte *string1, |
| 5732 const Ibyte *string2, | |
| 771 | 5733 Bytecount count)) |
| 5734 { | |
| 2367 | 5735 return strncmp ((const Chbyte *) string1, (const Chbyte *) string2, |
| 771 | 5736 (size_t) count); |
| 5737 } | |
| 5738 | |
| 2367 | 5739 DECLARE_INLINE_HEADER (int qxestrncmp_ascii (const Ibyte *string1, |
| 5740 const Ascbyte *string2, | |
| 5741 Bytecount count)) | |
| 771 | 5742 { |
| 2367 | 5743 return strncmp ((const Chbyte *) string1, string2, (size_t) count); |
| 771 | 5744 } |
| 5745 | |
| 867 | 5746 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy (Ibyte *strDest, |
| 2367 | 5747 const Ibyte *strSource)) |
| 771 | 5748 { |
| 2367 | 5749 return (Ibyte *) strcpy ((Chbyte *) strDest, (const Chbyte *) strSource); |
| 771 | 5750 } |
| 5751 | |
| 2367 | 5752 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy_ascii (Ibyte *strDest, |
| 5753 const Ascbyte *strSource)) | |
| 771 | 5754 { |
| 2367 | 5755 return (Ibyte *) strcpy ((Chbyte *) strDest, strSource); |
| 771 | 5756 } |
| 5757 | |
| 867 | 5758 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy (Ibyte *strDest, |
| 2367 | 5759 const Ibyte *strSource, |
| 5760 Bytecount count)) | |
| 771 | 5761 { |
| 2367 | 5762 return (Ibyte *) strncpy ((Chbyte *) strDest, (const Chbyte *) strSource, |
| 771 | 5763 (size_t) count); |
| 5764 } | |
| 5765 | |
| 2367 | 5766 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy_ascii (Ibyte *strDest, |
| 5767 const Ascbyte *strSource, | |
| 5768 Bytecount count)) | |
| 771 | 5769 { |
| 2367 | 5770 return (Ibyte *) strncpy ((Chbyte *) strDest, strSource, (size_t) count); |
| 771 | 5771 } |
| 5772 | |
| 867 | 5773 DECLARE_INLINE_HEADER (Ibyte *qxestrcat (Ibyte *strDest, |
| 2367 | 5774 const Ibyte *strSource)) |
| 771 | 5775 { |
| 2367 | 5776 return (Ibyte *) strcat ((Chbyte *) strDest, (const Chbyte *) strSource); |
| 771 | 5777 } |
| 5778 | |
| 2367 | 5779 DECLARE_INLINE_HEADER (Ibyte *qxestrcat_ascii (Ibyte *strDest, |
| 5780 const Ascbyte *strSource)) | |
| 771 | 5781 { |
| 2367 | 5782 return (Ibyte *) strcat ((Chbyte *) strDest, strSource); |
| 771 | 5783 } |
| 5784 | |
| 867 | 5785 DECLARE_INLINE_HEADER (Ibyte *qxestrncat (Ibyte *strDest, |
| 2367 | 5786 const Ibyte *strSource, |
| 5787 Bytecount count)) | |
| 771 | 5788 { |
| 2367 | 5789 return (Ibyte *) strncat ((Chbyte *) strDest, (const Chbyte *) strSource, |
| 771 | 5790 (size_t) count); |
| 5791 } | |
| 5792 | |
| 2367 | 5793 DECLARE_INLINE_HEADER (Ibyte *qxestrncat_ascii (Ibyte *strDest, |
| 5794 const Ascbyte *strSource, | |
| 5795 Bytecount count)) | |
| 771 | 5796 { |
| 2367 | 5797 return (Ibyte *) strncat ((Chbyte *) strDest, strSource, (size_t) count); |
| 771 | 5798 } |
| 5799 | |
| 867 | 5800 DECLARE_INLINE_HEADER (Ibyte *qxestrchr (const Ibyte *s, Ichar c)) |
| 771 | 5801 { |
| 5802 assert (c >= 0 && c <= 255); | |
| 2367 | 5803 return (Ibyte *) strchr ((const Chbyte *) s, c); |
| 771 | 5804 } |
| 5805 | |
| 867 | 5806 DECLARE_INLINE_HEADER (Ibyte *qxestrrchr (const Ibyte *s, Ichar c)) |
| 771 | 5807 { |
| 5808 assert (c >= 0 && c <= 255); | |
| 2367 | 5809 return (Ibyte *) strrchr ((const Chbyte *) s, c); |
| 771 | 5810 } |
| 5811 | |
| 867 | 5812 DECLARE_INLINE_HEADER (Ibyte *qxestrstr (const Ibyte *string1, |
| 2367 | 5813 const Ibyte *string2)) |
| 771 | 5814 { |
| 2367 | 5815 return (Ibyte *) strstr ((const Chbyte *) string1, (const Chbyte *) string2); |
| 771 | 5816 } |
| 5817 | |
| 867 | 5818 DECLARE_INLINE_HEADER (Bytecount qxestrcspn (const Ibyte *string, |
| 5819 const CIbyte *strCharSet)) | |
| 771 | 5820 { |
| 2367 | 5821 return (Bytecount) strcspn ((const Chbyte *) string, strCharSet); |
| 771 | 5822 } |
| 5823 | |
| 867 | 5824 DECLARE_INLINE_HEADER (Bytecount qxestrspn (const Ibyte *string, |
| 5825 const CIbyte *strCharSet)) | |
| 771 | 5826 { |
| 2367 | 5827 return (Bytecount) strspn ((const Chbyte *) string, strCharSet); |
| 771 | 5828 } |
| 5829 | |
| 867 | 5830 DECLARE_INLINE_HEADER (Ibyte *qxestrpbrk (const Ibyte *string, |
| 2367 | 5831 const CIbyte *strCharSet)) |
| 771 | 5832 { |
| 2367 | 5833 return (Ibyte *) strpbrk ((const Chbyte *) string, strCharSet); |
| 771 | 5834 } |
| 5835 | |
| 867 | 5836 DECLARE_INLINE_HEADER (Ibyte *qxestrtok (Ibyte *strToken, |
| 2367 | 5837 const CIbyte *strDelimit)) |
| 771 | 5838 { |
| 2367 | 5839 return (Ibyte *) strtok ((Chbyte *) strToken, strDelimit); |
| 771 | 5840 } |
| 5841 | |
| 867 | 5842 DECLARE_INLINE_HEADER (double qxestrtod (const Ibyte *nptr, |
| 5843 Ibyte **endptr)) | |
| 771 | 5844 { |
| 2367 | 5845 return strtod ((const Chbyte *) nptr, (Chbyte **) endptr); |
| 771 | 5846 } |
| 5847 | |
| 867 | 5848 DECLARE_INLINE_HEADER (long qxestrtol (const Ibyte *nptr, Ibyte **endptr, |
| 771 | 5849 int base)) |
| 5850 { | |
| 2367 | 5851 return strtol ((const Chbyte *) nptr, (Chbyte **) endptr, base); |
| 771 | 5852 } |
| 5853 | |
| 867 | 5854 DECLARE_INLINE_HEADER (unsigned long qxestrtoul (const Ibyte *nptr, |
| 5855 Ibyte **endptr, | |
| 771 | 5856 int base)) |
| 5857 { | |
| 2367 | 5858 return strtoul ((const Chbyte *) nptr, (Chbyte **) endptr, base); |
| 771 | 5859 } |
| 5860 | |
| 867 | 5861 DECLARE_INLINE_HEADER (int qxeatoi (const Ibyte *string)) |
| 771 | 5862 { |
| 2367 | 5863 return atoi ((const Chbyte *) string); |
| 771 | 5864 } |
| 5865 | |
| 1204 | 5866 DECLARE_INLINE_HEADER (Ibyte *qxestrupr (Ibyte *s)) |
| 5867 { | |
| 2367 | 5868 return (Ibyte *) strupr ((Chbyte *) s); |
| 1204 | 5869 } |
| 5870 | |
| 5871 DECLARE_INLINE_HEADER (Ibyte *qxestrlwr (Ibyte *s)) | |
| 5872 { | |
| 2367 | 5873 return (Ibyte *) strlwr ((Chbyte *) s); |
| 1204 | 5874 } |
| 5875 | |
| 867 | 5876 int qxesprintf (Ibyte *buffer, const CIbyte *format, ...) |
| 771 | 5877 PRINTF_ARGS (2, 3); |
| 5878 | |
| 2367 | 5879 DECLARE_INLINE_HEADER (int qxesscanf_ascii_1 (Ibyte *buffer, |
| 5880 const Ascbyte *format, | |
| 5881 void *ptr)) | |
| 5882 { | |
| 5883 /* #### DAMNIT! No vsscanf! */ | |
| 5884 return sscanf ((Chbyte *) buffer, format, ptr); | |
| 5885 } | |
| 5886 | |
| 771 | 5887 /* Do not use POSIX locale routines. Not Mule-correct. */ |
| 5888 #define qxestrcoll DO NOT USE. | |
| 5889 #define qxestrxfrm DO NOT USE. | |
| 5890 | |
| 867 | 5891 int qxestrcasecmp (const Ibyte *s1, const Ibyte *s2); |
| 2367 | 5892 int qxestrcasecmp_ascii (const Ibyte *s1, const Ascbyte *s2); |
| 867 | 5893 int qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2); |
| 2367 | 5894 int ascii_strcasecmp (const Ascbyte *s1, const Ascbyte *s2); |
| 771 | 5895 int lisp_strcasecmp (Lisp_Object s1, Lisp_Object s2); |
| 5896 int lisp_strcasecmp_i18n (Lisp_Object s1, Lisp_Object s2); | |
| 867 | 5897 int qxestrncasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 2367 | 5898 int qxestrncasecmp_ascii (const Ibyte *s1, const Ascbyte *s2, |
| 5899 Bytecount len); | |
| 867 | 5900 int qxestrncasecmp_i18n (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 2367 | 5901 int ascii_strncasecmp (const Ascbyte *s1, const Ascbyte *s2, |
| 771 | 5902 Bytecount len); |
| 867 | 5903 int qxememcmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 5904 int qxememcmp4 (const Ibyte *s1, Bytecount len1, | |
| 5905 const Ibyte *s2, Bytecount len2); | |
| 5906 int qxememcasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); | |
| 5907 int qxememcasecmp4 (const Ibyte *s1, Bytecount len1, | |
| 5908 const Ibyte *s2, Bytecount len2); | |
| 5909 int qxetextcmp (const Ibyte *s1, Bytecount len1, | |
| 5910 const Ibyte *s2, Bytecount len2); | |
| 5911 int qxetextcmp_matching (const Ibyte *s1, Bytecount len1, | |
| 5912 const Ibyte *s2, Bytecount len2, | |
| 801 | 5913 Charcount *matching); |
| 867 | 5914 int qxetextcasecmp (const Ibyte *s1, Bytecount len1, |
| 5915 const Ibyte *s2, Bytecount len2); | |
| 5916 int qxetextcasecmp_matching (const Ibyte *s1, Bytecount len1, | |
| 5917 const Ibyte *s2, Bytecount len2, | |
| 801 | 5918 Charcount *matching); |
| 771 | 5919 |
| 5920 void buffer_mule_signal_inserted_region (struct buffer *buf, Charbpos start, | |
| 5921 Bytecount bytelength, | |
| 5922 Charcount charlength); | |
| 5923 void buffer_mule_signal_deleted_region (struct buffer *buf, Charbpos start, | |
| 826 | 5924 Charbpos end, Bytebpos byte_start, |
| 5925 Bytebpos byte_end); | |
| 771 | 5926 |
| 2367 | 5927 typedef struct |
| 5928 { | |
| 5929 const char *srctext; | |
| 5930 void *dst; | |
| 5931 Bytecount dst_size; | |
| 5932 } alloca_convert_vals; | |
| 5933 | |
| 5934 typedef struct | |
| 5935 { | |
| 5936 Dynarr_declare (alloca_convert_vals); | |
| 5937 } alloca_convert_vals_dynarr; | |
| 5938 | |
| 5939 extern alloca_convert_vals_dynarr *active_alloca_convert; | |
| 5940 | |
| 5941 MODULE_API int find_pos_of_existing_active_alloca_convert (const char * | |
| 5942 srctext); | |
| 5943 | |
| 771 | 5944 /* Defined in unicode.c */ |
| 1204 | 5945 extern const struct sized_memory_description to_unicode_description; |
| 5946 extern const struct sized_memory_description from_unicode_description; | |
| 771 | 5947 void init_charset_unicode_tables (Lisp_Object charset); |
| 5948 void free_charset_unicode_tables (Lisp_Object charset); | |
| 5949 void recalculate_unicode_precedence (void); | |
| 5950 extern Lisp_Object Qunicode; | |
| 4096 | 5951 extern Lisp_Object Qutf_16, Qutf_8, Qucs_4, Qutf_7, Qutf_32; |
| 771 | 5952 #ifdef MEMORY_USAGE_STATS |
| 5953 Bytecount compute_from_unicode_table_size (Lisp_Object charset, | |
| 5954 struct overhead_stats *stats); | |
| 5955 Bytecount compute_to_unicode_table_size (Lisp_Object charset, | |
| 5956 struct overhead_stats *stats); | |
| 5957 #endif /* MEMORY_USAGE_STATS */ | |
| 5958 | |
| 428 | 5959 /* Defined in undo.c */ |
| 826 | 5960 EXFUN (Fundo_boundary, 0); |
| 5961 | |
| 428 | 5962 Lisp_Object truncate_undo_list (Lisp_Object, int, int); |
| 5963 void record_extent (Lisp_Object, int); | |
| 665 | 5964 void record_insert (struct buffer *, Charbpos, Charcount); |
| 5965 void record_delete (struct buffer *, Charbpos, Charcount); | |
| 5966 void record_change (struct buffer *, Charbpos, Charcount); | |
| 428 | 5967 |
| 5968 /* Defined in unex*.c */ | |
| 814 | 5969 #ifdef WIN32_NATIVE |
| 867 | 5970 int unexec (Ibyte *, Ibyte *, uintptr_t, uintptr_t, uintptr_t); |
| 814 | 5971 #else |
| 5972 int unexec (Extbyte *, Extbyte *, uintptr_t, uintptr_t, uintptr_t); | |
| 5973 #endif | |
| 428 | 5974 #ifdef RUN_TIME_REMAP |
| 5975 int run_time_remap (char *); | |
| 5976 #endif | |
| 5977 | |
| 5978 /* Defined in vm-limit.c */ | |
| 442 | 5979 void memory_warnings (void *, void (*) (const char *)); |
| 428 | 5980 |
| 442 | 5981 /*--------------- prototypes for constant symbols ------------*/ |
| 5982 | |
| 826 | 5983 /* #### We should get rid of this and put the prototypes back up there in |
| 5984 #### the per-file stuff, where they belong. */ | |
| 5985 | |
| 771 | 5986 /* Use the following when you have to add a bunch of symbols. */ |
| 5987 | |
| 5988 /* | |
| 5989 | |
| 5990 (defun redo-symbols (beg end) | |
| 5991 "Snarf any symbols out of the region and print them into a temporary buffer, | |
| 5992 which is displayed when the function finishes. The symbols are laid out with | |
| 5993 `extern Lisp_Object ' before each one, with as many as can fit on one line | |
| 5994 \(the maximum line width is controlled by the constant `max-line-length' in the | |
| 5995 code)." | |
| 5996 (interactive "r") | |
| 5997 (save-excursion | |
| 5998 (goto-char beg) | |
| 5999 (let (syms) | |
| 6000 (while (re-search-forward "\\s-\\(Q[A-Za-z_0-9]+\\)" end t) | |
| 6001 (push (match-string 1) syms)) | |
| 6002 (setq syms (sort syms #'string-lessp)) | |
| 6003 (with-output-to-temp-buffer "*Symbols*" | |
| 6004 (let* ((col 0) | |
| 6005 (start "extern Lisp_Object ") | |
| 6006 (startlen (length start)) | |
| 6007 ;; with a default-width frame of 80 chars, you can only fit | |
| 6008 ;; 79 before wrapping. you can see this to a lower value if | |
| 6009 ;; you don't want it right up against the right margin. | |
| 6010 (max-line-length 79)) | |
| 6011 (dolist (sym syms) | |
| 6012 (cond (;; if something already on line (this will always be the | |
| 6013 ;; case except the very first iteration), see what | |
| 6014 ;; space we've got. (need to take into account 2 | |
| 6015 ;; for the comma+space, 1 for the semicolon at the | |
| 6016 ;; end.) if enough space, do it. | |
| 6017 (and (> col 0) (< (+ col (length sym) 2) | |
| 6018 (1- max-line-length))) | |
| 6019 (princ ", ") | |
| 6020 (princ sym) | |
| 6021 (incf col 2) | |
| 6022 (incf col (length sym))) | |
| 6023 (t | |
| 6024 ;; either we're first iteration or we ran out of space. | |
| 6025 ;; if the latter, terminate the previous line. this | |
| 6026 ;; loop is written on purpose so that it always prints | |
| 6027 ;; at least one item, even if that would go over. | |
| 6028 (when (> col 0) | |
| 6029 (princ ";\n") | |
| 6030 (setq col 0)) | |
| 6031 (princ start) | |
| 6032 (incf col startlen) | |
| 6033 (princ sym) | |
| 6034 (incf col (length sym))))) | |
| 6035 ;; finally terminate the last line. | |
| 6036 (princ ";\n")))))) | |
| 6037 | |
| 6038 */ | |
| 6039 | |
| 4932 | 6040 extern Lisp_Object Qactivate_menubar_hook, Qand_optional, Qand_rest, Qautoload, |
| 6041 Qbackground, Qbackground_pixmap, Qblinking, Qbuffer_glyph_p, Qbuffer_live_p, | |
| 6042 Qcall_interactively, Qcategory_designator_p, | |
| 6043 Qcategory_table_value_p, Qcdr, Qcolor_pixmap_image_instance_p, Qcommandp, | |
| 6044 Qcompletion_ignore_case, Qconsole_live_p, Qconst_specifier, Qcurrent_menubar, | |
| 6045 Qdefun, Qdevice_live_p, Qdim, Qdirection, Qdisabled, Qdisabled_command_hook, | |
| 6046 Qdisplay_table, Qdll_error, Qend_open, Qerror_lacks_explanatory_string, | |
| 6047 Qevent_live_p, Qexit, Qextent_live_p, Qexternal_debugging_output, Qfeaturep, | |
| 6048 Qfile_error, Qfile_name_sans_extension, Qfinal, Qforeground, Qformat, | |
| 6049 Qframe_live_p, Qgraphic, Qgui_error, Qicon_glyph_p, Qidentity, Qinhibit_quit, | |
| 6050 Qinhibit_read_only, Qinteractive, Qlayout, Qload, Qlong_name, Qmacro, | |
| 6051 Qmakunbound, Qmark, Qmodule, Qmono_pixmap_image_instance_p, | |
| 6052 Qmouse_leave_buffer_hook, Qnative_layout, Qnetwork_error, | |
| 6053 Qnothing_image_instance_p, Qpoint, Qpointer_glyph_p, | |
| 6054 Qpointer_image_instance_p, Qprint_length, Qprint_string_length, Qprogn, | |
| 6055 Qread_char, Qread_from_minibuffer, Qreally_early_error_handler, | |
| 6056 Qregion_beginning, Qregion_end, Qregistries, Qreverse_direction_charset, | |
| 6057 Qrun_hooks, Qsans_modifiers, Qsave_buffers_kill_emacs, Qself_insert_command, | |
| 6058 Qself_insert_defer_undo, Qsequencep, Qset, Qshort_name, Qsound_error, | |
| 6059 Qstandard_input, Qstandard_output, Qstart_open, Qstring_lessp, Qsubwindow, | |
| 6060 Qsubwindow_image_instance_p, Qtext_image_instance_p, Qtop_level, Qunderline, | |
| 6061 Quser_files_and_directories, Qvalues, Qvariable_documentation, | |
| 6062 Qvariable_domain, Qwindow_live_p, Qyes_or_no_p; | |
| 6063 | |
| 6064 extern MODULE_API Lisp_Object Qprocess_error, Qt, Qunbound; | |
| 1632 | 6065 |
| 442 | 6066 #define SYMBOL(fou) extern Lisp_Object fou |
| 1632 | 6067 #define SYMBOL_MODULE_API(fou) extern MODULE_API Lisp_Object fou |
| 442 | 6068 #define SYMBOL_KEYWORD(la_cle_est_fou) extern Lisp_Object la_cle_est_fou |
| 6069 #define SYMBOL_GENERAL(tout_le_monde, est_fou) \ | |
| 6070 extern Lisp_Object tout_le_monde | |
| 6071 | |
| 6072 #include "general-slots.h" | |
| 6073 | |
| 6074 #undef SYMBOL | |
| 1632 | 6075 #undef SYMBOL_MODULE_API |
| 442 | 6076 #undef SYMBOL_KEYWORD |
| 6077 #undef SYMBOL_GENERAL | |
| 6078 | |
| 6079 /*--------------- prototypes for variables of type Lisp_Object ------------*/ | |
| 6080 | |
| 826 | 6081 /* #### We should get rid of this and put the prototypes back up there in |
| 6082 #### the per-file stuff, where they belong. */ | |
| 6083 | |
| 446 | 6084 extern Lisp_Object Vactivate_menubar_hook; |
| 6085 extern Lisp_Object Vautoload_queue, Vblank_menubar; | |
| 771 | 6086 extern Lisp_Object Vcommand_history; |
| 428 | 6087 extern Lisp_Object Vcommand_line_args, Vconfigure_info_directory; |
| 6088 extern Lisp_Object Vconfigure_site_directory, Vconfigure_site_module_directory; | |
| 6089 extern Lisp_Object Vconsole_list, Vcontrolling_terminal; | |
| 6090 extern Lisp_Object Vcurrent_compiled_function_annotation, Vcurrent_load_list; | |
| 6091 extern Lisp_Object Vcurrent_mouse_event, Vcurrent_prefix_arg, Vdata_directory; | |
| 434 | 6092 extern Lisp_Object Vdirectory_sep_char, Vdisabled_command_hook; |
| 6093 extern Lisp_Object Vdoc_directory, Vinternal_doc_file_name; | |
| 428 | 6094 extern Lisp_Object Vecho_area_buffer, Vemacs_major_version; |
| 6095 extern Lisp_Object Vemacs_minor_version, Vexec_directory, Vexec_path; | |
| 6096 extern Lisp_Object Vexecuting_macro, Vfeatures, Vfile_domain; | |
| 1927 | 6097 extern Lisp_Object Vinvocation_directory, Vinvocation_name; |
| 771 | 6098 extern Lisp_Object Vlast_command, Vlast_command_char; |
| 428 | 6099 extern Lisp_Object Vlast_command_event, Vlast_input_event; |
| 2548 | 6100 extern Lisp_Object Vload_file_name_internal, Vload_history; |
| 428 | 6101 extern Lisp_Object Vload_path, Vmark_even_if_inactive, Vmenubar_configuration; |
| 6102 extern Lisp_Object Vminibuf_preprompt, Vminibuf_prompt, Vminibuffer_zero; | |
| 6103 extern Lisp_Object Vmodule_directory, Vmswindows_downcase_file_names; | |
| 6104 extern Lisp_Object Vmswindows_get_true_file_attributes, Vobarray; | |
| 6105 extern Lisp_Object Vprint_length, Vprint_level, Vprocess_environment; | |
| 6106 extern Lisp_Object Vrecent_keys_ring, Vshell_file_name, Vsite_directory; | |
| 6107 extern Lisp_Object Vsite_module_directory; | |
| 6108 extern Lisp_Object Vstandard_input, Vstandard_output, Vstdio_str; | |
| 771 | 6109 extern Lisp_Object Vsynchronous_sounds, Vsystem_name; |
| 428 | 6110 extern Lisp_Object Vthis_command_keys, Vunread_command_event; |
| 6111 extern Lisp_Object Vx_initial_argv_list; | |
| 6112 | |
| 1927 | 6113 extern MODULE_API Lisp_Object Vinhibit_quit, Vquit_flag; |
| 6114 | |
| 1743 | 6115 END_C_DECLS |
| 1650 | 6116 |
| 440 | 6117 #endif /* INCLUDED_lisp_h_ */ |