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