Mercurial > hg > xemacs-beta
annotate src/lisp.h @ 5157:1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
-------------------- ChangeLog entries follow: --------------------
lisp/ChangeLog addition:
2010-03-18 Ben Wing <ben@xemacs.org>
* diagnose.el (show-memory-usage):
Rewrite to take into account API changes in memory-usage functions.
src/ChangeLog addition:
2010-03-18 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (disksave_object_finalization_1):
* alloc.c (lisp_object_storage_size):
* alloc.c (listu):
* alloc.c (listn):
* alloc.c (Fobject_memory_usage_stats):
* alloc.c (compute_memusage_stats_length):
* alloc.c (Fobject_memory_usage):
* alloc.c (Ftotal_object_memory_usage):
* alloc.c (malloced_storage_size):
* alloc.c (common_init_alloc_early):
* alloc.c (reinit_alloc_objects_early):
* alloc.c (reinit_alloc_early):
* alloc.c (init_alloc_once_early):
* alloc.c (syms_of_alloc):
* alloc.c (reinit_vars_of_alloc):
* buffer.c:
* buffer.c (struct buffer_stats):
* buffer.c (compute_buffer_text_usage):
* buffer.c (compute_buffer_usage):
* buffer.c (buffer_memory_usage):
* buffer.c (buffer_objects_create):
* buffer.c (syms_of_buffer):
* buffer.c (vars_of_buffer):
* console-impl.h (struct console_methods):
* dynarr.c (Dynarr_memory_usage):
* emacs.c (main_1):
* events.c (clear_event_resource):
* extents.c:
* extents.c (compute_buffer_extent_usage):
* extents.c (extent_objects_create):
* extents.h:
* faces.c:
* faces.c (compute_face_cachel_usage):
* faces.c (face_objects_create):
* faces.h:
* general-slots.h:
* glyphs.c:
* glyphs.c (compute_glyph_cachel_usage):
* glyphs.c (glyph_objects_create):
* glyphs.h:
* lisp.h:
* lisp.h (struct usage_stats):
* lrecord.h:
* lrecord.h (enum lrecord_type):
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE):
* lrecord.h (DEFINE_DUMPABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (MAKE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (MAKE_MODULE_LISP_OBJECT):
* lrecord.h (INIT_LISP_OBJECT):
* lrecord.h (INIT_MODULE_LISP_OBJECT):
* lrecord.h (UNDEF_LISP_OBJECT):
* lrecord.h (UNDEF_MODULE_LISP_OBJECT):
* lrecord.h (DECLARE_LISP_OBJECT):
* lrecord.h (DECLARE_MODULE_API_LISP_OBJECT):
* lrecord.h (DECLARE_MODULE_LISP_OBJECT):
* lstream.c:
* lstream.c (syms_of_lstream):
* lstream.c (vars_of_lstream):
* marker.c:
* marker.c (compute_buffer_marker_usage):
* mc-alloc.c (mc_alloced_storage_size):
* mc-alloc.h:
* mule-charset.c:
* mule-charset.c (struct charset_stats):
* mule-charset.c (compute_charset_usage):
* mule-charset.c (charset_memory_usage):
* mule-charset.c (mule_charset_objects_create):
* mule-charset.c (syms_of_mule_charset):
* mule-charset.c (vars_of_mule_charset):
* redisplay.c:
* redisplay.c (compute_rune_dynarr_usage):
* redisplay.c (compute_display_block_dynarr_usage):
* redisplay.c (compute_glyph_block_dynarr_usage):
* redisplay.c (compute_display_line_dynarr_usage):
* redisplay.c (compute_line_start_cache_dynarr_usage):
* redisplay.h:
* scrollbar-gtk.c (gtk_compute_scrollbar_instance_usage):
* scrollbar-msw.c (mswindows_compute_scrollbar_instance_usage):
* scrollbar-x.c (x_compute_scrollbar_instance_usage):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h:
* symbols.c:
* symbols.c (reinit_symbol_objects_early):
* symbols.c (init_symbols_once_early):
* symbols.c (reinit_symbols_early):
* symbols.c (defsymbol_massage_name_1):
* symsinit.h:
* ui-gtk.c:
* ui-gtk.c (emacs_gtk_object_getprop):
* ui-gtk.c (emacs_gtk_object_putprop):
* ui-gtk.c (ui_gtk_objects_create):
* unicode.c (compute_from_unicode_table_size_1):
* unicode.c (compute_to_unicode_table_size_1):
* unicode.c (compute_from_unicode_table_size):
* unicode.c (compute_to_unicode_table_size):
* window.c:
* window.c (struct window_stats):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
* window.c (window_memory_usage):
* window.c (window_objects_create):
* window.c (syms_of_window):
* window.c (vars_of_window):
* window.h:
Redo memory-usage mechanism, make it general; add way of dynamically
initializing Lisp object types -- OBJECT_HAS_METHOD(), similar to
CONSOLE_HAS_METHOD().
(1) Create OBJECT_HAS_METHOD(), OBJECT_HAS_PROPERTY() etc. for
specifying that a Lisp object type has a particular method or
property. Call such methods with OBJECT_METH, MAYBE_OBJECT_METH,
OBJECT_METH_OR_GIVEN; retrieve properties with OBJECT_PROPERTY.
Methods that formerly required a DEFINE_*GENERAL_LISP_OBJECT() to
specify them (getprop, putprop, remprop, plist, disksave) now
instead use the dynamic-method mechanism. The main benefit of
this is that new methods or properties can be added without
requiring that the declaration statements of all existing methods
be modified. We have to make the `struct lrecord_implementation'
non-const, but I don't think this should have any effect on speed --
the only possible method that's really speed-critical is the
mark method, and we already extract those out into a separate
(non-const) array for increased cache locality.
Object methods need to be reinitialized after pdump, so we put
them in separate functions such as face_objects_create(),
extent_objects_create() and call them appropriately from emacs.c
The only current object property (`memusage_stats_list') that
objects can specify is a Lisp object and gets staticpro()ed so it
only needs to be set during dump time, but because it references
symbols that might not exist in a syms_of_() function, we
initialize it in vars_of_(). There is also an object property
(`num_extra_memusage_stats') that is automatically initialized based
on `memusage_stats_list'; we do that in reinit_vars_of_alloc(),
which is called after all vars_of_() functions are called.
`disksaver' method was renamed `disksave' to correspond with the
name normally given to the function (e.g. disksave_lstream()).
(2) Generalize the memory-usage mechanism in `buffer-memory-usage',
`window-memory-usage', `charset-memory-usage' into an object-type-
specific mechanism called by a single function
`object-memory-usage'. (Former function `object-memory-usage'
renamed to `total-object-memory-usage'). Generalize the mechanism
of different "slices" so that we can have different "classes" of
memory described and different "slices" onto each class; `t'
separates classes, `nil' separates slices. Currently we have
three classes defined: the memory of an object itself,
non-Lisp-object memory associated with the object (e.g. arrays or
dynarrs stored as fields in the object), and Lisp-object memory
associated with the object (other internal Lisp objects stored in
the object). This isn't completely finished yet and we might need
to further separate the "other internal Lisp objects" class into
two classes.
The memory-usage mechanism uses a `struct usage_stats' (renamed
from `struct overhead_stats') to describe a malloc-view onto a set
of allocated memory (listing how much was requested and various
types of overhead) and a more general `struct generic_usage_stats'
(with a `struct usage_stats' in it) to hold all statistics about
object memory. `struct generic_usage_stats' contains an array of
32 Bytecounts, which are statistics of unspecified semantics. The
intention is that individual types declare a corresponding struct
(e.g. `struct window_stats') with the same structure but with
specific fields in place of the array, corresponding to specific
statistics. The number of such statistics is an object property
computed from the list of tags (Lisp symbols describing the
statistics) stored in `memusage_stats_list'. The idea here is to
allow particular object types to customize the number and
semantics of the statistics where completely avoiding consing.
This doesn't matter so much yet, but the intention is to have the
memory usage of all objects computed at the end of GC, at the same
time as other statistics are currently computed. The values for
all statistics for a single type would be added up to compute
aggregate values for all objects of a specific type. To make this
efficient, we can't allow any memory allocation at all.
(3) Create some additional functions for creating lists that
specify the elements directly as args rather than indirectly through
an array: listn() (number of args given), listu() (list terminated
by Qunbound).
(4) Delete a bit of remaining unused C window_config stuff, also
unused lrecord_type_popup_data.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Thu, 18 Mar 2010 10:50:06 -0500 |
| parents | 88bd4f3ef8e4 |
| children | 9e0b43d3095c |
| 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 | |
| 5090 | 88 @@#### marks places that need work to get Unicode-internal working, |
| 89 i.e. using UTF-8 as the internal text format. | |
| 90 | |
| 91 #### BILL! marks places that need work for GTK. | |
| 92 | |
| 93 #### GEOM! marks places needing work to fix various bugs in the handling | |
| 94 of window and frame sizing and positioning. Often the root of the | |
| 95 problems is that the code was originally written before there was a | |
| 96 gutter and then not completely fixed up to accommodate the gutter. | |
| 97 | |
| 2367 | 98 */ |
| 99 | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
100 /************************************************************************/ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
101 /* include files */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
102 /************************************************************************/ |
| 442 | 103 |
| 428 | 104 /* We include the following generally useful header files so that you |
| 105 don't have to worry about prototypes when using the standard C | |
| 106 library functions and macros. These files shouldn't be excessively | |
| 107 large so they shouldn't cause that much of a slowdown. */ | |
| 108 | |
| 109 #include <stdlib.h> | |
|
5016
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
110 /* 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
|
111 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
|
112 hacking around it. */ |
|
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
113 #define index old_index |
| 428 | 114 #include <string.h> /* primarily for memcpy, etc. */ |
|
5016
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
115 #undef index |
| 428 | 116 #include <stdio.h> /* NULL, etc. */ |
| 117 #include <ctype.h> | |
| 118 #include <stdarg.h> | |
| 119 #include <stddef.h> /* offsetof */ | |
| 120 #include <sys/types.h> | |
| 442 | 121 #include <limits.h> |
| 4932 | 122 #ifdef __cplusplus |
| 123 #include <limits> /* necessary for max()/min() under G++ 4 */ | |
| 124 #endif | |
| 125 | |
| 442 | 126 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
127 /************************************************************************/ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
128 /* error checking */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
129 /************************************************************************/ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
130 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
131 /* ------------------------- large categories ------------------------- */ |
| 853 | 132 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
133 /* How these work: |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
134 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
135 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
|
136 `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
|
137 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
|
138 `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
|
139 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
|
140 Consider `text': |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
141 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
142 `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
|
143 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
|
144 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
|
145 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
|
146 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
|
147 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
|
148 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
|
149 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
|
150 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
|
151 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
|
152 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
|
153 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
|
154 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
|
155 is not defined. |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
156 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
157 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
|
158 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
|
159 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
|
160 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
|
161 needed, they can always be defined. */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
162 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
163 /* #### 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
|
164 category/subcategory system. Here is one proposal: |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
165 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
166 Major category Minor categories |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
167 -------------------------------- |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
168 Allocation |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
169 Malloc |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
170 Dynarr |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
171 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
172 Display |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
173 Extents |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
174 Glyphs |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
175 Redisplay |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
176 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
177 Execution |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
178 Byte-Code |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
179 Catch |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
180 Garbage Collection |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
181 Trapping-Problems |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
182 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
183 Lisp Objects |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
184 Buffers |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
185 Char Tables |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
186 Events |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
187 Lstreams |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
188 Hash Tables |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
189 Range Tables |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
190 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
191 Types |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
192 Lrecord Types |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
193 Subtypes |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
194 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
195 Text |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
196 Byte Positions |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
197 Conversion |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
198 Eistrings |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
199 Itext |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
200 Lisp Strings |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
201 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
202 --ben |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
203 */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
204 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
205 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
206 #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
|
207 #define INLINE_ERROR_CHECK_CALL , __FILE__, __LINE__ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
208 #define DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
209 #define DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
210 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
211 /* 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
|
212 line of the calling function */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
213 #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
|
214 /* 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
|
215 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
|
216 #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
|
217 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
218 /* ------- the specific categories -------- */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
219 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
220 #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
|
221 #define ERROR_CHECK_ANY |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
222 #endif |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
223 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
224 /* KEEP THESE SORTED! */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
225 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
226 #ifdef ERROR_CHECK_BYTE_CODE |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
227 #define byte_code_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
228 #else /* not ERROR_CHECK_BYTE_CODE */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
229 #define byte_code_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
230 #endif /* ERROR_CHECK_BYTE_CODE */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
231 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
232 #ifdef ERROR_CHECK_DISPLAY |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
233 #define display_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
234 #else /* not ERROR_CHECK_DISPLAY */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
235 #define display_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
236 #endif /* ERROR_CHECK_DISPLAY */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
237 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
238 #ifdef ERROR_CHECK_EXTENTS |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
239 #define extent_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
240 #else /* not ERROR_CHECK_EXTENTS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
241 #define extent_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
242 #endif /* ERROR_CHECK_EXTENTS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
243 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
244 #ifdef ERROR_CHECK_GC |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
245 #define gc_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
246 #else /* not ERROR_CHECK_GC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
247 #define gc_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
248 #endif /* ERROR_CHECK_GC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
249 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
250 #ifdef ERROR_CHECK_GLYPHS |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
251 #define glyph_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
252 #else /* not ERROR_CHECK_GLYPHS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
253 #define glyph_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
254 #endif /* ERROR_CHECK_GLYPHS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
255 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
256 #ifdef ERROR_CHECK_MALLOC |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
257 #define malloc_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
258 #else /* not ERROR_CHECK_MALLOC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
259 #define malloc_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
260 #endif /* ERROR_CHECK_MALLOC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
261 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
262 #ifdef ERROR_CHECK_STRUCTURES |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
263 #define structure_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
264 #else /* not ERROR_CHECK_STRUCTURES */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
265 #define structure_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
266 #endif /* ERROR_CHECK_STRUCTURES */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
267 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
268 #ifdef ERROR_CHECK_TEXT |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
269 #define text_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
270 #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
|
271 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
272 #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
|
273 #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
|
274 #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
|
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 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
277 #else /* not ERROR_CHECK_TEXT */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
278 #define text_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
279 #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
|
280 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
281 #define inline_text_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
282 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
283 #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
|
284 #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
|
285 #define text_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
286 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
287 #endif /* ERROR_CHECK_TEXT */ |
| 853 | 288 |
| 1318 | 289 #ifdef ERROR_CHECK_TYPES |
| 290 #define type_checking_assert(assertion) assert (assertion) | |
| 291 #define type_checking_assert_at_line(assertion, file, line) \ | |
| 292 assert_at_line (assertion, file, line) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
293 #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
|
294 #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
|
295 #define INLINE_TYPE_CHECK_CALL INLINE_ERROR_CHECK_CALL |
| 1318 | 296 #define type_checking_assert_with_message(assertion, msg) \ |
| 297 assert_with_message (assertion, msg) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
298 #else /* not ERROR_CHECK_TYPES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
299 #define type_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
300 #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
|
301 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
302 #define inline_type_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
303 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
304 #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
|
305 #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
|
306 #define type_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
307 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
308 #endif /* ERROR_CHECK_TYPES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
309 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
310 /* ------------------------- small categories ------------------------- */ |
|
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 /* 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
|
313 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
|
314 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
|
315 necessary. |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
316 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
317 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
|
318 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
|
319 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
|
320 of ERROR_CHECK_STRUCTURES. |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
321 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
322 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
|
323 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
|
324 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
|
325 these become needed, they can always be defined. */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
326 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
327 #ifdef ERROR_CHECK_STRUCTURES |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
328 /* 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
|
329 #define ERROR_CHECK_CATCH |
| 5038 | 330 /* Check for incoherent dynarr structures, attempts to access Dynarr |
| 331 positions out of range, reentrant use of dynarrs through dynarr locking, | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
332 etc. */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
333 #define ERROR_CHECK_DYNARR |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
334 /* Check for insufficient use of call_trapping_problems(), particularly |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
335 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
|
336 #define ERROR_CHECK_TRAPPING_PROBLEMS |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
337 #endif /* ERROR_CHECK_STRUCTURES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
338 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
339 #ifdef ERROR_CHECK_CATCH |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
340 #define catch_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
341 #else /* not ERROR_CHECK_CATCH */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
342 #define catch_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
343 #endif /* ERROR_CHECK_CATCH */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
344 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
345 #ifdef ERROR_CHECK_DYNARR |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
346 #define dynarr_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
347 #else /* not ERROR_CHECK_DYNARR */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
348 #define dynarr_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
349 #endif /* ERROR_CHECK_DYNARR */ |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
350 |
| 1318 | 351 #ifdef ERROR_CHECK_TRAPPING_PROBLEMS |
| 352 #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
|
353 #else /* not ERROR_CHECK_TRAPPING_PROBLEMS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
354 #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
|
355 #endif /* ERROR_CHECK_TRAPPING_PROBLEMS */ |
| 1318 | 356 |
| 2367 | 357 /************************************************************************/ |
| 358 /** Definitions of basic types **/ | |
| 359 /************************************************************************/ | |
| 360 | |
| 361 /* ------------- generic 8/16/32/64/128-bit integral types ------------ */ | |
| 647 | 362 |
| 826 | 363 #if SIZEOF_SHORT == 2 |
| 364 #define INT_16_BIT short | |
| 365 #define UINT_16_BIT unsigned short | |
| 366 #elif SIZEOF_INT == 2 | |
| 367 /* Bwa ha ha. As if XEmacs could actually support such systems. */ | |
| 368 #define INT_16_BIT int | |
| 369 #define UINT_16_BIT unsigned int | |
| 370 #else | |
| 371 #error Unable to find a 16-bit integral type | |
| 372 #endif | |
| 373 | |
| 374 #if SIZEOF_INT == 4 | |
| 375 #define INT_32_BIT int | |
| 376 #define UINT_32_BIT unsigned int | |
| 377 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##U | |
| 378 #elif SIZEOF_LONG == 4 | |
| 379 /* Bwa ha ha again. */ | |
| 380 #define INT_32_BIT long | |
| 381 #define UINT_32_BIT unsigned long | |
| 382 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##UL | |
| 383 #elif SIZEOF_SHORT == 4 | |
| 384 /* And again. */ | |
| 385 #define INT_32_BIT short | |
| 386 #define UINT_32_BIT unsigned short | |
| 387 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##U | |
| 1429 | 388 #elif 1 /* Unable to find a 32-bit integral type! */ |
| 826 | 389 #error What kind of strange-ass system are you running on? |
| 390 #endif | |
| 391 | |
| 392 #if SIZEOF_LONG == 8 | |
| 393 #define INT_64_BIT long | |
| 394 #define UINT_64_BIT unsigned long | |
| 395 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##UL | |
| 396 #elif SIZEOF_LONG_LONG == 8 | |
| 397 #define INT_64_BIT long long | |
| 398 #define UINT_64_BIT unsigned long long | |
| 399 #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
|
400 #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
|
401 #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
|
402 #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
|
403 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##UI64 |
| 826 | 404 /* No error otherwise; just leave undefined */ |
| 405 #endif | |
| 406 | |
| 407 #if SIZEOF_LONG_LONG == 16 | |
| 408 #define INT_128_BIT long long | |
| 409 #define UINT_128_BIT unsigned long long | |
| 410 #define MAKE_128_BIT_UNSIGNED_CONSTANT(num) num##ULL | |
| 411 /* No error otherwise; just leave undefined */ | |
| 412 #endif | |
| 413 | |
| 414 /* #### Fill this in for other systems */ | |
| 415 #if defined (INT_64_BIT) && !(defined (i386) || defined (__i386__)) | |
| 416 #define EFFICIENT_INT_64_BIT INT_64_BIT | |
| 417 #define EFFICIENT_UINT_64_BIT UINT_64_BIT | |
| 418 #endif | |
| 419 | |
| 420 #if defined (INT_128_BIT) | |
| 421 #define EFFICIENT_INT_128_BIT INT_128_BIT | |
| 422 #define EFFICIENT_UINT_128_BIT UINT_128_BIT | |
| 423 #endif | |
| 424 | |
| 2367 | 425 #ifdef HAVE_INTTYPES_H |
| 426 #include <inttypes.h> | |
| 427 #elif defined (HAVE_INTPTR_T_IN_SYS_TYPES_H) | |
| 428 /* included elsewhere */ | |
| 429 #elif SIZEOF_VOID_P == SIZEOF_INT | |
| 430 typedef int intptr_t; | |
| 431 typedef unsigned int uintptr_t; | |
| 432 #elif SIZEOF_VOID_P == SIZEOF_LONG | |
| 433 typedef long intptr_t; | |
| 434 typedef unsigned long uintptr_t; | |
| 435 #elif defined (SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG | |
| 436 typedef long long intptr_t; | |
| 437 typedef unsigned long long uintptr_t; | |
| 438 #else | |
| 439 /* Just pray. May break, may not. */ | |
| 440 typedef long intptr_t; | |
| 441 typedef unsigned long uintptr_t; | |
| 442 #endif | |
| 443 | |
| 3988 | 444 #if SIZEOF_VOID_P == 8 |
| 445 #define DEADBEEF_CONSTANT 0xCAFEBABEDEADBEEF | |
| 446 #elif SIZEOF_VOID_P == 4 | |
| 447 #define DEADBEEF_CONSTANT 0xDEADBEEF | |
| 448 #else | |
| 449 #error "What size are your pointers, really?" | |
| 450 #endif /* SIZEOF_VOID_P == 8 */ | |
| 451 | |
| 2367 | 452 /* ---------------------- definition of EMACS_INT --------------------- */ |
| 453 | |
| 454 /* EMACS_INT is the underlying integral type into which a Lisp_Object must fit. | |
| 455 In particular, it must be large enough to contain a pointer. | |
| 456 config.h can override this, e.g. to use `long long' for bigger lisp ints. | |
| 457 | |
| 458 #### In point of fact, it would NOT be a good idea for config.h to mess | |
| 459 with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT | |
| 460 is the size of a pointer. */ | |
| 461 | |
| 462 #ifndef SIZEOF_EMACS_INT | |
| 463 # define SIZEOF_EMACS_INT SIZEOF_VOID_P | |
| 464 #endif | |
| 465 | |
| 466 #ifndef EMACS_INT | |
| 467 # if SIZEOF_EMACS_INT == SIZEOF_LONG | |
| 468 # define EMACS_INT long | |
| 469 # elif SIZEOF_EMACS_INT == SIZEOF_INT | |
| 470 # define EMACS_INT int | |
| 471 # elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG | |
| 472 # define EMACS_INT long long | |
| 473 # else | |
| 474 # error Unable to determine suitable type for EMACS_INT | |
| 475 # endif | |
| 476 #endif | |
| 477 | |
| 478 #ifndef EMACS_UINT | |
| 479 # define EMACS_UINT unsigned EMACS_INT | |
| 480 #endif | |
| 481 | |
| 482 #define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR) | |
| 483 | |
| 484 /* -------------------------- basic byte typedefs --------------------- */ | |
| 485 | |
| 486 /* The definitions we put here and in the next section use typedefs to | |
| 487 attribute specific meaning to types that by themselves are pretty | |
| 488 general. | |
| 489 | |
| 490 REMEMBER! These typedefs are purely for documentation purposes; from | |
| 647 | 491 the C code's perspective, they are exactly equivalent to `char *', |
| 492 `unsigned char *', etc., so you can freely use them with library | |
| 2367 | 493 functions declared as such. |
| 494 | |
| 495 (See also "Byte/Character Types" in text.c) | |
| 496 | |
| 497 The basic semantics for `char': | |
| 498 | |
| 499 a) [Ibyte] pointer to internally-formatted text | |
| 500 b) [Extbyte] pointer to text in some external format, which can be | |
| 501 defined as all formats other than the internal one | |
| 502 c) [Ascbyte] pure ASCII text | |
| 503 d) [Binbyte] binary data that is not meant to be interpreted as text | |
| 504 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
|
505 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
|
506 based/byte-based offsets of pointers |
| 2367 | 507 f) [Boolbyte] a zero or a one |
| 508 g) [Bitbyte] a byte used for bit fields | |
| 509 h) [Chbyte] null-semantics `char *'; used when casting an argument to | |
| 510 an external API where the the other types may not be | |
| 511 appropriate | |
| 512 | |
| 513 | |
| 514 Prefixing codes: | |
| 515 | |
| 516 C = plain char, when the base type is unsigned | |
| 517 U = unsigned | |
| 518 S = signed | |
| 519 | |
| 520 Ideally, XEmacs code should NEVER directly use `char' or any type | |
| 521 derived from it. This is for Mule-cleanliness. If you find yourself | |
| 522 wanting or needing to use `char' and one of the above six semantics does | |
| 523 not apply, add a new type of semantics; don't use `char' directly. | |
| 524 | |
| 525 See text.c under "Byte Types", and following sections. | |
| 526 */ | |
| 647 | 527 |
| 528 /* The data representing the text in a buffer is logically a set | |
| 867 | 529 of Ibytes, declared as follows. */ |
| 530 | |
| 531 typedef unsigned char Ibyte; | |
| 647 | 532 |
| 533 /* The following should be used when you are working with internal data | |
| 534 but for whatever reason need to have it declared a "char *". Examples | |
| 535 are function arguments whose values are most commonly literal strings, | |
| 536 or where you have to apply a stdlib string function to internal data. | |
| 537 | |
| 2367 | 538 In general, you should avoid this where possible and use Ascbyte if the |
| 539 text is just ASCII (e.g. string literals) or otherwise Ibyte, for | |
| 540 consistency. For example, the new Mule workspace contains Ibyte | |
| 541 versions of the stdlib string functions. */ | |
| 867 | 542 |
| 543 typedef char CIbyte; | |
| 647 | 544 |
| 545 /* The data representing a string in "external" format (binary or any | |
| 546 external encoding) is logically a set of Extbytes, declared as | |
| 547 follows. Extbyte is guaranteed to be just a char, so for example | |
| 548 strlen (Extbyte *) is OK. Extbyte is only a documentation device | |
| 549 for referring to external text. */ | |
| 550 | |
| 551 typedef char Extbyte; | |
| 771 | 552 typedef unsigned char UExtbyte; |
| 647 | 553 |
| 2367 | 554 #define EXTTEXT_ZTERM_SIZE (sizeof (Extbyte)) |
| 647 | 555 |
| 556 /* A byte in a string in entirely US-ASCII format: (Nothing outside | |
| 557 the range 00 - 7F) */ | |
| 558 | |
| 2367 | 559 typedef char Ascbyte; |
| 560 typedef unsigned char UAscbyte; | |
| 561 | |
| 562 /* A generic memory pointer, no text or binary semantics assumed. | |
| 563 In general, there should be no manipulation of the memory pointed to | |
| 564 by these pointers other than just copying it around. */ | |
| 565 | |
| 566 typedef unsigned char Rawbyte; | |
| 567 typedef char CRawbyte; | |
| 568 | |
| 569 /* A byte in a string in binary (not meant as text) format: */ | |
| 570 | |
| 571 typedef unsigned char Binbyte; | |
| 572 typedef char CBinbyte; | |
| 573 typedef signed char SBinbyte; | |
| 574 | |
| 575 /* A byte used to represent a boolean value: 0 or 1. | |
| 576 Normally use plain Boolint, and only use Boolbyte to save space. */ | |
| 577 | |
| 578 typedef char Boolbyte; | |
| 579 | |
| 580 /* A byte composed of bitfields. Hardly ever used. */ | |
| 581 | |
| 582 typedef unsigned char Bitbyte; | |
| 583 | |
| 584 /* A no-semantics `char'. Used (pretty-much) ONLY for casting arguments to | |
| 585 functions accepting a `char *', `unsigned char *', etc. where the other | |
| 586 types don't exactly apply and what you are logically concerned with is | |
| 587 the type of the function's argument and not its semantics. | |
| 588 | |
| 589 DO NOT DO NOT DO NOT DO NOT use this as a sloppy replacement for one of | |
| 590 the other types. If you're not using this as part of casting an | |
| 591 argument to a function call, and you're not Ben Wing, you're using it | |
| 592 wrong. Go find another one of the types. */ | |
| 593 | |
| 594 typedef char Chbyte; | |
| 595 typedef unsigned char UChbyte; | |
| 596 typedef signed char SChbyte; | |
| 597 | |
| 598 /* ------------------------ other text-related typedefs ------------------- */ | |
| 647 | 599 |
| 826 | 600 /* To the user, a buffer is made up of characters. In the non-Mule world, |
| 867 | 601 characters and Ibytes are equivalent, restricted to the range 0 - 255. |
| 3498 | 602 In the Mule world, many more characters are possible (21 bits worth, |
| 867 | 603 more or less), and a character requires (typically) 1 to 4 Ibytes for |
| 826 | 604 its representation in a buffer or string. Note that the representation |
| 605 of a character by itself, in a variable, is very different from its | |
| 606 representation in a string of text (in a buffer or Lisp string). | |
| 607 | |
| 608 Under Mule, text can be represented in more than one way. The "default" | |
| 609 format is variable-width (1 to 4 bytes) and compatible with ASCII -- | |
| 610 ASCII chars are stored in one byte, as themselves, and all other chars | |
| 611 use only high bytes. The default format is currently the only format | |
| 612 used for text stored anywhere but in a buffer. In a buffer, other | |
| 613 formats -- fixed-width formats (1, 2, or 4 bytes) -- are possible, for | |
| 614 speed. | |
| 615 | |
| 616 See text.c/text.h for a detailed discussion of all of this. */ | |
| 617 | |
| 618 /* A character, as represented on its own. */ | |
| 647 | 619 |
| 867 | 620 typedef int Ichar; |
| 647 | 621 |
| 826 | 622 /* The "raw value" of a character as stored in the buffer. In the default |
| 623 format, this is just the same as the character. In fixed-width formats, | |
| 624 this is the actual value in the buffer, which will be limited to the | |
| 625 range as established by the format. This is used when searching for a | |
| 626 character in a buffer -- it's faster to convert the character to the raw | |
| 627 value and look for that, than repeatedly convert each raw value in the | |
| 628 buffer into a character. */ | |
| 629 | |
| 867 | 630 typedef int Raw_Ichar; |
| 826 | 631 |
| 2367 | 632 /* Internal text as a series of textual units (8-bit bytes in the old |
| 633 "Mule" encoding -- still the standard internal encoding -- and in UTF-8, | |
| 634 but 16-bit bytes in UTF-16 and 32-bit bytes in UTF-32). See text.c. */ | |
| 635 | |
| 636 #ifdef UTF16_IBYTE_FORMAT | |
| 637 #define NON_ASCII_INTERNAL_FORMAT | |
| 638 typedef unsigned short Itext; | |
| 639 #else | |
| 640 typedef Ibyte Itext; | |
| 641 #endif | |
| 642 typedef EMACS_INT Textcount; | |
| 643 | |
| 644 #define ITEXT_SIZE (sizeof (Itext)) | |
| 645 /* Use this to emphasize that we are adding space for the zero-terminator */ | |
| 646 #define ITEXT_ZTERM_SIZE ITEXT_SIZE | |
| 647 | |
| 648 /* Wexttext is wchar_t on WIN32_NATIVE (and perhaps other systems that | |
| 649 support wchar_t's in library functions), and Extbyte otherwise. This is | |
| 650 used whenever we have to do any sort of manipulation of | |
| 651 externally-encoded strings -- generally a very bad idea, and unsafe, but | |
| 652 in some cases we have no choice (especially at startup, and esp. prior | |
| 653 to pdump, where we haven't loaded the Unicode tables necessary for | |
| 654 conversion under Windows). On platforms where the external encoding may | |
| 655 be Unicode (i.e. Windows), we always do our manipulations in Unicode, | |
| 656 converting to and from multibyte if necessary -- otherwise we'd have to | |
| 657 conditionalize on Unicode vs. multibyte all over the place, which is | |
| 658 just a nightmare. */ | |
| 659 #ifdef WIN32_NATIVE | |
| 660 #define WEXTTEXT_IS_WIDE | |
| 661 typedef wchar_t Wexttext; | |
| 662 #else | |
| 663 typedef Extbyte Wexttext; | |
| 664 #endif | |
| 826 | 665 |
| 666 #if !defined (__cplusplus) || !defined (CPLUSPLUS_INTEGRAL_CLASSES_NOT_YET) | |
| 667 | |
| 668 /* Counts of bytes or chars */ | |
| 669 | |
| 670 typedef EMACS_INT Bytecount; | |
| 671 typedef EMACS_INT Charcount; | |
| 672 | |
| 647 | 673 /* Different ways of referring to a position in a buffer. We use |
| 674 the typedefs in preference to 'EMACS_INT' to make it clearer what | |
| 826 | 675 sort of position is being used. See text.c for a description |
| 676 of the different positions. | |
| 677 | |
| 678 Note that buffer positions are 1-based, and there's a gap in the middle | |
| 679 of a buffer; that's why we have separate typedefs. For Lisp strings and | |
| 680 other strings of text, we just use Bytecount and Charcount. */ | |
| 800 | 681 |
| 665 | 682 typedef EMACS_INT Charbpos; |
| 683 typedef EMACS_INT Bytebpos; | |
| 684 typedef EMACS_INT Membpos; | |
| 647 | 685 |
| 826 | 686 /* Different ways of referring to a position that can be either in a buffer |
| 687 or string; used when passing around an object that can be either a | |
| 688 buffer or string, and an associated position. Conceptually, they | |
| 689 resolve as follows: | |
| 690 | |
| 691 Typedef Buffer String | |
| 692 ------------------------------------------------------ | |
| 693 Charxpos Charbpos Charcount | |
| 694 Bytexpos Bytebpos Bytecount | |
| 695 Memxpos Membpos Bytecount | |
| 696 | |
| 697 */ | |
| 698 | |
| 814 | 699 typedef EMACS_INT Charxpos; |
| 700 typedef EMACS_INT Bytexpos; | |
| 701 typedef EMACS_INT Memxpos; | |
| 702 | |
| 703 #else /* __cplusplus */ | |
| 704 | |
| 705 /* Implement strong type-checking of the above integral types by declaring | |
| 706 them to be classes and using operator overloading. Unfortunately this | |
| 707 is a huge pain in the ass because C++ doesn't strongly distinguish | |
| 708 "bool" and "size_t" from int. The problem is especially bad with "bool" | |
| 2956 | 709 -- if you want to be able to say `if (len--)' where len is e.g. a |
| 814 | 710 Bytecount, you need to declare a conversion operator to bool(); and |
| 711 since bool is just an alias for int, you suddenly get tons and tons of | |
| 712 ambiguities, which need to be resolved by lots of laborious declarations | |
| 713 for every single possible type combination. Hence the multitude of | |
| 714 declarations in DECLARE_INTCLASS_ARITH_COMPARE(). The bool/int | |
| 715 equivalence also means that we have to forcibly block the combinations | |
| 716 we don't want by creating overloaded versions of them and declaring them | |
| 717 private. */ | |
| 718 | |
| 719 class Bytecount; | |
| 720 class Bytebpos; | |
| 721 class Bytexpos; | |
| 722 class Charcount; | |
| 723 class Charbpos; | |
| 724 class Charxpos; | |
| 725 class Membpos; | |
| 726 class Memxpos; | |
| 727 | |
| 728 /* Declare the arithmetic and comparison operations for an integral class, | |
| 729 i.e. one of the above classes. If this is a "position" class, where the | |
| 730 difference between two positions is a different class (a "count" class), | |
| 731 then use POSCL for the position class and COUNTCL for the count class. | |
| 732 If this is a simple class, where all operations yield the same class, | |
| 733 substitute the same class for POSCL and COUNTCL. */ | |
| 734 | |
| 735 #define DECLARE_INTCLASS_ARITH_COMPARE(poscl, countcl) \ | |
| 736 poscl operator += (const countcl& l) { data += l.data; return *this; } \ | |
| 737 poscl operator -= (const countcl& l) { data -= l.data; return *this; } \ | |
| 738 poscl operator + (const countcl& l) const { return poscl (data + l.data); } \ | |
| 739 poscl operator - (const countcl& l) const { return poscl (data - l.data); } \ | |
| 740 poscl operator += (const int& l) { data += l; return *this; } \ | |
| 741 poscl operator -= (const int& l) { data -= l; return *this; } \ | |
| 742 poscl operator + (const int& l) const { return poscl (data + l); } \ | |
| 743 poscl operator - (const int& l) const { return poscl (data - l); } \ | |
| 744 poscl operator += (const unsigned int& l) { data += l; return *this; } \ | |
| 745 poscl operator -= (const unsigned int& l) { data -= l; return *this; } \ | |
| 746 poscl operator + (const unsigned int& l) const \ | |
| 747 { return poscl (data + l); } \ | |
| 748 poscl operator - (const unsigned int& l) const \ | |
| 749 { return poscl (data - l); } \ | |
| 750 poscl operator += (const long& l) { data += l; return *this; } \ | |
| 751 poscl operator -= (const long& l) { data -= l; return *this; } \ | |
| 752 poscl operator + (const long& l) const { return poscl (data + l); } \ | |
| 753 poscl operator - (const long& l) const { return poscl (data - l); } \ | |
| 754 poscl operator += (const unsigned long& l) { data += l; return *this; } \ | |
| 755 poscl operator -= (const unsigned long& l) { data -= l; return *this; } \ | |
| 756 poscl operator + (const unsigned long& l) const \ | |
| 757 { return poscl (data + l); } \ | |
| 758 poscl operator - (const unsigned long& l) const \ | |
| 759 { return poscl (data - l); } \ | |
| 760 poscl operator += (const short& l) { data += l; return *this; } \ | |
| 761 poscl operator -= (const short& l) { data -= l; return *this; } \ | |
| 762 poscl operator + (const short& l) const { return poscl (data + l); } \ | |
| 763 poscl operator - (const short& l) const { return poscl (data - l); } \ | |
| 764 poscl operator += (const unsigned short& l) { data += l; return *this; } \ | |
| 765 poscl operator -= (const unsigned short& l) { data -= l; return *this; } \ | |
| 766 poscl operator + (const unsigned short& l) const \ | |
| 767 { return poscl (data + l); } \ | |
| 768 poscl operator - (const unsigned short& l) const \ | |
| 769 { return poscl (data - l); } \ | |
| 770 \ | |
| 771 poscl operator *= (const countcl& l) { data *= l.data; return *this; } \ | |
| 772 poscl operator /= (const countcl& l) { data /= l.data; return *this; } \ | |
| 773 poscl operator * (const countcl& l) const { return poscl (data * l.data); } \ | |
| 774 poscl operator / (const countcl& l) const { return poscl (data / l.data); } \ | |
| 775 poscl operator *= (const int& l) { data *= l; return *this; } \ | |
| 776 poscl operator /= (const int& l) { data /= l; return *this; } \ | |
| 777 poscl operator * (const int& l) const { return poscl (data * l); } \ | |
| 778 poscl operator / (const int& l) const { return poscl (data / l); } \ | |
| 779 poscl operator *= (const unsigned int& l) { data *= l; return *this; } \ | |
| 780 poscl operator /= (const unsigned int& l) { data /= l; return *this; } \ | |
| 781 poscl operator * (const unsigned int& l) const { return poscl (data * l); } \ | |
| 782 poscl operator / (const unsigned int& l) const { return poscl (data / l); } \ | |
| 783 poscl operator *= (const long& l) { data *= l; return *this; } \ | |
| 784 poscl operator /= (const long& l) { data /= l; return *this; } \ | |
| 785 poscl operator * (const long& l) const { return poscl (data * l); } \ | |
| 786 poscl operator / (const long& l) const { return poscl (data / l); } \ | |
| 787 poscl operator *= (const unsigned long& l) { data *= l; return *this; } \ | |
| 788 poscl operator /= (const unsigned long& l) { data /= l; return *this; } \ | |
| 789 poscl operator * (const unsigned long& l) const \ | |
| 790 { return poscl (data * l); } \ | |
| 791 poscl operator / (const unsigned long& l) const \ | |
| 792 { return poscl (data / l); } \ | |
| 793 poscl operator *= (const short& l) { data *= l; return *this; } \ | |
| 794 poscl operator /= (const short& l) { data /= l; return *this; } \ | |
| 795 poscl operator * (const short& l) const { return poscl (data * l); } \ | |
| 796 poscl operator / (const short& l) const { return poscl (data / l); } \ | |
| 797 poscl operator *= (const unsigned short& l) { data *= l; return *this; } \ | |
| 798 poscl operator /= (const unsigned short& l) { data /= l; return *this; } \ | |
| 799 poscl operator * (const unsigned short& l) const \ | |
| 800 { return poscl (data * l); } \ | |
| 801 poscl operator / (const unsigned short& l) const \ | |
| 802 { return poscl (data / l); } \ | |
| 803 \ | |
| 804 poscl operator &= (const countcl& l) { data &= l.data; return *this; } \ | |
| 805 poscl operator |= (const countcl& l) { data |= l.data; return *this; } \ | |
| 806 poscl operator & (const countcl& l) const { return poscl (data & l.data); } \ | |
| 807 poscl operator | (const countcl& l) const { return poscl (data | l.data); } \ | |
| 808 poscl operator &= (const int& l) { data &= l; return *this; } \ | |
| 809 poscl operator |= (const int& l) { data |= l; return *this; } \ | |
| 810 poscl operator & (const int& l) const { return poscl (data & l); } \ | |
| 811 poscl operator | (const int& l) const { return poscl (data | l); } \ | |
| 812 poscl operator &= (const unsigned int& l) { data &= l; return *this; } \ | |
| 813 poscl operator |= (const unsigned int& l) { data |= l; return *this; } \ | |
| 814 poscl operator & (const unsigned int& l) const { return poscl (data & l); } \ | |
| 815 poscl operator | (const unsigned int& l) const { return poscl (data | l); } \ | |
| 816 poscl operator &= (const long& l) { data &= l; return *this; } \ | |
| 817 poscl operator |= (const long& l) { data |= l; return *this; } \ | |
| 818 poscl operator & (const long& l) const { return poscl (data & l); } \ | |
| 819 poscl operator | (const long& l) const { return poscl (data | l); } \ | |
| 820 poscl operator &= (const unsigned long& l) { data &= l; return *this; } \ | |
| 821 poscl operator |= (const unsigned long& l) { data |= l; return *this; } \ | |
| 822 poscl operator & (const unsigned long& l) const \ | |
| 823 { return poscl (data & l); } \ | |
| 824 poscl operator | (const unsigned long& l) const \ | |
| 825 { return poscl (data | l); } \ | |
| 826 poscl operator &= (const short& l) { data &= l; return *this; } \ | |
| 827 poscl operator |= (const short& l) { data |= l; return *this; } \ | |
| 828 poscl operator & (const short& l) const { return poscl (data & l); } \ | |
| 829 poscl operator | (const short& l) const { return poscl (data | l); } \ | |
| 830 poscl operator &= (const unsigned short& l) { data &= l; return *this; } \ | |
| 831 poscl operator |= (const unsigned short& l) { data |= l; return *this; } \ | |
| 832 poscl operator & (const unsigned short& l) const \ | |
| 833 { return poscl (data & l); } \ | |
| 834 poscl operator | (const unsigned short& l) const \ | |
| 835 { return poscl (data | l); } \ | |
| 836 \ | |
| 837 poscl operator - () { return poscl (-data); } \ | |
| 838 poscl operator-- () { data--; return *this; } \ | |
| 839 poscl operator-- (int) { data--; return poscl (data + 1); } \ | |
| 840 poscl operator++ () { data++; return *this; } \ | |
| 841 poscl operator++ (int) { data++; return poscl (data - 1); } \ | |
| 842 \ | |
| 843 bool operator < (const poscl& l) const { return data < l.data; } \ | |
| 844 bool operator <= (const poscl& l) const { return data <= l.data; } \ | |
| 845 bool operator > (const poscl& l) const { return data > l.data; } \ | |
| 846 bool operator >= (const poscl& l) const { return data >= l.data; } \ | |
| 847 bool operator == (const poscl& l) const { return data == l.data; } \ | |
| 848 bool operator != (const poscl& l) const { return data != l.data; } \ | |
| 849 bool operator < (const int& l) const { return data < (EMACS_INT) l; } \ | |
| 850 bool operator <= (const int& l) const { return data <= (EMACS_INT) l; } \ | |
| 851 bool operator > (const int& l) const { return data > (EMACS_INT) l; } \ | |
| 852 bool operator >= (const int& l) const { return data >= (EMACS_INT) l; } \ | |
| 853 bool operator == (const int& l) const { return data == (EMACS_INT) l; } \ | |
| 854 bool operator != (const int& l) const { return data != (EMACS_INT) l; } \ | |
| 855 bool operator < (const unsigned int& l) const \ | |
| 856 { return data < (EMACS_INT) l; } \ | |
| 857 bool operator <= (const unsigned int& l) const \ | |
| 858 { return data <= (EMACS_INT) l; } \ | |
| 859 bool operator > (const unsigned int& l) const \ | |
| 860 { return data > (EMACS_INT) l; } \ | |
| 861 bool operator >= (const unsigned int& l) const \ | |
| 862 { return data >= (EMACS_INT) l; } \ | |
| 863 bool operator == (const unsigned int& l) const \ | |
| 864 { return data == (EMACS_INT) l; } \ | |
| 865 bool operator != (const unsigned int& l) const \ | |
| 866 { return data != (EMACS_INT) l; } \ | |
| 867 bool operator < (const long& l) const { return data < (EMACS_INT) l; } \ | |
| 868 bool operator <= (const long& l) const { return data <= (EMACS_INT) l; } \ | |
| 869 bool operator > (const long& l) const { return data > (EMACS_INT) l; } \ | |
| 870 bool operator >= (const long& l) const { return data >= (EMACS_INT) l; } \ | |
| 871 bool operator == (const long& l) const { return data == (EMACS_INT) l; } \ | |
| 872 bool operator != (const long& l) const { return data != (EMACS_INT) l; } \ | |
| 873 bool operator < (const unsigned long& l) const \ | |
| 874 { return data < (EMACS_INT) l; } \ | |
| 875 bool operator <= (const unsigned long& l) const \ | |
| 876 { return data <= (EMACS_INT) l; } \ | |
| 877 bool operator > (const unsigned long& l) const \ | |
| 878 { return data > (EMACS_INT) l; } \ | |
| 879 bool operator >= (const unsigned long& l) const \ | |
| 880 { return data >= (EMACS_INT) l; } \ | |
| 881 bool operator == (const unsigned long& l) const \ | |
| 882 { return data == (EMACS_INT) l; } \ | |
| 883 bool operator != (const unsigned long& l) const \ | |
| 884 { return data != (EMACS_INT) l; } \ | |
| 885 bool operator < (const short& l) const { return data < (EMACS_INT) l; } \ | |
| 886 bool operator <= (const short& l) const { return data <= (EMACS_INT) l; } \ | |
| 887 bool operator > (const short& l) const { return data > (EMACS_INT) l; } \ | |
| 888 bool operator >= (const short& l) const { return data >= (EMACS_INT) l; } \ | |
| 889 bool operator == (const short& l) const { return data == (EMACS_INT) l; } \ | |
| 890 bool operator != (const short& l) const { return data != (EMACS_INT) l; } \ | |
| 891 bool operator < (const unsigned short& l) const \ | |
| 892 { return data < (EMACS_INT) l; } \ | |
| 893 bool operator <= (const unsigned short& l) const \ | |
| 894 { return data <= (EMACS_INT) l; } \ | |
| 895 bool operator > (const unsigned short& l) const \ | |
| 896 { return data > (EMACS_INT) l; } \ | |
| 897 bool operator >= (const unsigned short& l) const \ | |
| 898 { return data >= (EMACS_INT) l; } \ | |
| 899 bool operator == (const unsigned short& l) const \ | |
| 900 { return data == (EMACS_INT) l; } \ | |
| 901 bool operator != (const unsigned short& l) const \ | |
| 902 { return data != (EMACS_INT) l; } \ | |
| 903 bool operator ! () const { return !data; } | |
| 904 | |
| 905 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 906 between class GOOD and class BAD. Meant to go inside the private | |
| 907 section of class GOOD. */ | |
| 908 | |
| 909 #define DECLARE_BAD_INTCLASS_ARITH_COMPARE(good, bad) \ | |
| 910 good operator += (const bad& l) { return badret; } \ | |
| 911 good operator -= (const bad& l) { return badret; } \ | |
| 912 good operator *= (const bad& l) { return badret; } \ | |
| 913 good operator /= (const bad& l) { return badret; } \ | |
| 914 good operator + (const bad& l) { return badret; } \ | |
| 915 good operator - (const bad& l) { return badret; } \ | |
| 916 good operator * (const bad& l) { return badret; } \ | |
| 917 good operator / (const bad& l) { return badret; } \ | |
| 918 \ | |
| 919 bool operator < (const bad& l) { return 0; } \ | |
| 920 bool operator <= (const bad& l) { return 0; } \ | |
| 921 bool operator > (const bad& l) { return 0; } \ | |
| 922 bool operator >= (const bad& l) { return 0; } \ | |
| 923 bool operator == (const bad& l) { return 0; } \ | |
| 924 bool operator != (const bad& l) { return 0; } | |
| 925 | |
| 926 /* Declare the "bad" or disallowed arithmetic operations between class GOOD | |
| 927 and another of the same class, for a position class. Meant to go inside | |
| 928 the private section of class GOOD. */ | |
| 929 | |
| 930 #define DECLARE_BAD_POS_CLASS_ARITH(good) \ | |
| 931 good operator += (const good& l) { return badret; } \ | |
| 932 good operator -= (const good& l) { return badret; } \ | |
| 933 good operator *= (const good& l) { return badret; } \ | |
| 934 good operator /= (const good& l) { return badret; } \ | |
| 935 good operator + (const good& l) { return badret; } \ | |
| 936 good operator * (const good& l) { return badret; } \ | |
| 937 good operator / (const good& l) { return badret; } | |
| 938 | |
| 939 /* Basic declaration at the top of all integral classes. Don't call | |
| 940 directly, use one of the more specific versions below. */ | |
| 941 | |
| 942 #define DECLARE_INTCLASS(cl) \ | |
| 943 public: \ | |
| 944 EMACS_INT data; \ | |
| 945 cl () { data = 0xCDCDCDCD; } \ | |
| 946 cl (int i) { data = i; } \ | |
| 947 cl (unsigned int i) { data = i; } \ | |
| 948 cl (long i) { data = i; } \ | |
| 949 cl (unsigned long i) { data = i; } \ | |
| 950 cl (short i) { data = i; } \ | |
| 951 cl (unsigned short i) { data = i; } \ | |
| 952 operator EMACS_INT () const { return data; } | |
| 953 | |
| 954 /* Basic declaration at the top of all count classes. */ | |
| 955 | |
| 956 #define DECLARE_COUNT_CLASS(cl) \ | |
| 957 DECLARE_INTCLASS (cl) \ | |
| 958 DECLARE_INTCLASS_ARITH_COMPARE (cl, cl) \ | |
| 959 private: \ | |
| 960 static cl badret; | |
| 961 | |
| 962 /* Basic declaration at the bottom of the prelude of all position classes. | |
| 963 Don't call directly. */ | |
| 964 | |
| 965 #define DECLARE_POS_CLASS_SECOND_HALF(cl, countcl) \ | |
| 966 DECLARE_INTCLASS_ARITH_COMPARE (cl, countcl) \ | |
| 967 countcl operator - (const cl& l) const { return countcl (data - l.data); } \ | |
| 968 private: \ | |
| 969 static cl badret; \ | |
| 970 DECLARE_BAD_POS_INTCLASS_ARITH (cl) | |
| 971 | |
| 972 /* Basic declaration at the top of all buffer position classes. */ | |
| 973 | |
| 974 #define DECLARE_BPOS_CLASS(cl, countcl) \ | |
| 975 DECLARE_INTCLASS (cl) \ | |
| 976 DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) | |
| 977 | |
| 978 /* Basic declaration at the top of all X-position classes (that can refer | |
| 979 to buffers or strings). CL1 and CL2 are the equivalent more specific | |
| 1318 | 980 classes referring only to buffers or strings, respectively. */ |
| 814 | 981 |
| 982 #define DECLARE_XPOS_CLASS(cl, countcl, cl1, cl2) \ | |
| 983 DECLARE_INTCLASS (cl) \ | |
| 984 cl (const cl1& x) { data = x.data; } \ | |
| 985 cl (const cl2& x) { data = x.data; } \ | |
| 986 operator cl1 () const { return cl1 (data); } \ | |
| 987 operator cl2 () const { return cl2 (data); } \ | |
| 988 DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) | |
| 989 | |
| 990 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 991 between class CHARCL (a character class) and various non-character | |
| 992 classes. Meant to go inside the private section of class GOOD. */ | |
| 993 | |
| 994 #define DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE(charcl) \ | |
| 995 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytecount) \ | |
| 996 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytebpos) \ | |
| 997 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytexpos) \ | |
| 998 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Membpos) \ | |
| 999 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Memxpos) | |
| 1000 | |
| 1001 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1002 between class BYTECL (a byte class) and various non-byte classes. | |
| 1003 Meant to go inside the private section of class GOOD. */ | |
| 1004 | |
| 1005 #define DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE(bytecl) \ | |
| 1006 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ | |
| 1007 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ | |
| 1008 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ | |
| 1009 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Membpos) \ | |
| 1010 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Memxpos) | |
| 1011 | |
| 1012 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1013 between class BYTECL (a mem class) and various non-mem classes. | |
| 1014 Meant to go inside the private section of class GOOD. */ | |
| 1015 | |
| 1016 #define DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE(bytecl) \ | |
| 1017 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ | |
| 1018 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ | |
| 1019 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ | |
| 1020 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytebpos) \ | |
| 1021 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytexpos) | |
| 1022 | |
| 1023 class Charcount | |
| 1024 { | |
| 1025 DECLARE_COUNT_CLASS (Charcount) | |
| 1026 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charcount) | |
| 1027 }; | |
| 1028 | |
| 1029 class Charbpos | |
| 1030 { | |
| 1031 DECLARE_BPOS_CLASS (Charbpos, Charcount) | |
| 1032 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charbpos) | |
| 1033 }; | |
| 1034 | |
| 1035 class Charxpos | |
| 1036 { | |
| 1037 DECLARE_XPOS_CLASS (Charxpos, Charcount, Charbpos, Charcount) | |
| 1038 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charxpos) | |
| 1039 }; | |
| 1040 | |
| 1041 class Bytecount | |
| 1042 { | |
| 1043 DECLARE_COUNT_CLASS (Bytecount) | |
| 1044 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytecount) | |
| 1045 }; | |
| 1046 | |
| 1047 class Bytebpos | |
| 1048 { | |
| 1049 DECLARE_BPOS_CLASS (Bytebpos, Bytecount) | |
| 1050 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytebpos) | |
| 1051 }; | |
| 1052 | |
| 1053 class Bytexpos | |
| 1054 { | |
| 1055 DECLARE_XPOS_CLASS (Bytexpos, Bytecount, Bytebpos, Bytecount) | |
| 1056 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytexpos) | |
| 1057 }; | |
| 1058 | |
| 1059 class Membpos | |
| 1060 { | |
| 1061 DECLARE_BPOS_CLASS (Membpos, Bytecount) | |
| 1062 DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Membpos) | |
| 1063 }; | |
| 1064 | |
| 1065 class Memxpos | |
| 1066 { | |
| 1067 DECLARE_XPOS_CLASS (Memxpos, Bytecount, Membpos, Bytecount) | |
| 1068 DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Memxpos) | |
| 1069 }; | |
| 1070 | |
| 826 | 1071 #define DECLARE_POINTER_TYPE_ARITH_COUNT(pointer, countcl) \ |
| 1072 inline pointer operator += (const pointer & x, const countcl& y) \ | |
| 1073 { x += y.data; return x; } \ | |
| 1074 inline pointer operator -= (const pointer & x, const countcl& y) \ | |
| 1075 { x -= y.data; return x; } \ | |
| 1076 inline pointer operator + (const pointer x, const countcl& y) \ | |
| 1077 { return x + y.data; } \ | |
| 1078 inline pointer operator - (const pointer x, const countcl& y) \ | |
| 814 | 1079 { return x - y.data; } |
| 1080 | |
| 1081 #define DECLARE_INTEGRAL_TYPE_ARITH_COUNT(integral, countcl) \ | |
| 1082 inline integral operator += (integral & x, const countcl& y) \ | |
| 1083 { x += y.data; return x; } \ | |
| 1084 inline integral operator -= (integral & x, const countcl& y) \ | |
| 1085 { x -= y.data; return x; } \ | |
| 1086 inline countcl operator + (integral x, const countcl& y) \ | |
| 1087 { return countcl (x + y.data); } \ | |
| 1088 inline countcl operator - (integral x, const countcl& y) \ | |
| 1089 { return countcl (x - y.data); } | |
| 1090 | |
| 1091 #define DECLARE_INTEGRAL_TYPE_COMPARE(integral, cl) \ | |
| 1092 inline bool operator < (integral x, const cl& y) \ | |
| 1093 { return (EMACS_INT) x < y.data; } \ | |
| 1094 inline bool operator <= (integral x, const cl& y) \ | |
| 1095 { return (EMACS_INT) x <= y.data; } \ | |
| 1096 inline bool operator > (integral x, const cl& y) \ | |
| 1097 { return (EMACS_INT) x > y.data; } \ | |
| 1098 inline bool operator >= (integral x, const cl& y) \ | |
| 1099 { return (EMACS_INT) x >= y.data; } \ | |
| 1100 inline bool operator == (integral x, const cl& y) \ | |
| 1101 { return (EMACS_INT) x == y.data; } \ | |
| 1102 inline bool operator != (integral x, const cl& y) \ | |
| 1103 { return (EMACS_INT) x != y.data; } | |
| 1104 | |
| 1105 #if 0 | |
| 1106 /* Unfortunately C++ doesn't let you overload the ?: operator, so we have | |
| 1107 to manually deal with ambiguities using casting */ | |
| 1108 #define DECLARE_INTEGRAL_TYPE_TRISTATE(integral, cl) \ | |
| 1109 inline cl operator ?: (bool b, integral x, const cl& y) \ | |
| 1110 { return b ? cl (x) : y; } \ | |
| 1111 inline cl operator ?: (bool b, const cl& x, integral y) \ | |
| 1112 { return b ? x : cl (y); } | |
| 1113 #endif /* 0 */ | |
| 1114 | |
| 867 | 1115 /* DECLARE_POINTER_TYPE_ARITH_COUNT (const Ibyte *, Bytecount); |
| 826 | 1116 DECLARE_POINTER_TYPE_ARITH_COUNT (const Extbyte *, Bytecount); */ |
| 867 | 1117 DECLARE_POINTER_TYPE_ARITH_COUNT (Ibyte *, Bytecount); |
| 814 | 1118 DECLARE_POINTER_TYPE_ARITH_COUNT (Extbyte *, Bytecount); |
| 1119 | |
| 1120 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Bytecount); | |
| 1121 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Charcount); | |
| 1122 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Bytecount); | |
| 1123 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Charcount); | |
| 1124 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Bytecount); | |
| 1125 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Charcount); | |
| 1126 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Bytecount); | |
| 1127 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Charcount); | |
| 1128 | |
| 1129 DECLARE_INTEGRAL_TYPE_COMPARE (int, Bytecount); | |
| 1130 DECLARE_INTEGRAL_TYPE_COMPARE (int, Charcount); | |
| 1131 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Bytecount); | |
| 1132 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Charcount); | |
| 1133 DECLARE_INTEGRAL_TYPE_COMPARE (long, Bytecount); | |
| 1134 DECLARE_INTEGRAL_TYPE_COMPARE (long, Charcount); | |
| 1135 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Bytecount); | |
| 1136 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Charcount); | |
| 1137 | |
| 1138 #if 0 /* doesn't work */ | |
| 867 | 1139 inline Bytecount operator - (const Ibyte *x, const Ibyte *y) \ |
| 814 | 1140 { return Bytecount (x - y); } |
| 1141 #endif | |
| 1142 | |
| 1143 #endif /* __cplusplus */ | |
| 1144 | |
| 665 | 1145 /* Counts of elements */ |
| 1146 typedef EMACS_INT Elemcount; | |
| 1147 /* Hash codes */ | |
| 1148 typedef unsigned long Hashcode; | |
| 2367 | 1149 /* Booleans */ |
| 1150 typedef int Boolint; | |
| 771 | 1151 |
| 793 | 1152 /* ------------------------ basic compiler defines ------------------- */ |
| 428 | 1153 |
| 1743 | 1154 #include "compiler.h" |
| 1632 | 1155 |
| 793 | 1156 /* ------------------------ alignment definitions ------------------- */ |
| 1157 | |
| 454 | 1158 /* No type has a greater alignment requirement than max_align_t. |
| 1159 (except perhaps for types we don't use, like long double) */ | |
| 1160 typedef union | |
| 1161 { | |
| 1162 struct { long l; } l; | |
| 1163 struct { void *p; } p; | |
| 1164 struct { void (*f)(void); } f; | |
| 1165 struct { double d; } d; | |
| 1166 } max_align_t; | |
| 1167 | |
| 771 | 1168 /* ALIGNOF returns the required alignment of a type -- i.e. a value such |
| 1169 that data of this type must begin at a memory address which is a | |
| 1170 multiple of that value. For simple types, this is often the same size | |
| 1171 as the type itself. */ | |
| 1172 | |
| 428 | 1173 #ifndef ALIGNOF |
| 1174 # if defined (__GNUC__) && (__GNUC__ >= 2) | |
| 454 | 1175 /* gcc has an extension that gives us exactly what we want. */ |
| 1176 # define ALIGNOF(type) __alignof__ (type) | |
| 1177 # elif ! defined (__cplusplus) | |
| 1178 /* The following is mostly portable, except that: | |
| 1179 - it doesn't work for inside out declarations like void (*) (void). | |
| 1180 (so just call ALIGNOF with a typedef'ed name) | |
| 1181 - it doesn't work with C++. The C++ committee has decided, | |
| 1182 in its infinite wisdom, that: | |
| 1183 "Types must be declared in declarations, not in expressions." */ | |
| 1184 # define ALIGNOF(type) offsetof (struct { char c; type member; }, member) | |
| 428 | 1185 # else |
| 456 | 1186 /* C++ is annoying, but it has a big bag of tricks. |
| 1187 The following doesn't have the "inside out" declaration bug C does. */ | |
| 458 | 1188 template<typename T> struct alignment_trick { char c; T member; }; |
| 456 | 1189 # define ALIGNOF(type) offsetof (alignment_trick<type>, member) |
| 428 | 1190 # endif |
| 454 | 1191 #endif /* ALIGNOF */ |
| 428 | 1192 |
| 771 | 1193 /* ALIGN_SIZE returns the smallest size greater than or equal to LEN which |
| 1194 is a multiple of UNIT. This can be used to assure that data that | |
| 1195 follows a block of the returned size is of correct alignment for a type | |
| 1196 whose alignment (as returned by ALIGNOF) is UNIT (provided that the | |
| 1197 block itself is correctly aligned for this type; memory returned by | |
| 1198 malloc() is guaranteed to be correctly aligned for all types). */ | |
| 1199 | |
| 428 | 1200 #define ALIGN_SIZE(len, unit) \ |
| 1201 ((((len) + (unit) - 1) / (unit)) * (unit)) | |
| 1202 | |
| 826 | 1203 /* ALIGN_FOR_TYPE returns the smallest size greater than or equal to LEN |
| 1204 which is aligned for the given type. This can be used to assure that | |
| 1205 data that follows a block of the returned size is of correct alignment | |
| 1206 for the type (provided that the block itself is correctly aligned for | |
| 1207 this type; memory returned by malloc() is guaranteed to be correctly | |
| 1208 aligned for all types). */ | |
| 1209 | |
| 1210 #define ALIGN_FOR_TYPE(len, type) ALIGN_SIZE (len, ALIGNOF (type)) | |
| 1211 | |
| 771 | 1212 /* MAX_ALIGN_SIZE returns the smallest size greater than or equal to LEN |
| 1213 which guarantees that data following a block of such size is correctly | |
| 1214 aligned for all types (provided that the block itself is so aligned, | |
| 1215 which is the case for memory returned by malloc()). */ | |
| 1216 | |
| 826 | 1217 #define MAX_ALIGN_SIZE(len) ALIGN_FOR_TYPE (len, max_align_t) |
| 1218 | |
| 1219 /* ALIGN_PTR returns the smallest pointer >= PTR which is aligned for | |
| 1220 data of TYPE. */ | |
| 1221 #define ALIGN_PTR(ptr, type) ((void *) ALIGN_FOR_TYPE ((size_t) (ptr), type)) | |
| 428 | 1222 |
| 1743 | 1223 BEGIN_C_DECLS |
| 1650 | 1224 |
| 793 | 1225 /* ------------------------ assertions ------------------- */ |
| 428 | 1226 |
| 1227 /* We define assert iff USE_ASSERTIONS or DEBUG_XEMACS is defined. | |
| 1228 Otherwise we define it to be empty. Quantify has shown that the | |
| 1229 time the assert checks take is measurable so let's not include them | |
| 771 | 1230 in production binaries. |
| 1231 | |
| 788 | 1232 If ASSERTIONS_DONT_ABORT defined, we will continue after assertion |
| 1233 failures. | |
| 1234 | |
| 1235 assert_at_line() is used for asserts inside of inline functions called | |
| 1236 from error-checking macros. If we're not tricky, we just get the file | |
| 1237 and line of the inline function, which is not very useful. */ | |
| 428 | 1238 |
| 1239 /* Highly dubious kludge */ | |
| 1240 /* (thanks, Jamie, I feel better now -- ben) */ | |
| 2367 | 1241 MODULE_API void assert_failed (const Ascbyte *, int, const Ascbyte *); |
| 5090 | 1242 void assert_equal_failed (const Ascbyte *file, int line, EMACS_INT x, |
| 1243 EMACS_INT y, const Ascbyte *exprx, | |
| 1244 const Ascbyte *expry); | |
|
4914
1628e3b9601a
When aborting due to unknown opcode, output more descriptive msg
Ben Wing <ben@xemacs.org>
parents:
4910
diff
changeset
|
1245 #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
|
1246 #define abort_with_message(msg) assert_failed (__FILE__, __LINE__, msg) |
| 2535 | 1247 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1248 /* 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
|
1249 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
|
1250 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
|
1251 `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
|
1252 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
|
1253 change it in the future. */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1254 #define disabled_assert(x) ((void) (x)) |
| 4932 | 1255 #define disabled_assert_with_message(x, msg) ((void) msg, disabled_assert (x)) |
| 1256 #define disabled_assert_at_line(x, file, line) \ | |
| 1257 ((void) file, (void) line, disabled_assert (x)) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1258 |
| 2535 | 1259 #ifdef USE_ASSERTIONS |
| 428 | 1260 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x)) |
| 853 | 1261 # define assert_with_message(x, msg) \ |
| 1262 ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, msg)) | |
| 788 | 1263 # define assert_at_line(x, file, line) \ |
| 1264 ((x) ? (void) 0 : assert_failed (file, line, #x)) | |
| 5090 | 1265 # define assert_equal(x, y) \ |
| 1266 ((x) == (y) ? (void) 0 : \ | |
| 1267 assert_equal_failed (__FILE__, __LINE__, (EMACS_INT) x, (EMACS_INT) y, \ | |
| 1268 #x, #y)) | |
| 428 | 1269 #else |
| 2956 | 1270 /* This used to be ((void) (0)) but that triggers lots of unused variable |
| 1271 warnings. It's pointless to force all that code to be rewritten, with | |
| 1272 added ifdefs. Any reasonable compiler will eliminate an expression with | |
| 1273 no effects. */ | |
| 4932 | 1274 # define assert(x) disabled_assert (x) |
| 1275 # define assert_with_message(x, msg) disabled_assert_with_message (x, msg) | |
| 1276 # define assert_at_line(x, file, line) disabled_assert_at_line (x, file, line) | |
| 5090 | 1277 # define assert_equal(x, y) disabled_assert ((x) == (y)) |
| 428 | 1278 #endif |
| 1279 | |
| 2367 | 1280 /************************************************************************/ |
| 1281 /** Memory allocation **/ | |
| 1282 /************************************************************************/ | |
| 853 | 1283 |
| 793 | 1284 /* ------------------------ simple memory allocation ------------------- */ |
| 1285 | |
| 2367 | 1286 /* Basic memory allocation and freeing functions */ |
| 1287 void malloc_warning (const Ascbyte *); | |
| 1743 | 1288 MODULE_API void *xmalloc (Bytecount size) ATTRIBUTE_MALLOC; |
| 1289 MODULE_API void *xmalloc_and_zero (Bytecount size) ATTRIBUTE_MALLOC; | |
| 1290 MODULE_API void *xrealloc (void *, Bytecount size) ATTRIBUTE_MALLOC; | |
| 2367 | 1291 MODULE_API Chbyte *xstrdup (const Chbyte *) ATTRIBUTE_MALLOC; |
| 1292 | |
| 1293 /* Basic free function */ | |
| 1294 | |
| 1295 MODULE_API void xfree_1 (void *); | |
| 1296 #ifdef ERROR_CHECK_MALLOC | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1297 /* This used to use a temporary variable. But that triggered |
| 2367 | 1298 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
|
1299 #define xfree(lvalue) do \ |
| 2367 | 1300 { \ |
| 1301 xfree_1 (lvalue); \ | |
| 3988 | 1302 VOIDP_CAST (lvalue) = (void *) DEADBEEF_CONSTANT; \ |
| 2367 | 1303 } while (0) |
| 1304 #else | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1305 #define xfree(lvalue) xfree_1 (lvalue) |
| 2367 | 1306 #endif /* ERROR_CHECK_MALLOC */ |
| 1307 | |
| 1308 /* ------------------------ stack allocation -------------------------- */ | |
| 1309 | |
| 1310 /* Allocating excessively large blocks on the stack can cause crashes. | |
| 851 | 1311 We provide MALLOC_OR_ALLOCA() below for places where it's likely that |
| 1312 large amounts will be allocated; it mallocs the block if it's too big. | |
| 1313 Unfortunately, that requires a call to unbind_to() at the end of the | |
| 1314 function, and it's not feasible to rewrite all calls to alloca() this | |
| 1315 way. | |
| 1316 | |
| 1317 Instead, we use the portable C alloca() substitute in alloca.c above a | |
| 1318 certain size. This actually uses malloc(), but checks the current stack | |
| 1319 pointer to see if data from previous alloca() calls needs to be freed. | |
| 1320 However, this can lead to large heap sizes -- especially since cleanup | |
| 1321 can only happen in a parent function, and will never happen if (as will | |
| 1322 often be the case) it's the same function in the same place in the code | |
| 1323 that keeps tripping the alloca() limit. | |
| 1324 | |
| 1325 So we set up a system to periodically force cleanup. Currently we | |
| 1326 do cleanup: | |
| 1327 | |
| 1328 -- Only when there's C alloca() data, and then | |
| 1329 -- Every stack alloca() or allocation of Lisp data, every call to | |
| 1330 next_event_internal() [typically near the top of the stack], | |
| 1331 or every 10th funcall | |
| 1332 | |
| 1333 This should not be a big penalty because | |
| 1334 | |
| 1335 (a) If there are few C alloca() chunks, checking them will be fast | |
| 1336 (b) If not, we've allocated a huge amount of heap space (remember, each | |
| 1337 chunk represents > 256K of heap), and we really want them gone | |
| 1338 */ | |
| 1339 | |
| 1340 /* We use a larger maximum when the choice is alloca() vs. the C alloca() | |
| 1341 substitute than when the choice is vs. malloc(), because in the former | |
| 1342 case, our alternative choice is less palatable because the memory may | |
| 1343 not be freed for awhile. */ | |
| 1344 | |
| 1345 #define MAX_ALLOCA_VS_C_ALLOCA 262144 | |
| 1346 #define MAX_ALLOCA_VS_MALLOC 65536 | |
| 1347 | |
| 1348 #define MAX_FUNCALLS_BETWEEN_ALLOCA_CLEANUP 10 | |
| 1349 | |
| 1632 | 1350 extern MODULE_API Bytecount __temp_alloca_size__; |
| 851 | 1351 extern Bytecount funcall_alloca_count; |
| 1352 | |
| 1333 | 1353 #ifdef ERROR_CHECK_MALLOC |
| 1632 | 1354 extern MODULE_API int regex_malloc_disallowed; |
| 1333 | 1355 #define REGEX_MALLOC_CHECK() assert (!regex_malloc_disallowed) |
| 1356 #else | |
| 1357 #define REGEX_MALLOC_CHECK() ((void) 0) | |
| 1358 #endif | |
| 1359 | |
| 851 | 1360 /* Do stack or heap alloca() depending on size. |
| 1361 | |
| 1362 NOTE: The use of a global temporary like this is unsafe if ALLOCA() occurs | |
| 1363 twice anywhere in the same expression; but that seems highly unlikely. The | |
| 1364 alternative is to force all callers to declare a local temporary if the | |
| 1365 expression has side effects -- something easy to forget. */ | |
| 1366 | |
| 1367 #define ALLOCA(size) \ | |
| 1333 | 1368 (REGEX_MALLOC_CHECK (), \ |
| 1369 __temp_alloca_size__ = (size), \ | |
| 851 | 1370 __temp_alloca_size__ > MAX_ALLOCA_VS_C_ALLOCA ? \ |
| 1371 xemacs_c_alloca (__temp_alloca_size__) : \ | |
| 1372 (need_to_check_c_alloca ? xemacs_c_alloca (0) : 0, \ | |
| 1373 alloca (__temp_alloca_size__))) | |
| 1374 | |
| 1318 | 1375 /* Version of ALLOCA() that is guaranteed to work inside of function calls |
| 1376 (i.e., we call the C alloca if regular alloca() is broken inside of | |
| 1377 function calls). */ | |
| 1378 #ifdef BROKEN_ALLOCA_IN_FUNCTION_CALLS | |
| 1379 #define ALLOCA_FUNCALL_OK(size) xemacs_c_alloca (size) | |
| 1380 #else | |
| 1381 #define ALLOCA_FUNCALL_OK(size) ALLOCA (size) | |
| 1382 #endif | |
| 1383 | |
| 2367 | 1384 MODULE_API void *xemacs_c_alloca (unsigned int size) ATTRIBUTE_MALLOC; |
| 1385 | |
| 1386 MODULE_API int record_unwind_protect_freeing (void *ptr); | |
| 1387 | |
| 1388 DECLARE_INLINE_HEADER ( | |
| 1389 void * | |
| 1390 xmalloc_and_record_unwind (Bytecount size) | |
| 1391 ) | |
| 1392 { | |
| 1393 void *ptr = xmalloc (size); | |
| 1394 record_unwind_protect_freeing (ptr); | |
| 1395 return ptr; | |
| 1396 } | |
| 1397 | |
| 851 | 1398 /* WARNING: If you use this, you must unbind_to() at the end of your |
| 1399 function! */ | |
| 1400 | |
| 1401 #define MALLOC_OR_ALLOCA(size) \ | |
| 1333 | 1402 (REGEX_MALLOC_CHECK (), \ |
| 1403 __temp_alloca_size__ = (size), \ | |
| 851 | 1404 __temp_alloca_size__ > MAX_ALLOCA_VS_MALLOC ? \ |
| 1405 xmalloc_and_record_unwind (__temp_alloca_size__) : \ | |
| 1406 (need_to_check_c_alloca ? xemacs_c_alloca (0) : 0, \ | |
| 1407 alloca (__temp_alloca_size__))) | |
| 793 | 1408 |
| 2367 | 1409 /* -------------- convenience functions for memory allocation ------------- */ |
| 1410 | |
| 1411 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0]))) | |
| 1412 #define xnew(type) ((type *) xmalloc (sizeof (type))) | |
| 1413 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type))) | |
| 1414 #define xnew_and_zero(type) ((type *) xmalloc_and_zero (sizeof (type))) | |
| 1415 #define xzero(lvalue) ((void) memset (&(lvalue), '\0', sizeof (lvalue))) | |
| 1416 #define xnew_array_and_zero(type, len) ((type *) xmalloc_and_zero ((len) * sizeof (type))) | |
| 1417 | |
| 1418 #define alloca_new(type) ((type *) ALLOCA (sizeof (type))) | |
| 1419 #define alloca_array(type, len) ((type *) ALLOCA ((len) * sizeof (type))) | |
| 1420 | |
| 1421 #define alloca_itexts(num) alloca_array (Itext, num) | |
| 1422 #define alloca_ibytes(num) alloca_array (Ibyte, num) | |
| 1423 #define alloca_extbytes(num) alloca_array (Extbyte, num) | |
| 1424 #define alloca_rawbytes(num) alloca_array (Rawbyte, num) | |
| 1425 #define alloca_binbytes(num) alloca_array (Binbyte, num) | |
| 1426 #define alloca_ascbytes(num) alloca_array (Ascbyte, num) | |
| 1427 #define xmalloc_itexts(num) xnew_array (Itext, num) | |
| 1428 #define xnew_ibytes(num) xnew_array (Ibyte, num) | |
| 1429 #define xnew_extbytes(num) xnew_array (Extbyte, num) | |
| 1430 #define xnew_rawbytes(num) xnew_array (Rawbyte, num) | |
| 1431 #define xnew_binbytes(num) xnew_array (Binbyte, num) | |
| 1432 #define xnew_ascbytes(num) xnew_array (Ascbyte, num) | |
| 1433 | |
| 1434 /* Make an alloca'd copy of a Ibyte * */ | |
| 1435 #define IBYTE_STRING_TO_ALLOCA(p, lval) \ | |
| 1436 do { \ | |
| 1437 Ibyte **_bsta_ = (Ibyte **) &(lval); \ | |
| 1438 const Ibyte *_bsta_2 = (p); \ | |
| 1439 Bytecount _bsta_3 = qxestrlen (_bsta_2); \ | |
| 1440 *_bsta_ = alloca_ibytes (1 + _bsta_3); \ | |
| 1441 memcpy (*_bsta_, _bsta_2, 1 + _bsta_3); \ | |
| 1442 } while (0) | |
| 1443 | |
| 1444 /* ----------------- convenience functions for reallocation --------------- */ | |
| 1445 | |
| 1446 #define XREALLOC_ARRAY(ptr, type, len) \ | |
| 1447 ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type)))) | |
| 1448 | |
| 793 | 1449 /* also generally useful if you want to avoid arbitrary size limits |
| 1450 but don't need a full dynamic array. Assumes that BASEVAR points | |
| 1451 to a malloced array of TYPE objects (or possibly a NULL pointer, | |
| 1452 if SIZEVAR is 0), with the total size stored in SIZEVAR. This | |
| 1453 macro will realloc BASEVAR as necessary so that it can hold at | |
| 1454 least NEEDED_SIZE objects. The reallocing is done by doubling, | |
| 1455 which ensures constant amortized time per element. */ | |
| 1456 #define DO_REALLOC(basevar, sizevar, needed_size, type) do { \ | |
| 1457 Bytecount do_realloc_needed_size = (needed_size); \ | |
| 1333 | 1458 REGEX_MALLOC_CHECK (); \ |
| 793 | 1459 if ((sizevar) < do_realloc_needed_size) \ |
| 1460 { \ | |
| 1461 if ((sizevar) < 32) \ | |
| 1462 (sizevar) = 32; \ | |
| 1463 while ((sizevar) < do_realloc_needed_size) \ | |
| 1464 (sizevar) *= 2; \ | |
| 1465 XREALLOC_ARRAY (basevar, type, (sizevar)); \ | |
| 1466 } \ | |
| 1467 } while (0) | |
| 1468 | |
| 2367 | 1469 /************************************************************************/ |
| 1470 /** Definitions of more complex types **/ | |
| 1471 /************************************************************************/ | |
| 428 | 1472 |
| 647 | 1473 /* Note that the simplest typedefs are near the top of this file. */ |
| 1474 | |
| 428 | 1475 /* We put typedefs here so that prototype declarations don't choke. |
| 1476 Note that we don't actually declare the structures here (except | |
| 5038 | 1477 maybe for simple structures like dynarrs); that keeps them private |
| 428 | 1478 to the routines that actually use them. */ |
| 1479 | |
| 771 | 1480 /* ------------------------------- */ |
| 1481 /* Error_Behavior typedefs */ | |
| 1482 /* ------------------------------- */ | |
| 1483 | |
| 800 | 1484 #ifndef ERROR_CHECK_TYPES |
| 771 | 1485 |
| 1486 typedef enum error_behavior | |
| 428 | 1487 { |
| 771 | 1488 ERROR_ME, |
| 1489 ERROR_ME_NOT, | |
| 793 | 1490 ERROR_ME_WARN, |
| 1491 ERROR_ME_DEBUG_WARN | |
| 771 | 1492 } Error_Behavior; |
| 1493 | |
| 1494 #define ERRB_EQ(a, b) ((a) == (b)) | |
| 1495 | |
| 1496 #else | |
| 1497 | |
| 1498 /* By defining it like this, we provide strict type-checking | |
| 1499 for code that lazily uses ints. */ | |
| 1500 | |
| 1501 typedef struct _error_behavior_struct_ | |
| 428 | 1502 { |
| 771 | 1503 int really_unlikely_name_to_have_accidentally_in_a_non_errb_structure; |
| 1504 } Error_Behavior; | |
| 1505 | |
| 1506 extern Error_Behavior ERROR_ME; | |
| 1507 extern Error_Behavior ERROR_ME_NOT; | |
| 1508 extern Error_Behavior ERROR_ME_WARN; | |
| 793 | 1509 extern Error_Behavior ERROR_ME_DEBUG_WARN; |
| 771 | 1510 |
| 1511 #define ERRB_EQ(a, b) \ | |
| 1512 ((a).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure == \ | |
| 1513 (b).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure) | |
| 1514 | |
| 1515 #endif | |
| 1516 | |
| 1517 /* ------------------------------- */ | |
| 1518 /* Empty structures and typedefs */ | |
| 1519 /* ------------------------------- */ | |
| 428 | 1520 |
| 1521 struct buffer; /* "buffer.h" */ | |
| 1522 struct console; /* "console.h" */ | |
| 1523 struct device; /* "device.h" */ | |
| 1524 struct extent_fragment; | |
| 1525 struct extent; | |
| 1526 struct frame; /* "frame.h" */ | |
| 1527 struct window; /* "window.h" */ | |
| 771 | 1528 struct utimbuf; /* "systime.h" or <utime.h> */ |
| 428 | 1529 struct display_line; |
| 1530 struct display_glyph_area; | |
| 1531 struct display_box; | |
| 1532 struct redisplay_info; | |
| 1533 struct window_mirror; | |
| 1534 struct scrollbar_instance; | |
| 1535 struct font_metric_info; | |
| 1536 struct face_cachel; | |
| 1537 struct console_type_entry; | |
| 1538 | |
| 771 | 1539 /* This is shared by process.h, events.h and others in future. |
| 1540 See events.h for description */ | |
| 4123 | 1541 typedef unsigned EMACS_INT USID; |
| 771 | 1542 typedef int face_index; |
| 1543 typedef int glyph_index; | |
| 1726 | 1544 typedef struct lstream Lstream; /* lstream.h */ |
| 872 | 1545 typedef struct extent *EXTENT; /* extents-impl.h */ |
| 771 | 1546 typedef struct Lisp_Event Lisp_Event; /* "events.h" */ |
| 872 | 1547 typedef struct Lisp_Face Lisp_Face; /* "faces-impl.h" */ |
| 771 | 1548 typedef struct Lisp_Process Lisp_Process; /* "procimpl.h" */ |
| 872 | 1549 typedef struct Lisp_Color_Instance Lisp_Color_Instance; /* objects-impl.h */ |
| 1550 typedef struct Lisp_Font_Instance Lisp_Font_Instance; /* objects-impl.h */ | |
| 1726 | 1551 typedef struct Lisp_Image_Instance Lisp_Image_Instance; /* glyphs.h */ |
| 771 | 1552 typedef struct Lisp_Gui_Item Lisp_Gui_Item; |
| 1553 | |
| 1554 /* ------------------------------- */ | |
| 1555 /* enum typedefs */ | |
| 1556 /* ------------------------------- */ | |
| 1557 | |
| 428 | 1558 enum run_hooks_condition |
| 1559 { | |
| 1560 RUN_HOOKS_TO_COMPLETION, | |
| 1561 RUN_HOOKS_UNTIL_SUCCESS, | |
| 1562 RUN_HOOKS_UNTIL_FAILURE | |
| 1563 }; | |
| 1564 | |
| 1565 enum edge_style | |
| 1566 { | |
| 1567 EDGE_ETCHED_IN, | |
| 1568 EDGE_ETCHED_OUT, | |
| 1569 EDGE_BEVEL_IN, | |
| 1570 EDGE_BEVEL_OUT | |
| 1571 }; | |
| 1572 | |
| 1573 enum munge_me_out_the_door | |
| 1574 { | |
| 1575 MUNGE_ME_FUNCTION_KEY, | |
| 1576 MUNGE_ME_KEY_TRANSLATION | |
| 1577 }; | |
| 1578 | |
|
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
|
1579 /* 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
|
1580 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
|
1581 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
|
1582 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
|
1583 */ |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1584 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
|
1585 { |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1586 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
|
1587 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
|
1588 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
|
1589 }; |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1590 |
| 771 | 1591 /* ------------------------------- */ |
| 1592 /* misc */ | |
| 1593 /* ------------------------------- */ | |
| 1594 | |
| 1595 #ifdef MEMORY_USAGE_STATS | |
| 1596 | |
| 1597 /* This structure is used to keep statistics on the amount of memory | |
| 1598 in use. | |
| 1599 | |
| 1600 WAS_REQUESTED stores the actual amount of memory that was requested | |
| 1601 of the allocation function. The *_OVERHEAD fields store the | |
| 1602 additional amount of memory that was grabbed by the functions to | |
| 1603 facilitate allocation, reallocation, etc. MALLOC_OVERHEAD is for | |
| 1604 memory allocated with malloc(); DYNARR_OVERHEAD is for dynamic | |
| 1605 arrays; GAP_OVERHEAD is for gap arrays. Note that for (e.g.) | |
| 1606 dynamic arrays, there is both MALLOC_OVERHEAD and DYNARR_OVERHEAD | |
| 1607 memory: The dynamic array allocates memory above and beyond what | |
| 1608 was asked of it, and when it in turns allocates memory using | |
| 1609 malloc(), malloc() allocates memory beyond what it was asked | |
| 1610 to allocate. | |
| 1611 | |
| 1612 Functions that accept a structure of this sort do not initialize | |
| 1613 the fields to 0, and add any existing values to whatever was there | |
| 1614 before; this way, you can get a cumulative effect. */ | |
| 1615 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1616 struct usage_stats |
| 771 | 1617 { |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1618 Bytecount was_requested; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1619 Bytecount malloc_overhead; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1620 Bytecount dynarr_overhead; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1621 Bytecount gap_overhead; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1622 }; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1623 |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1624 struct generic_usage_stats |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1625 { |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1626 struct usage_stats u; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1627 Bytecount othervals[32]; |
| 771 | 1628 }; |
| 1629 | |
| 1630 #endif /* MEMORY_USAGE_STATS */ | |
| 1631 | |
| 428 | 1632 |
| 1633 /************************************************************************/ | |
| 1634 /* Definition of Lisp_Object data type */ | |
| 1635 /************************************************************************/ | |
| 1636 | |
| 1637 /* Define the fundamental Lisp data structures */ | |
| 1638 | |
| 1639 /* This is the set of Lisp data types */ | |
| 1640 | |
| 1641 enum Lisp_Type | |
| 1642 { | |
| 1643 Lisp_Type_Record, | |
| 1644 Lisp_Type_Int_Even, | |
| 1645 Lisp_Type_Char, | |
| 1646 Lisp_Type_Int_Odd | |
| 1647 }; | |
| 1648 | |
| 1649 #define POINTER_TYPE_P(type) ((type) == Lisp_Type_Record) | |
| 1650 | |
| 1651 /* Overridden by m/next.h */ | |
| 1652 #ifndef ASSERT_VALID_POINTER | |
| 1653 # define ASSERT_VALID_POINTER(pnt) (assert ((((EMACS_UINT) pnt) & 3) == 0)) | |
| 1654 #endif | |
| 1655 | |
| 1656 #define GCMARKBITS 0 | |
| 1657 #define GCTYPEBITS 2 | |
| 1658 #define GCBITS 2 | |
| 1659 #define INT_GCBITS 1 | |
| 1660 | |
| 1661 #define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS) | |
| 1662 #define VALBITS (BITS_PER_EMACS_INT - GCBITS) | |
| 542 | 1663 #define EMACS_INT_MAX ((EMACS_INT) ((1UL << (INT_VALBITS - 1)) -1UL)) |
| 442 | 1664 #define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1) |
| 802 | 1665 /* WARNING: evaluates its arg twice. */ |
| 1666 #define NUMBER_FITS_IN_AN_EMACS_INT(num) \ | |
| 1667 ((num) <= EMACS_INT_MAX && (num) >= EMACS_INT_MIN) | |
| 428 | 1668 |
| 1669 #ifdef USE_UNION_TYPE | |
| 1670 # include "lisp-union.h" | |
| 1671 #else /* !USE_UNION_TYPE */ | |
| 1672 # include "lisp-disunion.h" | |
| 1673 #endif /* !USE_UNION_TYPE */ | |
| 1674 | |
| 1675 #define XPNTR(x) ((void *) XPNTRVAL(x)) | |
| 1676 | |
| 1677 /* Close your eyes now lest you vomit or spontaneously combust ... */ | |
| 1678 | |
| 1679 #define HACKEQ_UNSAFE(obj1, obj2) \ | |
| 1680 (EQ (obj1, obj2) || (!POINTER_TYPE_P (XTYPE (obj1)) \ | |
| 1681 && !POINTER_TYPE_P (XTYPE (obj2)) \ | |
| 1682 && XCHAR_OR_INT (obj1) == XCHAR_OR_INT (obj2))) | |
| 1683 | |
| 1684 #ifdef DEBUG_XEMACS | |
| 1632 | 1685 extern MODULE_API int debug_issue_ebola_notices; |
| 1686 MODULE_API int eq_with_ebola_notice (Lisp_Object, Lisp_Object); | |
| 428 | 1687 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) \ |
| 1688 (debug_issue_ebola_notices ? eq_with_ebola_notice (obj1, obj2) \ | |
| 1689 : EQ (obj1, obj2)) | |
| 1690 #else | |
| 1691 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) EQ (obj1, obj2) | |
| 1692 #endif | |
| 1693 | |
| 1694 /* OK, you can open them again */ | |
| 1695 | |
| 1743 | 1696 END_C_DECLS |
| 1650 | 1697 |
| 4967 | 1698 #include "lrecord.h" |
| 1699 | |
| 5013 | 1700 /* Turn any void * pointer into a Lisp object. This is the counterpart of |
| 1701 STORE_LISP_IN_VOID, which works in the opposite direction. Note that | |
| 1702 you CANNOT use STORE_LISP_IN_VOID to undo the effects of STORE_VOID_IN_LISP! | |
| 1703 Instead, you GET_VOID_FROM_LISP: | |
| 1704 | |
| 1705 STORE_VOID_IN_LISP <--> GET_VOID_FROM_LISP vs. | |
| 1706 STORE_LISP_IN_VOID <--> GET_LISP_FROM_VOID | |
| 1707 | |
| 1708 STORE_VOID_IN_LISP has a restriction on the void * pointers it can | |
| 1709 handle -- the pointer must be an even address (lowest bit set to 0). | |
| 1710 Generally this is not a problem as nowadays virtually all allocation is | |
| 1711 at least 4-byte aligned, if not 8-byte. | |
| 1712 | |
| 1713 However, if this proves problematic, you can use make_opaque_ptr(), which | |
| 1714 is guaranteed to handle any kind of void * pointer but which does | |
| 1715 Lisp allocation. | |
| 1716 */ | |
| 1717 | |
| 1718 DECLARE_INLINE_HEADER ( | |
| 1719 Lisp_Object | |
| 1720 STORE_VOID_IN_LISP (void *ptr) | |
| 1721 ) | |
| 1722 { | |
| 1723 EMACS_UINT p = (EMACS_UINT) ptr; | |
| 1724 | |
| 1725 type_checking_assert ((p & 1) == 0); | |
| 1726 return make_int (p >> 1); | |
| 1727 } | |
| 1728 | |
| 1729 DECLARE_INLINE_HEADER ( | |
| 1730 void * | |
| 1731 GET_VOID_FROM_LISP (Lisp_Object obj) | |
| 1732 ) | |
| 1733 { | |
| 1734 EMACS_UINT p = XUINT (obj); | |
| 1735 return (void *) (p << 1); | |
| 1736 } | |
| 1737 | |
| 428 | 1738 /************************************************************************/ |
| 5038 | 1739 /** Definitions of dynamic arrays (dynarrs) and other allocators **/ |
| 4967 | 1740 /************************************************************************/ |
| 428 | 1741 |
| 1743 | 1742 BEGIN_C_DECLS |
| 1650 | 1743 |
| 4967 | 1744 /************* Dynarr declaration *************/ |
| 3293 | 1745 |
| 3092 | 1746 #ifdef NEW_GC |
| 4967 | 1747 #define DECLARE_DYNARR_LISP_IMP() \ |
| 1748 const struct lrecord_implementation *lisp_imp; | |
| 1749 #else | |
| 1750 #define DECLARE_DYNARR_LISP_IMP() | |
| 1751 #endif | |
| 1752 | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1753 #ifdef ERROR_CHECK_DYNARR |
| 4967 | 1754 #define DECLARE_DYNARR_LOCKED() \ |
| 1755 int locked; | |
| 3092 | 1756 #else |
| 4967 | 1757 #define DECLARE_DYNARR_LOCKED() |
| 1758 #endif | |
| 1759 | |
| 1760 #define Dynarr_declare(type) \ | |
| 1761 struct lrecord_header header; \ | |
| 1762 type *base; \ | |
| 1763 DECLARE_DYNARR_LISP_IMP () \ | |
| 1764 DECLARE_DYNARR_LOCKED () \ | |
| 5038 | 1765 int elsize_; \ |
| 4967 | 1766 int len_; \ |
| 1767 int largest_; \ | |
| 1768 int max_ | |
| 3092 | 1769 |
| 1770 typedef struct dynarr | |
| 1771 { | |
| 1772 Dynarr_declare (void); | |
| 1773 } Dynarr; | |
| 1774 | |
| 4967 | 1775 #define XD_DYNARR_DESC(base_type, sub_desc) \ |
| 1776 { XD_BLOCK_PTR, offsetof (base_type, base), \ | |
| 1777 XD_INDIRECT(1, 0), {sub_desc} }, \ | |
| 1778 { XD_INT, offsetof (base_type, len_) }, \ | |
| 1779 { XD_INT_RESET, offsetof (base_type, largest_), XD_INDIRECT(1, 0) }, \ | |
| 1780 { XD_INT_RESET, offsetof (base_type, max_), XD_INDIRECT(1, 0) } | |
| 1781 | |
| 1782 #ifdef NEW_GC | |
| 1783 #define XD_LISP_DYNARR_DESC(base_type, sub_desc) \ | |
| 1784 { XD_LISP_OBJECT_BLOCK_PTR, offsetof (base_type, base), \ | |
| 1785 XD_INDIRECT(1, 0), {sub_desc} }, \ | |
| 1786 { XD_INT, offsetof (base_type, len_) }, \ | |
| 1787 { XD_INT_RESET, offsetof (base_type, largest_), XD_INDIRECT(1, 0) }, \ | |
| 1788 { XD_INT_RESET, offsetof (base_type, max_), XD_INDIRECT(1, 0) } | |
| 1789 #endif /* NEW_GC */ | |
| 1790 | |
| 1791 /************* Dynarr verification *************/ | |
| 1792 | |
| 5038 | 1793 /* Dynarr locking and verification. |
| 1794 | |
| 1795 [I] VERIFICATION | |
| 1796 | |
| 1797 Verification routines simply return their basic argument, possibly | |
| 1798 casted, but in the process perform some verification on it, aborting if | |
| 1799 the verification fails. The verification routines take FILE and LINE | |
| 1800 parameters, and use them to output the file and line of the caller | |
| 1801 when an abort occurs, rather than the file and line of the inline | |
| 1802 function, which is less than useful. | |
| 1803 | |
| 1804 There are three basic types of verification routines: | |
| 1805 | |
| 1806 (1) Verify the dynarr itself. This verifies the basic invariant | |
| 1807 involving the length/size values: | |
| 1808 | |
| 1809 0 <= Dynarr_length(d) <= Dynarr_largest(d) <= Dynarr_max(d) | |
| 1810 | |
| 1811 (2) Verify the dynarr itself prior to modifying it. This performs | |
| 1812 the same verification as previously, but also checks that the | |
| 1813 dynarr is not locked (see below). | |
| 1814 | |
| 1815 (3) Verify a dynarr position. Unfortunately we have to have | |
| 1816 different verification routines depending on which kind of operation | |
| 1817 is being performed: | |
| 1818 | |
| 1819 (a) For Dynarr_at(), we check that the POS is bounded by Dynarr_largest(), | |
| 1820 i.e. 0 <= POS < Dynarr_largest(). | |
| 1821 (b) For Dynarr_atp_allow_end(), we also have to allow | |
| 1822 POS == Dynarr_largest(). | |
| 1823 (c) For Dynarr_atp(), we behave largely like Dynarr_at() but make a | |
| 1824 special exception when POS == 0 and Dynarr_largest() == 0 -- see | |
| 1825 comment below. | |
| 1826 (d) Some other routines contain the POS verification within their code, | |
| 1827 and make the check 0 <= POS < Dynarr_length() or | |
| 1828 0 <= POS <= Dynarr_length(). | |
| 1829 | |
| 1830 #### It is not well worked-out whether and in what circumstances it's | |
| 1831 allowed to use a position that is between Dynarr_length() and | |
| 1832 Dynarr_largest(). The ideal solution is to never allow this, and require | |
| 1833 instead that code first change the length before accessing higher | |
| 1834 positions. That would require looking through all the code that accesses | |
| 1835 dynarrs and fixing it appropriately (especially redisplay code, and | |
| 1836 especially redisplay code in the vicinity of a reference to | |
| 1837 Dynarr_largest(), since such code usually checks explicitly to see whether | |
| 1838 there is extra stuff between Dynarr_length() and Dynarr_largest().) | |
| 1839 | |
| 1840 [II] LOCKING | |
| 1841 | |
| 1842 The idea behind dynarr locking is simple: Locking a dynarr prevents | |
| 1843 any modification from occurring, or rather, leads to an abort upon | |
| 1844 any attempt to modify a dynarr. | |
| 1845 | |
| 1846 Dynarr locking was originally added to catch some sporadic and hard-to- | |
| 1847 debug crashes in the redisplay code where dynarrs appeared to be getting | |
| 1848 corrupted in an unexpected fashion. The solution was to lock the | |
| 1849 dynarrs that were getting corrupted (in this case, the display-line | |
| 1850 dynarrs) around calls to routines that weren't supposed to be changing | |
| 1851 these dynarrs but might somehow be calling code that modified them. | |
| 1852 This eventually revealed that there was a reentrancy problem with | |
| 1853 redisplay that involved the QUIT mechanism and the processing done in | |
| 1854 order to determine whether C-g had been pressed -- this processing | |
| 1855 involves retrieving, processing and queueing pending events to see | |
| 1856 whether any of them result in a C-g keypress. However, at least under | |
| 1857 MS Windows this can result in redisplay being called reentrantly. | |
| 1858 For more info:-- | |
| 1859 | |
| 1860 (Info-goto-node "(internals)Critical Redisplay Sections") | |
| 1861 | |
| 1862 */ | |
| 1863 | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1864 #ifdef ERROR_CHECK_DYNARR |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1865 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1866 int |
| 5038 | 1867 Dynarr_verify_pos_at (void *d, Elemcount pos, const Ascbyte *file, int line) |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1868 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1869 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1870 Dynarr *dy = (Dynarr *) d; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1871 /* 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
|
1872 accesses stuff between len and largest. */ |
| 4967 | 1873 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
|
1874 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1875 } |
|
4929
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
1876 |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1877 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1878 int |
| 5038 | 1879 Dynarr_verify_pos_atp (void *d, Elemcount pos, const Ascbyte *file, int line) |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1880 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1881 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1882 Dynarr *dy = (Dynarr *) d; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1883 /* 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
|
1884 accesses stuff between len and largest. */ |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1885 /* [[ 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
|
1886 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1887 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
|
1888 Dynarr_length (dyn)); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1889 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1890 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
|
1891 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
|
1892 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
|
1893 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
|
1894 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
|
1895 so we put in a special check. --ben ]] |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1896 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1897 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
|
1898 `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
|
1899 done only for Dynarr_begin() not for general Dynarr_atp(). --ben */ |
| 4967 | 1900 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
|
1901 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1902 /* #### 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
|
1903 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
|
1904 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
|
1905 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
|
1906 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
|
1907 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
|
1908 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
|
1909 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
|
1910 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
|
1911 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
|
1912 behavior, possibly overwriting other memory, which is bad). --ben */ |
| 4967 | 1913 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
|
1914 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1915 } |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1916 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1917 DECLARE_INLINE_HEADER ( |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1918 int |
| 5038 | 1919 Dynarr_verify_pos_atp_allow_end (void *d, Elemcount pos, const Ascbyte *file, |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1920 int line) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1921 ) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1922 { |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1923 Dynarr *dy = (Dynarr *) d; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1924 /* 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
|
1925 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
|
1926 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
|
1927 legitimately space. See comments in Dynarr_verify_pos_atp.()*/ |
| 4967 | 1928 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
|
1929 return pos; |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1930 } |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1931 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1932 #else |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
1933 #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
|
1934 #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
|
1935 #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
|
1936 #endif /* ERROR_CHECK_DYNARR */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1937 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1938 #ifdef ERROR_CHECK_DYNARR |
| 4967 | 1939 DECLARE_INLINE_HEADER ( |
| 1940 Dynarr * | |
| 1941 Dynarr_verify_1 (void *d, const Ascbyte *file, int line) | |
| 1942 ) | |
| 1943 { | |
| 1944 Dynarr *dy = (Dynarr *) d; | |
| 1945 assert_at_line (dy->len_ >= 0 && dy->len_ <= dy->largest_ && | |
| 1946 dy->largest_ <= dy->max_, file, line); | |
| 1947 return dy; | |
| 1948 } | |
| 1949 | |
| 1950 DECLARE_INLINE_HEADER ( | |
| 1951 Dynarr * | |
| 1952 Dynarr_verify_mod_1 (void *d, const Ascbyte *file, int line) | |
| 1953 ) | |
| 1954 { | |
| 1955 Dynarr *dy = (Dynarr *) d; | |
| 1956 assert_at_line (!dy->locked, file, line); | |
| 1957 return Dynarr_verify_1 (d, file, line); | |
| 1958 } | |
| 1959 | |
| 1960 #define Dynarr_verify(d) Dynarr_verify_1 (d, __FILE__, __LINE__) | |
| 1961 #define Dynarr_verify_mod(d) Dynarr_verify_mod_1 (d, __FILE__, __LINE__) | |
| 5038 | 1962 |
| 1963 DECLARE_INLINE_HEADER ( | |
| 1964 void | |
| 1965 Dynarr_lock (void *d) | |
| 1966 ) | |
| 1967 { | |
| 1968 Dynarr *dy = Dynarr_verify_mod (d); | |
| 1969 dy->locked = 1; | |
| 1970 } | |
| 1971 | |
| 1972 DECLARE_INLINE_HEADER ( | |
| 1973 void | |
| 1974 Dynarr_unlock (void *d) | |
| 1975 ) | |
| 1976 { | |
| 1977 Dynarr *dy = Dynarr_verify (d); | |
| 1978 assert (dy->locked); | |
| 1979 dy->locked = 0; | |
| 1980 } | |
| 1981 | |
| 1982 #else /* not ERROR_CHECK_DYNARR */ | |
| 1983 | |
|
5005
4170f3809a28
Cast correctly, Dynarr_verify, Dynarr_verify_mod, no ERROR_CHECK_STRUCTURES
Aidan Kehoe <kehoea@parhasard.net>
parents:
5001
diff
changeset
|
1984 #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
|
1985 #define Dynarr_verify_mod(d) ((Dynarr *) d) |
| 4967 | 1986 #define Dynarr_lock(d) DO_NOTHING |
| 1987 #define Dynarr_unlock(d) DO_NOTHING | |
| 5038 | 1988 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
1989 #endif /* ERROR_CHECK_DYNARR */ |
| 4967 | 1990 |
| 1991 /************* Dynarr creation *************/ | |
| 1992 | |
| 5038 | 1993 MODULE_API void *Dynarr_newf (Bytecount elsize); |
| 4967 | 1994 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
|
1995 |
| 3293 | 1996 #ifdef NEW_GC |
| 5038 | 1997 MODULE_API void *Dynarr_lisp_newf (Bytecount elsize, |
| 3092 | 1998 const struct lrecord_implementation |
| 1999 *dynarr_imp, | |
| 2000 const struct lrecord_implementation *imp); | |
| 2001 | |
| 2002 #define Dynarr_lisp_new(type, dynarr_imp, imp) \ | |
| 2003 ((type##_dynarr *) Dynarr_lisp_newf (sizeof (type), dynarr_imp, imp)) | |
| 2004 #define Dynarr_lisp_new2(dynarr_type, type, dynarr_imp, imp) \ | |
| 2005 ((dynarr_type *) Dynarr_lisp_newf (sizeof (type)), dynarr_imp, imp) | |
| 3293 | 2006 #endif /* NEW_GC */ |
| 3092 | 2007 #define Dynarr_new(type) ((type##_dynarr *) Dynarr_newf (sizeof (type))) |
| 2008 #define Dynarr_new2(dynarr_type, type) \ | |
| 2009 ((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
|
2010 |
| 4967 | 2011 /************* Dynarr access *************/ |
| 2012 | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
2013 #ifdef ERROR_CHECK_DYNARR |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
2014 #define Dynarr_at(d, pos) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
2015 ((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
|
2016 #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
|
2017 (&((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
|
2018 #define Dynarr_atp(d, pos) \ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
2019 (&((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
|
2020 #else |
|
b5ad8cf9f6e4
fix dynarr-related crash apparently due to compiler bug
Ben Wing <ben@xemacs.org>
parents:
4880
diff
changeset
|
2021 #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
|
2022 #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
|
2023 #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
|
2024 #endif |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
2025 |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4843
diff
changeset
|
2026 /* Old #define Dynarr_atp(d, pos) (&Dynarr_at (d, pos)) */ |
| 3092 | 2027 #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
|
2028 #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
|
2029 #define Dynarr_past_lastp(d) Dynarr_atp_allow_end (d, Dynarr_length (d)) |
| 4967 | 2030 |
| 2031 | |
| 2032 /************* Dynarr length/size retrieval and setting *************/ | |
| 2033 | |
| 5038 | 2034 /* Retrieve the length of a dynarr. The `+ 0' is to ensure that this cannot |
| 4967 | 2035 be used as an lvalue. */ |
| 2036 #define Dynarr_length(d) (Dynarr_verify (d)->len_ + 0) | |
| 5038 | 2037 /* Retrieve the largest ever length seen of a dynarr. The `+ 0' is to |
| 4967 | 2038 ensure that this cannot be used as an lvalue. */ |
| 2039 #define Dynarr_largest(d) (Dynarr_verify (d)->largest_ + 0) | |
| 2040 /* Retrieve the number of elements that fit in the currently allocated | |
| 2041 space. The `+ 0' is to ensure that this cannot be used as an lvalue. */ | |
| 2042 #define Dynarr_max(d) (Dynarr_verify (d)->max_ + 0) | |
| 5038 | 2043 /* Return the size in bytes of an element in a dynarr. */ |
| 2044 #define Dynarr_elsize(d) (Dynarr_verify (d)->elsize_ + 0) | |
| 2045 /* Retrieve the advertised memory usage of a dynarr, i.e. the number of | |
| 2046 bytes occupied by the elements in the dynarr, not counting any overhead. */ | |
| 2047 #define Dynarr_sizeof(d) (Dynarr_length (d) * Dynarr_elsize (d)) | |
| 2048 | |
| 2049 /* Actually set the length of a dynarr. This is a low-level routine that | |
| 2050 should not be directly used; use Dynarr_set_length() or | |
| 2051 Dynarr_set_lengthr() instead. */ | |
| 2052 DECLARE_INLINE_HEADER ( | |
| 2053 void | |
| 2054 Dynarr_set_length_1 (void *d, Elemcount len) | |
| 2055 ) | |
| 2056 { | |
| 2057 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2058 dynarr_checking_assert (len >= 0 && len <= Dynarr_max (dy)); | |
| 2059 /* Use the raw field references here otherwise we get a crash because | |
| 2060 we've set the length but not yet fixed up the largest value. */ | |
| 2061 dy->len_ = len; | |
| 2062 if (dy->len_ > dy->largest_) | |
| 2063 dy->largest_ = dy->len_; | |
| 2064 (void) Dynarr_verify_mod (d); | |
| 2065 } | |
| 2066 | |
| 2067 /* "Restricted set-length": Set the length of dynarr D to LEN, | |
| 2068 which must be in the range [0, Dynarr_largest(d)]. */ | |
| 2069 | |
| 2070 DECLARE_INLINE_HEADER ( | |
| 2071 void | |
| 2072 Dynarr_set_lengthr (void *d, Elemcount len) | |
| 2073 ) | |
| 2074 { | |
| 2075 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2076 dynarr_checking_assert (len >= 0 && len <= Dynarr_largest (dy)); | |
| 2077 Dynarr_set_length_1 (dy, len); | |
| 2078 } | |
| 2079 | |
| 2080 /* "Restricted increment": Increment the length of dynarr D by 1; the resulting | |
| 2081 length must be in the range [0, Dynarr_largest(d)]. */ | |
| 2082 | |
| 2083 #define Dynarr_incrementr(d) Dynarr_set_lengthr (d, Dynarr_length (d) + 1) | |
| 2084 | |
| 2085 | |
| 2086 MODULE_API void Dynarr_resize (void *d, Elemcount size); | |
| 2087 | |
| 2088 DECLARE_INLINE_HEADER ( | |
| 2089 void | |
| 2090 Dynarr_resize_to_fit (void *d, Elemcount size) | |
| 2091 ) | |
| 2092 { | |
| 2093 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2094 if (size > Dynarr_max (dy)) | |
| 2095 Dynarr_resize (dy, size); | |
| 2096 } | |
| 2097 | |
| 2098 #define Dynarr_resize_to_add(d, numels) \ | |
| 2099 Dynarr_resize_to_fit (d, Dynarr_length (d) + numels) | |
| 2100 | |
| 2101 /* This is an optimization. This is like Dynarr_set_length() but the length | |
| 2102 is guaranteed to be at least as big as the existing length. */ | |
| 2103 | |
| 2104 DECLARE_INLINE_HEADER ( | |
| 2105 void | |
| 2106 Dynarr_increase_length (void *d, Elemcount len) | |
| 2107 ) | |
| 2108 { | |
| 2109 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2110 dynarr_checking_assert (len >= Dynarr_length (dy)); | |
| 2111 Dynarr_resize_to_fit (dy, len); | |
| 2112 Dynarr_set_length_1 (dy, len); | |
| 2113 } | |
| 2114 | |
| 2115 /* Set the length of dynarr D to LEN. If the length increases, resize as | |
| 2116 necessary to fit. (NOTE: This will leave uninitialized memory. If you | |
| 2117 aren't planning on immediately overwriting the memory, use | |
| 2118 Dynarr_set_length_and_zero() to zero out all the memory that would | |
| 2119 otherwise be uninitialized.) */ | |
| 2120 | |
| 2121 DECLARE_INLINE_HEADER ( | |
| 2122 void | |
| 2123 Dynarr_set_length (void *d, Elemcount len) | |
| 2124 ) | |
| 2125 { | |
| 2126 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2127 Elemcount old_len = Dynarr_length (dy); | |
| 2128 if (old_len >= len) | |
| 2129 Dynarr_set_lengthr (dy, len); | |
| 2130 else | |
| 2131 Dynarr_increase_length (d, len); | |
| 2132 } | |
| 2133 | |
| 2134 #define Dynarr_increment(d) Dynarr_increase_length (d, Dynarr_length (d) + 1) | |
| 2135 | |
| 2136 /* Zero LEN contiguous elements starting at POS. */ | |
| 2137 | |
| 2138 DECLARE_INLINE_HEADER ( | |
| 2139 void | |
| 2140 Dynarr_zero_many (void *d, Elemcount pos, Elemcount len) | |
| 2141 ) | |
| 2142 { | |
| 2143 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2144 memset ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), 0, | |
| 2145 len*Dynarr_elsize (dy)); | |
| 2146 } | |
| 2147 | |
| 2148 /* This is an optimization. This is like Dynarr_set_length_and_zero() but | |
| 2149 the length is guaranteed to be at least as big as the existing | |
| 2150 length. */ | |
| 2151 | |
| 2152 DECLARE_INLINE_HEADER ( | |
| 2153 void | |
| 2154 Dynarr_increase_length_and_zero (void *d, Elemcount len) | |
| 2155 ) | |
| 2156 { | |
| 2157 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2158 Elemcount old_len = Dynarr_length (dy); | |
| 2159 Dynarr_increase_length (dy, len); | |
| 2160 Dynarr_zero_many (dy, old_len, len - old_len); | |
| 2161 } | |
| 2162 | |
| 2163 /* Set the length of dynarr D to LEN. If the length increases, resize as | |
| 2164 necessary to fit and zero out all the elements between the old and new | |
| 2165 lengths. */ | |
| 2166 | |
| 2167 DECLARE_INLINE_HEADER ( | |
| 2168 void | |
| 2169 Dynarr_set_length_and_zero (void *d, Elemcount len) | |
| 2170 ) | |
| 2171 { | |
| 2172 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2173 Elemcount old_len = Dynarr_length (dy); | |
| 2174 if (old_len >= len) | |
| 2175 Dynarr_set_lengthr (dy, len); | |
| 2176 else | |
| 2177 Dynarr_increase_length_and_zero (d, len); | |
| 2178 } | |
| 2179 | |
| 2180 /* Reset the dynarr's length to 0. */ | |
| 2181 #define Dynarr_reset(d) Dynarr_set_lengthr (d, 0) | |
| 4967 | 2182 |
| 2183 #ifdef MEMORY_USAGE_STATS | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
2184 struct usage_stats; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
2185 Bytecount Dynarr_memory_usage (void *d, struct usage_stats *stats); |
| 4967 | 2186 #endif |
| 2187 | |
| 5038 | 2188 /************* Adding/deleting elements to/from a dynarr *************/ |
| 2189 | |
| 2190 /* Set the Lisp implementation of the element at POS in dynarr D. Only | |
| 2191 does this if the dynarr holds Lisp objects of a particular type (the | |
| 2192 objects themselves, not pointers to them), and only under NEW_GC. */ | |
| 4967 | 2193 |
| 2194 #ifdef NEW_GC | |
| 5038 | 2195 #define DYNARR_SET_LISP_IMP(d, pos) \ |
| 4967 | 2196 do { \ |
| 5038 | 2197 if ((d)->lisp_imp) \ |
| 4967 | 2198 set_lheader_implementation \ |
| 5038 | 2199 ((struct lrecord_header *)&(((d)->base)[pos]), (d)->lisp_imp); \ |
| 2200 } while (0) | |
| 2201 #else | |
| 2202 #define DYNARR_SET_LISP_IMP(d, pos) DO_NOTHING | |
| 2203 #endif /* (not) NEW_GC */ | |
| 2204 | |
| 2205 /* Add Element EL to the end of dynarr D. */ | |
| 2206 | |
| 2207 #define Dynarr_add(d, el) \ | |
| 2208 do { \ | |
| 2209 Elemcount _da_pos = Dynarr_length (d); \ | |
| 2210 (void) Dynarr_verify_mod (d); \ | |
| 2211 Dynarr_increment (d); \ | |
| 2212 ((d)->base)[_da_pos] = (el); \ | |
| 2213 DYNARR_SET_LISP_IMP (d, _da_pos); \ | |
| 4967 | 2214 } while (0) |
| 5038 | 2215 |
| 2216 /* Set EL as the element at position POS in dynarr D. | |
| 2217 Expand the dynarr as necessary so that its length is enough to include | |
| 2218 position POS within it, and zero out any new elements created as a | |
| 2219 result of expansion, other than the one at POS. */ | |
| 2220 | |
| 2221 #define Dynarr_set(d, pos, el) \ | |
| 4967 | 2222 do { \ |
| 5038 | 2223 Elemcount _ds_pos = (pos); \ |
| 4967 | 2224 (void) Dynarr_verify_mod (d); \ |
| 5038 | 2225 if (Dynarr_length (d) < _ds_pos + 1) \ |
| 2226 Dynarr_increase_length_and_zero (d, _ds_pos + 1); \ | |
| 2227 ((d)->base)[_ds_pos] = (el); \ | |
| 2228 DYNARR_SET_LISP_IMP (d, _ds_pos); \ | |
| 4967 | 2229 } while (0) |
| 5038 | 2230 |
| 2231 /* Add LEN contiguous elements, stored at BASE, to dynarr D. If BASE is | |
| 2232 NULL, reserve space but don't store anything. */ | |
| 2233 | |
| 2234 DECLARE_INLINE_HEADER ( | |
| 2235 void | |
| 2236 Dynarr_add_many (void *d, const void *base, Elemcount len) | |
| 2237 ) | |
| 2238 { | |
| 2239 /* This duplicates Dynarr_insert_many to some extent; but since it is | |
| 2240 called so often, it seemed useful to remove the unnecessary stuff | |
| 2241 from that function and to make it inline */ | |
| 2242 Dynarr *dy = Dynarr_verify_mod (d); | |
| 2243 Elemcount pos = Dynarr_length (dy); | |
| 2244 Dynarr_increase_length (dy, Dynarr_length (dy) + len); | |
| 2245 if (base) | |
| 2246 memcpy ((Rawbyte *) dy->base + pos*Dynarr_elsize (dy), base, | |
| 2247 len*Dynarr_elsize (dy)); | |
| 2248 } | |
| 2249 | |
| 2250 /* Insert LEN elements, currently pointed to by BASE, into dynarr D | |
| 2251 starting at position POS. */ | |
| 2252 | |
| 2253 MODULE_API void Dynarr_insert_many (void *d, const void *base, Elemcount len, | |
| 2254 Elemcount pos); | |
| 2255 | |
| 2256 /* Prepend LEN elements, currently pointed to by BASE, to the beginning. */ | |
| 2257 | |
| 2258 #define Dynarr_prepend_many(d, base, len) Dynarr_insert_many (d, base, len, 0) | |
| 2259 | |
| 2260 /* Add literal string S to dynarr D, which should hold chars or unsigned | |
| 2261 chars. The final zero byte is not stored. */ | |
| 2262 | |
| 3092 | 2263 #define Dynarr_add_literal_string(d, s) Dynarr_add_many (d, s, sizeof (s) - 1) |
| 5038 | 2264 |
| 2265 /* Convert Lisp string S to an external encoding according to CODESYS and | |
| 2266 add to dynarr D, which should hold chars or unsigned chars. No final | |
| 2267 zero byte is appended. */ | |
| 2268 | |
| 2269 /* #### This should be an inline function but LISP_STRING_TO_SIZED_EXTERNAL | |
| 2270 isn't declared yet. */ | |
| 2271 | |
| 2272 #define Dynarr_add_ext_lisp_string(d, s, codesys) \ | |
| 3092 | 2273 do { \ |
| 2274 Lisp_Object dyna_ls_s = (s); \ | |
| 2275 Lisp_Object dyna_ls_cs = (codesys); \ | |
| 2276 Extbyte *dyna_ls_eb; \ | |
| 2277 Bytecount dyna_ls_bc; \ | |
| 2278 \ | |
| 2279 LISP_STRING_TO_SIZED_EXTERNAL (dyna_ls_s, dyna_ls_eb, \ | |
| 2280 dyna_ls_bc, dyna_ls_cs); \ | |
| 2281 Dynarr_add_many (d, dyna_ls_eb, dyna_ls_bc); \ | |
| 2282 } while (0) | |
| 2283 | |
| 5038 | 2284 /* Delete LEN elements starting at position POS. */ |
| 2285 | |
| 2286 MODULE_API void Dynarr_delete_many (void *d, Elemcount pos, Elemcount len); | |
| 2287 | |
| 2288 /* Pop off (i.e. delete) the last element from the dynarr and return it */ | |
| 3092 | 2289 |
| 2290 #define Dynarr_pop(d) \ | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
2291 (dynarr_checking_assert (Dynarr_length (d) > 0), \ |
| 4967 | 2292 Dynarr_verify_mod (d)->len_--, \ |
| 2293 Dynarr_at (d, Dynarr_length (d))) | |
| 5038 | 2294 |
| 2295 /* Delete the item at POS */ | |
| 2296 | |
| 2297 #define Dynarr_delete(d, pos) Dynarr_delete_many (d, pos, 1) | |
| 2298 | |
| 2299 /* Delete the item located at memory address P, which must be a `type *' | |
| 2300 pointer, where `type' is the type of the elements of the dynarr. */ | |
| 3092 | 2301 #define Dynarr_delete_by_pointer(d, p) \ |
| 2302 Dynarr_delete_many (d, (p) - ((d)->base), 1) | |
| 2303 | |
| 5038 | 2304 /* Delete all elements that are numerically equal to EL. */ |
| 2305 | |
| 3092 | 2306 #define Dynarr_delete_object(d, el) \ |
| 2307 do \ | |
| 2308 { \ | |
| 2309 REGISTER int i; \ | |
| 2310 for (i = Dynarr_length (d) - 1; i >= 0; i--) \ | |
| 2311 { \ | |
| 2312 if (el == Dynarr_at (d, i)) \ | |
| 2313 Dynarr_delete_many (d, i, 1); \ | |
| 2314 } \ | |
| 2315 } while (0) | |
| 2316 | |
| 4967 | 2317 /************* Dynarr typedefs *************/ |
| 3092 | 2318 |
| 2319 /* Dynarr typedefs -- basic types first */ | |
| 2320 | |
| 2321 typedef struct | |
| 2322 { | |
| 2323 Dynarr_declare (Ibyte); | |
| 2324 } Ibyte_dynarr; | |
| 2325 | |
| 2326 typedef struct | |
| 2327 { | |
| 2328 Dynarr_declare (Extbyte); | |
| 2329 } Extbyte_dynarr; | |
| 2330 | |
| 2331 typedef struct | |
| 2332 { | |
| 2333 Dynarr_declare (Ichar); | |
| 2334 } Ichar_dynarr; | |
| 2335 | |
| 2336 typedef struct | |
| 2337 { | |
| 2338 Dynarr_declare (char); | |
| 2339 } char_dynarr; | |
| 2340 | |
| 2341 typedef struct | |
| 2342 { | |
| 2343 Dynarr_declare (char *); | |
| 2344 } char_ptr_dynarr; | |
| 2345 | |
| 2346 typedef unsigned char unsigned_char; | |
| 2347 typedef struct | |
| 2348 { | |
| 2349 Dynarr_declare (unsigned char); | |
| 2350 } unsigned_char_dynarr; | |
| 2351 | |
| 2352 typedef unsigned long unsigned_long; | |
| 2353 typedef struct | |
| 2354 { | |
| 2355 Dynarr_declare (unsigned long); | |
| 2356 } unsigned_long_dynarr; | |
| 2357 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2358 typedef const Ascbyte *const_Ascbyte_ptr; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2359 typedef struct |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2360 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2361 Dynarr_declare (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2362 } const_Ascbyte_ptr_dynarr; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2363 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
2364 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
|
2365 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
|
2366 |
| 3092 | 2367 typedef struct |
| 2368 { | |
| 2369 Dynarr_declare (int); | |
| 2370 } int_dynarr; | |
| 2371 | |
| 2372 typedef struct | |
| 2373 { | |
| 2374 Dynarr_declare (Charbpos); | |
| 2375 } Charbpos_dynarr; | |
| 2376 | |
| 2377 typedef struct | |
| 2378 { | |
| 2379 Dynarr_declare (Bytebpos); | |
| 2380 } Bytebpos_dynarr; | |
| 2381 | |
| 2382 typedef struct | |
| 2383 { | |
| 2384 Dynarr_declare (Charcount); | |
| 2385 } Charcount_dynarr; | |
| 2386 | |
| 2387 typedef struct | |
| 2388 { | |
| 2389 Dynarr_declare (Bytecount); | |
| 2390 } Bytecount_dynarr; | |
| 2391 | |
| 2392 /* Dynarr typedefs -- more complex types */ | |
| 2393 | |
| 2394 typedef struct | |
| 2395 { | |
| 2396 Dynarr_declare (struct face_cachel); | |
| 2397 } face_cachel_dynarr; | |
| 2398 | |
| 3293 | 2399 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2400 DECLARE_LISP_OBJECT (face_cachel_dynarr, face_cachel_dynarr); |
| 3092 | 2401 #define XFACE_CACHEL_DYNARR(x) \ |
| 2402 XRECORD (x, face_cachel_dynarr, face_cachel_dynarr) | |
| 2403 #define wrap_face_cachel_dynarr(p) wrap_record (p, face_cachel_dynarr) | |
| 2404 #define FACE_CACHEL_DYNARRP(x) RECORDP (x, face_cachel_dynarr) | |
| 2405 #define CHECK_FACE_CACHEL_DYNARR(x) CHECK_RECORD (x, face_cachel_dynarr) | |
| 2406 #define CONCHECK_FACE_CACHEL_DYNARR(x) CONCHECK_RECORD (x, face_cachel_dynarr) | |
| 3293 | 2407 #endif /* NEW_GC */ |
| 3092 | 2408 |
| 2409 typedef struct | |
| 2410 { | |
| 2411 Dynarr_declare (struct glyph_cachel); | |
| 2412 } glyph_cachel_dynarr; | |
| 2413 | |
| 3293 | 2414 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2415 DECLARE_LISP_OBJECT (glyph_cachel_dynarr, glyph_cachel_dynarr); |
| 3092 | 2416 #define XGLYPH_CACHEL_DYNARR(x) \ |
| 2417 XRECORD (x, glyph_cachel_dynarr, glyph_cachel_dynarr) | |
| 2418 #define wrap_glyph_cachel_dynarr(p) wrap_record (p, glyph_cachel_dynarr) | |
| 2419 #define GLYPH_CACHEL_DYNARRP(x) RECORDP (x, glyph_cachel_dynarr) | |
| 2420 #define CHECK_GLYPH_CACHEL_DYNARR(x) CHECK_RECORD (x, glyph_cachel_dynarr) | |
| 2421 #define CONCHECK_GLYPH_CACHEL_DYNARR(x) \ | |
| 2422 CONCHECK_RECORD (x, glyph_cachel_dynarr) | |
| 3293 | 2423 #endif /* NEW_GC */ |
| 3092 | 2424 |
| 2425 typedef struct | |
| 2426 { | |
| 2427 Dynarr_declare (struct console_type_entry); | |
| 2428 } console_type_entry_dynarr; | |
| 2429 | |
| 2430 /* WARNING WARNING WARNING. You must ensure on your own that proper | |
| 2431 GC protection is provided for the elements in this array. */ | |
| 2432 typedef struct | |
| 2433 { | |
| 2434 Dynarr_declare (Lisp_Object); | |
| 2435 } Lisp_Object_dynarr; | |
| 2436 | |
| 2437 typedef struct | |
| 2438 { | |
| 2439 Dynarr_declare (Lisp_Object *); | |
| 2440 } Lisp_Object_ptr_dynarr; | |
| 2441 | |
| 4967 | 2442 |
| 2443 /************* Stack-like malloc/free: Another allocator *************/ | |
| 2444 | |
| 2445 void *stack_like_malloc (Bytecount size); | |
| 2446 void stack_like_free (void *val); | |
| 2447 | |
| 2448 | |
| 2449 /************************************************************************/ | |
| 2450 /** Definitions of other basic Lisp objects **/ | |
| 2451 /************************************************************************/ | |
| 2452 | |
| 442 | 2453 /*------------------------------ unbound -------------------------------*/ |
| 428 | 2454 |
| 2455 /* Qunbound is a special Lisp_Object (actually of type | |
| 2456 symbol-value-forward), that can never be visible to | |
| 2457 the Lisp caller and thus can be used in the C code | |
| 2458 to mean "no such value". */ | |
| 2459 | |
| 2460 #define UNBOUNDP(val) EQ (val, Qunbound) | |
| 2461 | |
| 771 | 2462 /* Evaluate expr, return it if it's not Qunbound. */ |
| 2463 #define RETURN_IF_NOT_UNBOUND(expr) do \ | |
| 2464 { \ | |
| 2465 Lisp_Object ret_nunb_val = (expr); \ | |
| 2466 if (!UNBOUNDP (ret_nunb_val)) \ | |
| 2467 RETURN_SANS_WARNINGS ret_nunb_val; \ | |
| 2468 } while (0) | |
| 2469 | |
| 442 | 2470 /*------------------------------- cons ---------------------------------*/ |
| 428 | 2471 |
| 2472 /* In a cons, the markbit of the car is the gc mark bit */ | |
| 2473 | |
| 2474 struct Lisp_Cons | |
| 2475 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2476 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 853 | 2477 Lisp_Object car_, cdr_; |
| 428 | 2478 }; |
| 2479 typedef struct Lisp_Cons Lisp_Cons; | |
| 2480 | |
| 2481 #if 0 /* FSFmacs */ | |
| 2482 /* Like a cons, but records info on where the text lives that it was read from */ | |
| 2483 /* This is not really in use now */ | |
| 2484 | |
| 2485 struct Lisp_Buffer_Cons | |
| 2486 { | |
| 2487 Lisp_Object car, cdr; | |
| 2488 struct buffer *buffer; | |
| 665 | 2489 int charbpos; |
| 428 | 2490 }; |
| 2491 #endif | |
| 2492 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2493 DECLARE_MODULE_API_LISP_OBJECT (cons, Lisp_Cons); |
| 428 | 2494 #define XCONS(x) XRECORD (x, cons, Lisp_Cons) |
| 617 | 2495 #define wrap_cons(p) wrap_record (p, cons) |
| 428 | 2496 #define CONSP(x) RECORDP (x, cons) |
| 2497 #define CHECK_CONS(x) CHECK_RECORD (x, cons) | |
| 2498 #define CONCHECK_CONS(x) CONCHECK_RECORD (x, cons) | |
| 2499 | |
| 3263 | 2500 #ifdef NEW_GC |
| 2720 | 2501 #define CONS_MARKED_P(c) MARKED_P (&((c)->lheader)) |
| 2502 #define MARK_CONS(c) MARK (&((c)->lheader)) | |
| 3263 | 2503 #else /* not NEW_GC */ |
| 428 | 2504 #define CONS_MARKED_P(c) MARKED_RECORD_HEADER_P(&((c)->lheader)) |
| 2505 #define MARK_CONS(c) MARK_RECORD_HEADER (&((c)->lheader)) | |
| 3263 | 2506 #endif /* not NEW_GC */ |
| 428 | 2507 |
| 1632 | 2508 extern MODULE_API Lisp_Object Qnil; |
| 428 | 2509 |
| 2510 #define NILP(x) EQ (x, Qnil) | |
| 853 | 2511 #define cons_car(a) ((a)->car_) |
| 2512 #define cons_cdr(a) ((a)->cdr_) | |
| 2513 #define XCAR(a) (XCONS (a)->car_) | |
| 2514 #define XCDR(a) (XCONS (a)->cdr_) | |
| 1318 | 2515 #define XCADR(a) (XCAR (XCDR (a))) |
| 2516 #define XCDDR(a) (XCDR (XCDR (a))) | |
| 2517 #define XCADDR(a) (XCAR (XCDDR (a))) | |
| 2518 #define XCDDDR(a) (XCDR (XCDDR (a))) | |
| 2519 #define XCADDDR(a) (XCAR (XCDDDR (a))) | |
| 2520 #define XCDDDDR(a) (XCDR (XCDDDR (a))) | |
| 2521 #define XCADDDDR(a) (XCAR (XCDDDDR (a))) | |
| 2522 #define XCDDDDDR(a) (XCDR (XCDDDDR (a))) | |
| 2523 #define XCADDDDDR(a) (XCAR (XCDDDDDR (a))) | |
| 2524 #define XCDDDDDDR(a) (XCDR (XCDDDDDR (a))) | |
| 2525 #define X1ST(a) XCAR (a) | |
| 2526 #define X2ND(a) XCADR (a) | |
| 2527 #define X3RD(a) XCADDR (a) | |
| 2528 #define X4TH(a) XCADDDR (a) | |
| 2529 #define X5TH(a) XCADDDDR (a) | |
| 2530 #define X6TH(a) XCADDDDDR (a) | |
| 2531 | |
| 853 | 2532 #define XSETCAR(a, b) (XCONS (a)->car_ = (b)) |
| 2533 #define XSETCDR(a, b) (XCONS (a)->cdr_ = (b)) | |
| 428 | 2534 #define LISTP(x) (CONSP(x) || NILP(x)) |
| 2535 | |
| 2536 #define CHECK_LIST(x) do { \ | |
| 2537 if (!LISTP (x)) \ | |
| 2538 dead_wrong_type_argument (Qlistp, x); \ | |
| 2539 } while (0) | |
| 2540 | |
| 2541 #define CONCHECK_LIST(x) do { \ | |
| 2542 if (!LISTP (x)) \ | |
| 2543 x = wrong_type_argument (Qlistp, x); \ | |
| 2544 } while (0) | |
| 2545 | |
| 442 | 2546 /*---------------------- list traversal macros -------------------------*/ |
| 2547 | |
| 2548 /* Note: These macros are for traversing through a list in some format, | |
| 2549 and executing code that you specify on each member of the list. | |
| 2550 | |
| 2551 There are two kinds of macros, those requiring surrounding braces, and | |
| 2552 those not requiring this. Which type of macro will be indicated. | |
| 2553 The general format for using a brace-requiring macro is | |
| 2554 | |
| 2555 { | |
| 2556 LIST_LOOP_3 (elt, list, tail) | |
| 2557 execute_code_here; | |
| 2558 } | |
| 2559 | |
| 2560 or | |
| 2561 | |
| 2562 { | |
| 2563 LIST_LOOP_3 (elt, list, tail) | |
| 2564 { | |
| 2565 execute_code_here; | |
| 2566 } | |
| 2567 } | |
| 2568 | |
| 2569 You can put variable declarations between the brace and beginning of | |
| 2570 macro, but NOTHING ELSE. | |
| 2571 | |
| 2572 The brace-requiring macros typically declare themselves any arguments | |
| 2573 that are initialized and iterated by the macros. If for some reason | |
| 2574 you need to declare these arguments yourself (e.g. to do something on | |
| 2575 them before the iteration starts, use the _NO_DECLARE versions of the | |
| 2576 macros.) | |
| 2577 */ | |
| 2578 | |
| 2579 /* There are two basic kinds of macros: those that handle "internal" lists | |
| 2580 that are known to be correctly structured (i.e. first element is a cons | |
| 2581 or nil, and the car of each cons is also a cons or nil, and there are | |
| 2582 no circularities), and those that handle "external" lists, where the | |
| 2583 list may have any sort of invalid formation. This is reflected in | |
| 2584 the names: those with "EXTERNAL_" work with external lists, and those | |
| 2585 without this prefix work with internal lists. The internal-list | |
| 2586 macros will hit an assertion failure if the structure is ill-formed; | |
| 2587 the external-list macros will signal an error in this case, either a | |
| 2588 malformed-list error or a circular-list error. | |
| 2589 */ | |
| 2590 | |
| 2367 | 2591 /* LIST_LOOP is a simple, old-fashioned macro. It doesn't require brace |
| 2592 surrounding, and iterates through a list, which may or may not known to | |
| 2593 be syntactically correct. It accepts two args, TAIL (set progressively | |
| 2594 to each cons starting with the first), and LIST, the list to iterate | |
| 2595 over. TAIL needs to be defined by the caller. | |
| 442 | 2596 |
| 2597 In each iteration, you can retrieve the current list item using XCAR | |
| 2598 (tail), or destructively modify the list using XSETCAR (tail, | |
| 2599 ...). */ | |
| 2600 | |
| 428 | 2601 #define LIST_LOOP(tail, list) \ |
| 2602 for (tail = list; \ | |
| 2603 !NILP (tail); \ | |
| 2604 tail = XCDR (tail)) | |
| 2605 | |
| 442 | 2606 /* The following macros are the "core" macros for list traversal. |
| 2607 | |
| 2608 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2609 | |
| 2610 LIST_LOOP_2 and EXTERNAL_LIST_LOOP_2 are the standard, most-often used | |
| 2611 macros. They take two arguments, an element variable ELT and the list | |
| 2612 LIST. ELT is automatically declared, and set to each element in turn | |
| 2613 from LIST. | |
| 2614 | |
| 2615 LIST_LOOP_3 and EXTERNAL_LIST_LOOP_3 are the same, but they have a third | |
| 2616 argument TAIL, another automatically-declared variable. At each iteration, | |
| 2617 this one points to the cons cell for which ELT is the car. | |
| 2618 | |
| 2619 EXTERNAL_LIST_LOOP_4 is like EXTERNAL_LIST_LOOP_3 but takes an additional | |
| 2620 LEN argument, again automatically declared, which counts the number of | |
| 2621 iterations gone by. It is 0 during the first iteration. | |
| 2622 | |
| 2623 EXTERNAL_LIST_LOOP_4_NO_DECLARE is like EXTERNAL_LIST_LOOP_4 but none | |
| 2624 of the variables are automatically declared, and so you need to declare | |
| 2625 them yourself. (ELT and TAIL are Lisp_Objects, and LEN is an EMACS_INT.) | |
| 2626 */ | |
| 2627 | |
| 2628 #define LIST_LOOP_2(elt, list) \ | |
| 2629 LIST_LOOP_3(elt, list, unused_tail_##elt) | |
| 2630 | |
| 2631 #define LIST_LOOP_3(elt, list, tail) \ | |
| 2632 Lisp_Object elt, tail; \ | |
| 2633 for (tail = list; \ | |
| 2634 NILP (tail) ? \ | |
| 2635 0 : (elt = XCAR (tail), 1); \ | |
| 2636 tail = XCDR (tail)) | |
| 428 | 2637 |
| 2638 /* The following macros are for traversing lisp lists. | |
| 2639 Signal an error if LIST is not properly acyclic and nil-terminated. | |
| 2640 | |
| 2641 Use tortoise/hare algorithm to check for cycles, but only if it | |
| 2642 looks like the list is getting too long. Not only is the hare | |
| 2643 faster than the tortoise; it even gets a head start! */ | |
| 2644 | |
| 2645 /* Optimized and safe macros for looping over external lists. */ | |
| 2646 #define CIRCULAR_LIST_SUSPICION_LENGTH 1024 | |
| 2647 | |
| 2648 #define EXTERNAL_LIST_LOOP_1(list) \ | |
| 2649 Lisp_Object ELL1_elt, ELL1_hare, ELL1_tortoise; \ | |
| 442 | 2650 EMACS_INT ELL1_len; \ |
| 2651 PRIVATE_EXTERNAL_LIST_LOOP_6 (ELL1_elt, list, ELL1_len, ELL1_hare, \ | |
| 428 | 2652 ELL1_tortoise, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2653 | |
| 2654 #define EXTERNAL_LIST_LOOP_2(elt, list) \ | |
| 442 | 2655 Lisp_Object elt, hare_##elt, tortoise_##elt; \ |
| 2656 EMACS_INT len_##elt; \ | |
| 2657 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ | |
| 428 | 2658 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2659 | |
| 2367 | 2660 |
| 2661 #define GC_EXTERNAL_LIST_LOOP_2(elt, list) \ | |
| 2662 do { \ | |
| 2663 XGCDECL3 (elt); \ | |
| 2664 Lisp_Object elt, hare_##elt, tortoise_##elt; \ | |
| 2665 EMACS_INT len_##elt; \ | |
| 2666 XGCPRO3 (elt, elt, hare_##elt, tortoise_##elt); \ | |
| 2667 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ | |
| 2668 tortoise_##elt, \ | |
| 2669 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2670 | |
| 2671 #define END_GC_EXTERNAL_LIST_LOOP(elt) \ | |
| 2672 XUNGCPRO (elt); \ | |
| 2673 } \ | |
| 2674 while (0) | |
| 2675 | |
| 428 | 2676 #define EXTERNAL_LIST_LOOP_3(elt, list, tail) \ |
| 442 | 2677 Lisp_Object elt, tail, tortoise_##elt; \ |
| 2678 EMACS_INT len_##elt; \ | |
| 2679 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, tail, \ | |
| 2680 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2681 | |
| 2682 #define EXTERNAL_LIST_LOOP_4_NO_DECLARE(elt, list, tail, len) \ | |
| 428 | 2683 Lisp_Object tortoise_##elt; \ |
| 442 | 2684 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail, \ |
| 428 | 2685 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2686 | |
| 2687 #define EXTERNAL_LIST_LOOP_4(elt, list, tail, len) \ | |
| 442 | 2688 Lisp_Object elt, tail, tortoise_##elt; \ |
| 2689 EMACS_INT len; \ | |
| 2690 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail, \ | |
| 428 | 2691 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2692 | |
| 2693 | |
| 444 | 2694 #define PRIVATE_EXTERNAL_LIST_LOOP_6(elt, list, len, hare, \ |
| 2695 tortoise, suspicion_length) \ | |
| 2696 for (tortoise = hare = list, len = 0; \ | |
| 2697 \ | |
| 2698 (CONSP (hare) ? ((elt = XCAR (hare)), 1) : \ | |
| 2699 (NILP (hare) ? 0 : \ | |
| 2700 (signal_malformed_list_error (list), 0))); \ | |
| 2701 \ | |
| 2702 hare = XCDR (hare), \ | |
| 2703 (void) \ | |
| 2704 ((++len > suspicion_length) \ | |
| 2705 && \ | |
| 2706 ((((len & 1) != 0) && (tortoise = XCDR (tortoise), 0)), \ | |
| 2707 (EQ (hare, tortoise) && (signal_circular_list_error (list), 0))))) | |
| 428 | 2708 |
| 442 | 2709 /* GET_LIST_LENGTH and GET_EXTERNAL_LIST_LENGTH: |
| 2710 | |
| 2711 These two macros return the length of LIST (either an internal or external | |
| 2712 list, according to which macro is used), stored into LEN (which must | |
| 2713 be declared by the caller). Circularities are trapped in external lists | |
| 2714 (and cause errors). Neither macro need be declared inside brackets. */ | |
| 2715 | |
| 2716 #define GET_LIST_LENGTH(list, len) do { \ | |
| 2717 Lisp_Object GLL_tail; \ | |
| 2718 for (GLL_tail = list, len = 0; \ | |
| 2719 !NILP (GLL_tail); \ | |
| 2720 GLL_tail = XCDR (GLL_tail), ++len) \ | |
| 2721 DO_NOTHING; \ | |
| 2722 } while (0) | |
| 2723 | |
| 2724 #define GET_EXTERNAL_LIST_LENGTH(list, len) \ | |
| 2725 do { \ | |
| 2726 Lisp_Object GELL_elt, GELL_tail; \ | |
| 2727 EXTERNAL_LIST_LOOP_4_NO_DECLARE (GELL_elt, list, GELL_tail, len) \ | |
| 2728 ; \ | |
| 2729 } while (0) | |
| 2730 | |
| 2731 /* For a list that's known to be in valid list format, where we may | |
| 2732 be deleting the current element out of the list -- | |
| 2500 | 2733 will ABORT() if the list is not in valid format */ |
| 442 | 2734 #define LIST_LOOP_DELETING(consvar, nextconsvar, list) \ |
| 2735 for (consvar = list; \ | |
| 2736 !NILP (consvar) ? (nextconsvar = XCDR (consvar), 1) :0; \ | |
| 2737 consvar = nextconsvar) | |
| 2738 | |
| 2739 /* LIST_LOOP_DELETE_IF and EXTERNAL_LIST_LOOP_DELETE_IF: | |
| 2740 | |
| 2741 These two macros delete all elements of LIST (either an internal or | |
| 2742 external list, according to which macro is used) satisfying | |
| 2743 CONDITION, a C expression referring to variable ELT. ELT is | |
| 2744 automatically declared. Circularities are trapped in external | |
| 2745 lists (and cause errors). Neither macro need be declared inside | |
| 2746 brackets. */ | |
| 2747 | |
| 2748 #define LIST_LOOP_DELETE_IF(elt, list, condition) do { \ | |
| 2749 /* Do not use ##list when creating new variables because \ | |
| 2750 that may not be just a variable name. */ \ | |
| 2751 Lisp_Object prev_tail_##elt = Qnil; \ | |
| 2752 LIST_LOOP_3 (elt, list, tail_##elt) \ | |
| 2753 { \ | |
| 2754 if (condition) \ | |
| 2755 { \ | |
| 2756 if (NILP (prev_tail_##elt)) \ | |
| 2757 list = XCDR (tail_##elt); \ | |
| 2758 else \ | |
| 2759 XCDR (prev_tail_##elt) = XCDR (tail_##elt); \ | |
| 2760 } \ | |
| 2761 else \ | |
| 2762 prev_tail_##elt = tail_##elt; \ | |
| 2763 } \ | |
| 2764 } while (0) | |
| 2765 | |
| 2766 #define EXTERNAL_LIST_LOOP_DELETE_IF(elt, list, condition) do { \ | |
| 2767 Lisp_Object prev_tail_##elt = Qnil; \ | |
| 2768 EXTERNAL_LIST_LOOP_4 (elt, list, tail_##elt, len_##elt) \ | |
| 2769 { \ | |
| 2770 if (condition) \ | |
| 2771 { \ | |
| 2772 if (NILP (prev_tail_##elt)) \ | |
| 2773 list = XCDR (tail_##elt); \ | |
| 2774 else \ | |
| 2775 XCDR (prev_tail_##elt) = XCDR (tail_##elt); \ | |
| 2776 /* Keep tortoise from ever passing hare. */ \ | |
| 2777 len_##elt = 0; \ | |
| 2778 } \ | |
| 2779 else \ | |
| 2780 prev_tail_##elt = tail_##elt; \ | |
| 2781 } \ | |
| 2782 } while (0) | |
| 2783 | |
| 2784 | |
| 1204 | 2785 /* Macros for looping over internal alists. |
| 2786 | |
| 2787 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2788 | |
| 2789 ALIST_LOOP_3 loops over an alist, at each iteration setting CAR and CDR | |
| 2790 to the car and cdr of the acons. CAR and CDR are automatically | |
| 2791 declared. | |
| 2792 | |
| 2793 ALIST_LOOP_4 is similar to ALIST_LOOP_3 but contains an additional | |
| 2794 variable ACONS at the beginning for access to the acons itself.All of | |
| 2795 the variables ACONS, CAR and CDR are automatically declared. | |
| 2796 */ | |
| 2797 | |
| 2798 #define ALIST_LOOP_3(car, cdr, alist) \ | |
| 2799 Lisp_Object _al3_acons_##car, car, cdr, _al3_tail_##car; \ | |
| 2800 for (_al3_tail_##car = alist; \ | |
| 2801 NILP (_al3_tail_##car) ? \ | |
| 2802 0 : (_al3_acons_##car = XCAR (_al3_tail_##car), \ | |
| 2803 car = XCAR (_al3_acons_##car), \ | |
| 2804 cdr = XCDR (_al3_acons_##car), 1); \ | |
| 2805 _al3_tail_##car = XCDR (_al3_tail_##car)) | |
| 2806 | |
| 2807 #define ALIST_LOOP_4(acons, car, cdr, list) \ | |
| 2808 Lisp_Object acons, car, cdr, _al4_tail_##car; \ | |
| 2809 for (_al4_tail_##car = list; \ | |
| 2810 NILP (_al4_tail_##car) ? \ | |
| 2811 0 : (elt = XCAR (_al4_tail_##car), car = XCAR (elt), \ | |
| 2812 cdr = XCDR (elt), 1); \ | |
| 2813 _al4_tail_##car = XCDR (tail)) | |
| 2814 | |
| 442 | 2815 /* Macros for looping over external alists. |
| 2816 | |
| 2817 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2818 | |
| 2819 EXTERNAL_ALIST_LOOP_4 is similar to EXTERNAL_LIST_LOOP_2, but it | |
| 2820 assumes the elements are aconses (the elements in an alist) and | |
| 2821 sets two additional argument variables ELT_CAR and ELT_CDR to the | |
| 2822 car and cdr of the acons. All of the variables ELT, ELT_CAR and | |
| 2823 ELT_CDR are automatically declared. | |
| 2824 | |
| 2825 EXTERNAL_ALIST_LOOP_5 adds a TAIL argument to EXTERNAL_ALIST_LOOP_4, | |
| 2826 just like EXTERNAL_LIST_LOOP_3 does, and again TAIL is automatically | |
| 2827 declared. | |
| 2828 | |
| 2829 EXTERNAL_ALIST_LOOP_6 adds a LEN argument to EXTERNAL_ALIST_LOOP_5, | |
| 2830 just like EXTERNAL_LIST_LOOP_4 does, and again LEN is automatically | |
| 2831 declared. | |
| 2832 | |
| 2833 EXTERNAL_ALIST_LOOP_6_NO_DECLARE does not declare any of its arguments, | |
| 2834 just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these must be declared | |
| 2835 manually. | |
| 2836 */ | |
| 428 | 2837 |
| 2838 /* Optimized and safe macros for looping over external alists. */ | |
| 2839 #define EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, list) \ | |
| 442 | 2840 Lisp_Object elt, elt_car, elt_cdr; \ |
| 428 | 2841 Lisp_Object hare_##elt, tortoise_##elt; \ |
| 2842 EMACS_INT len_##elt; \ | |
| 442 | 2843 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2844 len_##elt, hare_##elt, tortoise_##elt, \ |
| 2845 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2846 | |
| 2847 #define EXTERNAL_ALIST_LOOP_5(elt, elt_car, elt_cdr, list, tail) \ | |
| 442 | 2848 Lisp_Object elt, elt_car, elt_cdr, tail; \ |
| 428 | 2849 Lisp_Object tortoise_##elt; \ |
| 2850 EMACS_INT len_##elt; \ | |
| 442 | 2851 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2852 len_##elt, tail, tortoise_##elt, \ |
| 2853 CIRCULAR_LIST_SUSPICION_LENGTH) \ | |
| 2854 | |
| 2855 #define EXTERNAL_ALIST_LOOP_6(elt, elt_car, elt_cdr, list, tail, len) \ | |
| 442 | 2856 Lisp_Object elt, elt_car, elt_cdr, tail; \ |
| 2857 EMACS_INT len; \ | |
| 428 | 2858 Lisp_Object tortoise_##elt; \ |
| 442 | 2859 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2860 len, tail, tortoise_##elt, \ |
| 2861 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2862 | |
| 442 | 2863 #define EXTERNAL_ALIST_LOOP_6_NO_DECLARE(elt, elt_car, elt_cdr, list, \ |
| 2864 tail, len) \ | |
| 2865 Lisp_Object tortoise_##elt; \ | |
| 2866 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ | |
| 2867 len, tail, tortoise_##elt, \ | |
| 2868 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2869 | |
| 2870 | |
| 2871 #define PRIVATE_EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list, len, \ | |
| 2872 hare, tortoise, suspicion_length) \ | |
| 2873 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, hare, tortoise, \ | |
| 2874 suspicion_length) \ | |
| 428 | 2875 if (CONSP (elt) ? (elt_car = XCAR (elt), elt_cdr = XCDR (elt), 0) :1) \ |
| 2876 continue; \ | |
| 2877 else | |
| 2878 | |
| 442 | 2879 /* Macros for looping over external property lists. |
| 2880 | |
| 2881 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2882 | |
| 2883 EXTERNAL_PROPERTY_LIST_LOOP_3 maps over an external list assumed to | |
| 2884 be a property list, consisting of alternating pairs of keys | |
| 2885 (typically symbols or keywords) and values. Each iteration | |
| 2886 processes one such pair out of LIST, assigning the two elements to | |
| 2887 KEY and VALUE respectively. Malformed lists and circularities are | |
| 2888 trapped as usual, and in addition, property lists with an odd number | |
| 2889 of elements also signal an error. | |
| 2890 | |
| 2891 EXTERNAL_PROPERTY_LIST_LOOP_4 adds a TAIL argument to | |
| 2892 EXTERNAL_PROPERTY_LIST_LOOP_3, just like EXTERNAL_LIST_LOOP_3 does, | |
| 2893 and again TAIL is automatically declared. | |
| 2894 | |
| 2895 EXTERNAL_PROPERTY_LIST_LOOP_5 adds a LEN argument to | |
| 2896 EXTERNAL_PROPERTY_LIST_LOOP_4, just like EXTERNAL_LIST_LOOP_4 does, | |
| 2897 and again LEN is automatically declared. Note that in this case, | |
| 2898 LEN counts the iterations, NOT the total number of list elements | |
| 2899 processed, which is 2 * LEN. | |
| 2900 | |
| 2901 EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE does not declare any of its | |
| 2902 arguments, just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these | |
| 2903 must be declared manually. */ | |
| 428 | 2904 |
| 2905 /* Optimized and safe macros for looping over external property lists. */ | |
| 2906 #define EXTERNAL_PROPERTY_LIST_LOOP_3(key, value, list) \ | |
| 2907 Lisp_Object key, value, hare_##key, tortoise_##key; \ | |
| 442 | 2908 EMACS_INT len_##key; \ |
| 428 | 2909 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, hare_##key, \ |
| 2910 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2911 | |
| 2912 #define EXTERNAL_PROPERTY_LIST_LOOP_4(key, value, list, tail) \ | |
| 2913 Lisp_Object key, value, tail, tortoise_##key; \ | |
| 442 | 2914 EMACS_INT len_##key; \ |
| 428 | 2915 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, tail, \ |
| 2916 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2917 | |
| 2918 #define EXTERNAL_PROPERTY_LIST_LOOP_5(key, value, list, tail, len) \ | |
| 2919 Lisp_Object key, value, tail, tortoise_##key; \ | |
| 2920 EMACS_INT len; \ | |
| 2921 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail, \ | |
| 2922 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2923 | |
| 442 | 2924 #define EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE(key, value, list, \ |
| 2925 tail, len) \ | |
| 2926 Lisp_Object tortoise_##key; \ | |
| 2927 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail, \ | |
| 2928 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2929 | |
| 428 | 2930 |
| 2931 #define EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len, hare, \ | |
| 2932 tortoise, suspicion_length) \ | |
| 2933 for (tortoise = hare = list, len = 0; \ | |
| 2934 \ | |
| 2935 ((CONSP (hare) && \ | |
| 2936 (key = XCAR (hare), \ | |
| 2937 hare = XCDR (hare), \ | |
| 442 | 2938 (CONSP (hare) ? 1 : \ |
| 2939 (signal_malformed_property_list_error (list), 0)))) ? \ | |
| 428 | 2940 (value = XCAR (hare), 1) : \ |
| 2941 (NILP (hare) ? 0 : \ | |
| 2942 (signal_malformed_property_list_error (list), 0))); \ | |
| 2943 \ | |
| 2944 hare = XCDR (hare), \ | |
| 2945 ((++len < suspicion_length) ? \ | |
| 2946 ((void) 0) : \ | |
| 2947 (((len & 1) ? \ | |
| 2948 ((void) (tortoise = XCDR (XCDR (tortoise)))) : \ | |
| 2949 ((void) 0)) \ | |
| 2950 , \ | |
| 2951 (EQ (hare, tortoise) ? \ | |
| 2952 ((void) signal_circular_property_list_error (list)) : \ | |
| 2953 ((void) 0))))) | |
| 2954 | |
| 2421 | 2955 #define PRIVATE_PROPERTY_LIST_LOOP_4(tail, key, value, plist) \ |
| 2956 for (tail = plist; \ | |
| 2957 NILP (tail) ? 0 : \ | |
| 2958 (key = XCAR (tail), tail = XCDR (tail), \ | |
| 2959 value = XCAR (tail), tail = XCDR (tail), 1); \ | |
| 428 | 2960 ) |
| 2961 | |
| 2421 | 2962 #define PROPERTY_LIST_LOOP_3(key, value, plist) \ |
| 2963 Lisp_Object key, value, tail_##key; \ | |
| 2964 PRIVATE_PROPERTY_LIST_LOOP_4 (tail_##key, key, value, plist) | |
| 2965 | |
| 2966 #define GC_PROPERTY_LIST_LOOP_3(key, value, plist) \ | |
| 2967 do { \ | |
| 2968 XGCDECL3 (key); \ | |
| 2969 Lisp_Object key, value, tail_##key; \ | |
| 2970 XGCPRO3 (key, key, value, tail_##key); \ | |
| 2971 PRIVATE_PROPERTY_LIST_LOOP_4 (tail_##key, key, value, plist) | |
| 2972 | |
| 2973 #define END_GC_PROPERTY_LIST_LOOP(key) \ | |
| 2974 XUNGCPRO (key); \ | |
| 2975 } \ | |
| 2976 while (0) | |
| 2977 | |
| 428 | 2978 /* Return 1 if LIST is properly acyclic and nil-terminated, else 0. */ |
| 826 | 2979 DECLARE_INLINE_HEADER ( |
| 2980 int | |
| 428 | 2981 TRUE_LIST_P (Lisp_Object object) |
| 826 | 2982 ) |
| 428 | 2983 { |
| 2984 Lisp_Object hare, tortoise; | |
| 2985 EMACS_INT len; | |
| 2986 | |
| 2987 for (hare = tortoise = object, len = 0; | |
| 2988 CONSP (hare); | |
| 2989 hare = XCDR (hare), len++) | |
| 2990 { | |
| 2991 if (len < CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2992 continue; | |
| 2993 | |
| 2994 if (len & 1) | |
| 2995 tortoise = XCDR (tortoise); | |
| 2996 else if (EQ (hare, tortoise)) | |
| 2997 return 0; | |
| 2998 } | |
| 2999 | |
| 3000 return NILP (hare); | |
| 3001 } | |
| 3002 | |
| 3003 /* Signal an error if LIST is not properly acyclic and nil-terminated. */ | |
| 3004 #define CHECK_TRUE_LIST(list) do { \ | |
| 3005 Lisp_Object CTL_list = (list); \ | |
| 3006 Lisp_Object CTL_hare, CTL_tortoise; \ | |
| 436 | 3007 EMACS_INT CTL_len; \ |
| 428 | 3008 \ |
| 3009 for (CTL_hare = CTL_tortoise = CTL_list, CTL_len = 0; \ | |
| 3010 CONSP (CTL_hare); \ | |
| 3011 CTL_hare = XCDR (CTL_hare), CTL_len++) \ | |
| 3012 { \ | |
| 3013 if (CTL_len < CIRCULAR_LIST_SUSPICION_LENGTH) \ | |
| 3014 continue; \ | |
| 3015 \ | |
| 3016 if (CTL_len & 1) \ | |
| 3017 CTL_tortoise = XCDR (CTL_tortoise); \ | |
| 3018 else if (EQ (CTL_hare, CTL_tortoise)) \ | |
| 3019 Fsignal (Qcircular_list, list1 (CTL_list)); \ | |
| 3020 } \ | |
| 3021 \ | |
| 3022 if (! NILP (CTL_hare)) \ | |
| 3023 signal_malformed_list_error (CTL_list); \ | |
| 3024 } while (0) | |
| 3025 | |
| 442 | 3026 /*------------------------------ string --------------------------------*/ |
| 428 | 3027 |
| 3092 | 3028 #ifdef NEW_GC |
| 3029 struct Lisp_String_Direct_Data | |
| 3030 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3031 NORMAL_LISP_OBJECT_HEADER header; |
| 3092 | 3032 Bytecount size; |
| 3033 Ibyte data[1]; | |
| 3034 }; | |
| 3035 typedef struct Lisp_String_Direct_Data Lisp_String_Direct_Data; | |
| 3036 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3037 DECLARE_MODULE_API_LISP_OBJECT (string_direct_data, Lisp_String_Direct_Data); |
| 3092 | 3038 #define XSTRING_DIRECT_DATA(x) \ |
| 3039 XRECORD (x, string_direct_data, Lisp_String_Direct_Data) | |
| 3040 #define wrap_string_direct_data(p) wrap_record (p, string_direct_data) | |
| 3041 #define STRING_DIRECT_DATAP(x) RECORDP (x, string_direct_data) | |
| 3042 #define CHECK_STRING_DIRECT_DATA(x) CHECK_RECORD (x, string_direct_data) | |
| 3043 #define CONCHECK_STRING_DIRECT_DATA(x) CONCHECK_RECORD (x, string_direct_data) | |
| 3044 | |
| 3045 #define XSTRING_DIRECT_DATA_SIZE(x) XSTRING_DIRECT_DATA (x)->size | |
| 3046 #define XSTRING_DIRECT_DATA_DATA(x) XSTRING_DIRECT_DATA (x)->data | |
| 3047 | |
| 3048 | |
| 3049 struct Lisp_String_Indirect_Data | |
| 3050 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3051 NORMAL_LISP_OBJECT_HEADER header; |
| 3092 | 3052 Bytecount size; |
| 3053 Ibyte *data; | |
| 3054 }; | |
| 3055 typedef struct Lisp_String_Indirect_Data Lisp_String_Indirect_Data; | |
| 3056 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3057 DECLARE_MODULE_API_LISP_OBJECT (string_indirect_data, Lisp_String_Indirect_Data); |
| 3092 | 3058 #define XSTRING_INDIRECT_DATA(x) \ |
| 3059 XRECORD (x, string_indirect_data, Lisp_String_Indirect_Data) | |
| 3060 #define wrap_string_indirect_data(p) wrap_record (p, string_indirect_data) | |
| 3061 #define STRING_INDIRECT_DATAP(x) RECORDP (x, string_indirect_data) | |
| 3062 #define CHECK_STRING_INDIRECT_DATA(x) CHECK_RECORD (x, string_indirect_data) | |
| 3063 #define CONCHECK_STRING_INDIRECT_DATA(x) \ | |
| 3064 CONCHECK_RECORD (x, string_indirect_data) | |
| 3065 | |
| 3066 #define XSTRING_INDIRECT_DATA_SIZE(x) XSTRING_INDIRECT_DATA (x)->size | |
| 3067 #define XSTRING_INDIRECT_DATA_DATA(x) XSTRING_INDIRECT_DATA (x)->data | |
| 3068 | |
| 3069 | |
| 3070 #define XSTRING_DATA_SIZE(s) ((s)->indirect)? \ | |
| 3071 XSTRING_INDIRECT_DATA_SIZE ((s)->data_object): \ | |
| 3072 XSTRING_DIRECT_DATA_SIZE ((s)->data_object) | |
| 3073 #define XSTRING_DATA_DATA(s) ((s)->indirect)? \ | |
| 3074 XSTRING_INDIRECT_DATA_DATA ((s)->data_object): \ | |
| 3075 XSTRING_DIRECT_DATA_DATA ((s)->data_object) | |
| 3076 | |
| 3077 #define XSET_STRING_DATA_SIZE(s, len) \ | |
| 3078 if ((s)->indirect) \ | |
| 3079 XSTRING_INDIRECT_DATA_SIZE ((s)->data_object) = len; \ | |
| 3080 else \ | |
| 3081 XSTRING_DIRECT_DATA_SIZE ((s)->data_object) = len | |
| 3082 #define XSET_STRING_DATA_DATA(s, ptr) \ | |
| 3083 if ((s)->indirect) \ | |
| 3084 XSTRING_INDIRECT_DATA_DATA ((s)->data_object) = ptr; \ | |
| 3085 else \ | |
| 3086 XSTRING_DIRECT_DATA_DATA ((s)->data_object) = ptr | |
| 3087 #endif /* NEW_GC */ | |
| 3088 | |
| 428 | 3089 struct Lisp_String |
| 3090 { | |
| 771 | 3091 union |
| 3092 { | |
| 3093 struct lrecord_header lheader; | |
| 3094 struct | |
| 3095 { | |
| 3096 /* WARNING: Everything before ascii_begin must agree exactly with | |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
3097 struct lrecord_header. (Actually, the `free' field in old-GC |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
3098 overlaps with ascii_begin there; we can get away with this |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
3099 because in old-GC the `free' field is used only for lcrecords. */ |
| 771 | 3100 unsigned int type :8; |
| 3263 | 3101 #ifdef NEW_GC |
| 2720 | 3102 unsigned int lisp_readonly :1; |
| 3103 unsigned int free :1; | |
| 3104 /* Number of chars at beginning of string that are one byte in length | |
| 3105 (byte_ascii_p) */ | |
| 3106 unsigned int ascii_begin :22; | |
| 3263 | 3107 #else /* not NEW_GC */ |
| 771 | 3108 unsigned int mark :1; |
| 3109 unsigned int c_readonly :1; | |
| 3110 unsigned int lisp_readonly :1; | |
| 3111 /* Number of chars at beginning of string that are one byte in length | |
| 826 | 3112 (byte_ascii_p) */ |
| 771 | 3113 unsigned int ascii_begin :21; |
| 3263 | 3114 #endif /* not NEW_GC */ |
| 771 | 3115 } v; |
| 3116 } u; | |
| 3092 | 3117 #ifdef NEW_GC |
| 3118 int indirect; | |
| 3119 Lisp_Object data_object; | |
| 3120 #else /* not NEW_GC */ | |
| 793 | 3121 Bytecount size_; |
| 867 | 3122 Ibyte *data_; |
| 3092 | 3123 #endif /* not NEW_GC */ |
| 428 | 3124 Lisp_Object plist; |
| 3125 }; | |
| 3126 typedef struct Lisp_String Lisp_String; | |
| 3127 | |
| 3263 | 3128 #ifdef NEW_GC |
| 3063 | 3129 #define MAX_STRING_ASCII_BEGIN ((1 << 22) - 1) |
| 3263 | 3130 #else /* not NEW_GC */ |
| 851 | 3131 #define MAX_STRING_ASCII_BEGIN ((1 << 21) - 1) |
| 3263 | 3132 #endif /* not NEW_GC */ |
| 771 | 3133 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3134 DECLARE_MODULE_API_LISP_OBJECT (string, Lisp_String); |
| 428 | 3135 #define XSTRING(x) XRECORD (x, string, Lisp_String) |
| 617 | 3136 #define wrap_string(p) wrap_record (p, string) |
| 428 | 3137 #define STRINGP(x) RECORDP (x, string) |
| 3138 #define CHECK_STRING(x) CHECK_RECORD (x, string) | |
| 3139 #define CONCHECK_STRING(x) CONCHECK_RECORD (x, string) | |
| 3140 | |
| 826 | 3141 /* Most basic macros for strings -- basically just accessing or setting |
| 3142 fields -- are here. Everything else is in text.h, since they depend on | |
| 3143 stuff there. */ | |
| 428 | 3144 |
| 793 | 3145 /* Operations on Lisp_String *'s; only ones left */ |
| 3092 | 3146 #ifdef NEW_GC |
| 3304 | 3147 #define set_lispstringp_direct(s) ((s)->indirect = 0) |
| 3092 | 3148 #define set_lispstringp_indirect(s) ((s)->indirect = 1) |
| 3149 #define set_lispstringp_length(s, len) XSET_STRING_DATA_SIZE (s, len) | |
| 3150 #define set_lispstringp_data(s, ptr) XSET_STRING_DATA_DATA (s, ptr) | |
| 3151 #else /* not NEW_GC */ | |
| 826 | 3152 #define set_lispstringp_length(s, len) ((void) ((s)->size_ = (len))) |
| 3153 #define set_lispstringp_data(s, ptr) ((void) ((s)->data_ = (ptr))) | |
| 3092 | 3154 #endif /* not NEW_GC */ |
| 826 | 3155 |
| 3156 /* Operations on strings as Lisp_Objects. Don't manipulate Lisp_String *'s | |
| 3157 in any new code. */ | |
| 3092 | 3158 #ifdef NEW_GC |
| 3159 #define STRING_DATA_OBJECT(s) ((s)->data_object) | |
| 3160 #define XSTRING_DATA_OBJECT(s) (STRING_DATA_OBJECT (XSTRING (s))) | |
| 3161 #define XSTRING_LENGTH(s) (XSTRING_DATA_SIZE (XSTRING (s))) | |
| 3162 #else /* not NEW_GC */ | |
| 793 | 3163 #define XSTRING_LENGTH(s) (XSTRING (s)->size_) |
| 3092 | 3164 #endif /* not NEW_GC */ |
| 793 | 3165 #define XSTRING_PLIST(s) (XSTRING (s)->plist) |
| 3092 | 3166 #ifdef NEW_GC |
| 3167 #define XSTRING_DATA(s) (XSTRING_DATA_DATA (XSTRING (s))) | |
| 3168 #else /* not NEW_GC */ | |
| 793 | 3169 #define XSTRING_DATA(s) (XSTRING (s)->data_ + 0) |
| 3092 | 3170 #endif /* not NEW_GC */ |
| 793 | 3171 #define XSTRING_ASCII_BEGIN(s) (XSTRING (s)->u.v.ascii_begin + 0) |
| 826 | 3172 #define XSET_STRING_LENGTH(s, ptr) set_lispstringp_length (XSTRING (s), ptr) |
| 3173 #define XSET_STRING_DATA(s, ptr) set_lispstringp_data (XSTRING (s), ptr) | |
| 771 | 3174 /* WARNING: If you modify an existing string, you must call |
| 3175 bump_string_modiff() afterwards. */ | |
| 793 | 3176 #define XSET_STRING_ASCII_BEGIN(s, val) \ |
| 3177 ((void) (XSTRING (s)->u.v.ascii_begin = (val))) | |
| 826 | 3178 #define XSTRING_FORMAT(s) FORMAT_DEFAULT |
| 428 | 3179 |
| 456 | 3180 /* Return the true aligned size of a struct whose last member is a |
| 3181 variable-length array field. (this is known as the "struct hack") */ | |
| 3182 /* Implementation: in practice, structtype and fieldtype usually have | |
| 3183 the same alignment, but we can't be sure. We need to use | |
| 3184 ALIGN_SIZE to be absolutely sure of getting the correct alignment. | |
| 3185 To help the compiler's optimizer, we use a ternary expression that | |
| 3186 only a very stupid compiler would fail to correctly simplify. */ | |
| 3187 #define FLEXIBLE_ARRAY_STRUCT_SIZEOF(structtype, \ | |
| 3188 fieldtype, \ | |
| 3189 fieldname, \ | |
| 3190 array_length) \ | |
| 3191 (ALIGNOF (structtype) == ALIGNOF (fieldtype) \ | |
| 3192 ? (offsetof (structtype, fieldname) + \ | |
| 3193 (offsetof (structtype, fieldname[1]) - \ | |
| 3194 offsetof (structtype, fieldname[0])) * \ | |
| 3195 (array_length)) \ | |
| 826 | 3196 : (ALIGN_FOR_TYPE \ |
| 456 | 3197 ((offsetof (structtype, fieldname) + \ |
| 3198 (offsetof (structtype, fieldname[1]) - \ | |
| 3199 offsetof (structtype, fieldname[0])) * \ | |
| 3200 (array_length)), \ | |
| 826 | 3201 structtype))) |
| 442 | 3202 |
| 3203 /*------------------------------ vector --------------------------------*/ | |
| 428 | 3204 |
| 3205 struct Lisp_Vector | |
| 3206 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3207 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 3208 long size; |
| 3209 Lisp_Object contents[1]; | |
| 3210 }; | |
| 3211 typedef struct Lisp_Vector Lisp_Vector; | |
| 3212 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3213 DECLARE_LISP_OBJECT (vector, Lisp_Vector); |
| 428 | 3214 #define XVECTOR(x) XRECORD (x, vector, Lisp_Vector) |
| 617 | 3215 #define wrap_vector(p) wrap_record (p, vector) |
| 428 | 3216 #define VECTORP(x) RECORDP (x, vector) |
| 3217 #define CHECK_VECTOR(x) CHECK_RECORD (x, vector) | |
| 3218 #define CONCHECK_VECTOR(x) CONCHECK_RECORD (x, vector) | |
| 3219 | |
| 3220 #define vector_length(v) ((v)->size) | |
| 3221 #define XVECTOR_LENGTH(s) vector_length (XVECTOR (s)) | |
| 3222 #define vector_data(v) ((v)->contents) | |
| 3223 #define XVECTOR_DATA(s) vector_data (XVECTOR (s)) | |
| 3224 | |
| 442 | 3225 /*---------------------------- bit vectors -----------------------------*/ |
| 428 | 3226 |
| 3227 #if (LONGBITS < 16) | |
| 3228 #error What the hell?! | |
| 3229 #elif (LONGBITS < 32) | |
| 3230 # define LONGBITS_LOG2 4 | |
| 3231 # define LONGBITS_POWER_OF_2 16 | |
| 3232 #elif (LONGBITS < 64) | |
| 3233 # define LONGBITS_LOG2 5 | |
| 3234 # define LONGBITS_POWER_OF_2 32 | |
| 3235 #elif (LONGBITS < 128) | |
| 3236 # define LONGBITS_LOG2 6 | |
| 3237 # define LONGBITS_POWER_OF_2 64 | |
| 3238 #else | |
| 3239 #error You really have 128-bit integers?! | |
| 3240 #endif | |
| 3241 | |
| 3242 struct Lisp_Bit_Vector | |
| 3243 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3244 NORMAL_LISP_OBJECT_HEADER lheader; |
| 665 | 3245 Elemcount size; |
| 428 | 3246 unsigned long bits[1]; |
| 3247 }; | |
| 3248 typedef struct Lisp_Bit_Vector Lisp_Bit_Vector; | |
| 3249 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3250 DECLARE_LISP_OBJECT (bit_vector, Lisp_Bit_Vector); |
| 428 | 3251 #define XBIT_VECTOR(x) XRECORD (x, bit_vector, Lisp_Bit_Vector) |
| 617 | 3252 #define wrap_bit_vector(p) wrap_record (p, bit_vector) |
| 428 | 3253 #define BIT_VECTORP(x) RECORDP (x, bit_vector) |
| 3254 #define CHECK_BIT_VECTOR(x) CHECK_RECORD (x, bit_vector) | |
| 3255 #define CONCHECK_BIT_VECTOR(x) CONCHECK_RECORD (x, bit_vector) | |
| 3256 | |
| 3257 #define BITP(x) (INTP (x) && (XINT (x) == 0 || XINT (x) == 1)) | |
| 3258 | |
| 3259 #define CHECK_BIT(x) do { \ | |
| 3260 if (!BITP (x)) \ | |
| 3261 dead_wrong_type_argument (Qbitp, x);\ | |
| 3262 } while (0) | |
| 3263 | |
| 3264 #define CONCHECK_BIT(x) do { \ | |
| 3265 if (!BITP (x)) \ | |
| 3266 x = wrong_type_argument (Qbitp, x); \ | |
| 3267 } while (0) | |
| 3268 | |
| 3269 #define bit_vector_length(v) ((v)->size) | |
| 3270 | |
| 826 | 3271 DECLARE_INLINE_HEADER ( |
| 3272 int | |
| 665 | 3273 bit_vector_bit (Lisp_Bit_Vector *v, Elemcount n) |
| 826 | 3274 ) |
| 428 | 3275 { |
| 3276 return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1))) | |
| 3277 & 1); | |
| 3278 } | |
| 3279 | |
| 826 | 3280 DECLARE_INLINE_HEADER ( |
| 3281 void | |
| 665 | 3282 set_bit_vector_bit (Lisp_Bit_Vector *v, Elemcount n, int value) |
| 826 | 3283 ) |
| 428 | 3284 { |
| 3285 if (value) | |
| 3286 v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1))); | |
| 3287 else | |
| 3288 v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1))); | |
| 3289 } | |
| 3290 | |
| 3291 /* Number of longs required to hold LEN bits */ | |
| 3292 #define BIT_VECTOR_LONG_STORAGE(len) \ | |
| 3293 (((len) + LONGBITS_POWER_OF_2 - 1) >> LONGBITS_LOG2) | |
| 3294 | |
| 3659 | 3295 /* For when we want to include a bit vector in another structure, and we |
| 3296 know it's of a fixed size. */ | |
| 3297 #define DECLARE_INLINE_LISP_BIT_VECTOR(numbits) struct { \ | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3298 NORMAL_LISP_OBJECT_HEADER lheader; \ |
| 3659 | 3299 Elemcount size; \ |
| 3300 unsigned long bits[BIT_VECTOR_LONG_STORAGE(numbits)]; \ | |
| 3301 } | |
|
4995
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3302 /*---------------------- array, sequence -----------------------------*/ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3303 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3304 #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
|
3305 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3306 #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
|
3307 if (!ARRAYP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3308 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
|
3309 } while (0) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3310 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3311 #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
|
3312 if (!ARRAYP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3313 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
|
3314 } while (0) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3315 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3316 #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
|
3317 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3318 #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
|
3319 if (!SEQUENCEP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3320 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
|
3321 } while (0) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3322 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3323 #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
|
3324 if (!SEQUENCEP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
3325 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
|
3326 } while (0) |
| 853 | 3327 |
| 442 | 3328 /*------------------------------ symbol --------------------------------*/ |
| 428 | 3329 |
| 440 | 3330 typedef struct Lisp_Symbol Lisp_Symbol; |
| 428 | 3331 struct Lisp_Symbol |
| 3332 { | |
|
5124
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
3333 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 428 | 3334 /* next symbol in this obarray bucket */ |
| 440 | 3335 Lisp_Symbol *next; |
| 793 | 3336 Lisp_Object name; |
| 428 | 3337 Lisp_Object value; |
| 3338 Lisp_Object function; | |
| 3339 Lisp_Object plist; | |
| 3340 }; | |
| 3341 | |
| 3342 #define SYMBOL_IS_KEYWORD(sym) \ | |
| 826 | 3343 ((string_byte (symbol_name (XSYMBOL (sym)), 0) == ':') \ |
| 428 | 3344 && EQ (sym, oblookup (Vobarray, \ |
| 793 | 3345 XSTRING_DATA (symbol_name (XSYMBOL (sym))), \ |
| 3346 XSTRING_LENGTH (symbol_name (XSYMBOL (sym)))))) | |
| 428 | 3347 #define KEYWORDP(obj) (SYMBOLP (obj) && SYMBOL_IS_KEYWORD (obj)) |
| 3348 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3349 DECLARE_MODULE_API_LISP_OBJECT (symbol, Lisp_Symbol); |
| 428 | 3350 #define XSYMBOL(x) XRECORD (x, symbol, Lisp_Symbol) |
| 617 | 3351 #define wrap_symbol(p) wrap_record (p, symbol) |
| 428 | 3352 #define SYMBOLP(x) RECORDP (x, symbol) |
| 3353 #define CHECK_SYMBOL(x) CHECK_RECORD (x, symbol) | |
| 3354 #define CONCHECK_SYMBOL(x) CONCHECK_RECORD (x, symbol) | |
| 3355 | |
| 3356 #define symbol_next(s) ((s)->next) | |
| 3357 #define symbol_name(s) ((s)->name) | |
| 3358 #define symbol_value(s) ((s)->value) | |
| 3359 #define symbol_function(s) ((s)->function) | |
| 3360 #define symbol_plist(s) ((s)->plist) | |
| 3361 | |
| 793 | 3362 #define XSYMBOL_NEXT(s) (XSYMBOL (s)->next) |
| 3363 #define XSYMBOL_NAME(s) (XSYMBOL (s)->name) | |
| 3364 #define XSYMBOL_VALUE(s) (XSYMBOL (s)->value) | |
| 3365 #define XSYMBOL_FUNCTION(s) (XSYMBOL (s)->function) | |
| 3366 #define XSYMBOL_PLIST(s) (XSYMBOL (s)->plist) | |
| 3367 | |
| 3368 | |
| 442 | 3369 /*------------------------------- subr ---------------------------------*/ |
| 428 | 3370 |
| 853 | 3371 /* A function that takes no arguments and returns a Lisp_Object. |
| 3372 We could define such types for n arguments, if needed. */ | |
| 428 | 3373 typedef Lisp_Object (*lisp_fn_t) (void); |
| 3374 | |
| 3375 struct Lisp_Subr | |
| 3376 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3377 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 442 | 3378 short min_args; |
| 3379 short max_args; | |
| 3379 | 3380 /* #### We should make these const Ascbyte * or const Ibyte *, not const |
| 3381 char *. */ | |
| 442 | 3382 const char *prompt; |
| 3383 const char *doc; | |
| 3384 const char *name; | |
| 428 | 3385 lisp_fn_t subr_fn; |
| 3386 }; | |
| 3387 typedef struct Lisp_Subr Lisp_Subr; | |
| 3388 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3389 DECLARE_LISP_OBJECT (subr, Lisp_Subr); |
| 428 | 3390 #define XSUBR(x) XRECORD (x, subr, Lisp_Subr) |
| 617 | 3391 #define wrap_subr(p) wrap_record (p, subr) |
| 428 | 3392 #define SUBRP(x) RECORDP (x, subr) |
| 3393 #define CHECK_SUBR(x) CHECK_RECORD (x, subr) | |
| 3394 #define CONCHECK_SUBR(x) CONCHECK_RECORD (x, subr) | |
| 3395 | |
| 436 | 3396 #define subr_function(subr) ((subr)->subr_fn) |
| 3397 #define SUBR_FUNCTION(subr,max_args) \ | |
| 3398 ((Lisp_Object (*) (EXFUN_##max_args)) (subr)->subr_fn) | |
| 3399 #define subr_name(subr) ((subr)->name) | |
| 428 | 3400 |
| 442 | 3401 /*------------------------------ marker --------------------------------*/ |
| 3402 | |
| 428 | 3403 |
| 440 | 3404 typedef struct Lisp_Marker Lisp_Marker; |
| 428 | 3405 struct Lisp_Marker |
| 3406 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3407 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 440 | 3408 Lisp_Marker *next; |
| 3409 Lisp_Marker *prev; | |
| 428 | 3410 struct buffer *buffer; |
| 665 | 3411 Membpos membpos; |
| 428 | 3412 char insertion_type; |
| 3413 }; | |
| 3414 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3415 DECLARE_MODULE_API_LISP_OBJECT (marker, Lisp_Marker); |
| 428 | 3416 #define XMARKER(x) XRECORD (x, marker, Lisp_Marker) |
| 617 | 3417 #define wrap_marker(p) wrap_record (p, marker) |
| 428 | 3418 #define MARKERP(x) RECORDP (x, marker) |
| 3419 #define CHECK_MARKER(x) CHECK_RECORD (x, marker) | |
| 3420 #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker) | |
| 3421 | |
| 3422 /* 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
|
3423 /* assert (!INTP (XMARKER (x)->lheader.next.v)); */ |
| 428 | 3424 |
| 3425 #define marker_next(m) ((m)->next) | |
| 3426 #define marker_prev(m) ((m)->prev) | |
| 3427 | |
| 3063 | 3428 /*-------------------basic int (no connection to char)------------------*/ |
| 3429 | |
| 3430 #define ZEROP(x) EQ (x, Qzero) | |
| 428 | 3431 |
| 800 | 3432 #ifdef ERROR_CHECK_TYPES |
| 428 | 3433 |
| 3063 | 3434 #define XINT(x) XINT_1 (x, __FILE__, __LINE__) |
| 3435 | |
| 3436 DECLARE_INLINE_HEADER ( | |
| 3437 EMACS_INT | |
| 3438 XINT_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3439 ) | |
| 3440 { | |
| 3441 assert_at_line (INTP (obj), file, line); | |
| 3442 return XREALINT (obj); | |
| 3443 } | |
| 3444 | |
| 5038 | 3445 #else /* not ERROR_CHECK_TYPES */ |
| 3063 | 3446 |
| 3447 #define XINT(obj) XREALINT (obj) | |
| 3448 | |
| 5038 | 3449 #endif /* (not) ERROR_CHECK_TYPES */ |
| 3063 | 3450 |
| 3451 #define CHECK_INT(x) do { \ | |
| 3452 if (!INTP (x)) \ | |
| 3453 dead_wrong_type_argument (Qintegerp, x); \ | |
| 3454 } while (0) | |
| 3455 | |
| 3456 #define CONCHECK_INT(x) do { \ | |
| 3457 if (!INTP (x)) \ | |
| 3458 x = wrong_type_argument (Qintegerp, x); \ | |
| 3459 } while (0) | |
| 3460 | |
| 5038 | 3461 /* NOTE NOTE NOTE! This definition of "natural number" is mathematically |
| 3462 wrong. Mathematically, a natural number is a positive integer; 0 | |
| 3463 isn't included. This would be better called NONNEGINT(). */ | |
| 3464 | |
| 3063 | 3465 #define NATNUMP(x) (INTP (x) && XINT (x) >= 0) |
| 3466 | |
| 3467 #define CHECK_NATNUM(x) do { \ | |
| 3468 if (!NATNUMP (x)) \ | |
| 3469 dead_wrong_type_argument (Qnatnump, x); \ | |
| 3470 } while (0) | |
| 3471 | |
| 3472 #define CONCHECK_NATNUM(x) do { \ | |
| 3473 if (!NATNUMP (x)) \ | |
| 3474 x = wrong_type_argument (Qnatnump, x); \ | |
| 3475 } while (0) | |
| 3476 | |
|
5092
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3477 END_C_DECLS |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3478 |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3479 /* -------------- properties of internally-formatted text ------------- */ |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3480 |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3481 #include "text.h" |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3482 |
| 3063 | 3483 /*------------------------------- char ---------------------------------*/ |
| 3484 | |
|
5092
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3485 BEGIN_C_DECLS |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3486 |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3487 #ifdef ERROR_CHECK_TYPES |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
3488 |
| 3063 | 3489 /* NOTE: There are basic functions for converting between a character and |
| 3490 the string representation of a character in text.h, as well as lots of | |
| 3491 other character-related stuff. There are other functions/macros for | |
| 3492 working with Ichars in charset.h, for retrieving the charset of an | |
| 3493 Ichar, the length of an Ichar when converted to text, etc. | |
| 3494 */ | |
| 3495 | |
| 3496 DECLARE_INLINE_HEADER ( | |
| 3497 int | |
| 3498 CHARP_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3499 ) | |
| 3500 { | |
| 3501 if (XTYPE (obj) != Lisp_Type_Char) | |
| 3502 return 0; | |
| 3503 assert_at_line (valid_ichar_p (XCHARVAL (obj)), file, line); | |
| 3504 return 1; | |
| 3505 } | |
| 3506 | |
| 3507 #define CHARP(x) CHARP_1 (x, __FILE__, __LINE__) | |
| 3508 | |
| 826 | 3509 DECLARE_INLINE_HEADER ( |
| 867 | 3510 Ichar |
| 2367 | 3511 XCHAR_1 (Lisp_Object obj, const Ascbyte *file, int line) |
| 826 | 3512 ) |
| 428 | 3513 { |
| 3063 | 3514 Ichar ch; |
| 788 | 3515 assert_at_line (CHARP (obj), file, line); |
| 3063 | 3516 ch = XCHARVAL (obj); |
| 3517 assert_at_line (valid_ichar_p (ch), file, line); | |
| 3518 return ch; | |
| 428 | 3519 } |
| 3520 | |
| 788 | 3521 #define XCHAR(x) XCHAR_1 (x, __FILE__, __LINE__) |
| 3522 | |
| 3063 | 3523 #else /* not ERROR_CHECK_TYPES */ |
| 3524 | |
| 3525 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char) | |
| 3526 #define XCHAR(x) ((Ichar) XCHARVAL (x)) | |
| 3527 | |
| 3528 #endif /* (else) not ERROR_CHECK_TYPES */ | |
| 3529 | |
| 3530 #define CONCHECK_CHAR(x) do { \ | |
| 3531 if (!CHARP (x)) \ | |
| 3532 x = wrong_type_argument (Qcharacterp, x); \ | |
| 3533 } while (0) | |
| 3534 | |
| 3535 #define CHECK_CHAR(x) do { \ | |
| 3536 if (!CHARP (x)) \ | |
| 3537 dead_wrong_type_argument (Qcharacterp, x); \ | |
| 3538 } while (0) | |
| 3539 | |
| 3540 | |
| 3541 DECLARE_INLINE_HEADER ( | |
| 3542 Lisp_Object | |
| 3543 make_char (Ichar val) | |
| 3544 ) | |
| 3545 { | |
| 3546 type_checking_assert (valid_ichar_p (val)); | |
| 3547 /* This is defined in lisp-union.h or lisp-disunion.h */ | |
| 3548 return make_char_1 (val); | |
| 3549 } | |
| 3550 | |
| 3551 /*------------------------- int-char connection ------------------------*/ | |
| 3552 | |
| 3553 #ifdef ERROR_CHECK_TYPES | |
| 3554 | |
| 3555 #define XCHAR_OR_INT(x) XCHAR_OR_INT_1 (x, __FILE__, __LINE__) | |
| 3556 | |
| 3557 DECLARE_INLINE_HEADER ( | |
| 3558 EMACS_INT | |
| 3559 XCHAR_OR_INT_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3560 ) | |
| 3561 { | |
| 3562 assert_at_line (INTP (obj) || CHARP (obj), file, line); | |
| 3563 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3564 } | |
| 3565 | |
| 788 | 3566 #else /* no error checking */ |
| 3567 | |
| 4134 | 3568 /* obj is multiply eval'ed and not an lvalue; use an inline function instead |
| 3569 of a macro. */ | |
| 3570 DECLARE_INLINE_HEADER ( | |
| 3571 EMACS_INT | |
| 3572 XCHAR_OR_INT (Lisp_Object obj) | |
| 3573 ) | |
| 3574 { | |
| 3575 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3576 } | |
| 788 | 3577 |
| 3578 #endif /* no error checking */ | |
| 428 | 3579 |
| 3063 | 3580 /* True of X is an integer whose value is the valid integral equivalent of a |
| 3581 character. */ | |
| 3582 | |
| 3583 #define CHAR_INTP(x) (INTP (x) && valid_ichar_p (XINT (x))) | |
| 3584 | |
| 3585 /* True of X is a character or an integral value that can be converted into a | |
| 3586 character. */ | |
| 3587 #define CHAR_OR_CHAR_INTP(x) (CHARP (x) || CHAR_INTP (x)) | |
| 3588 | |
| 3589 DECLARE_INLINE_HEADER ( | |
| 3590 Ichar | |
| 3591 XCHAR_OR_CHAR_INT (Lisp_Object obj) | |
| 3592 ) | |
| 3593 { | |
| 3594 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3595 } | |
| 3596 | |
| 3597 /* Signal an error if CH is not a valid character or integer Lisp_Object. | |
| 3598 If CH is an integer Lisp_Object, convert it to a character Lisp_Object, | |
| 3599 but merely by repackaging, without performing tests for char validity. | |
| 3600 */ | |
| 3601 | |
| 3602 #define CHECK_CHAR_COERCE_INT(x) do { \ | |
| 3603 if (CHARP (x)) \ | |
| 3604 ; \ | |
| 3605 else if (CHAR_INTP (x)) \ | |
| 3606 x = make_char (XINT (x)); \ | |
| 3607 else \ | |
| 3608 x = wrong_type_argument (Qcharacterp, x); \ | |
| 3609 } while (0) | |
| 3610 | |
| 3611 /* next three always continuable because they coerce their arguments. */ | |
| 3612 #define CHECK_INT_COERCE_CHAR(x) do { \ | |
| 3613 if (INTP (x)) \ | |
| 3614 ; \ | |
| 3615 else if (CHARP (x)) \ | |
| 3616 x = make_int (XCHAR (x)); \ | |
| 3617 else \ | |
| 3618 x = wrong_type_argument (Qinteger_or_char_p, x); \ | |
| 3619 } while (0) | |
| 3620 | |
| 3621 #define CHECK_INT_COERCE_MARKER(x) do { \ | |
| 3622 if (INTP (x)) \ | |
| 3623 ; \ | |
| 3624 else if (MARKERP (x)) \ | |
| 3625 x = make_int (marker_position (x)); \ | |
| 3626 else \ | |
| 3627 x = wrong_type_argument (Qinteger_or_marker_p, x); \ | |
| 3628 } while (0) | |
| 3629 | |
| 3630 #define CHECK_INT_COERCE_CHAR_OR_MARKER(x) do { \ | |
| 3631 if (INTP (x)) \ | |
| 3632 ; \ | |
| 3633 else if (CHARP (x)) \ | |
| 3634 x = make_int (XCHAR (x)); \ | |
| 3635 else if (MARKERP (x)) \ | |
| 3636 x = make_int (marker_position (x)); \ | |
| 3637 else \ | |
| 3638 x = wrong_type_argument (Qinteger_char_or_marker_p, x); \ | |
| 3639 } while (0) | |
| 428 | 3640 |
| 442 | 3641 /*------------------------------ float ---------------------------------*/ |
| 428 | 3642 |
| 3643 /* Note: the 'unused_next_' field exists only to ensure that the | |
| 3644 `next' pointer fits within the structure, for the purposes of the | |
| 3645 free list. This makes a difference in the unlikely case of | |
| 3646 sizeof(double) being smaller than sizeof(void *). */ | |
| 3647 | |
| 3648 struct Lisp_Float | |
| 3649 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3650 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 428 | 3651 union { double d; struct Lisp_Float *unused_next_; } data; |
| 3652 }; | |
| 3653 typedef struct Lisp_Float Lisp_Float; | |
| 3654 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3655 DECLARE_LISP_OBJECT (float, Lisp_Float); |
| 428 | 3656 #define XFLOAT(x) XRECORD (x, float, Lisp_Float) |
| 617 | 3657 #define wrap_float(p) wrap_record (p, float) |
| 428 | 3658 #define FLOATP(x) RECORDP (x, float) |
| 3659 #define CHECK_FLOAT(x) CHECK_RECORD (x, float) | |
| 3660 #define CONCHECK_FLOAT(x) CONCHECK_RECORD (x, float) | |
| 3661 | |
| 3662 #define float_data(f) ((f)->data.d) | |
| 3663 #define XFLOAT_DATA(x) float_data (XFLOAT (x)) | |
| 3664 | |
| 3665 #define XFLOATINT(n) extract_float (n) | |
| 3666 | |
| 3667 #define CHECK_INT_OR_FLOAT(x) do { \ | |
| 3668 if (!INT_OR_FLOATP (x)) \ | |
| 3669 dead_wrong_type_argument (Qnumberp, x); \ | |
| 3670 } while (0) | |
| 3671 | |
| 3672 #define CONCHECK_INT_OR_FLOAT(x) do { \ | |
| 3673 if (!INT_OR_FLOATP (x)) \ | |
| 3674 x = wrong_type_argument (Qnumberp, x); \ | |
| 3675 } while (0) | |
| 3676 | |
| 3677 # define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x)) | |
| 3678 | |
| 442 | 3679 /*--------------------------- readonly objects -------------------------*/ |
| 440 | 3680 |
| 3263 | 3681 #ifndef NEW_GC |
| 428 | 3682 #define CHECK_C_WRITEABLE(obj) \ |
| 3683 do { if (c_readonly (obj)) c_write_error (obj); } while (0) | |
| 3684 | |
| 2720 | 3685 #define C_READONLY(obj) (C_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj))) |
| 3263 | 3686 #endif /* not NEW_GC */ |
| 2720 | 3687 |
| 428 | 3688 #define CHECK_LISP_WRITEABLE(obj) \ |
| 3689 do { if (lisp_readonly (obj)) lisp_write_error (obj); } while (0) | |
| 3690 | |
| 3691 #define LISP_READONLY(obj) (LISP_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj))) | |
| 3692 | |
| 980 | 3693 /*----------------------------- structures ----------------------------*/ |
| 428 | 3694 |
| 3695 typedef struct structure_keyword_entry structure_keyword_entry; | |
| 3696 struct structure_keyword_entry | |
| 3697 { | |
| 3698 Lisp_Object keyword; | |
| 3699 int (*validate) (Lisp_Object keyword, Lisp_Object value, | |
| 578 | 3700 Error_Behavior errb); |
| 428 | 3701 }; |
| 3702 | |
| 3703 typedef struct | |
| 3704 { | |
| 3705 Dynarr_declare (structure_keyword_entry); | |
| 3706 } structure_keyword_entry_dynarr; | |
| 3707 | |
| 3708 typedef struct structure_type structure_type; | |
| 3709 struct structure_type | |
| 3710 { | |
| 3711 Lisp_Object type; | |
| 3712 structure_keyword_entry_dynarr *keywords; | |
| 578 | 3713 int (*validate) (Lisp_Object data, Error_Behavior errb); |
| 428 | 3714 Lisp_Object (*instantiate) (Lisp_Object data); |
| 3715 }; | |
| 3716 | |
| 3717 typedef struct | |
| 3718 { | |
| 3719 Dynarr_declare (structure_type); | |
| 3720 } structure_type_dynarr; | |
| 3721 | |
| 3722 struct structure_type *define_structure_type (Lisp_Object type, | |
| 3723 int (*validate) | |
| 3724 (Lisp_Object data, | |
| 578 | 3725 Error_Behavior errb), |
| 428 | 3726 Lisp_Object (*instantiate) |
| 3727 (Lisp_Object data)); | |
| 3728 void define_structure_type_keyword (struct structure_type *st, | |
| 3729 Lisp_Object keyword, | |
| 3730 int (*validate) (Lisp_Object keyword, | |
| 3731 Lisp_Object value, | |
| 578 | 3732 Error_Behavior errb)); |
| 428 | 3733 |
| 858 | 3734 /*---------------------------- weak boxes ------------------------------*/ |
| 3735 | |
| 3736 struct weak_box | |
| 3737 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3738 NORMAL_LISP_OBJECT_HEADER header; |
| 858 | 3739 Lisp_Object value; |
| 3740 | |
| 3741 Lisp_Object next_weak_box; /* don't mark through this! */ | |
| 3742 }; | |
| 3743 | |
| 3744 void prune_weak_boxes (void); | |
| 3745 Lisp_Object make_weak_box (Lisp_Object value); | |
| 3746 Lisp_Object weak_box_ref (Lisp_Object value); | |
| 3747 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3748 DECLARE_LISP_OBJECT (weak_box, struct weak_box); |
| 858 | 3749 #define XWEAK_BOX(x) XRECORD (x, weak_box, struct weak_box) |
| 3750 #define XSET_WEAK_BOX(x, v) (XWEAK_BOX (x)->value = (v)) | |
| 3751 #define wrap_weak_box(p) wrap_record (p, weak_box) | |
| 3752 #define WEAK_BOXP(x) RECORDP (x, weak_box) | |
| 3753 #define CHECK_WEAK_BOX(x) CHECK_RECORD (x, weak_box) | |
| 3754 #define CONCHECK_WEAK_BOX(x) CONCHECK_RECORD (x, weak_box) | |
| 3755 | |
| 888 | 3756 /*--------------------------- ephemerons ----------------------------*/ |
| 3757 | |
| 3758 struct ephemeron | |
| 3759 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3760 NORMAL_LISP_OBJECT_HEADER header; |
| 888 | 3761 |
| 3762 Lisp_Object key; | |
| 3763 | |
| 3764 /* This field holds a pair. The cdr of this cons points to the next | |
| 3765 ephemeron in Vall_ephemerons. The car points to another pair | |
| 3766 whose car is the value and whose cdr is the finalizer. | |
| 3767 | |
| 3768 This representation makes it very easy to unlink an ephemeron | |
| 3769 from Vall_ephemerons and chain it into | |
| 3770 Vall_ephemerons_to_finalize. */ | |
| 3771 | |
| 3772 Lisp_Object cons_chain; | |
| 3773 | |
| 3774 Lisp_Object value; | |
| 3775 }; | |
| 3776 | |
| 3777 void prune_ephemerons (void); | |
| 3778 Lisp_Object ephemeron_value(Lisp_Object ephi); | |
| 1590 | 3779 void init_marking_ephemerons(void); |
| 3780 int continue_marking_ephemerons(void); | |
| 888 | 3781 int finish_marking_ephemerons(void); |
| 3782 Lisp_Object zap_finalize_list(void); | |
| 3783 Lisp_Object make_ephemeron(Lisp_Object key, Lisp_Object value, Lisp_Object finalizer); | |
| 3784 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3785 DECLARE_LISP_OBJECT(ephemeron, struct ephemeron); |
| 888 | 3786 #define XEPHEMERON(x) XRECORD (x, ephemeron, struct ephemeron) |
| 3787 #define XEPHEMERON_REF(x) (XEPHEMERON (x)->value) | |
| 3788 #define XEPHEMERON_NEXT(x) (XCDR (XEPHEMERON(x)->cons_chain)) | |
| 3789 #define XEPHEMERON_FINALIZER(x) (XCDR (XCAR (XEPHEMERON (x)->cons_chain))) | |
| 3790 #define XSET_EPHEMERON_NEXT(x, n) (XSETCDR (XEPHEMERON(x)->cons_chain, n)) | |
| 3791 #define XSET_EPHEMERON_VALUE(x, v) (XEPHEMERON(x)->value = (v)) | |
| 3792 #define XSET_EPHEMERON_KEY(x, k) (XEPHEMERON(x)->key = (k)) | |
| 3793 #define wrap_ephemeron(p) wrap_record (p, ephemeron) | |
| 3794 #define EPHEMERONP(x) RECORDP (x, ephemeron) | |
| 3795 #define CHECK_EPHEMERON(x) CHECK_RECORD (x, ephemeron) | |
| 3796 #define CONCHECK_EPHEMERON(x) CONCHECK_RECORD (x, ephemeron) | |
| 3797 | |
| 858 | 3798 |
| 442 | 3799 /*---------------------------- weak lists ------------------------------*/ |
| 428 | 3800 |
| 3801 enum weak_list_type | |
| 3802 { | |
| 3803 /* element disappears if it's unmarked. */ | |
| 3804 WEAK_LIST_SIMPLE, | |
| 3805 /* element disappears if it's a cons and either its car or | |
| 3806 cdr is unmarked. */ | |
| 3807 WEAK_LIST_ASSOC, | |
| 3808 /* element disappears if it's a cons and its car is unmarked. */ | |
| 3809 WEAK_LIST_KEY_ASSOC, | |
| 3810 /* element disappears if it's a cons and its cdr is unmarked. */ | |
| 442 | 3811 WEAK_LIST_VALUE_ASSOC, |
| 3812 /* element disappears if it's a cons and neither its car nor | |
| 3813 its cdr is marked. */ | |
| 3814 WEAK_LIST_FULL_ASSOC | |
| 428 | 3815 }; |
| 3816 | |
| 3817 struct weak_list | |
| 3818 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3819 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 3820 Lisp_Object list; /* don't mark through this! */ |
| 3821 enum weak_list_type type; | |
| 3822 Lisp_Object next_weak; /* don't mark through this! */ | |
| 3823 }; | |
| 3824 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3825 DECLARE_LISP_OBJECT (weak_list, struct weak_list); |
| 428 | 3826 #define XWEAK_LIST(x) XRECORD (x, weak_list, struct weak_list) |
| 617 | 3827 #define wrap_weak_list(p) wrap_record (p, weak_list) |
| 428 | 3828 #define WEAK_LISTP(x) RECORDP (x, weak_list) |
| 3829 #define CHECK_WEAK_LIST(x) CHECK_RECORD (x, weak_list) | |
| 3830 #define CONCHECK_WEAK_LIST(x) CONCHECK_RECORD (x, weak_list) | |
| 3831 | |
| 3832 #define weak_list_list(w) ((w)->list) | |
| 3833 #define XWEAK_LIST_LIST(w) (XWEAK_LIST (w)->list) | |
| 3834 | |
| 3835 Lisp_Object make_weak_list (enum weak_list_type type); | |
| 3836 /* The following two are only called by the garbage collector */ | |
| 3837 int finish_marking_weak_lists (void); | |
| 3838 void prune_weak_lists (void); | |
| 3839 | |
| 1743 | 3840 END_C_DECLS |
| 428 | 3841 |
| 3842 /************************************************************************/ | |
| 3843 /* Definitions of primitive Lisp functions and variables */ | |
| 3844 /************************************************************************/ | |
| 3845 | |
| 3846 | |
| 3847 /* DEFUN - Define a built-in Lisp-visible C function or `subr'. | |
| 3848 `lname' should be the name to give the function in Lisp, | |
| 3849 as a null-terminated C string. | |
| 3850 `Fname' should be the C equivalent of `lname', using only characters | |
| 3851 valid in a C identifier, with an "F" prepended. | |
| 3852 The name of the C constant structure that records information | |
| 3853 on this function for internal use is "S" concatenated with Fname. | |
| 3854 `min_args' should be a number, the minimum number of arguments allowed. | |
| 3855 `max_args' should be a number, the maximum number of arguments allowed, | |
| 3856 or else MANY or UNEVALLED. | |
| 3857 MANY means pass a vector of evaluated arguments, | |
| 3858 in the form of an integer number-of-arguments | |
| 3859 followed by the address of a vector of Lisp_Objects | |
| 3860 which contains the argument values. | |
| 3861 UNEVALLED means pass the list of unevaluated arguments. | |
| 3862 `prompt' says how to read arguments for an interactive call. | |
| 3863 See the doc string for `interactive'. | |
| 3864 A null string means call interactively with no arguments. | |
| 3865 `arglist' are the comma-separated arguments (always Lisp_Objects) for | |
| 3866 the function. | |
| 3867 The docstring for the function is placed as a "C" comment between | |
| 3868 the prompt and the `args' argument. make-docfile reads the | |
| 3869 comment and creates the DOC file from it. | |
| 3870 */ | |
| 3871 | |
| 3872 #define EXFUN_0 void | |
| 3873 #define EXFUN_1 Lisp_Object | |
| 3874 #define EXFUN_2 Lisp_Object,Lisp_Object | |
| 3875 #define EXFUN_3 Lisp_Object,Lisp_Object,Lisp_Object | |
| 3876 #define EXFUN_4 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object | |
| 3877 #define EXFUN_5 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object | |
| 3878 #define EXFUN_6 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3879 Lisp_Object | |
| 3880 #define EXFUN_7 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3881 Lisp_Object,Lisp_Object | |
| 3882 #define EXFUN_8 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3883 Lisp_Object,Lisp_Object,Lisp_Object | |
| 3884 #define EXFUN_MANY int, Lisp_Object* | |
| 3885 #define EXFUN_UNEVALLED Lisp_Object | |
| 3886 #define EXFUN(sym, max_args) Lisp_Object sym (EXFUN_##max_args) | |
| 2268 | 3887 #define EXFUN_NORETURN(sym, max_args) \ |
| 3888 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, sym (EXFUN_##max_args)) | |
| 428 | 3889 |
| 3890 #define SUBR_MAX_ARGS 8 | |
| 3891 #define MANY -2 | |
| 3892 #define UNEVALLED -1 | |
| 3893 | |
| 3894 /* Can't be const, because then subr->doc is read-only and | |
| 3895 Snarf_documentation chokes */ | |
| 3896 | |
| 3263 | 3897 #ifdef NEW_GC |
| 2720 | 3898 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3899 Lisp_Object Fname (EXFUN_##max_args); \ | |
| 3900 static struct Lisp_Subr MC_ALLOC_S##Fname = \ | |
| 3901 { \ | |
| 3902 { /* struct lrecord_header */ \ | |
| 3903 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3904 1, /* lisp_readonly bit */ \ | |
| 3905 0, /* free */ \ | |
| 3906 0 /* uid */ \ | |
| 3907 }, \ | |
| 3908 min_args, \ | |
| 3909 max_args, \ | |
| 3910 prompt, \ | |
| 3911 0, /* doc string */ \ | |
| 3912 lname, \ | |
| 3913 (lisp_fn_t) Fname \ | |
| 3914 }; \ | |
| 2814 | 3915 static struct Lisp_Subr *S##Fname; \ |
| 2720 | 3916 Lisp_Object Fname (DEFUN_##max_args arglist) |
| 3917 | |
| 3918 #define DEFUN_NORETURN(lname, Fname, min_args, max_args, prompt, arglist) \ | |
| 3919 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, Fname (EXFUN_##max_args)); \ | |
| 3920 static struct Lisp_Subr MC_ALLOC_S##Fname = \ | |
| 3921 { \ | |
| 3922 { /* struct lrecord_header */ \ | |
| 3923 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3924 1, /* lisp_readonly bit */ \ | |
| 3925 0, /* free */ \ | |
| 3926 0 /* uid */ \ | |
| 3927 }, \ | |
| 3928 min_args, \ | |
| 3929 max_args, \ | |
| 3930 prompt, \ | |
| 3931 0, /* doc string */ \ | |
| 3932 lname, \ | |
| 3933 (lisp_fn_t) Fname \ | |
| 3934 }; \ | |
| 2814 | 3935 static struct Lisp_Subr *S##Fname; \ |
| 2720 | 3936 DOESNT_RETURN_TYPE (Lisp_Object) Fname (DEFUN_##max_args arglist) |
| 2834 | 3937 #define GET_DEFUN_LISP_OBJECT(Fname) \ |
| 3938 wrap_subr (S##Fname); | |
| 3263 | 3939 #else /* not NEW_GC */ |
| 428 | 3940 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3941 Lisp_Object Fname (EXFUN_##max_args); \ | |
| 442 | 3942 static struct Lisp_Subr S##Fname = \ |
| 3943 { \ | |
| 3944 { /* struct lrecord_header */ \ | |
| 3945 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3946 1, /* mark bit */ \ | |
| 3947 1, /* c_readonly bit */ \ | |
| 1111 | 3948 1, /* lisp_readonly bit */ \ |
| 442 | 3949 }, \ |
| 3950 min_args, \ | |
| 3951 max_args, \ | |
| 3952 prompt, \ | |
| 3953 0, /* doc string */ \ | |
| 3954 lname, \ | |
| 3955 (lisp_fn_t) Fname \ | |
| 3956 }; \ | |
| 428 | 3957 Lisp_Object Fname (DEFUN_##max_args arglist) |
| 3958 | |
| 2268 | 3959 #define DEFUN_NORETURN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3960 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, Fname (EXFUN_##max_args)); \ | |
| 3961 static struct Lisp_Subr S##Fname = \ | |
| 3962 { \ | |
| 3963 { /* struct lrecord_header */ \ | |
| 3964 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3965 1, /* mark bit */ \ | |
| 3966 1, /* c_readonly bit */ \ | |
| 3967 1, /* lisp_readonly bit */ \ | |
| 3968 }, \ | |
| 3969 min_args, \ | |
| 3970 max_args, \ | |
| 3971 prompt, \ | |
| 3972 0, /* doc string */ \ | |
| 3973 lname, \ | |
| 3974 (lisp_fn_t) Fname \ | |
| 3975 }; \ | |
| 3976 DOESNT_RETURN_TYPE (Lisp_Object) Fname (DEFUN_##max_args arglist) | |
| 2834 | 3977 #define GET_DEFUN_LISP_OBJECT(Fname) \ |
| 3978 wrap_subr (&S##Fname); | |
| 3263 | 3979 #endif /* not NEW_GC */ |
| 2268 | 3980 |
| 428 | 3981 /* Heavy ANSI C preprocessor hackery to get DEFUN to declare a |
| 3982 prototype that matches max_args, and add the obligatory | |
| 3983 `Lisp_Object' type declaration to the formal C arguments. */ | |
| 3984 | |
| 3985 #define DEFUN_MANY(named_int, named_Lisp_Object) named_int, named_Lisp_Object | |
| 3986 #define DEFUN_UNEVALLED(args) Lisp_Object args | |
| 3987 #define DEFUN_0() void | |
| 3988 #define DEFUN_1(a) Lisp_Object a | |
| 3989 #define DEFUN_2(a,b) DEFUN_1(a), Lisp_Object b | |
| 3990 #define DEFUN_3(a,b,c) DEFUN_2(a,b), Lisp_Object c | |
| 3991 #define DEFUN_4(a,b,c,d) DEFUN_3(a,b,c), Lisp_Object d | |
| 3992 #define DEFUN_5(a,b,c,d,e) DEFUN_4(a,b,c,d), Lisp_Object e | |
| 3993 #define DEFUN_6(a,b,c,d,e,f) DEFUN_5(a,b,c,d,e), Lisp_Object f | |
| 3994 #define DEFUN_7(a,b,c,d,e,f,g) DEFUN_6(a,b,c,d,e,f), Lisp_Object g | |
| 3995 #define DEFUN_8(a,b,c,d,e,f,g,h) DEFUN_7(a,b,c,d,e,f,g),Lisp_Object h | |
| 3996 | |
| 3997 /* WARNING: If you add defines here for higher values of max_args, | |
| 3998 make sure to also fix the clauses in PRIMITIVE_FUNCALL(), | |
| 3999 and change the define of SUBR_MAX_ARGS above. */ | |
| 4000 | |
| 4001 #include "symeval.h" | |
| 4002 | |
| 1743 | 4003 BEGIN_C_DECLS |
| 1650 | 4004 |
| 428 | 4005 /* `specpdl' is the special binding/unwind-protect stack. |
| 4006 | |
| 4007 Knuth says (see the Jargon File): | |
| 4008 At MIT, `pdl' [abbreviation for `Push Down List'] used to | |
| 4009 be a more common synonym for `stack'. | |
| 4010 Everywhere else `stack' seems to be the preferred term. | |
| 4011 | |
| 4012 specpdl_depth is the current depth of `specpdl'. | |
| 771 | 4013 Save this for use later as arg to `unbind_to_1'. */ |
| 1632 | 4014 extern MODULE_API int specpdl_depth_counter; |
| 428 | 4015 #define specpdl_depth() specpdl_depth_counter |
| 4016 | |
| 442 | 4017 |
| 4018 #define CHECK_FUNCTION(fun) do { \ | |
| 4019 while (NILP (Ffunctionp (fun))) \ | |
| 4020 signal_invalid_function_error (fun); \ | |
| 4021 } while (0) | |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4022 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4023 /************************************************************************/ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4024 /* Parsing keyword arguments */ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4025 /************************************************************************/ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4026 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4027 /* The C subr must have been declared with MANY as its max args, and this |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4028 PARSE_KEYWORDS call must come before any statements. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4029 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4030 FUNCTION is the name of the current function, as a symbol. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4031 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4032 NARGS is the count of arguments supplied to FUNCTION. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4033 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4034 ARGS is a pointer to the argument vector (not a Lisp vector) supplied to |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4035 FUNCTION. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4036 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4037 KEYWORDS_OFFSET is the offset into ARGS where the keyword arguments start. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4038 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4039 KEYWORD_COUNT is the number of keywords FUNCTION is normally prepared to |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4040 handle. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4041 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4042 KEYWORDS is a parenthesised list of those keywords, without the initial |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4043 Q_. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4044 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4045 KEYWORD_DEFAULTS allows you to set non-nil defaults. Put (keywordname = |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4046 initial_value) in this parameter, a collection of C statements surrounded |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4047 by parentheses and separated by the comma operator. If you don't need |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4048 this, supply NULL as KEYWORD_DEFAULTS. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4049 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4050 ALLOW_OTHER_KEYS corresponds to the &allow-other-keys argument list |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4051 entry in defun*; it is 1 if other keys are normally allowed, 0 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4052 otherwise. This may be overridden in the caller by specifying |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4053 :allow-other-keys t in the argument list. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4054 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4055 For keywords which appear multiple times in the called argument list, the |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4056 leftmost one overrides, as specified in section 7.1.1 of the CLHS. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4057 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4058 If you want to check whether a given keyword argument was set (as in the |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4059 SVAR argument to defun*), supply Qunbound as its default in |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4060 KEYWORD_DEFAULTS, and examine it once PARSE_KEYWORDS is done. Lisp code |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4061 cannot supply Qunbound as an argument, so if it is still Qunbound, it was |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4062 not set. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4063 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4064 There is no elegant way with this macro to have one name for the keyword |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4065 and an unrelated name for the local variable, as is possible with the |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4066 ((:keyword unrelated-var)) syntax in defun* and in Common Lisp. That |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4067 shouldn't matter in practice. */ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4068 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4069 #define PARSE_KEYWORDS(function, nargs, args, keywords_offset, \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4070 keyword_count, keywords, keyword_defaults, \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4071 allow_other_keys) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4072 DECLARE_N_KEYWORDS_##keyword_count keywords; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4073 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4074 do \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4075 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4076 Lisp_Object pk_key, pk_value; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4077 Elemcount pk_i = nargs - 1; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4078 Boolint pk_allow_other_keys = allow_other_keys; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4079 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4080 if ((nargs - keywords_offset) & 1) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4081 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4082 if (!allow_other_keys \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4083 && !(pk_allow_other_keys \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4084 = non_nil_allow_other_keys_p (keywords_offset, \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4085 nargs, args))) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4086 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4087 signal_wrong_number_of_arguments_error (function, nargs); \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4088 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4089 else \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4090 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4091 /* Ignore the trailing arg; so below always sees an even \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4092 number of arguments. */ \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4093 pk_i -= 1; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4094 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4095 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4096 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4097 (void)(keyword_defaults); \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4098 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4099 /* Start from the end, because the leftmost element overrides. */ \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4100 while (pk_i > keywords_offset) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4101 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4102 pk_value = args[pk_i--]; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4103 pk_key = args[pk_i--]; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4104 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4105 if (0) {} \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4106 CHECK_N_KEYWORDS_##keyword_count keywords \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4107 else if (allow_other_keys || pk_allow_other_keys) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4108 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4109 continue; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4110 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4111 else if (!(pk_allow_other_keys \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4112 = non_nil_allow_other_keys_p (keywords_offset, \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4113 nargs, args))) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4114 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4115 invalid_keyword_argument (function, pk_key); \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4116 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4117 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4118 } while (0) |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4119 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4120 #define DECLARE_N_KEYWORDS_1(a) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4121 Lisp_Object a = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4122 #define DECLARE_N_KEYWORDS_2(a,b) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4123 DECLARE_N_KEYWORDS_1(a), b = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4124 #define DECLARE_N_KEYWORDS_3(a,b,c) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4125 DECLARE_N_KEYWORDS_2(a,b), c = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4126 #define DECLARE_N_KEYWORDS_4(a,b,c,d) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4127 DECLARE_N_KEYWORDS_3(a,b,c), d = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4128 #define DECLARE_N_KEYWORDS_5(a,b,c,d,e) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4129 DECLARE_N_KEYWORDS_4(a,b,c,d), e = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4130 #define DECLARE_N_KEYWORDS_6(a,b,c,d,e,f) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4131 DECLARE_N_KEYWORDS_5(a,b,c,d,e), f = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4132 #define DECLARE_N_KEYWORDS_7(a,b,c,d,e,f,g) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4133 DECLARE_N_KEYWORDS_6(a,b,c,d,e,f), g = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4134 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4135 #define CHECK_N_KEYWORDS_1(a) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4136 else if (EQ (pk_key, Q_##a)) { a = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4137 #define CHECK_N_KEYWORDS_2(a,b) CHECK_N_KEYWORDS_1(a) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4138 else if (EQ (pk_key, Q_##b)) { b = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4139 #define CHECK_N_KEYWORDS_3(a,b,c) CHECK_N_KEYWORDS_2(a,b) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4140 else if (EQ (pk_key, Q_##c)) { c = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4141 #define CHECK_N_KEYWORDS_4(a,b,c,d) CHECK_N_KEYWORDS_3(a,b,c) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4142 else if (EQ (pk_key, Q_##d)) { d = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4143 #define CHECK_N_KEYWORDS_5(a,b,c,d,e) CHECK_N_KEYWORDS_4(a,b,c,d) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4144 else if (EQ (pk_key, Q_##e)) { e = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4145 #define CHECK_N_KEYWORDS_6(a,b,c,d,e,f) CHECK_N_KEYWORDS_5(a,b,c,d,e) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4146 else if (EQ (pk_key, Q_##f)) { f = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4147 #define CHECK_N_KEYWORDS_7(a,b,c,d,e,f,g) CHECK_N_KEYWORDS_6(a,b,c,d,e,f) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4148 else if (EQ (pk_key, Q_##g)) { g = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4149 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4150 Boolint non_nil_allow_other_keys_p (Elemcount offset, int nargs, |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4151 Lisp_Object *args); |
| 442 | 4152 |
| 428 | 4153 |
| 4154 /************************************************************************/ | |
| 4155 /* Checking for QUIT */ | |
| 4156 /************************************************************************/ | |
| 4157 | |
| 1123 | 4158 /* NOTE NOTE NOTE: Invoking QUIT can cause random Lisp code to be executed! |
| 4159 This can happen in numerous ways. For example, on many platforms, QUIT | |
| 4160 needs to drain the event queue to see whether there's a C-g in the works. | |
| 4161 A side effect of this is that, if there's a menu-press event, menu filters | |
| 4162 (i.e. Lisp code) will be invoked. Lisp code could also happen if there's | |
| 4163 an asynchronous timeout, or if the debugger is invoked as a result of | |
| 4164 debug-on-quit and the user returns by hitting `r', etc. etc. | |
| 4165 | |
| 4166 However, GC CANNOT HAPPEN. It is forbidden everywhere within the QUIT- | |
| 4167 processing code, because most callers cannot tolerate GC during QUIT | |
| 4168 since it's just too prevalent. */ | |
| 4169 | |
| 853 | 4170 /* The exact workings of this mechanism are described in detail in signal.c. */ |
| 4171 | |
| 428 | 4172 /* Asynchronous events set something_happened, and then are processed |
| 4173 within the QUIT macro. At this point, we are guaranteed to not be in | |
| 4174 any sensitive code. */ | |
| 4175 | |
| 1632 | 4176 extern MODULE_API volatile int something_happened; |
| 4177 extern MODULE_API int dont_check_for_quit; | |
| 4178 MODULE_API void check_what_happened (void); | |
| 4179 | |
| 4180 extern MODULE_API volatile int quit_check_signal_happened; | |
| 428 | 4181 extern volatile int quit_check_signal_tick_count; |
| 1632 | 4182 MODULE_API void check_quit (void); |
| 4183 | |
| 4184 MODULE_API void signal_quit (void); | |
| 428 | 4185 |
| 853 | 4186 int begin_dont_check_for_quit (void); |
| 4187 int begin_do_check_for_quit (void); | |
| 4188 | |
| 4189 /* Nonzero if the values of `quit-flag' and `inhibit-quit' indicate | |
| 4190 that a quit should be signalled. */ | |
| 771 | 4191 #define QUIT_FLAG_SAYS_SHOULD_QUIT \ |
| 4192 (!NILP (Vquit_flag) && \ | |
| 4193 (NILP (Vinhibit_quit) \ | |
| 4194 || (EQ (Vquit_flag, Qcritical) && !dont_check_for_quit))) | |
| 4195 | |
| 853 | 4196 /* Nonzero if ought to quit now. This is the "efficient" version, which |
| 4197 respects the flags set to indicate whether the full quit check should | |
| 4198 be done. Therefore it may be inaccurate (i.e. lagging reality), esp. | |
| 4199 when poll for quit is used. | |
| 4200 | |
| 4201 This is defined for code that wants to allow quitting, but needs to | |
| 4202 do some cleanup if that happens. (You could always register the cleanup | |
| 4203 code using record_unwind_protect(), but sometimes it makes more sense | |
| 4204 to do it using QUITP.) To use this macro, just call it at the | |
| 4205 appropriate time, and if its value is non-zero, do your cleanup code | |
| 4206 and then call QUIT. | |
| 4207 | |
| 4208 A different version (below) is used for the actual QUIT macro. */ | |
| 428 | 4209 #define QUITP \ |
| 853 | 4210 ((quit_check_signal_happened ? check_quit () : (void) 0), \ |
| 771 | 4211 QUIT_FLAG_SAYS_SHOULD_QUIT) |
| 428 | 4212 |
| 853 | 4213 /* This is the version actually called by QUIT. The difference |
| 4214 between it and QUITP is that it also has side effects in that it | |
| 4215 will handle anything else that has recently signalled itself | |
| 4216 asynchronously and wants to be handled now. Currently this | |
| 4217 includes executing asynchronous timeouts that may have been set | |
| 4218 from Lisp or from the poll-for-quit or poll-for-sigchld | |
| 4219 timers. (#### It seems that, to be slightly more accurate, we | |
| 4220 should also process poll-for-quit timers in the above version. | |
| 4221 However, this mechanism is inherently approximate, so it really | |
| 4222 doesn't matter much.) In the future, it might also include doing a | |
| 4223 thread context switch. Callers of QUITP generally don't except | |
| 1123 | 4224 random side effects to happen (#### unfortunately, random side effects |
| 4225 can happen anyway, e.g. through menu filters -- see comment above), | |
| 4226 so we have this different version. */ | |
| 428 | 4227 #define INTERNAL_QUITP \ |
| 853 | 4228 ((something_happened ? check_what_happened () : (void) 0), \ |
| 771 | 4229 QUIT_FLAG_SAYS_SHOULD_QUIT) |
| 428 | 4230 |
| 4231 /* Check quit-flag and quit if it is non-nil. Also do any other things | |
| 853 | 4232 that are triggered by asynchronous events and might want to be |
| 4233 handled. */ | |
| 428 | 4234 #define QUIT do { if (INTERNAL_QUITP) signal_quit (); } while (0) |
| 4235 | |
| 4236 | |
| 4237 /************************************************************************/ | |
| 4238 /* hashing */ | |
| 4239 /************************************************************************/ | |
| 4240 | |
| 4241 /* #### for a 64-bit machine, we should substitute a prime just over 2^32 */ | |
| 4242 #define GOOD_HASH 65599 /* prime number just over 2^16; Dragon book, p. 435 */ | |
| 4243 #define HASH2(a,b) (GOOD_HASH * (a) + (b)) | |
| 4244 #define HASH3(a,b,c) (GOOD_HASH * HASH2 (a,b) + (c)) | |
| 4245 #define HASH4(a,b,c,d) (GOOD_HASH * HASH3 (a,b,c) + (d)) | |
| 4246 #define HASH5(a,b,c,d,e) (GOOD_HASH * HASH4 (a,b,c,d) + (e)) | |
| 4247 #define HASH6(a,b,c,d,e,f) (GOOD_HASH * HASH5 (a,b,c,d,e) + (f)) | |
| 4248 #define HASH7(a,b,c,d,e,f,g) (GOOD_HASH * HASH6 (a,b,c,d,e,f) + (g)) | |
| 4249 #define HASH8(a,b,c,d,e,f,g,h) (GOOD_HASH * HASH7 (a,b,c,d,e,f,g) + (h)) | |
| 4250 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i)) | |
| 4251 | |
| 5013 | 4252 #define LISP_HASH(obj) ((unsigned long) STORE_LISP_IN_VOID (obj)) |
| 2516 | 4253 Hashcode memory_hash (const void *xv, Bytecount size); |
| 4254 Hashcode internal_hash (Lisp_Object obj, int depth); | |
| 4255 Hashcode internal_array_hash (Lisp_Object *arr, int size, int depth); | |
| 428 | 4256 |
| 4257 | |
| 4258 /************************************************************************/ | |
| 4259 /* String translation */ | |
| 4260 /************************************************************************/ | |
| 4261 | |
| 771 | 4262 /* When support for message translation exists, GETTEXT() translates a |
| 4263 string from English into the language defined by | |
| 4264 `current-language-environment'. This is done by looking the string | |
| 4265 up in a large predefined table; if no translation is found, the | |
| 4266 original string is returned, and the failure is possibly logged so | |
| 4267 that the translation can later be entered into the table. | |
| 4268 | |
| 4269 In addition to this, there is a mechanism to snarf message strings | |
| 4270 out of the source code so that they can be entered into the tables. | |
| 4271 This is what make-msgfile.lex does. | |
| 4272 | |
| 4273 Handling `format' strings is more difficult: The format string | |
| 4274 should get translated, but not under all circumstances. When the | |
| 4275 format string is a Lisp string, what should happen is that | |
| 4276 Fformat() should format the untranslated args[0] and return that, | |
| 4277 and also call Fgettext() on args[0] and, if that is different, | |
| 4278 format it and store it in the `string-translatable' property of the | |
| 4279 returned string. See Fgettext(). | |
| 4280 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4281 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
|
4282 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
|
4283 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
|
4284 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
|
4285 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
|
4286 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
|
4287 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4288 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
|
4289 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
|
4290 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
|
4291 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
|
4292 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
|
4293 build_msg_ascstring(). |
| 771 | 4294 */ |
| 4295 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4296 /* 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
|
4297 translated into a foreign language. */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4298 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
|
4299 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4300 ASSERT_ASCTEXT_ASCII (s); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4301 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4302 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4303 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4304 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
|
4305 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4306 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4307 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4308 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4309 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
|
4310 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4311 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4312 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4313 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4314 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
|
4315 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4316 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4317 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4318 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4319 #define GETTEXT ASCGETTEXT |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4320 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4321 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
|
4322 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
|
4323 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
|
4324 #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
|
4325 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4326 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4327 /* 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
|
4328 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
|
4329 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
|
4330 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
|
4331 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
|
4332 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
|
4333 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
|
4334 during message snarfing (see above). |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4335 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4336 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
|
4337 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
|
4338 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
|
4339 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
|
4340 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
|
4341 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
|
4342 this property). |
| 428 | 4343 */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4344 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4345 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
|
4346 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4347 ASSERT_ASCTEXT_ASCII (s); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4348 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4349 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4350 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4351 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
|
4352 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4353 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4354 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4355 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4356 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
|
4357 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4358 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4359 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4360 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4361 #define DEFER_GETTEXT DEFER_ASCGETTEXT |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4362 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4363 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
|
4364 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
|
4365 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
|
4366 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4367 #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
|
4368 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4369 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4370 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
|
4371 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
|
4372 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
|
4373 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4374 #define write_msg_string write_msg_ascstring |
| 428 | 4375 |
| 4376 | |
| 4377 /************************************************************************/ | |
| 4378 /* Garbage collection / GC-protection */ | |
| 4379 /************************************************************************/ | |
| 4380 | |
| 4381 /* Structure for recording stack slots that need marking */ | |
| 4382 | |
| 4383 /* This is a chain of structures, each of which points at a Lisp_Object | |
| 4384 variable whose value should be marked in garbage collection. | |
| 4385 Normally every link of the chain is an automatic variable of a function, | |
| 4386 and its `val' points to some argument or local variable of the function. | |
| 4387 On exit to the function, the chain is set back to the value it had on | |
| 4388 entry. This way, no link remains in the chain when the stack frame | |
| 4389 containing the link disappears. | |
| 4390 | |
| 4391 Every function that can call Feval must protect in this fashion all | |
| 4392 Lisp_Object variables whose contents will be used again. */ | |
| 4393 | |
| 1632 | 4394 extern MODULE_API struct gcpro *gcprolist; |
| 428 | 4395 |
| 1743 | 4396 END_C_DECLS |
| 1650 | 4397 |
| 1204 | 4398 /* #### Catching insufficient gcpro: |
| 4399 | |
| 4400 The C++ code below catches GCPRO without UNGCPRO or vice-versa. | |
| 4401 Catching cases where there's no GCPRO or UNGCPRO but should be, however, | |
| 4402 is much harder, but could be done: | |
| 4403 | |
| 4404 1. Lisp_Object becomes a real object. Its creator and destructor need to | |
| 4405 figure out whether the object is on the stack (by looking at the range | |
| 4406 that `this' is within), and if so, add the pointer to a list of all | |
| 4407 stack-based Lisp_Objects. | |
| 4408 | |
| 4409 2. The assignment method needs to do reference-counting on actual Lisp | |
| 4410 objects -- in particular, we need to know if there are any references | |
| 4411 to a Lisp object that are *NOT* from stack-based Lisp_Objects. | |
| 4412 | |
| 4413 3. When we get to a point in the code where we might garbage collect -- | |
| 4414 i.e. Ffuncall(), Feval(), or Fgarbage_collect() is called -- we look | |
| 4415 at our list of stack-based Lisp_Objects, and if there are any that | |
| 4416 point to Lisp objects with no non-stack references, see if there are | |
| 4417 any gcpros pointing to the object, and if not, set a flag indicating | |
| 4418 that the object is "destroyed". (Don't abort yet because the function | |
| 4419 might not use the object any more.) | |
| 4420 | |
| 4421 4. When we detag a pointer using XFOO(), abort if its "destroyed" flag | |
| 4422 is set. | |
| 4423 | |
| 4424 --ben | |
| 4425 */ | |
| 4426 | |
| 428 | 4427 struct gcpro |
| 4428 { | |
| 4429 struct gcpro *next; | |
| 771 | 4430 const Lisp_Object *var; /* Address of first protected variable */ |
| 428 | 4431 int nvars; /* Number of consecutive protected variables */ |
| 1204 | 4432 #if defined (__cplusplus) && defined (ERROR_CHECK_GC) |
| 4433 /* Try to catch GCPRO without UNGCPRO, or vice-versa. G++ complains (at | |
| 4434 least with sufficient numbers of warnings enabled, i.e. -Weffc++) if a | |
| 4435 copy constructor or assignment operator is not defined. */ | |
| 4436 gcpro () : next (0), var (0), nvars (0) { } | |
| 4437 gcpro (const gcpro& g) : next (g.next), var (g.var), nvars (g.nvars) { } | |
| 4438 gcpro& operator= (const gcpro& g) { next = g.next; var = g.var; | |
| 4439 nvars = g.nvars; | |
| 4440 return *this;} | |
| 4441 ~gcpro () { assert (!next); } | |
| 4442 #endif /* defined (__cplusplus) && defined (ERROR_CHECK_GC) */ | |
| 428 | 4443 }; |
| 4444 | |
| 4445 /* Normally, you declare variables gcpro1, gcpro2, ... and use the | |
| 4446 GCPROn() macros. However, if you need to have nested gcpro's, | |
| 4447 declare ngcpro1, ngcpro2, ... and use NGCPROn(). If you need | |
| 4448 to nest another level, use nngcpro1, nngcpro2, ... and use | |
| 4449 NNGCPROn(). If you need to nest yet another level, create | |
| 4450 the appropriate macros. */ | |
| 4451 | |
| 1123 | 4452 /* NOTE: About comments like "This function does not GC": These are there to |
| 4453 try to track whether GCPROing is necessary. Strictly speaking, some | |
| 4454 functions that say this might actually GC, but only when it is never | |
| 4455 possible to return (more specifically, in the process of signalling an | |
| 4456 error, the debugger may be invoked, and could GC). For GCPRO purposes, | |
| 4457 you only have to worry about functions that can GC and then return. | |
| 4458 The QUIT macro cannot GC any more, although this wasn't true at some point, | |
| 4459 and so some "This function can GC" comments may be inaccurate. | |
| 4460 */ | |
| 4461 | |
| 1743 | 4462 BEGIN_C_DECLS |
| 1650 | 4463 |
| 2367 | 4464 #define XGCDECL1(x) struct gcpro x##cpro1 |
| 4465 #define XGCDECL2(x) struct gcpro x##cpro1, x##cpro2 | |
| 4466 #define XGCDECL3(x) struct gcpro x##cpro1, x##cpro2, x##cpro3 | |
| 4467 #define XGCDECL4(x) struct gcpro x##cpro1, x##cpro2, x##cpro3, x##cpro4 | |
| 4468 #define XGCDECL5(x) struct gcpro x##cpro1, x##cpro2, x##cpro3, x##cpro4, x##cpro5 | |
| 4469 | |
| 428 | 4470 #ifdef DEBUG_GCPRO |
| 4471 | |
| 2367 | 4472 MODULE_API void debug_gcpro1 (Ascbyte *, int, struct gcpro *, Lisp_Object *); |
| 4473 MODULE_API void debug_gcpro2 (Ascbyte *, int, struct gcpro *, struct gcpro *, | |
| 1632 | 4474 Lisp_Object *, Lisp_Object *); |
| 2367 | 4475 MODULE_API void debug_gcpro3 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4476 struct gcpro *, Lisp_Object *, Lisp_Object *, |
| 4477 Lisp_Object *); | |
| 2367 | 4478 MODULE_API void debug_gcpro4 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4479 struct gcpro *, struct gcpro *, Lisp_Object *, |
| 4480 Lisp_Object *, Lisp_Object *, Lisp_Object *); | |
| 2367 | 4481 MODULE_API void debug_gcpro5 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4482 struct gcpro *, struct gcpro *, struct gcpro *, |
| 4483 Lisp_Object *, Lisp_Object *, Lisp_Object *, | |
| 4484 Lisp_Object *, Lisp_Object *); | |
| 2367 | 4485 MODULE_API void debug_ungcpro(Ascbyte *, int, struct gcpro *); |
| 4486 | |
| 4487 #define XGCPRO1(x,v) \ | |
| 4488 debug_gcpro1 (__FILE__, __LINE__,&x##cpro1,&v) | |
| 4489 #define XGCPRO2(x,v1,v2) \ | |
| 4490 debug_gcpro2 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&v1,&v2) | |
| 4491 #define XGCPRO3(x,v1,v2,v3) \ | |
| 4492 debug_gcpro3 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4493 &v1,&v2,&v3) | |
| 4494 #define XGCPRO4(x,v1,v2,v3,v4) \ | |
| 4495 debug_gcpro4 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4496 &x##cpro4, \ | |
| 428 | 4497 &v1,&v2,&v3,&v4) |
| 2367 | 4498 #define XGCPRO5(x,v1,v2,v3,v4,v5) \ |
| 4499 debug_gcpro5 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4500 &x##cpro4,&x##cpro5, \ | |
| 428 | 4501 &v1,&v2,&v3,&v4,&v5) |
| 2367 | 4502 #define XUNGCPRO(x) \ |
| 4503 debug_ungcpro(__FILE__, __LINE__,&x##cpro1) | |
| 428 | 4504 |
| 4505 #else /* ! DEBUG_GCPRO */ | |
| 4506 | |
| 2367 | 4507 #define XGCPRO1(x, var1) ((void) ( \ |
| 4508 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4509 gcprolist = &x##cpro1 )) | |
| 4510 | |
| 4511 #define XGCPRO2(x, var1, var2) ((void) ( \ | |
| 4512 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4513 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4514 gcprolist = &x##cpro2 )) | |
| 4515 | |
| 4516 #define XGCPRO3(x, var1, var2, var3) ((void) ( \ | |
| 4517 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4518 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4519 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4520 gcprolist = &x##cpro3 )) | |
| 4521 | |
| 4522 #define XGCPRO4(x, var1, var2, var3, var4) ((void) ( \ | |
| 4523 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4524 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4525 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4526 x##cpro4.next = &x##cpro3, x##cpro4.var = &var4, x##cpro4.nvars = 1, \ | |
| 4527 gcprolist = &x##cpro4 )) | |
| 4528 | |
| 4529 #define XGCPRO5(x, var1, var2, var3, var4, var5) ((void) ( \ | |
| 4530 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4531 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4532 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4533 x##cpro4.next = &x##cpro3, x##cpro4.var = &var4, x##cpro4.nvars = 1, \ | |
| 4534 x##cpro5.next = &x##cpro4, x##cpro5.var = &var5, x##cpro5.nvars = 1, \ | |
| 4535 gcprolist = &x##cpro5 )) | |
| 4536 | |
| 4537 #define XGCPRO1_ARRAY(x, array, n) ((void) ( \ | |
| 4538 x##cpro1.next = gcprolist, x##cpro1.var = array, x##cpro1.nvars = n, \ | |
| 4539 gcprolist = &x##cpro1 )) | |
| 4540 | |
| 4541 #define XGCPRO2_ARRAY(x, array1, n1, array2, n2) ((void) ( \ | |
| 4542 x##cpro1.next = gcprolist, x##cpro1.var = array1, x##cpro1.nvars = n1, \ | |
| 4543 x##cpro2.next = &x##cpro1, x##cpro2.var = array2, x##cpro2.nvars = n2, \ | |
| 4544 gcprolist = &x##cpro2 )) | |
| 4545 | |
| 4546 #define XGCPRO3_ARRAY(x, array1, n1, array2, n2, array3, n3) ((void) ( \ | |
| 4547 x##cpro1.next = gcprolist, x##cpro1.var = array1, x##cpro1.nvars = n1, \ | |
| 4548 x##cpro2.next = &x##cpro1, x##cpro2.var = array2, x##cpro2.nvars = n2, \ | |
| 4549 x##cpro3.next = &x##cpro2, x##cpro3.var = array3, x##cpro3.nvars = n3, \ | |
| 4550 gcprolist = &x##cpro3 )) | |
| 853 | 4551 |
| 1204 | 4552 #if defined (__cplusplus) && defined (ERROR_CHECK_GC) |
| 4553 /* We need to reset each gcpro to avoid triggering the assert() in | |
| 4554 ~gcpro(). This happens in UNGCPRO and longjmp(). */ | |
| 4555 #define UNWIND_GCPRO_TO(val) \ | |
| 4556 do \ | |
| 4557 { \ | |
| 4558 struct gcpro *__gcpro_stop = (val); \ | |
| 4559 /* Try to catch UNGCPRO without GCPRO. We arrange for there to be a \ | |
| 4560 sentinel at the end of the gcprolist, so it should never be NULL. */ \ | |
| 4561 assert (__gcpro_stop); \ | |
| 4562 while (gcprolist != __gcpro_stop) \ | |
| 4563 { \ | |
| 4564 struct gcpro *__gcpro_next = gcprolist->next; \ | |
| 4565 gcprolist->next = 0; \ | |
| 4566 gcprolist = __gcpro_next; \ | |
| 4567 assert (gcprolist); \ | |
| 4568 } \ | |
| 4569 } while (0) | |
| 4570 #else | |
| 4571 #define UNWIND_GCPRO_TO(val) (gcprolist = (val)) | |
| 4572 #endif /* defined (__cplusplus) && defined (ERROR_CHECK_GC) */ | |
| 4573 | |
| 2367 | 4574 #define XUNGCPRO(x) UNWIND_GCPRO_TO (x##cpro1.next) |
| 428 | 4575 |
| 4576 #endif /* ! DEBUG_GCPRO */ | |
| 4577 | |
| 2367 | 4578 #define GCDECL1 XGCDECL1 (g) |
| 4579 #define GCDECL2 XGCDECL2 (g) | |
| 4580 #define GCDECL3 XGCDECL3 (g) | |
| 4581 #define GCDECL4 XGCDECL4 (g) | |
| 4582 #define GCDECL5 XGCDECL5 (g) | |
| 4583 | |
| 4584 #define GCPRO1(a) XGCPRO1 (g,a) | |
| 4585 #define GCPRO2(a,b) XGCPRO2 (g,a,b) | |
| 4586 #define GCPRO3(a,b,c) XGCPRO3 (g,a,b,c) | |
| 4587 #define GCPRO4(a,b,c,d) XGCPRO4 (g,a,b,c,d) | |
| 4588 #define GCPRO5(a,b,c,d,e) XGCPRO5 (g,a,b,c,d,e) | |
| 4589 | |
| 4590 #define GCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(g,a1,n1) | |
| 4591 #define GCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (g,a1,n1,a2,n2) | |
| 4592 #define GCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (g,a1,n1,a2,n2,a3,n3) | |
| 4593 | |
| 4594 #define UNGCPRO XUNGCPRO (g) | |
| 4595 | |
| 4596 #define NGCDECL1 XGCDECL1 (ng) | |
| 4597 #define NGCDECL2 XGCDECL2 (ng) | |
| 4598 #define NGCDECL3 XGCDECL3 (ng) | |
| 4599 #define NGCDECL4 XGCDECL4 (ng) | |
| 4600 #define NGCDECL5 XGCDECL5 (ng) | |
| 4601 | |
| 4602 #define NGCPRO1(a) XGCPRO1 (ng,a) | |
| 4603 #define NGCPRO2(a,b) XGCPRO2 (ng,a,b) | |
| 4604 #define NGCPRO3(a,b,c) XGCPRO3 (ng,a,b,c) | |
| 4605 #define NGCPRO4(a,b,c,d) XGCPRO4 (ng,a,b,c,d) | |
| 4606 #define NGCPRO5(a,b,c,d,e) XGCPRO5 (ng,a,b,c,d,e) | |
| 4607 | |
| 4608 #define NGCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(ng,a1,n1) | |
| 4609 #define NGCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (ng,a1,n1,a2,n2) | |
| 4610 #define NGCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (ng,a1,n1,a2,n2,a3,n3) | |
| 4611 | |
| 4612 #define NUNGCPRO XUNGCPRO (ng) | |
| 4613 | |
| 4614 #define NNGCDECL1 XGCDECL1 (nng) | |
| 4615 #define NNGCDECL2 XGCDECL2 (nng) | |
| 4616 #define NNGCDECL3 XGCDECL3 (nng) | |
| 4617 #define NNGCDECL4 XGCDECL4 (nng) | |
| 4618 #define NNGCDECL5 XGCDECL5 (nng) | |
| 4619 | |
| 4620 #define NNGCPRO1(a) XGCPRO1 (nng,a) | |
| 4621 #define NNGCPRO2(a,b) XGCPRO2 (nng,a,b) | |
| 4622 #define NNGCPRO3(a,b,c) XGCPRO3 (nng,a,b,c) | |
| 4623 #define NNGCPRO4(a,b,c,d) XGCPRO4 (nng,a,b,c,d) | |
| 4624 #define NNGCPRO5(a,b,c,d,e) XGCPRO5 (nng,a,b,c,d,e) | |
| 4625 | |
| 4626 #define NNGCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(nng,a1,n1) | |
| 4627 #define NNGCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (nng,a1,n1,a2,n2) | |
| 4628 #define NNGCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (nng,a1,n1,a2,n2,a3,n3) | |
| 4629 | |
| 4630 #define NNUNGCPRO XUNGCPRO (nng) | |
| 4631 | |
| 428 | 4632 /* Evaluate expr, UNGCPRO, and then return the value of expr. */ |
| 4633 #define RETURN_UNGCPRO(expr) do \ | |
| 4634 { \ | |
| 4635 Lisp_Object ret_ungc_val = (expr); \ | |
| 4636 UNGCPRO; \ | |
| 4637 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4638 } while (0) | |
| 4639 | |
| 4640 /* Evaluate expr, NUNGCPRO, UNGCPRO, and then return the value of expr. */ | |
| 4641 #define RETURN_NUNGCPRO(expr) do \ | |
| 4642 { \ | |
| 4643 Lisp_Object ret_ungc_val = (expr); \ | |
| 4644 NUNGCPRO; \ | |
| 4645 UNGCPRO; \ | |
| 4646 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4647 } while (0) | |
| 4648 | |
| 4649 /* Evaluate expr, NNUNGCPRO, NUNGCPRO, UNGCPRO, and then return the | |
| 4650 value of expr. */ | |
| 4651 #define RETURN_NNUNGCPRO(expr) do \ | |
| 4652 { \ | |
| 4653 Lisp_Object ret_ungc_val = (expr); \ | |
| 4654 NNUNGCPRO; \ | |
| 4655 NUNGCPRO; \ | |
| 4656 UNGCPRO; \ | |
| 4657 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4658 } while (0) | |
| 4659 | |
| 452 | 4660 extern Lisp_Object_ptr_dynarr *staticpros; |
| 3092 | 4661 extern Lisp_Object_ptr_dynarr *staticpros_nodump; |
| 771 | 4662 #ifdef DEBUG_XEMACS |
| 4663 | |
| 4664 /* Help debug crashes gc-marking a staticpro'ed object. */ | |
| 4665 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4666 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
|
4667 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
|
4668 #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
|
4669 #define staticpro_nodump(ptr) staticpro_nodump_1 (ptr, #ptr) |
| 771 | 4670 |
| 996 | 4671 #ifdef HAVE_SHLIB |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4672 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
|
4673 #define unstaticpro_nodump(ptr) unstaticpro_nodump_1 (ptr, #ptr) |
| 996 | 4674 #endif |
| 4675 | |
| 771 | 4676 #else |
| 611 | 4677 |
| 428 | 4678 /* Call staticpro (&var) to protect static variable `var'. */ |
| 1632 | 4679 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
|
4680 /* 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
|
4681 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
|
4682 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
|
4683 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
|
4684 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
|
4685 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
|
4686 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
|
4687 out of the variable name. */ |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4688 #define staticpro_1(ptr, name) staticpro (ptr) |
| 428 | 4689 |
| 4690 /* Call staticpro_nodump (&var) to protect static variable `var'. */ | |
| 4691 /* var will not be saved at dump time */ | |
| 1632 | 4692 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
|
4693 #define staticpro_nodump_1(ptr, name) staticpro_nodump (ptr) |
| 428 | 4694 |
| 996 | 4695 #ifdef HAVE_SHLIB |
| 4696 /* Call unstaticpro_nodump (&var) to stop protecting static variable `var'. */ | |
| 1632 | 4697 MODULE_API void unstaticpro_nodump (Lisp_Object *); |
| 996 | 4698 #endif |
| 4699 | |
| 771 | 4700 #endif |
| 4701 | |
| 3263 | 4702 #ifdef NEW_GC |
| 2720 | 4703 extern Lisp_Object_dynarr *mcpros; |
| 4704 #ifdef DEBUG_XEMACS | |
| 4705 /* 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
|
4706 MODULE_API void mcpro_1 (Lisp_Object, const Ascbyte *); |
| 2720 | 4707 #define mcpro(ptr) mcpro_1 (ptr, #ptr) |
| 4708 #else /* not DEBUG_XEMACS */ | |
| 4709 /* Call mcpro (&var) to protect mc variable `var'. */ | |
| 4710 MODULE_API void mcpro (Lisp_Object); | |
| 4711 #endif /* not DEBUG_XEMACS */ | |
| 3263 | 4712 #endif /* NEW_GC */ |
| 2720 | 4713 |
| 771 | 4714 void register_post_gc_action (void (*fun) (void *), void *arg); |
| 4715 int begin_gc_forbidden (void); | |
| 4716 void end_gc_forbidden (int count); | |
| 1957 | 4717 extern int gc_currently_forbidden; |
| 771 | 4718 |
| 1743 | 4719 END_C_DECLS |
| 1650 | 4720 |
| 771 | 4721 |
| 4722 /************************************************************************/ | |
| 4723 /* Misc definitions */ | |
| 4724 /************************************************************************/ | |
| 442 | 4725 |
| 4726 /************************************************************************/ | |
| 1983 | 4727 /* Other numeric types */ |
| 4728 /************************************************************************/ | |
| 4729 #include "number.h" | |
| 4730 | |
| 4731 | |
| 4732 /************************************************************************/ | |
| 442 | 4733 /* prototypes */ |
| 4734 /************************************************************************/ | |
| 4735 | |
| 4736 /* NOTE: Prototypes should go HERE, not in various header files, unless | |
| 4737 they specifically reference a type that's not defined in lisp.h. | |
| 4738 (And even then, you might consider adding the type to lisp.h.) | |
| 4739 | |
| 4740 The idea is that header files typically contain the innards of objects, | |
| 4741 and we want to minimize the number of "dependencies" of one file on | |
| 4742 the specifics of such objects. Putting prototypes here minimizes the | |
| 4743 number of header files that need to be included -- good for a number | |
| 4744 of reasons. --ben */ | |
| 4745 | |
| 4746 /* Prototypes for all init/syms_of/vars_of initialization functions. */ | |
| 4747 #include "symsinit.h" | |
| 4748 | |
| 1743 | 4749 BEGIN_C_DECLS |
| 1650 | 4750 |
| 826 | 4751 /* Defined in abbrev.c */ |
| 1632 | 4752 MODULE_API EXFUN (Fexpand_abbrev, 0); |
| 826 | 4753 |
| 428 | 4754 /* Defined in alloc.c */ |
| 1632 | 4755 MODULE_API EXFUN (Fcons, 2); |
| 4756 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
|
4757 EXFUN (Fbit_vector, MANY); |
| 826 | 4758 EXFUN (Fmake_byte_code, MANY); |
| 1632 | 4759 MODULE_API EXFUN (Fmake_list, 2); |
| 4760 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
|
4761 EXFUN (Fstring, MANY); |
| 1632 | 4762 MODULE_API EXFUN (Fmake_symbol, 1); |
| 4763 MODULE_API EXFUN (Fmake_vector, 2); | |
| 4764 MODULE_API EXFUN (Fvector, MANY); | |
| 826 | 4765 |
|
5146
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5143
diff
changeset
|
4766 void deadbeef_memory (void *ptr, Bytecount size); |
| 3263 | 4767 #ifndef NEW_GC |
| 428 | 4768 void release_breathing_space (void); |
| 3263 | 4769 #endif /* not NEW_GC */ |
| 428 | 4770 Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object); |
| 1632 | 4771 MODULE_API Lisp_Object make_vector (Elemcount, Lisp_Object); |
| 4772 MODULE_API Lisp_Object vector1 (Lisp_Object); | |
| 4773 MODULE_API Lisp_Object vector2 (Lisp_Object, Lisp_Object); | |
| 4774 MODULE_API Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 665 | 4775 Lisp_Object make_bit_vector (Elemcount, Lisp_Object); |
| 4776 Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, Elemcount); | |
| 428 | 4777 Lisp_Object noseeum_make_marker (void); |
| 3092 | 4778 #ifndef NEW_GC |
| 428 | 4779 void garbage_collect_1 (void); |
| 3092 | 4780 #endif /* not NEW_GC */ |
| 1632 | 4781 MODULE_API Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object); |
| 4782 MODULE_API Lisp_Object cons3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4783 MODULE_API Lisp_Object list1 (Lisp_Object); | |
| 4784 MODULE_API Lisp_Object list2 (Lisp_Object, Lisp_Object); | |
| 4785 MODULE_API Lisp_Object list3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4786 MODULE_API Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4787 Lisp_Object); | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4788 MODULE_API Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, |
| 1632 | 4789 Lisp_Object, Lisp_Object); |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4790 MODULE_API Lisp_Object list6 (Lisp_Object, Lisp_Object, Lisp_Object, |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4791 Lisp_Object, Lisp_Object, Lisp_Object); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4792 MODULE_API Lisp_Object listn (int numargs, ...); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4793 MODULE_API Lisp_Object listu (Lisp_Object, ...); |
| 428 | 4794 DECLARE_DOESNT_RETURN (memory_full (void)); |
| 4795 void disksave_object_finalization (void); | |
| 4796 extern int purify_flag; | |
| 3092 | 4797 #ifndef NEW_GC |
| 428 | 4798 extern EMACS_INT gc_generation_number[1]; |
| 3092 | 4799 #endif /* not NEW_GC */ |
| 428 | 4800 int c_readonly (Lisp_Object); |
| 4801 int lisp_readonly (Lisp_Object); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
4802 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
|
4803 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
|
4804 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
|
4805 MODULE_API Lisp_Object build_extstring (const Extbyte *, Lisp_Object); |
| 1632 | 4806 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
|
4807 MODULE_API Lisp_Object make_extstring (const Extbyte *, EMACS_INT, Lisp_Object); |
| 771 | 4808 void init_string_ascii_begin (Lisp_Object string); |
| 428 | 4809 Lisp_Object make_uninit_string (Bytecount); |
| 1632 | 4810 MODULE_API Lisp_Object make_float (double); |
| 867 | 4811 Lisp_Object make_string_nocopy (const Ibyte *, Bytecount); |
| 853 | 4812 void free_cons (Lisp_Object); |
| 428 | 4813 void free_list (Lisp_Object); |
| 4814 void free_alist (Lisp_Object); | |
| 1204 | 4815 void free_marker (Lisp_Object); |
| 428 | 4816 int object_dead_p (Lisp_Object); |
| 4817 void mark_object (Lisp_Object obj); | |
| 3092 | 4818 #ifndef NEW_GC |
| 1598 | 4819 #ifdef USE_KKCC |
| 2645 | 4820 #ifdef DEBUG_XEMACS |
| 4821 void kkcc_gc_stack_push_lisp_object_1 (Lisp_Object obj, int level, int pos); | |
| 4822 #define kkcc_gc_stack_push_lisp_object(obj, level, pos) \ | |
| 4823 kkcc_gc_stack_push_lisp_object_1 (obj, level, pos) | |
| 4824 void kkcc_backtrace (void); | |
| 4825 #else | |
| 4826 void kkcc_gc_stack_push_lisp_object_1 (Lisp_Object obj); | |
| 4827 #define kkcc_gc_stack_push_lisp_object(obj, level, pos) \ | |
| 4828 kkcc_gc_stack_push_lisp_object_1 (obj) | |
| 4829 #define kkcc_backtrace() | |
| 4830 #endif | |
| 1598 | 4831 #endif /* USE_KKCC */ |
| 3092 | 4832 #endif /* not NEW_GC */ |
| 428 | 4833 int marked_p (Lisp_Object obj); |
| 851 | 4834 extern int funcall_allocation_flag; |
| 814 | 4835 extern int need_to_garbage_collect; |
| 1632 | 4836 extern MODULE_API int need_to_check_c_alloca; |
| 888 | 4837 extern int need_to_signal_post_gc; |
| 1333 | 4838 extern Lisp_Object Qpost_gc_hook, Qgarbage_collecting; |
| 851 | 4839 void recompute_funcall_allocation_flag (void); |
| 428 | 4840 |
| 4841 #ifdef MEMORY_USAGE_STATS | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4842 Bytecount malloced_storage_size (void *, Bytecount, struct usage_stats *); |
| 665 | 4843 Bytecount fixed_type_block_overhead (Bytecount); |
| 428 | 4844 #endif |
| 1204 | 4845 |
| 4846 #ifdef EVENT_DATA_AS_OBJECTS | |
| 4847 Lisp_Object make_key_data (void); | |
| 4848 Lisp_Object make_button_data (void); | |
| 4849 Lisp_Object make_motion_data (void); | |
| 4850 Lisp_Object make_process_data (void); | |
| 4851 Lisp_Object make_timeout_data (void); | |
| 4852 Lisp_Object make_magic_data (void); | |
| 4853 Lisp_Object make_magic_eval_data (void); | |
| 4854 Lisp_Object make_eval_data (void); | |
| 4855 Lisp_Object make_misc_user_data (void); | |
| 4856 void free_key_data (Lisp_Object); | |
| 4857 void free_button_data (Lisp_Object); | |
| 4858 void free_motion_data (Lisp_Object); | |
| 4859 void free_process_data (Lisp_Object); | |
| 4860 void free_timeout_data (Lisp_Object); | |
| 4861 void free_magic_data (Lisp_Object); | |
| 4862 void free_magic_eval_data (Lisp_Object); | |
| 4863 void free_eval_data (Lisp_Object); | |
| 4864 void free_misc_user_data (Lisp_Object); | |
| 4865 #endif /* EVENT_DATA_AS_OBJECTS */ | |
| 934 | 4866 |
| 428 | 4867 /* Defined in buffer.c */ |
| 4868 Lisp_Object get_truename_buffer (Lisp_Object); | |
| 4869 void switch_to_buffer (Lisp_Object, Lisp_Object); | |
| 4870 extern int find_file_compare_truenames; | |
| 4871 extern int find_file_use_truenames; | |
| 867 | 4872 Ibyte *get_initial_directory (Ibyte *pathname, Bytecount size); |
| 771 | 4873 void set_buffer_internal (struct buffer *b); |
| 4874 struct buffer *decode_buffer (Lisp_Object buffer, int allow_string); | |
| 4875 | |
| 4876 void record_buffer (Lisp_Object buf); | |
| 4877 Lisp_Object get_buffer (Lisp_Object name, | |
| 4878 int error_if_deleted_or_does_not_exist); | |
| 4879 int map_over_sharing_buffers (struct buffer *buf, | |
| 4880 int (*mapfun) (struct buffer *buf, | |
| 4881 void *closure), | |
| 4882 void *closure); | |
| 1204 | 4883 void cleanup_buffer_undo_lists (void); |
| 771 | 4884 |
| 4885 extern struct buffer *current_buffer; | |
| 4886 | |
| 4887 extern void init_initial_directory (void); /* initialize initial_directory */ | |
| 4888 | |
| 4889 EXFUN (Fbuffer_disable_undo, 1); | |
| 1632 | 4890 MODULE_API EXFUN (Fbuffer_modified_p, 1); |
| 4891 MODULE_API EXFUN (Fbuffer_name, 1); | |
| 4892 MODULE_API EXFUN (Fcurrent_buffer, 0); | |
| 771 | 4893 EXFUN (Ferase_buffer, 1); |
| 4894 EXFUN (Fget_buffer, 1); | |
| 4895 EXFUN (Fget_buffer_create, 1); | |
| 4896 EXFUN (Fget_file_buffer, 1); | |
| 1632 | 4897 MODULE_API EXFUN (Fkill_buffer, 1); |
| 771 | 4898 EXFUN (Fother_buffer, 3); |
| 4899 EXFUN (Frecord_buffer, 1); | |
| 1632 | 4900 MODULE_API EXFUN (Fset_buffer, 1); |
| 771 | 4901 EXFUN (Fset_buffer_modified_p, 2); |
| 4902 | |
| 4903 extern Lisp_Object QSscratch, Qafter_change_function, Qafter_change_functions; | |
| 4904 extern Lisp_Object Qbefore_change_function, Qbefore_change_functions; | |
| 4905 extern Lisp_Object Qbuffer_or_string_p, Qdefault_directory, Qfirst_change_hook; | |
| 4906 extern Lisp_Object Qpermanent_local, Vafter_change_function; | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4907 extern Lisp_Object Qbuffer_live_p; |
| 771 | 4908 extern Lisp_Object Vafter_change_functions, Vbefore_change_function; |
| 4909 extern Lisp_Object Vbefore_change_functions, Vbuffer_alist, Vbuffer_defaults; | |
| 4910 extern Lisp_Object Vinhibit_read_only, Vtransient_mark_mode; | |
| 428 | 4911 |
| 563 | 4912 /* Defined in bytecode.c */ |
| 826 | 4913 EXFUN (Fbyte_code, 3); |
| 4914 | |
| 593 | 4915 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
|
4916 (const Ascbyte *reason, Lisp_Object frob)); |
| 563 | 4917 |
| 4932 | 4918 extern Lisp_Object Qbyte_code, Qinvalid_byte_code; |
| 563 | 4919 |
| 826 | 4920 /* Defined in callint.c */ |
| 4921 EXFUN (Fcall_interactively, 3); | |
| 4922 EXFUN (Fprefix_numeric_value, 1); | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4923 extern Lisp_Object Qcall_interactively; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4924 extern Lisp_Object Qmouse_leave_buffer_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4925 extern Lisp_Object Qread_from_minibuffer; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4926 extern Lisp_Object Vcommand_history; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4927 extern Lisp_Object Vcurrent_prefix_arg; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4928 extern Lisp_Object Vmark_even_if_inactive; |
| 826 | 4929 |
| 4930 /* Defined in casefiddle.c */ | |
| 4931 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
|
4932 EXFUN (Fcanoncase, 2); |
| 826 | 4933 EXFUN (Fupcase, 2); |
| 4934 EXFUN (Fupcase_initials, 2); | |
| 4935 EXFUN (Fupcase_initials_region, 3); | |
| 4936 EXFUN (Fupcase_region, 3); | |
| 4937 | |
| 4938 /* Defined in casetab.c */ | |
| 4939 EXFUN (Fset_standard_case_table, 1); | |
| 4940 | |
| 4941 /* Defined in chartab.c */ | |
| 4942 EXFUN (Freset_char_table, 1); | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4943 extern Lisp_Object Qcategory_designator_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4944 extern Lisp_Object Qcategory_table_value_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4945 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4946 /* Defined in cmdloop.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4947 extern Lisp_Object Qdisabled_command_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4948 extern Lisp_Object Qreally_early_error_handler; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4949 extern Lisp_Object Qtop_level; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4950 extern Lisp_Object Vdisabled_command_hook; |
| 826 | 4951 |
| 4952 /* Defined in cmds.c */ | |
| 4953 EXFUN (Fbeginning_of_line, 2); | |
| 4954 EXFUN (Fend_of_line, 2); | |
| 4955 EXFUN (Fforward_char, 2); | |
| 4956 EXFUN (Fforward_line, 2); | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4957 extern Lisp_Object Qself_insert_command; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4958 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4959 /* Defined in console.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4960 extern Lisp_Object Qconsole_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4961 extern Lisp_Object Vconsole_list; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4962 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4963 /* Defined in console-stream.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4964 extern Lisp_Object Vstdio_str; |
| 826 | 4965 |
| 428 | 4966 /* Defined in data.c */ |
| 826 | 4967 EXFUN (Fadd1, 1); |
| 4968 EXFUN (Faref, 2); | |
| 4969 EXFUN (Faset, 3); | |
| 4970 EXFUN (Fcar, 1); | |
| 4971 EXFUN (Fcar_safe, 1); | |
| 4972 EXFUN (Fcdr, 1); | |
| 919 | 4973 EXFUN (Fcdr_safe, 1); |
| 826 | 4974 EXFUN (Fgeq, MANY); |
| 4975 EXFUN (Fgtr, MANY); | |
| 4976 EXFUN (Findirect_function, 1); | |
| 4977 EXFUN (Fleq, MANY); | |
| 4978 EXFUN (Flistp, 1); | |
| 4979 EXFUN (Flss, MANY); | |
| 4980 EXFUN (Fmax, MANY); | |
| 4981 EXFUN (Fmin, MANY); | |
| 4982 EXFUN (Fminus, MANY); | |
| 4983 EXFUN (Fnumber_to_string, 1); | |
| 4984 EXFUN (Fplus, MANY); | |
| 4985 EXFUN (Fquo, MANY); | |
| 4986 EXFUN (Frem, 2); | |
| 4987 EXFUN (Fsetcar, 2); | |
| 4988 EXFUN (Fsetcdr, 2); | |
| 4989 EXFUN (Fsub1, 1); | |
| 4990 EXFUN (Fsubr_max_args, 1); | |
| 4991 EXFUN (Fsubr_min_args, 1); | |
| 4992 EXFUN (Ftimes, MANY); | |
| 4993 | |
| 428 | 4994 DECLARE_DOESNT_RETURN (c_write_error (Lisp_Object)); |
| 4995 DECLARE_DOESNT_RETURN (lisp_write_error (Lisp_Object)); | |
| 4996 DECLARE_DOESNT_RETURN (args_out_of_range (Lisp_Object, Lisp_Object)); | |
| 4997 DECLARE_DOESNT_RETURN (args_out_of_range_3 (Lisp_Object, Lisp_Object, | |
| 4998 Lisp_Object)); | |
| 1632 | 4999 MODULE_API Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object); |
| 5000 MODULE_API | |
| 428 | 5001 DECLARE_DOESNT_RETURN (dead_wrong_type_argument (Lisp_Object, Lisp_Object)); |
| 5002 void check_int_range (EMACS_INT, EMACS_INT, EMACS_INT); | |
| 5003 | |
| 771 | 5004 EXFUN (Fint_to_char, 1); |
| 5005 EXFUN (Fchar_to_int, 1); | |
| 5006 | |
| 428 | 5007 enum arith_comparison { |
| 5008 arith_equal, | |
| 5009 arith_notequal, | |
| 5010 arith_less, | |
| 5011 arith_grtr, | |
| 5012 arith_less_or_equal, | |
| 5013 arith_grtr_or_equal }; | |
| 5014 Lisp_Object arithcompare (Lisp_Object, Lisp_Object, enum arith_comparison); | |
| 5015 | |
| 707 | 5016 /* Do NOT use word_to_lisp or wasteful_word_to_lisp to decode time_t's |
| 5017 unless you KNOW arg is non-negative. They cannot return negative | |
| 5018 values! Use make_time. */ | |
| 428 | 5019 Lisp_Object word_to_lisp (unsigned int); |
| 5020 unsigned int lisp_to_word (Lisp_Object); | |
| 5021 | |
| 4932 | 5022 extern Lisp_Object Qarrayp, Qbitp, Qchar_or_string_p, Qcharacterp, |
| 5023 Qerror_conditions, Qerror_message, Qinteger_char_or_marker_p, | |
| 5024 Qinteger_or_char_p, Qinteger_or_marker_p, Qlambda, Qlistp, Qnatnump, | |
| 5025 Qnonnegativep, Qnumber_char_or_marker_p, Qnumberp, Qquote, Qtrue_list_p; | |
| 5026 extern MODULE_API Lisp_Object Qintegerp; | |
| 5027 | |
| 5028 extern Lisp_Object Qarith_error, Qbeginning_of_buffer, Qbuffer_read_only, | |
| 5029 Qcircular_list, Qcircular_property_list, Qconversion_error, | |
| 5030 Qcyclic_variable_indirection, Qdomain_error, Qediting_error, | |
| 5031 Qend_of_buffer, Qend_of_file, Qerror, Qfile_error, Qinternal_error, | |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
5032 Qinvalid_change, Qinvalid_constant, Qinvalid_function, |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
5033 Qinvalid_keyword_argument, Qinvalid_operation, |
| 4932 | 5034 Qinvalid_read_syntax, Qinvalid_state, Qio_error, Qlist_formation_error, |
| 5035 Qmalformed_list, Qmalformed_property_list, Qno_catch, Qout_of_memory, | |
| 5036 Qoverflow_error, Qprinting_unreadable_object, Qquit, Qrange_error, | |
| 5037 Qsetting_constant, Qsingularity_error, Qstack_overflow, | |
| 5038 Qstructure_formation_error, Qtext_conversion_error, Qunderflow_error, | |
| 5039 Qvoid_function, Qvoid_variable, Qwrong_number_of_arguments, | |
| 5040 Qwrong_type_argument; | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5041 extern Lisp_Object Qcdr; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5042 extern Lisp_Object Qerror_lacks_explanatory_string; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5043 extern Lisp_Object Qfile_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5044 extern Lisp_Object Qsequencep; |
| 4932 | 5045 extern MODULE_API Lisp_Object Qinvalid_argument, Qsyntax_error; |
| 5046 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5047 /* Defined in device.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5048 extern Lisp_Object Qdevice_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5049 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5050 /* Defined in device-x.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5051 extern Lisp_Object Vx_initial_argv_list; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5052 |
| 428 | 5053 /* Defined in dired.c */ |
| 867 | 5054 Lisp_Object make_directory_hash_table (const Ibyte *); |
| 428 | 5055 Lisp_Object wasteful_word_to_lisp (unsigned int); |
| 5056 | |
| 5057 /* Defined in doc.c */ | |
| 826 | 5058 EXFUN (Fsubstitute_command_keys, 1); |
| 5059 | |
| 814 | 5060 Lisp_Object unparesseuxify_doc_string (int fd, EMACS_INT position, |
| 867 | 5061 Ibyte *name_nonreloc, |
| 814 | 5062 Lisp_Object name_reloc, |
| 5063 int standard_doc_file); | |
| 428 | 5064 Lisp_Object read_doc_string (Lisp_Object); |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5065 extern Lisp_Object Vinternal_doc_file_name; |
| 428 | 5066 |
| 5067 /* Defined in doprnt.c */ | |
| 867 | 5068 Bytecount emacs_doprnt_va (Lisp_Object stream, const Ibyte *format_nonreloc, |
| 771 | 5069 Bytecount format_length, Lisp_Object format_reloc, |
| 5070 va_list vargs); | |
| 867 | 5071 Bytecount emacs_doprnt (Lisp_Object stream, const Ibyte *format_nonreloc, |
| 771 | 5072 Bytecount format_length, Lisp_Object format_reloc, |
| 5073 int nargs, const Lisp_Object *largs, ...); | |
| 867 | 5074 Lisp_Object emacs_vsprintf_string_lisp (const CIbyte *format_nonreloc, |
| 771 | 5075 Lisp_Object format_reloc, int nargs, |
| 5076 const Lisp_Object *largs); | |
| 867 | 5077 Lisp_Object emacs_sprintf_string_lisp (const CIbyte *format_nonreloc, |
| 771 | 5078 Lisp_Object format_reloc, int nargs, ...); |
| 867 | 5079 Ibyte *emacs_vsprintf_malloc_lisp (const CIbyte *format_nonreloc, |
| 771 | 5080 Lisp_Object format_reloc, int nargs, |
| 5081 const Lisp_Object *largs, | |
| 5082 Bytecount *len_out); | |
| 867 | 5083 Ibyte *emacs_sprintf_malloc_lisp (Bytecount *len_out, |
| 5084 const CIbyte *format_nonreloc, | |
| 771 | 5085 Lisp_Object format_reloc, int nargs, ...); |
| 867 | 5086 Lisp_Object emacs_vsprintf_string (const CIbyte *format, va_list vargs); |
| 5087 Lisp_Object emacs_sprintf_string (const CIbyte *format, ...) | |
| 771 | 5088 PRINTF_ARGS (1, 2); |
| 867 | 5089 Ibyte *emacs_vsprintf_malloc (const CIbyte *format, va_list vargs, |
| 771 | 5090 Bytecount *len_out); |
| 867 | 5091 Ibyte *emacs_sprintf_malloc (Bytecount *len_out, const CIbyte *format, ...) |
| 771 | 5092 PRINTF_ARGS (2, 3); |
| 867 | 5093 Bytecount emacs_vsprintf (Ibyte *output, const CIbyte *format, |
| 771 | 5094 va_list vargs); |
| 867 | 5095 Bytecount emacs_sprintf (Ibyte *output, const CIbyte *format, ...) |
| 771 | 5096 PRINTF_ARGS (2, 3); |
| 5097 | |
| 428 | 5098 |
| 5099 /* Defined in editfns.c */ | |
| 826 | 5100 EXFUN (Fbobp, 1); |
| 5101 EXFUN (Fbolp, 1); | |
| 5102 EXFUN (Fbuffer_substring, 3); | |
| 5103 EXFUN (Fchar_after, 2); | |
| 5104 EXFUN (Fchar_to_string, 1); | |
| 5105 EXFUN (Fdelete_region, 3); | |
| 5106 EXFUN (Feobp, 1); | |
| 5107 EXFUN (Feolp, 1); | |
| 5108 EXFUN (Ffollowing_char, 1); | |
| 5109 EXFUN (Fformat, MANY); | |
| 5110 EXFUN (Fgoto_char, 2); | |
| 5111 EXFUN (Finsert, MANY); | |
| 5112 EXFUN (Finsert_buffer_substring, 3); | |
| 5113 EXFUN (Finsert_char, 4); | |
| 5114 EXFUN (Fnarrow_to_region, 3); | |
| 5115 EXFUN (Fpoint, 1); | |
| 5116 EXFUN (Fpoint_marker, 2); | |
| 5117 EXFUN (Fpoint_max, 1); | |
| 5118 EXFUN (Fpoint_min, 1); | |
| 5119 EXFUN (Fpreceding_char, 1); | |
| 5120 EXFUN (Fsystem_name, 0); | |
| 5121 EXFUN (Fuser_home_directory, 0); | |
| 5122 EXFUN (Fuser_login_name, 1); | |
| 5123 EXFUN (Fwiden, 1); | |
| 5124 | |
| 428 | 5125 void uncache_home_directory (void); |
| 867 | 5126 Ibyte *get_home_directory (void); |
| 5127 Ibyte *user_login_name (uid_t *); | |
| 428 | 5128 void buffer_insert1 (struct buffer *, Lisp_Object); |
| 665 | 5129 Lisp_Object make_string_from_buffer (struct buffer *, Charbpos, Charcount); |
| 5130 Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Charbpos, Charcount); | |
| 707 | 5131 Lisp_Object make_time (time_t); |
| 428 | 5132 Lisp_Object save_excursion_save (void); |
| 844 | 5133 Lisp_Object save_restriction_save (struct buffer *buf); |
| 428 | 5134 Lisp_Object save_excursion_restore (Lisp_Object); |
| 5135 Lisp_Object save_restriction_restore (Lisp_Object); | |
| 771 | 5136 void widen_buffer (struct buffer *b, int no_clip); |
| 5137 int beginning_of_line_p (struct buffer *b, Charbpos pt); | |
| 428 | 5138 Lisp_Object save_current_buffer_restore (Lisp_Object); |
| 5139 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5140 extern Lisp_Object Qformat; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5141 extern Lisp_Object Qmark; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5142 extern Lisp_Object Qpoint; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5143 extern Lisp_Object Qregion_beginning; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5144 extern Lisp_Object Qregion_end; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5145 extern Lisp_Object Quser_files_and_directories; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5146 extern Lisp_Object Vsystem_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5147 |
| 428 | 5148 /* Defined in emacs.c */ |
| 2268 | 5149 EXFUN_NORETURN (Fkill_emacs, 1); |
| 826 | 5150 EXFUN (Frunning_temacs_p, 0); |
| 1123 | 5151 EXFUN (Fforce_debugging_signal, 1); |
| 826 | 5152 |
| 428 | 5153 SIGTYPE fatal_error_signal (int); |
| 2367 | 5154 Lisp_Object make_arg_list (int, Wexttext **); |
| 5155 void make_argc_argv (Lisp_Object, int *, Wexttext ***); | |
| 5156 void free_argc_argv (Wexttext **); | |
| 771 | 5157 Lisp_Object split_external_path (const Extbyte *path); |
| 867 | 5158 Lisp_Object split_env_path (const CIbyte *evarname, const Ibyte *default_); |
| 771 | 5159 |
| 428 | 5160 /* Nonzero means don't do interactive redisplay and don't change tty modes */ |
| 442 | 5161 extern int noninteractive, noninteractive1; |
| 2367 | 5162 extern int inhibit_non_essential_conversion_operations; |
| 428 | 5163 extern int preparing_for_armageddon; |
| 458 | 5164 extern Fixnum emacs_priority; |
| 428 | 5165 extern int suppress_early_error_handler_backtrace; |
| 771 | 5166 void debug_break (void); |
| 4854 | 5167 int debug_can_access_memory (const void *ptr, Bytecount len); |
| 2210 | 5168 DECLARE_DOESNT_RETURN (really_abort (void)); |
| 776 | 5169 void zero_out_command_line_status_vars (void); |
| 428 | 5170 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5171 extern Lisp_Object Qsave_buffers_kill_emacs; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5172 extern Lisp_Object Vcommand_line_args; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5173 extern Lisp_Object Vconfigure_info_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5174 extern Lisp_Object Vconfigure_site_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5175 extern Lisp_Object Vconfigure_site_module_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5176 extern Lisp_Object Vdata_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5177 extern Lisp_Object Vdoc_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5178 extern Lisp_Object Vemacs_major_version; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5179 extern Lisp_Object Vemacs_minor_version; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5180 extern Lisp_Object Vexec_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5181 extern Lisp_Object Vexec_path; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5182 extern Lisp_Object Vinvocation_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5183 extern Lisp_Object Vinvocation_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5184 extern Lisp_Object Vmodule_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5185 extern Lisp_Object Vsite_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5186 extern Lisp_Object Vsite_module_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5187 |
| 826 | 5188 /* Defined in emodules.c */ |
| 996 | 5189 #ifdef HAVE_SHLIB |
| 826 | 5190 EXFUN (Flist_modules, 0); |
| 5191 EXFUN (Fload_module, 3); | |
| 996 | 5192 extern int unloading_module; |
| 5193 #endif | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5194 extern Lisp_Object Qdll_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5195 extern Lisp_Object Qmodule; |
| 826 | 5196 |
| 428 | 5197 /* Defined in eval.c */ |
| 1706 | 5198 MODULE_API EXFUN (Fapply, MANY); |
| 826 | 5199 EXFUN (Fbacktrace, 2); |
| 5200 EXFUN (Fcommand_execute, 3); | |
| 5201 EXFUN (Fcommandp, 1); | |
|
4744
17f7e9191c0b
Rationalise duplicated functionality, #'custom-quote, #'quote-maybe.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4690
diff
changeset
|
5202 EXFUN (Fquote_maybe, 1); |
| 1706 | 5203 MODULE_API EXFUN (Feval, 1); |
| 5204 MODULE_API EXFUN (Ffuncall, MANY); | |
| 826 | 5205 EXFUN (Ffunctionp, 1); |
| 5206 EXFUN (Finteractive_p, 0); | |
| 5207 EXFUN (Fprogn, UNEVALLED); | |
| 1706 | 5208 MODULE_API EXFUN (Fsignal, 2); |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
5209 MODULE_API EXFUN_NORETURN (Fthrow, UNEVALLED); |
| 1706 | 5210 MODULE_API EXFUN (Fcall_with_condition_handler, MANY); |
| 853 | 5211 EXFUN (Ffunction_max_args, 1); |
| 5212 EXFUN (Ffunction_min_args, 1); | |
| 826 | 5213 |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
5214 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
|
5215 Lisp_Object, int, |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
5216 Lisp_Object, Lisp_Object)); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
5217 |
| 1632 | 5218 MODULE_API DECLARE_DOESNT_RETURN (signal_error_1 (Lisp_Object, Lisp_Object)); |
| 563 | 5219 void maybe_signal_error_1 (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 5220 Error_Behavior); |
| 563 | 5221 Lisp_Object maybe_signal_continuable_error_1 (Lisp_Object, Lisp_Object, |
| 578 | 5222 Lisp_Object, Error_Behavior); |
| 1743 | 5223 MODULE_API DECLARE_DOESNT_RETURN (signal_ferror (Lisp_Object, const CIbyte *, |
| 5224 ...)) PRINTF_ARGS(2, 3); | |
| 578 | 5225 void maybe_signal_ferror (Lisp_Object, Lisp_Object, Error_Behavior, |
| 867 | 5226 const CIbyte *, ...) PRINTF_ARGS (4, 5); |
| 5227 Lisp_Object signal_continuable_ferror (Lisp_Object, const CIbyte *, ...) | |
| 442 | 5228 PRINTF_ARGS (2, 3); |
| 563 | 5229 Lisp_Object maybe_signal_continuable_ferror (Lisp_Object, Lisp_Object, |
| 578 | 5230 Error_Behavior, |
| 867 | 5231 const CIbyte *, ...) |
| 442 | 5232 PRINTF_ARGS (4, 5); |
| 563 | 5233 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5234 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
|
5235 DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const Ascbyte *, |
| 563 | 5236 Lisp_Object)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5237 void maybe_signal_error (Lisp_Object, const Ascbyte *, Lisp_Object, |
| 578 | 5238 Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5239 Lisp_Object signal_continuable_error (Lisp_Object, const Ascbyte *, |
| 563 | 5240 Lisp_Object); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5241 Lisp_Object maybe_signal_continuable_error (Lisp_Object, const Ascbyte *, |
| 563 | 5242 Lisp_Object, |
| 578 | 5243 Lisp_Object, Error_Behavior); |
| 1743 | 5244 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
|
5245 const Ascbyte *, ...)) |
| 1743 | 5246 PRINTF_ARGS(3, 4); |
| 563 | 5247 void maybe_signal_ferror_with_frob (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 5248 Error_Behavior, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5249 const Ascbyte *, ...) PRINTF_ARGS (5, 6); |
| 563 | 5250 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
|
5251 const Ascbyte *, |
| 563 | 5252 ...) PRINTF_ARGS (3, 4); |
| 5253 Lisp_Object maybe_signal_continuable_ferror_with_frob (Lisp_Object, | |
| 5254 Lisp_Object, | |
| 5255 Lisp_Object, | |
| 578 | 5256 Error_Behavior, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5257 const Ascbyte *, ...) |
| 442 | 5258 PRINTF_ARGS (5, 6); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5259 DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 5260 Lisp_Object, Lisp_Object)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5261 void maybe_signal_error_2 (Lisp_Object, const Ascbyte *, Lisp_Object, |
| 578 | 5262 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
|
5263 Lisp_Object signal_continuable_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 5264 Lisp_Object, Lisp_Object); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5265 Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 5266 Lisp_Object, Lisp_Object, |
| 5267 Lisp_Object, | |
| 578 | 5268 Error_Behavior); |
| 563 | 5269 |
| 5270 | |
| 1927 | 5271 MODULE_API DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object)); |
| 5272 MODULE_API DECLARE_DOESNT_RETURN (signal_malformed_property_list_error | |
| 5273 (Lisp_Object)); | |
| 5274 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object)); | |
| 5275 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_property_list_error | |
| 5276 (Lisp_Object)); | |
| 436 | 5277 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5278 DECLARE_DOESNT_RETURN (syntax_error (const Ascbyte *reason, |
| 609 | 5279 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5280 DECLARE_DOESNT_RETURN (syntax_error_2 (const Ascbyte *reason, |
| 609 | 5281 Lisp_Object frob1, |
| 442 | 5282 Lisp_Object frob2)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5283 void maybe_syntax_error (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 5284 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5285 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
|
5286 DECLARE_DOESNT_RETURN (sferror_2 (const Ascbyte *reason, Lisp_Object frob1, |
| 563 | 5287 Lisp_Object frob2)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5288 void maybe_sferror (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 5289 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5290 MODULE_API DECLARE_DOESNT_RETURN (invalid_argument (const Ascbyte *reason, |
| 1632 | 5291 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5292 MODULE_API DECLARE_DOESNT_RETURN (invalid_argument_2 (const Ascbyte *reason, |
| 1632 | 5293 Lisp_Object frob1, |
| 5294 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5295 void maybe_invalid_argument (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 5296 Error_Behavior); |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
5297 MODULE_API DECLARE_DOESNT_RETURN (invalid_keyword_argument (Lisp_Object fun, |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
5298 Lisp_Object kw)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5299 MODULE_API DECLARE_DOESNT_RETURN (invalid_operation (const Ascbyte *reason, |
| 1632 | 5300 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5301 MODULE_API DECLARE_DOESNT_RETURN (invalid_operation_2 (const Ascbyte *reason, |
| 1632 | 5302 Lisp_Object frob1, |
| 5303 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5304 MODULE_API void maybe_invalid_operation (const Ascbyte *, Lisp_Object, |
| 1632 | 5305 Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5306 DECLARE_DOESNT_RETURN (invalid_state (const Ascbyte *reason, |
| 563 | 5307 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5308 DECLARE_DOESNT_RETURN (invalid_state_2 (const Ascbyte *reason, |
| 563 | 5309 Lisp_Object frob1, |
| 5310 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5311 void maybe_invalid_state (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 609 | 5312 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5313 DECLARE_DOESNT_RETURN (invalid_change (const Ascbyte *reason, |
| 563 | 5314 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5315 DECLARE_DOESNT_RETURN (invalid_change_2 (const Ascbyte *reason, |
| 563 | 5316 Lisp_Object frob1, |
| 5317 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5318 void maybe_invalid_change (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 609 | 5319 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5320 MODULE_API DECLARE_DOESNT_RETURN (invalid_constant (const Ascbyte *reason, |
| 1632 | 5321 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5322 DECLARE_DOESNT_RETURN (invalid_constant_2 (const Ascbyte *reason, |
| 563 | 5323 Lisp_Object frob1, |
| 5324 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5325 void maybe_invalid_constant (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 5326 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5327 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
|
5328 MODULE_API DECLARE_DOESNT_RETURN (out_of_memory (const Ascbyte *reason, |
| 1632 | 5329 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5330 DECLARE_DOESNT_RETURN (stack_overflow (const Ascbyte *reason, |
| 442 | 5331 Lisp_Object frob)); |
| 5332 | |
| 436 | 5333 Lisp_Object signal_void_function_error (Lisp_Object); |
| 5334 Lisp_Object signal_invalid_function_error (Lisp_Object); | |
| 5335 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int); | |
| 5336 | |
| 428 | 5337 Lisp_Object run_hook_with_args_in_buffer (struct buffer *, int, Lisp_Object *, |
| 5338 enum run_hooks_condition); | |
| 5339 Lisp_Object run_hook_with_args (int, Lisp_Object *, enum run_hooks_condition); | |
| 5340 void va_run_hook_with_args (Lisp_Object, int, ...); | |
| 5341 void va_run_hook_with_args_in_buffer (struct buffer *, Lisp_Object, int, ...); | |
| 5342 Lisp_Object run_hook (Lisp_Object); | |
| 1706 | 5343 MODULE_API Lisp_Object apply1 (Lisp_Object, Lisp_Object); |
| 5344 MODULE_API Lisp_Object call0 (Lisp_Object); | |
| 5345 MODULE_API Lisp_Object call1 (Lisp_Object, Lisp_Object); | |
| 5346 MODULE_API Lisp_Object call2 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5347 MODULE_API Lisp_Object call3 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5348 Lisp_Object); | |
| 5349 MODULE_API Lisp_Object call4 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5350 Lisp_Object, Lisp_Object); | |
| 5351 MODULE_API Lisp_Object call5 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5352 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5353 MODULE_API Lisp_Object call6 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5354 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5355 Lisp_Object); | |
| 5356 MODULE_API Lisp_Object call7 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5357 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5358 Lisp_Object, Lisp_Object); | |
| 5359 MODULE_API Lisp_Object call8 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5360 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5361 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 428 | 5362 Lisp_Object call0_in_buffer (struct buffer *, Lisp_Object); |
| 5363 Lisp_Object call1_in_buffer (struct buffer *, Lisp_Object, Lisp_Object); | |
| 5364 Lisp_Object call2_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 5365 Lisp_Object); | |
| 5366 Lisp_Object call3_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 5367 Lisp_Object, Lisp_Object); | |
| 5368 Lisp_Object call4_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 5369 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5370 Lisp_Object call5_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 5371 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5372 Lisp_Object); | |
| 5373 Lisp_Object call6_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 5374 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 5375 Lisp_Object, Lisp_Object); | |
| 5376 Lisp_Object eval_in_buffer (struct buffer *, Lisp_Object); | |
| 853 | 5377 |
| 5378 struct call_trapping_problems_result | |
| 5379 { | |
| 5380 int caught_error, caught_throw; | |
| 5381 Lisp_Object error_conditions, data; | |
| 5382 Lisp_Object backtrace; | |
| 5383 Lisp_Object thrown_tag; | |
| 5384 Lisp_Object thrown_value; | |
| 5385 }; | |
| 5386 | |
| 5387 #define NO_INHIBIT_ERRORS (1<<0) | |
| 5388 #define NO_INHIBIT_THROWS (1<<1) | |
| 5389 #define INTERNAL_INHIBIT_ERRORS (1<<0) | |
| 5390 #define INTERNAL_INHIBIT_THROWS (1<<1) | |
| 5391 #define INHIBIT_WARNING_ISSUE (1<<2) | |
| 5392 #define ISSUE_WARNINGS_AT_DEBUG_LEVEL (1<<3) | |
| 5393 #define INHIBIT_QUIT (1<<4) | |
| 5394 #define UNINHIBIT_QUIT (1<<5) | |
| 5395 #define INHIBIT_GC (1<<6) | |
| 5396 #define INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION (1<<7) | |
| 5397 #define INHIBIT_EXISTING_CODING_SYSTEM_DELETION (1<<8) | |
| 5398 #define INHIBIT_EXISTING_CHARSET_DELETION (1<<9) | |
| 5399 #define INHIBIT_PERMANENT_DISPLAY_OBJECT_CREATION (1<<10) | |
| 5400 #define INHIBIT_CODING_SYSTEM_CREATION (1<<11) | |
| 5401 #define INHIBIT_CHARSET_CREATION (1<<12) | |
| 5402 #define INHIBIT_EXISTING_BUFFER_TEXT_MODIFICATION (1<<13) | |
| 5403 #define INHIBIT_ANY_CHANGE_AFFECTING_REDISPLAY (1<<14) | |
| 5404 #define INHIBIT_ENTERING_DEBUGGER (1<<15) | |
| 5405 #define CALL_WITH_SUSPENDED_ERRORS (1<<16) | |
| 1333 | 5406 #define POSTPONE_WARNING_ISSUE (1<<17) |
| 853 | 5407 |
| 5408 enum check_allowed_operation | |
| 5409 { | |
| 5410 OPERATION_DELETE_OBJECT, | |
| 5411 OPERATION_CREATE_OBJECT, | |
| 5412 OPERATION_MODIFY_BUFFER_TEXT, | |
| 1429 | 5413 OPERATION_MODIFY_OBJECT_PROPERTY |
| 853 | 5414 }; |
| 5415 | |
| 5416 int get_inhibit_flags (void); | |
| 5417 void check_allowed_operation (int what, Lisp_Object obj, Lisp_Object prop); | |
| 5418 void note_object_created (Lisp_Object obj); | |
| 5419 void note_object_deleted (Lisp_Object obj); | |
| 5420 Lisp_Object call_with_condition_handler (Lisp_Object (*handler) (Lisp_Object, | |
| 5421 Lisp_Object, | |
| 5422 Lisp_Object), | |
| 5423 Lisp_Object handler_arg, | |
| 5424 Lisp_Object (*fun) (Lisp_Object), | |
| 5425 Lisp_Object arg); | |
| 1318 | 5426 int set_trapping_problems_flags (int flags); |
| 853 | 5427 Lisp_Object call_trapping_problems (Lisp_Object warning_class, |
| 2367 | 5428 const Ascbyte *warning_string, |
| 853 | 5429 int flags, |
| 5430 struct call_trapping_problems_result | |
| 5431 *problem, | |
| 5432 Lisp_Object (*fun) (void *), | |
| 5433 void *arg); | |
| 5434 Lisp_Object va_call_trapping_problems (Lisp_Object warning_class, | |
| 2367 | 5435 const Ascbyte *warning_string, |
| 853 | 5436 int flags, |
| 5437 struct call_trapping_problems_result | |
| 5438 *problem, | |
| 5439 lisp_fn_t fun, int nargs, ...); | |
| 2367 | 5440 Lisp_Object call0_trapping_problems (const Ascbyte *, Lisp_Object, int); |
| 5441 Lisp_Object call1_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, | |
| 853 | 5442 int); |
| 2367 | 5443 Lisp_Object call2_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 5444 Lisp_Object, int); |
| 2367 | 5445 Lisp_Object call3_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 5446 Lisp_Object, Lisp_Object, int); |
| 2367 | 5447 Lisp_Object call4_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 5448 Lisp_Object, Lisp_Object, Lisp_Object, |
| 5449 int); | |
| 2367 | 5450 Lisp_Object call5_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 5451 Lisp_Object, Lisp_Object, Lisp_Object, |
| 5452 Lisp_Object, int); | |
| 2367 | 5453 Lisp_Object eval_in_buffer_trapping_problems (const Ascbyte *, struct buffer *, |
| 853 | 5454 Lisp_Object, int); |
| 1333 | 5455 Lisp_Object run_hook_trapping_problems (Lisp_Object, Lisp_Object, int); |
| 5456 Lisp_Object safe_run_hook_trapping_problems (Lisp_Object, Lisp_Object, int); | |
| 5457 Lisp_Object run_hook_with_args_in_buffer_trapping_problems (Lisp_Object, | |
| 5458 struct buffer *, | |
| 5459 int nargs, | |
| 853 | 5460 Lisp_Object *args, |
| 5461 enum | |
| 5462 run_hooks_condition | |
| 5463 cond, int flags); | |
| 1333 | 5464 Lisp_Object run_hook_with_args_trapping_problems (Lisp_Object, |
| 853 | 5465 int nargs, |
| 5466 Lisp_Object *args, | |
| 5467 enum run_hooks_condition | |
| 5468 cond, | |
| 5469 int flags); | |
| 1333 | 5470 Lisp_Object va_run_hook_with_args_trapping_problems (Lisp_Object, |
| 853 | 5471 Lisp_Object hook_var, |
| 5472 int nargs, ...); | |
| 1333 | 5473 Lisp_Object va_run_hook_with_args_in_buffer_trapping_problems (Lisp_Object, |
| 5474 struct buffer *, | |
| 5475 Lisp_Object, | |
| 853 | 5476 int nargs, ...); |
| 5477 Lisp_Object call_with_suspended_errors (lisp_fn_t, Lisp_Object, | |
| 5478 Lisp_Object, | |
| 578 | 5479 Error_Behavior, int, ...); |
| 428 | 5480 /* C Code should be using internal_catch, record_unwind_p, condition_case_1 */ |
| 1318 | 5481 int proper_redisplay_wrapping_in_place (void); |
| 428 | 5482 Lisp_Object internal_catch (Lisp_Object, Lisp_Object (*) (Lisp_Object), |
| 853 | 5483 Lisp_Object, int * volatile, |
| 2532 | 5484 Lisp_Object * volatile, |
| 853 | 5485 Lisp_Object * volatile); |
| 428 | 5486 Lisp_Object condition_case_1 (Lisp_Object, |
| 5487 Lisp_Object (*) (Lisp_Object), | |
| 5488 Lisp_Object, | |
| 5489 Lisp_Object (*) (Lisp_Object, Lisp_Object), | |
| 5490 Lisp_Object); | |
| 5491 Lisp_Object condition_case_3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 1632 | 5492 MODULE_API Lisp_Object unbind_to_1 (int, Lisp_Object); |
| 771 | 5493 #define unbind_to(obj) unbind_to_1 (obj, Qnil) |
| 428 | 5494 void specbind (Lisp_Object, Lisp_Object); |
| 1632 | 5495 MODULE_API int record_unwind_protect (Lisp_Object (*) (Lisp_Object), |
| 5496 Lisp_Object); | |
| 771 | 5497 int record_unwind_protect_freeing_dynarr (void *ptr); |
| 1333 | 5498 int record_unwind_protect_restoring_int (int *addr, int val); |
| 802 | 5499 int internal_bind_int (int *addr, int newval); |
| 5500 int internal_bind_lisp_object (Lisp_Object *addr, Lisp_Object newval); | |
| 970 | 5501 void do_autoload (Lisp_Object, Lisp_Object); /* GCPROs both arguments */ |
| 428 | 5502 Lisp_Object un_autoload (Lisp_Object); |
| 5503 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
|
5504 MODULE_API void warn_when_safe (Lisp_Object, Lisp_Object, const Ascbyte *, |
| 1632 | 5505 ...) PRINTF_ARGS (3, 4); |
| 1292 | 5506 extern int backtrace_with_internal_sections; |
| 428 | 5507 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5508 extern Lisp_Object Qand_optional; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5509 extern Lisp_Object Qand_rest; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5510 extern Lisp_Object Qautoload; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5511 extern Lisp_Object Qcommandp; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5512 extern Lisp_Object Qdefun; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5513 extern Lisp_Object Qexit; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5514 extern Lisp_Object Qinhibit_quit; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5515 extern Lisp_Object Qinteractive; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5516 extern Lisp_Object Qmacro; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5517 extern Lisp_Object Qprogn; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5518 extern Lisp_Object Qrun_hooks; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5519 extern Lisp_Object Qvalues; |
|
4841
3465c3161fea
when `debug', abort when lisp error during loadup
Ben Wing <ben@xemacs.org>
parents:
4805
diff
changeset
|
5520 extern Lisp_Object Vdebug_on_error; |
| 1315 | 5521 extern Lisp_Object Vstack_trace_on_error; |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5522 extern Lisp_Object Vautoload_queue; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5523 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5524 extern MODULE_API Lisp_Object Vinhibit_quit, Vquit_flag; |
| 428 | 5525 |
| 5526 /* Defined in event-stream.c */ | |
| 826 | 5527 EXFUN (Faccept_process_output, 3); |
| 5528 EXFUN (Fadd_timeout, 4); | |
| 5529 EXFUN (Fdisable_timeout, 1); | |
| 5530 EXFUN (Fdiscard_input, 0); | |
| 5531 EXFUN (Fdispatch_event, 1); | |
| 5532 EXFUN (Fenqueue_eval_event, 2); | |
| 5533 EXFUN (Fnext_event, 2); | |
| 5534 EXFUN (Fread_key_sequence, 3); | |
| 5535 EXFUN (Fsit_for, 2); | |
| 5536 EXFUN (Fsleep_for, 1); | |
| 5537 | |
| 428 | 5538 void wait_delaying_user_input (int (*) (void *), void *); |
| 1268 | 5539 int detect_input_pending (int how_many); |
| 428 | 5540 void reset_this_command_keys (Lisp_Object, int); |
| 5541 Lisp_Object enqueue_misc_user_event (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5542 Lisp_Object enqueue_misc_user_event_pos (Lisp_Object, Lisp_Object, | |
| 5543 Lisp_Object, int, int, int, int); | |
| 442 | 5544 extern int modifier_keys_are_sticky; |
| 428 | 5545 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5546 extern Lisp_Object Qdisabled; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5547 extern Lisp_Object Qsans_modifiers; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5548 extern Lisp_Object Qself_insert_defer_undo; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5549 extern Lisp_Object Vcontrolling_terminal; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5550 extern Lisp_Object Vcurrent_mouse_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5551 extern Lisp_Object Vlast_command; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5552 extern Lisp_Object Vlast_command_char; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5553 extern Lisp_Object Vlast_command_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5554 extern Lisp_Object Vlast_input_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5555 extern Lisp_Object Vrecent_keys_ring; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5556 extern Lisp_Object Vthis_command_keys; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5557 extern Lisp_Object Vunread_command_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5558 |
| 428 | 5559 /* Defined in event-Xt.c */ |
| 5560 void signal_special_Xt_user_event (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5561 | |
| 5562 | |
| 5563 /* Defined in events.c */ | |
| 826 | 5564 EXFUN (Fcopy_event, 2); |
| 2862 | 5565 EXFUN (Fevent_to_character, 4); |
| 826 | 5566 |
| 428 | 5567 void clear_event_resource (void); |
| 5568 Lisp_Object allocate_event (void); | |
| 5569 | |
| 771 | 5570 EXFUN (Fevent_x_pixel, 1); |
| 5571 EXFUN (Fevent_y_pixel, 1); | |
| 5572 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5573 extern Lisp_Object Qevent_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5574 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5575 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5576 /* Defined in extents.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5577 extern Lisp_Object Qend_open; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5578 extern Lisp_Object Qextent_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5579 extern Lisp_Object Qstart_open; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5580 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5581 /* Defined in faces.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5582 extern Lisp_Object Qbackground; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5583 extern Lisp_Object Qbackground_pixmap; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5584 extern Lisp_Object Qblinking; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5585 extern Lisp_Object Qdim; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5586 extern Lisp_Object Qdisplay_table; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5587 extern Lisp_Object Qforeground; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5588 extern Lisp_Object Qunderline; |
| 771 | 5589 |
| 5590 /* Defined in file-coding.c */ | |
| 5591 EXFUN (Fcoding_category_list, 0); | |
| 5592 EXFUN (Fcoding_category_system, 1); | |
| 5593 EXFUN (Fcoding_priority_list, 0); | |
| 5594 EXFUN (Fcoding_system_description, 1); | |
| 5595 EXFUN (Fcoding_system_documentation, 1); | |
| 5596 EXFUN (Fcoding_system_list, 1); | |
| 5597 EXFUN (Fcoding_system_name, 1); | |
| 5598 EXFUN (Fcoding_system_p, 1); | |
| 5599 EXFUN (Fcoding_system_property, 2); | |
| 5600 EXFUN (Fcoding_system_type, 1); | |
| 5601 EXFUN (Fcopy_coding_system, 2); | |
| 5602 EXFUN (Fdecode_big5_char, 1); | |
| 5603 EXFUN (Fdecode_coding_region, 4); | |
| 5604 EXFUN (Fdecode_shift_jis_char, 1); | |
| 5605 EXFUN (Fdefine_coding_system_alias, 2); | |
| 5606 EXFUN (Fdetect_coding_region, 3); | |
| 5607 EXFUN (Fdefault_encoding_detection_enabled_p, 0); | |
| 5608 EXFUN (Fencode_big5_char, 1); | |
| 5609 EXFUN (Fencode_coding_region, 4); | |
| 5610 EXFUN (Fencode_shift_jis_char, 1); | |
| 5611 EXFUN (Ffind_coding_system, 1); | |
| 5612 EXFUN (Fget_coding_system, 1); | |
|
4690
257b468bf2ca
Move the #'query-coding-region implementation to C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4682
diff
changeset
|
5613 EXFUN (Fmake_coding_system_internal, 4); |
| 771 | 5614 EXFUN (Fset_coding_category_system, 2); |
| 5615 EXFUN (Fset_coding_priority_list, 1); | |
| 5616 EXFUN (Fsubsidiary_coding_system, 2); | |
| 5617 | |
| 5618 extern Lisp_Object Qshift_jis, Qiso2022, Qbig5, Qccl; | |
| 5619 extern Lisp_Object Qcharset_g0; | |
| 5620 extern Lisp_Object Qcharset_g1, Qcharset_g2, Qcharset_g3, Qcoding_system_error; | |
| 5621 extern Lisp_Object Qcoding_systemp, Qcr, Qcrlf, Qdecode, Qencode; | |
| 5622 extern Lisp_Object Qeol_cr, Qeol_crlf, Qeol_lf, Qeol_type, Qescape_quoted; | |
| 5623 extern Lisp_Object Qforce_g0_on_output, Qforce_g1_on_output; | |
| 5624 extern Lisp_Object Qforce_g2_on_output, Qforce_g3_on_output; | |
| 5625 extern Lisp_Object Qinput_charset_conversion, Qlf, Qlock_shift; | |
| 5626 extern Lisp_Object Qmnemonic, Qno_ascii_cntl, Qno_ascii_eol; | |
| 5627 extern Lisp_Object Qno_conversion, Qraw_text; | |
| 5628 extern Lisp_Object Qno_iso6429, Qoutput_charset_conversion; | |
| 5629 extern Lisp_Object Qpost_read_conversion, Qpre_write_conversion, Qseven; | |
| 5630 extern Lisp_Object Qshort, Vcoding_system_for_read; | |
| 5631 extern Lisp_Object Vcoding_system_for_write; | |
| 5632 extern Lisp_Object Vfile_name_coding_system, Vkeyboard_coding_system; | |
| 5633 extern Lisp_Object Vterminal_coding_system; | |
| 5634 extern Lisp_Object Qcanonicalize_after_coding; | |
| 5635 int coding_system_is_for_text_file (Lisp_Object coding_system); | |
| 5636 Lisp_Object find_coding_system_for_text_file (Lisp_Object name, int eol_wrap); | |
| 1632 | 5637 MODULE_API Lisp_Object get_coding_system_for_text_file (Lisp_Object name, |
| 5638 int eol_wrap); | |
| 771 | 5639 int coding_system_is_binary (Lisp_Object coding_system); |
| 5640 | |
| 5641 | |
| 428 | 5642 /* Defined in fileio.c */ |
| 826 | 5643 EXFUN (Fdirectory_file_name, 1); |
| 5644 EXFUN (Fdo_auto_save, 2); | |
| 5645 EXFUN (Fexpand_file_name, 2); | |
| 5646 EXFUN (Ffile_accessible_directory_p, 1); | |
| 5647 EXFUN (Ffile_directory_p, 1); | |
| 5648 EXFUN (Ffile_executable_p, 1); | |
| 5649 EXFUN (Ffile_exists_p, 1); | |
| 5650 EXFUN (Ffile_name_absolute_p, 1); | |
| 5651 EXFUN (Ffile_name_as_directory, 1); | |
| 5652 EXFUN (Ffile_name_directory, 1); | |
| 5653 EXFUN (Ffile_name_nondirectory, 1); | |
| 5654 EXFUN (Ffile_readable_p, 1); | |
| 5655 EXFUN (Ffile_symlink_p, 1); | |
| 5656 EXFUN (Ffile_truename, 2); | |
| 5657 EXFUN (Ffind_file_name_handler, 2); | |
| 5658 EXFUN (Finsert_file_contents_internal, 7); | |
| 5659 EXFUN (Fmake_temp_name, 1); | |
| 5660 EXFUN (Fsubstitute_in_file_name, 1); | |
| 5661 EXFUN (Funhandled_file_name_directory, 1); | |
| 5662 EXFUN (Fverify_visited_file_modtime, 1); | |
| 5663 | |
| 428 | 5664 void record_auto_save (void); |
| 5665 void force_auto_save_soon (void); | |
| 563 | 5666 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
|
5667 const Ascbyte *reason, |
| 563 | 5668 Lisp_Object data)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5669 DECLARE_DOESNT_RETURN (report_file_error (const Ascbyte *, Lisp_Object)); |
| 428 | 5670 Lisp_Object lisp_strerror (int); |
| 5671 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object); | |
| 5672 int internal_delete_file (Lisp_Object); | |
| 2526 | 5673 Ibyte *find_end_of_directory_component (const Ibyte *path, |
| 5674 Bytecount len); | |
| 428 | 5675 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5676 extern Lisp_Object Qfile_name_sans_extension; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5677 extern Lisp_Object Vdirectory_sep_char; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5678 |
| 428 | 5679 /* Defined in filelock.c */ |
| 826 | 5680 EXFUN (Funlock_buffer, 0); |
| 5681 | |
| 428 | 5682 void lock_file (Lisp_Object); |
| 5683 void unlock_file (Lisp_Object); | |
| 5684 void unlock_all_files (void); | |
| 5685 void unlock_buffer (struct buffer *); | |
| 5686 | |
| 5687 /* Defined in floatfns.c */ | |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4677
diff
changeset
|
5688 EXFUN (Ftruncate, 2); |
| 826 | 5689 |
| 428 | 5690 double extract_float (Lisp_Object); |
| 5691 | |
| 5692 /* Defined in fns.c */ | |
| 1632 | 5693 MODULE_API EXFUN (Fappend, MANY); |
| 826 | 5694 EXFUN (Fassoc, 2); |
| 5695 EXFUN (Fassq, 2); | |
| 5696 EXFUN (Fcanonicalize_lax_plist, 2); | |
| 5697 EXFUN (Fcanonicalize_plist, 2); | |
| 5698 EXFUN (Fcheck_valid_plist, 1); | |
| 5699 EXFUN (Fconcat, MANY); | |
| 5700 EXFUN (Fcopy_alist, 1); | |
| 5701 EXFUN (Fcopy_list, 1); | |
| 5702 EXFUN (Fcopy_sequence, 1); | |
| 5703 EXFUN (Fcopy_tree, 2); | |
| 5704 EXFUN (Fdelete, 2); | |
| 5705 EXFUN (Fdelq, 2); | |
| 5706 EXFUN (Fdestructive_alist_to_plist, 1); | |
| 5707 EXFUN (Felt, 2); | |
| 1632 | 5708 MODULE_API EXFUN (Fequal, 2); |
| 5709 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
|
5710 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
|
5711 MODULE_API EXFUN (Fequalp, 2); |
| 826 | 5712 EXFUN (Flast, 2); |
| 5713 EXFUN (Flax_plist_get, 3); | |
| 5714 EXFUN (Flax_plist_remprop, 2); | |
| 1632 | 5715 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
|
5716 EXFUN (FmapcarX, MANY); |
| 826 | 5717 EXFUN (Fmember, 2); |
| 5718 EXFUN (Fmemq, 2); | |
| 5719 EXFUN (Fnconc, MANY); | |
| 1632 | 5720 MODULE_API EXFUN (Fnreverse, 1); |
| 826 | 5721 EXFUN (Fnthcdr, 2); |
| 5722 EXFUN (Fold_assq, 2); | |
| 5723 EXFUN (Fold_equal, 2); | |
| 5724 EXFUN (Fold_member, 2); | |
| 5725 EXFUN (Fold_memq, 2); | |
| 5726 EXFUN (Fplist_get, 3); | |
| 5727 EXFUN (Fplist_member, 2); | |
| 5728 EXFUN (Fplist_put, 3); | |
| 1632 | 5729 MODULE_API EXFUN (Fprovide, 1); |
| 5730 MODULE_API EXFUN (Fput, 3); | |
| 826 | 5731 EXFUN (Frassq, 2); |
| 5732 EXFUN (Fremassq, 2); | |
| 5733 EXFUN (Freplace_list, 2); | |
| 1632 | 5734 MODULE_API EXFUN (Freverse, 1); |
| 1268 | 5735 EXFUN (Fsafe_length, 1); |
| 826 | 5736 EXFUN (Fsort, 2); |
| 5737 EXFUN (Fstring_equal, 2); | |
| 5738 EXFUN (Fstring_lessp, 2); | |
|
5089
99f8ebc082d9
Make #'substring an alias of #'subseq; give the latter the byte code.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5084
diff
changeset
|
5739 EXFUN (Fsubseq, 3); |
| 826 | 5740 EXFUN (Fvalid_plist_p, 1); |
| 5741 | |
| 428 | 5742 Lisp_Object list_sort (Lisp_Object, Lisp_Object, |
| 5743 int (*) (Lisp_Object, Lisp_Object, Lisp_Object)); | |
| 5744 Lisp_Object merge (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5745 | |
| 5746 void bump_string_modiff (Lisp_Object); | |
| 5747 Lisp_Object memq_no_quit (Lisp_Object, Lisp_Object); | |
| 5748 Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object); | |
| 5749 Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object); | |
| 5750 Lisp_Object rassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5751 Lisp_Object delq_no_quit (Lisp_Object, Lisp_Object); | |
| 5752 Lisp_Object delq_no_quit_and_free_cons (Lisp_Object, Lisp_Object); | |
| 5753 Lisp_Object remassoc_no_quit (Lisp_Object, Lisp_Object); | |
| 5754 Lisp_Object remassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5755 Lisp_Object remrassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5756 | |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4888
diff
changeset
|
5757 int plists_differ (Lisp_Object, Lisp_Object, int, int, int, int); |
| 428 | 5758 Lisp_Object internal_plist_get (Lisp_Object, Lisp_Object); |
| 5759 void internal_plist_put (Lisp_Object *, Lisp_Object, Lisp_Object); | |
| 5760 int internal_remprop (Lisp_Object *, Lisp_Object); | |
| 5761 Lisp_Object external_plist_get (Lisp_Object *, Lisp_Object, | |
| 578 | 5762 int, Error_Behavior); |
| 428 | 5763 void external_plist_put (Lisp_Object *, Lisp_Object, |
| 578 | 5764 Lisp_Object, int, Error_Behavior); |
| 5765 int external_remprop (Lisp_Object *, Lisp_Object, int, Error_Behavior); | |
| 853 | 5766 int internal_equal_trapping_problems (Lisp_Object warning_class, |
| 2367 | 5767 const Ascbyte *warning_string, |
| 853 | 5768 int flags, |
| 5769 struct call_trapping_problems_result *p, | |
| 5770 int retval, | |
| 5771 Lisp_Object obj1, Lisp_Object obj2, | |
| 5772 int depth); | |
| 428 | 5773 int internal_equal (Lisp_Object, Lisp_Object, int); |
| 801 | 5774 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
|
5775 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
|
5776 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
|
5777 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
|
5778 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
|
5779 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
|
5780 int internal_equal_0 (Lisp_Object, Lisp_Object, int, int); |
| 428 | 5781 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
|
5782 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
|
5783 void check_losing_bytecode (const Ascbyte *, Lisp_Object); |
| 428 | 5784 |
| 771 | 5785 Lisp_Object add_suffix_to_symbol (Lisp_Object symbol, |
| 2367 | 5786 const Ascbyte *ascii_string); |
| 5787 Lisp_Object add_prefix_to_symbol (const Ascbyte *ascii_string, | |
| 771 | 5788 Lisp_Object symbol); |
| 5789 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5790 extern Lisp_Object Qidentity; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5791 extern Lisp_Object Qstring_lessp; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5792 extern Lisp_Object Qyes_or_no_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5793 extern Lisp_Object Vfeatures; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5794 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5795 /* Defined in frame.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5796 extern Lisp_Object Qframe_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5797 |
| 826 | 5798 /* Defined in free-hook.c */ |
| 5799 EXFUN (Freally_free, 1); | |
| 5800 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5801 /* Defined in general.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5802 #define SYMBOL(fou) extern Lisp_Object fou |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5803 #define SYMBOL_MODULE_API(fou) extern MODULE_API Lisp_Object fou |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5804 #define SYMBOL_KEYWORD(la_cle_est_fou) extern Lisp_Object la_cle_est_fou |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5805 #define SYMBOL_GENERAL(tout_le_monde, est_fou) \ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5806 extern Lisp_Object tout_le_monde |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5807 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5808 #include "general-slots.h" |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5809 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5810 #undef SYMBOL |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5811 #undef SYMBOL_MODULE_API |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5812 #undef SYMBOL_KEYWORD |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5813 #undef SYMBOL_GENERAL |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5814 |
| 428 | 5815 /* Defined in glyphs.c */ |
| 826 | 5816 EXFUN (Fmake_glyph_internal, 1); |
| 5817 | |
| 578 | 5818 Error_Behavior decode_error_behavior_flag (Lisp_Object); |
| 5819 Lisp_Object encode_error_behavior_flag (Error_Behavior); | |
| 428 | 5820 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5821 extern Lisp_Object Qbuffer_glyph_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5822 extern Lisp_Object Qcolor_pixmap_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5823 extern Lisp_Object Qicon_glyph_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5824 extern Lisp_Object Qmono_pixmap_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5825 extern Lisp_Object Qnothing_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5826 extern Lisp_Object Qpointer_glyph_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5827 extern Lisp_Object Qpointer_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5828 extern Lisp_Object Qsubwindow; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5829 extern Lisp_Object Qsubwindow_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5830 extern Lisp_Object Qtext_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5831 |
| 563 | 5832 /* Defined in glyphs-shared.c */ |
| 5833 void shared_resource_validate (Lisp_Object instantiator); | |
| 5834 Lisp_Object shared_resource_normalize (Lisp_Object inst, | |
| 5835 Lisp_Object console_type, | |
| 5836 Lisp_Object dest_mask, | |
| 5837 Lisp_Object tag); | |
| 5838 extern Lisp_Object Q_resource_type, Q_resource_id; | |
| 5839 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5840 /* Defined in glyphs-widget.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5841 extern Lisp_Object Qlayout; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5842 extern Lisp_Object Qnative_layout; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5843 |
| 563 | 5844 /* Defined in gui.c */ |
| 2367 | 5845 DECLARE_DOESNT_RETURN (gui_error (const Ascbyte *reason, |
| 563 | 5846 Lisp_Object frob)); |
| 2367 | 5847 DECLARE_DOESNT_RETURN (gui_error_2 (const Ascbyte *reason, |
| 569 | 5848 Lisp_Object frob0, Lisp_Object frob1)); |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5849 extern Lisp_Object Qgui_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5850 |
| 428 | 5851 /* Defined in indent.c */ |
| 826 | 5852 EXFUN (Findent_to, 3); |
| 5853 EXFUN (Fvertical_motion, 3); | |
| 5854 | |
| 5855 int byte_spaces_at_point (struct buffer *, Bytebpos); | |
| 665 | 5856 int column_at_point (struct buffer *, Charbpos, int); |
| 793 | 5857 int string_column_at_point (Lisp_Object, Charbpos, int); |
| 428 | 5858 int current_column (struct buffer *); |
| 5859 void invalidate_current_column (void); | |
| 665 | 5860 Charbpos vmotion (struct window *, Charbpos, int, int *); |
| 5861 Charbpos vmotion_pixels (Lisp_Object, Charbpos, int, int, int *); | |
| 428 | 5862 |
| 771 | 5863 /* Defined in insdel.c */ |
| 5864 void set_buffer_point (struct buffer *buf, Charbpos pos, Bytebpos bipos); | |
| 5865 | |
| 826 | 5866 /* Defined in intl.c */ |
| 5867 EXFUN (Fgettext, 1); | |
| 5868 | |
| 428 | 5869 /* Defined in keymap.c */ |
| 826 | 5870 EXFUN (Fdefine_key, 3); |
| 5871 EXFUN (Fkey_description, 1); | |
| 5872 EXFUN (Flookup_key, 3); | |
| 5873 EXFUN (Fmake_sparse_keymap, 1); | |
| 5874 | |
| 793 | 5875 void where_is_to_char (Lisp_Object, Eistring *); |
| 428 | 5876 |
| 5877 /* Defined in lread.c */ | |
| 826 | 5878 EXFUN (Fread, 1); |
| 5879 | |
| 428 | 5880 void ebolify_bytecode_constants (Lisp_Object); |
| 5881 void close_load_descs (void); | |
| 5882 int locate_file (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, int); | |
| 5883 EXFUN (Flocate_file_clear_hashing, 1); | |
| 442 | 5884 int isfloat_string (const char *); |
| 1983 | 5885 #ifdef HAVE_RATIO |
| 5886 int isratio_string (const char *); | |
| 5887 #endif | |
| 428 | 5888 |
| 5889 /* Well, I've decided to enable this. -- ben */ | |
| 5890 /* And I've decided to make it work right. -- sb */ | |
| 5891 #define LOADHIST | |
| 5892 /* Define the following symbol to enable load history of dumped files */ | |
| 5893 #define LOADHIST_DUMPED | |
| 5894 /* Define the following symbol to enable load history of C source */ | |
| 5895 #define LOADHIST_BUILTIN | |
| 5896 | |
| 5897 #ifdef LOADHIST /* this is just a stupid idea */ | |
| 5898 #define LOADHIST_ATTACH(x) \ | |
| 5899 do { if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); } \ | |
| 5900 while (0) | |
| 5901 #else /*! LOADHIST */ | |
| 5902 # define LOADHIST_ATTACH(x) | |
| 5903 #endif /*! LOADHIST */ | |
| 5904 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5905 extern Lisp_Object Qfeaturep; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5906 extern Lisp_Object Qload; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5907 extern Lisp_Object Qread_char; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5908 extern Lisp_Object Qstandard_input; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5909 extern Lisp_Object Vcurrent_load_list; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5910 extern Lisp_Object Vfile_domain; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5911 extern Lisp_Object Vload_file_name_internal; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5912 extern Lisp_Object Vload_history; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5913 extern Lisp_Object Vload_path; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5914 extern Lisp_Object Vstandard_input; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5915 |
| 826 | 5916 /* Defined in macros.c */ |
| 5917 EXFUN (Fexecute_kbd_macro, 2); | |
| 5918 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5919 extern Lisp_Object Vexecuting_macro; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5920 |
| 428 | 5921 /* Defined in marker.c */ |
| 826 | 5922 EXFUN (Fcopy_marker, 2); |
| 5923 EXFUN (Fmake_marker, 0); | |
| 5924 EXFUN (Fmarker_buffer, 1); | |
| 5925 EXFUN (Fmarker_position, 1); | |
| 5926 EXFUN (Fset_marker, 3); | |
| 5927 EXFUN (Fset_marker_insertion_type, 2); | |
| 5928 | |
| 5929 Bytebpos byte_marker_position (Lisp_Object); | |
| 665 | 5930 Charbpos marker_position (Lisp_Object); |
| 826 | 5931 void set_byte_marker_position (Lisp_Object, Bytebpos); |
| 665 | 5932 void set_marker_position (Lisp_Object, Charbpos); |
| 428 | 5933 void unchain_marker (Lisp_Object); |
| 5934 Lisp_Object noseeum_copy_marker (Lisp_Object, Lisp_Object); | |
| 5935 Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5936 #ifdef MEMORY_USAGE_STATS | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
5937 int compute_buffer_marker_usage (struct buffer *, struct usage_stats *); |
| 428 | 5938 #endif |
| 771 | 5939 void init_buffer_markers (struct buffer *b); |
| 5940 void uninit_buffer_markers (struct buffer *b); | |
| 428 | 5941 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5942 /* Defined in menubar.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5943 extern Lisp_Object Qactivate_menubar_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5944 extern Lisp_Object Qcurrent_menubar; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5945 extern Lisp_Object Vactivate_menubar_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5946 extern Lisp_Object Vblank_menubar; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5947 extern Lisp_Object Vmenubar_configuration; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5948 |
| 428 | 5949 /* Defined in minibuf.c */ |
| 5950 extern int minibuf_level; | |
| 867 | 5951 Charcount scmp_1 (const Ibyte *, const Ibyte *, Charcount, int); |
| 428 | 5952 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case) |
| 5953 extern int completion_ignore_case; | |
| 867 | 5954 int regexp_ignore_completion_p (const Ibyte *, Lisp_Object, |
| 428 | 5955 Bytecount, Bytecount); |
| 5956 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int); | |
| 5957 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int); | |
| 867 | 5958 void echo_area_append (struct frame *, const Ibyte *, Lisp_Object, |
| 428 | 5959 Bytecount, Bytecount, Lisp_Object); |
| 867 | 5960 void echo_area_message (struct frame *, const Ibyte *, Lisp_Object, |
| 428 | 5961 Bytecount, Bytecount, Lisp_Object); |
| 5962 Lisp_Object echo_area_status (struct frame *); | |
| 5963 int echo_area_active (struct frame *); | |
| 5964 Lisp_Object echo_area_contents (struct frame *); | |
| 867 | 5965 void message_internal (const Ibyte *, Lisp_Object, Bytecount, Bytecount); |
| 5966 void message_append_internal (const Ibyte *, Lisp_Object, | |
| 428 | 5967 Bytecount, Bytecount); |
| 1632 | 5968 MODULE_API void message (const char *, ...) PRINTF_ARGS (1, 2); |
| 442 | 5969 void message_append (const char *, ...) PRINTF_ARGS (1, 2); |
| 5970 void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2); | |
| 428 | 5971 void clear_message (void); |
| 5972 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5973 extern Lisp_Object Qcompletion_ignore_case; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5974 extern Lisp_Object Vecho_area_buffer; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5975 extern Lisp_Object Vminibuf_preprompt; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5976 extern Lisp_Object Vminibuf_prompt; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5977 extern Lisp_Object Vminibuffer_zero; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5978 |
| 771 | 5979 /* Defined in mule-charset.c */ |
| 826 | 5980 EXFUN (Fmake_charset, 3); |
| 5981 | |
| 771 | 5982 extern Lisp_Object Ql2r, Qr2l; |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5983 extern Lisp_Object Qdirection; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5984 extern Lisp_Object Qfinal; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5985 extern Lisp_Object Qgraphic; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5986 extern Lisp_Object Qlong_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5987 extern Lisp_Object Qregistries; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5988 extern Lisp_Object Qreverse_direction_charset; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5989 extern Lisp_Object Qshort_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5990 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5991 /* Defined in nt.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5992 extern Lisp_Object Vmswindows_get_true_file_attributes; |
| 771 | 5993 |
| 428 | 5994 /* Defined in print.c */ |
| 826 | 5995 EXFUN (Fdisplay_error, 2); |
| 5996 EXFUN (Ferror_message_string, 1); | |
| 5997 EXFUN (Fprin1, 2); | |
| 5998 EXFUN (Fprin1_to_string, 2); | |
| 5999 EXFUN (Fprinc, 2); | |
| 6000 EXFUN (Fprint, 2); | |
| 6001 | |
|
4394
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4355
diff
changeset
|
6002 Lisp_Object prin1_to_string (Lisp_Object, int); |
| 771 | 6003 |
| 6004 /* Lower-level ways to output data: */ | |
| 3085 | 6005 void default_object_printer (Lisp_Object, Lisp_Object, int); |
| 771 | 6006 void print_internal (Lisp_Object, Lisp_Object, int); |
| 428 | 6007 void debug_print (Lisp_Object); |
| 1204 | 6008 void debug_p4 (Lisp_Object obj); |
| 6009 void debug_p3 (Lisp_Object obj); | |
| 6010 void debug_short_backtrace (int); | |
| 6011 void debug_backtrace (void); | |
| 428 | 6012 /* NOTE: Do not call this with the data of a Lisp_String. Use princ. |
| 6013 * Note: stream should be defaulted before calling | |
| 6014 * (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
|
6015 MODULE_API void write_istring (Lisp_Object stream, const Ibyte *str); |
| 771 | 6016 /* Same goes for this function. */ |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
6017 MODULE_API void write_cistring (Lisp_Object stream, const CIbyte *str); |
| 771 | 6018 /* Same goes for this function. */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
6019 MODULE_API void write_ascstring (Lisp_Object stream, const Ascbyte *str); |
| 428 | 6020 /* Same goes for this function. */ |
| 867 | 6021 void write_string_1 (Lisp_Object stream, const Ibyte *str, Bytecount size); |
| 826 | 6022 void write_eistring (Lisp_Object stream, const Eistring *ei); |
| 771 | 6023 |
| 6024 /* Higher-level (printf-style) ways to output data: */ | |
| 1632 | 6025 MODULE_API void write_fmt_string (Lisp_Object stream, const CIbyte *fmt, ...); |
| 6026 MODULE_API void write_fmt_string_lisp (Lisp_Object stream, const CIbyte *fmt, | |
| 6027 int nargs, ...); | |
| 867 | 6028 void stderr_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); |
| 6029 void stderr_out_lisp (const CIbyte *, int nargs, ...); | |
| 6030 void stdout_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); | |
| 1346 | 6031 void external_out (int dest, const CIbyte *fmt, ...) PRINTF_ARGS (2, 3); |
| 867 | 6032 void debug_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); |
| 1743 | 6033 DECLARE_DOESNT_RETURN (fatal (const CIbyte *, ...)) PRINTF_ARGS(1, 2); |
| 771 | 6034 |
| 6035 /* Internal functions: */ | |
| 1261 | 6036 Lisp_Object canonicalize_printcharfun (Lisp_Object printcharfun); |
| 771 | 6037 void temp_output_buffer_setup (Lisp_Object); |
| 6038 void temp_output_buffer_show (Lisp_Object, Lisp_Object); | |
| 428 | 6039 void print_cons (Lisp_Object, Lisp_Object, int); |
| 6040 void print_vector (Lisp_Object, Lisp_Object, int); | |
| 6041 void print_string (Lisp_Object, Lisp_Object, int); | |
| 771 | 6042 void print_symbol (Lisp_Object, Lisp_Object, int); |
| 6043 void print_float (Lisp_Object, Lisp_Object, int); | |
| 603 | 6044 /* The number of bytes required to store the decimal printed |
| 6045 representation of an integral type. Add a few bytes for truncation, | |
| 6046 optional sign prefix, and null byte terminator. | |
| 614 | 6047 2.40824 == log (256) / log (10). |
| 6048 | |
| 6049 We don't use floating point since Sun cc (buggily?) cannot use | |
| 6050 floating point computations to define a compile-time integral | |
| 6051 constant. */ | |
| 603 | 6052 #define DECIMAL_PRINT_SIZE(integral_type) \ |
| 614 | 6053 (((2410824 * sizeof (integral_type)) / 1000000) + 3) |
| 577 | 6054 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
|
6055 void ulong_to_bit_string (char *, unsigned long); |
| 428 | 6056 extern int print_escape_newlines; |
| 1632 | 6057 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
|
6058 extern int in_debug_print; |
| 428 | 6059 Lisp_Object internal_with_output_to_temp_buffer (Lisp_Object, |
| 6060 Lisp_Object (*) (Lisp_Object), | |
| 6061 Lisp_Object, Lisp_Object); | |
| 6062 void float_to_string (char *, double); | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
6063 void internal_object_printer (Lisp_Object obj, Lisp_Object printcharfun, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
6064 int UNUSED (escapeflag)); |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
6065 void external_object_printer (Lisp_Object obj, Lisp_Object printcharfun, |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
6066 int UNUSED (escapeflag)); |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
6067 MODULE_API DECLARE_DOESNT_RETURN (printing_unreadable_object_fmt (const CIbyte *, |
| 4846 | 6068 ...)) |
| 6069 PRINTF_ARGS (1, 2); | |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
6070 DECLARE_DOESNT_RETURN (printing_unreadable_lisp_object (Lisp_Object obj, |
| 4846 | 6071 const Ibyte *name)); |
| 428 | 6072 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6073 extern Lisp_Object Qexternal_debugging_output; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6074 extern Lisp_Object Qprint_length; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6075 extern Lisp_Object Qprint_string_length; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6076 extern Lisp_Object Qstandard_output; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6077 extern Lisp_Object Vprint_length; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6078 extern Lisp_Object Vprint_level; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6079 extern Lisp_Object Vstandard_output; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6080 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6081 /* Defined in process.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6082 extern Lisp_Object Qnetwork_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6083 extern MODULE_API Lisp_Object Qprocess_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6084 extern Lisp_Object Vprocess_environment; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6085 extern Lisp_Object Vshell_file_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6086 |
| 428 | 6087 /* Defined in rangetab.c */ |
| 826 | 6088 EXFUN (Fclear_range_table, 1); |
| 6089 EXFUN (Fget_range_table, 3); | |
| 2421 | 6090 EXFUN (Fmake_range_table, 1); |
| 826 | 6091 EXFUN (Fput_range_table, 4); |
|
4690
257b468bf2ca
Move the #'query-coding-region implementation to C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4682
diff
changeset
|
6092 EXFUN (Fcopy_range_table, 1); |
| 826 | 6093 |
| 2421 | 6094 extern Lisp_Object Qstart_closed_end_open; |
| 6095 extern Lisp_Object Qstart_open_end_open; | |
| 6096 extern Lisp_Object Qstart_closed_end_closed; | |
| 6097 extern Lisp_Object Qstart_open_end_closed; | |
| 6098 | |
| 428 | 6099 void put_range_table (Lisp_Object, EMACS_INT, EMACS_INT, Lisp_Object); |
| 6100 int unified_range_table_bytes_needed (Lisp_Object); | |
| 6101 int unified_range_table_bytes_used (void *); | |
| 6102 void unified_range_table_copy_data (Lisp_Object, void *); | |
| 6103 Lisp_Object unified_range_table_lookup (void *, EMACS_INT, Lisp_Object); | |
| 6104 int unified_range_table_nentries (void *); | |
| 6105 void unified_range_table_get_range (void *, int, EMACS_INT *, EMACS_INT *, | |
| 6106 Lisp_Object *); | |
| 6107 | |
| 6108 /* Defined in search.c */ | |
| 826 | 6109 EXFUN (Fmatch_beginning, 1); |
| 6110 EXFUN (Fmatch_end, 1); | |
| 6111 EXFUN (Fskip_chars_backward, 3); | |
| 6112 EXFUN (Fskip_chars_forward, 3); | |
| 6113 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
|
6114 EXFUN (Fregexp_quote, 1); |
| 826 | 6115 |
| 428 | 6116 struct re_pattern_buffer; |
| 6117 struct re_registers; | |
| 867 | 6118 Charbpos scan_buffer (struct buffer *, Ichar, Charbpos, Charbpos, EMACS_INT, |
| 826 | 6119 EMACS_INT *, int); |
| 665 | 6120 Charbpos find_next_newline (struct buffer *, Charbpos, int); |
| 6121 Charbpos find_next_newline_no_quit (struct buffer *, Charbpos, int); | |
| 826 | 6122 Bytebpos byte_find_next_newline_no_quit (struct buffer *, Bytebpos, int); |
| 867 | 6123 Bytecount byte_find_next_ichar_in_string (Lisp_Object, Ichar, Bytecount, |
| 826 | 6124 EMACS_INT); |
| 665 | 6125 Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos, int); |
| 826 | 6126 struct re_pattern_buffer *compile_pattern (Lisp_Object pattern, |
| 6127 struct re_registers *regp, | |
| 6128 Lisp_Object translate, | |
| 6129 Lisp_Object searchobj, | |
| 6130 struct buffer *searchbuf, | |
| 6131 int posix, Error_Behavior errb); | |
| 867 | 6132 Bytecount fast_string_match (Lisp_Object, const Ibyte *, |
| 428 | 6133 Lisp_Object, Bytecount, |
| 578 | 6134 Bytecount, int, Error_Behavior, int); |
| 428 | 6135 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object); |
| 507 | 6136 extern Fixnum warn_about_possibly_incompatible_back_references; |
| 502 | 6137 |
| 428 | 6138 |
| 6139 /* Defined in signal.c */ | |
| 6140 void init_interrupts_late (void); | |
| 6141 | |
| 6142 /* Defined in sound.c */ | |
| 826 | 6143 EXFUN (Fding, 3); |
| 6144 | |
| 428 | 6145 void init_device_sound (struct device *); |
| 2367 | 6146 DECLARE_DOESNT_RETURN (report_sound_error (const Ascbyte *, Lisp_Object)); |
| 428 | 6147 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6148 extern Lisp_Object Qsound_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6149 extern Lisp_Object Vsynchronous_sounds; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6150 |
| 428 | 6151 /* Defined in specifier.c */ |
| 826 | 6152 EXFUN (Fadd_spec_to_specifier, 5); |
| 6153 EXFUN (Fspecifier_spec_list, 4); | |
| 6154 | |
| 428 | 6155 Lisp_Object specifier_instance (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 6156 Error_Behavior, int, int, Lisp_Object); |
| 428 | 6157 Lisp_Object specifier_instance_no_quit (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 6158 Error_Behavior, int, Lisp_Object); |
| 428 | 6159 |
| 6160 /* Defined in symbols.c */ | |
| 826 | 6161 EXFUN (Fboundp, 1); |
| 6162 EXFUN (Fbuilt_in_variable_type, 1); | |
| 6163 EXFUN (Fdefault_boundp, 1); | |
| 6164 EXFUN (Fdefault_value, 1); | |
| 6165 EXFUN (Ffboundp, 1); | |
| 6166 EXFUN (Ffset, 2); | |
| 6167 EXFUN (Fintern, 2); | |
|
4355
a2af1ff1761f
Provide a DEFAULT argument in #'intern-soft.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4329
diff
changeset
|
6168 EXFUN (Fintern_soft, 3); |
| 826 | 6169 EXFUN (Fkill_local_variable, 1); |
| 6170 EXFUN (Fset, 2); | |
| 6171 EXFUN (Fset_default, 2); | |
| 6172 EXFUN (Fsymbol_function, 1); | |
| 6173 EXFUN (Fsymbol_name, 1); | |
| 6174 EXFUN (Fsymbol_plist, 1); | |
| 6175 EXFUN (Fsymbol_value, 1); | |
| 6176 | |
| 867 | 6177 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
|
6178 Lisp_Object intern_istring (const Ibyte *str); |
| 1632 | 6179 MODULE_API Lisp_Object intern (const CIbyte *str); |
| 867 | 6180 Lisp_Object intern_converting_underscores_to_dashes (const CIbyte *str); |
| 6181 Lisp_Object oblookup (Lisp_Object, const Ibyte *, Bytecount); | |
| 428 | 6182 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *); |
| 6183 Lisp_Object indirect_function (Lisp_Object, int); | |
| 6184 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object); | |
| 6185 void kill_buffer_local_variables (struct buffer *); | |
| 6186 int symbol_value_buffer_local_info (Lisp_Object, struct buffer *); | |
| 6187 Lisp_Object find_symbol_value (Lisp_Object); | |
| 6188 Lisp_Object find_symbol_value_quickly (Lisp_Object, int); | |
| 6189 Lisp_Object top_level_value (Lisp_Object); | |
| 6190 void reject_constant_symbols (Lisp_Object sym, Lisp_Object newval, | |
| 6191 int function_p, | |
| 6192 Lisp_Object follow_past_lisp_magic); | |
| 6193 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6194 extern Lisp_Object Qconst_specifier; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6195 extern Lisp_Object Qmakunbound; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6196 extern Lisp_Object Qset; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6197 extern Lisp_Object Qvariable_documentation; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6198 extern Lisp_Object Qvariable_domain; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6199 extern MODULE_API Lisp_Object Qt, Qunbound; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6200 extern Lisp_Object Vobarray; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6201 |
| 428 | 6202 /* Defined in syntax.c */ |
| 665 | 6203 Charbpos scan_words (struct buffer *, Charbpos, int); |
| 826 | 6204 EXFUN (Fchar_syntax, 2); |
| 6205 EXFUN (Fforward_word, 2); | |
| 6206 extern Lisp_Object Vstandard_syntax_table; | |
| 3250 | 6207 void signal_syntax_cache_extent_changed (EXTENT extent); |
| 6208 void signal_syntax_cache_extent_adjust (struct buffer *buf); | |
| 826 | 6209 void init_buffer_syntax_cache (struct buffer *buf); |
| 6210 void mark_buffer_syntax_cache (struct buffer *buf); | |
| 6211 void uninit_buffer_syntax_cache (struct buffer *buf); | |
| 6212 extern Lisp_Object Qsyntax_table; | |
| 428 | 6213 |
| 771 | 6214 /* Defined in sysdep.c */ |
| 6215 long get_random (void); | |
| 6216 void seed_random (long arg); | |
| 6217 | |
| 6218 /* Defined in text.c */ | |
| 867 | 6219 void find_charsets_in_ibyte_string (unsigned char *charsets, |
| 6220 const Ibyte *str, | |
| 771 | 6221 Bytecount len); |
| 867 | 6222 void find_charsets_in_ichar_string (unsigned char *charsets, |
| 6223 const Ichar *str, | |
| 771 | 6224 Charcount len); |
| 867 | 6225 int ibyte_string_displayed_columns (const Ibyte *str, Bytecount len); |
| 6226 int ichar_string_displayed_columns (const Ichar *str, Charcount len); | |
| 6227 Charcount ibyte_string_nonascii_chars (const Ibyte *str, Bytecount len); | |
| 6228 void convert_ibyte_string_into_ichar_dynarr (const Ibyte *str, | |
| 771 | 6229 Bytecount len, |
| 867 | 6230 Ichar_dynarr *dyn); |
| 6231 Charcount convert_ibyte_string_into_ichar_string (const Ibyte *str, | |
| 771 | 6232 Bytecount len, |
| 867 | 6233 Ichar *arr); |
| 6234 void convert_ichar_string_into_ibyte_dynarr (Ichar *arr, int nels, | |
| 6235 Ibyte_dynarr *dyn); | |
| 6236 Ibyte *convert_ichar_string_into_malloced_string (Ichar *arr, int nels, | |
| 771 | 6237 Bytecount *len_out); |
| 867 | 6238 Bytecount copy_text_between_formats (const Ibyte *src, Bytecount srclen, |
| 826 | 6239 Internal_Format srcfmt, |
| 6240 Lisp_Object srcobj, | |
| 867 | 6241 Ibyte *dst, Bytecount dstlen, |
| 826 | 6242 Internal_Format dstfmt, |
| 6243 Lisp_Object dstobj, | |
| 6244 Bytecount *src_used); | |
| 6245 Bytecount copy_buffer_text_out (struct buffer *buf, Bytebpos pos, | |
| 867 | 6246 Bytecount len, Ibyte *dst, Bytecount dstlen, |
| 826 | 6247 Internal_Format dstfmt, Lisp_Object dstobj, |
| 6248 Bytecount *src_used); | |
| 771 | 6249 |
| 6250 /* flags for get_buffer_pos_char(), get_buffer_range_char(), etc. */ | |
| 6251 /* At most one of GB_COERCE_RANGE and GB_NO_ERROR_IF_BAD should be | |
| 6252 specified. At most one of GB_NEGATIVE_FROM_END and GB_NO_ERROR_IF_BAD | |
| 6253 should be specified. */ | |
| 6254 | |
| 6255 #define GB_ALLOW_PAST_ACCESSIBLE (1 << 0) | |
| 6256 #define GB_ALLOW_NIL (1 << 1) | |
| 6257 #define GB_CHECK_ORDER (1 << 2) | |
| 6258 #define GB_COERCE_RANGE (1 << 3) | |
| 6259 #define GB_NO_ERROR_IF_BAD (1 << 4) | |
| 6260 #define GB_NEGATIVE_FROM_END (1 << 5) | |
| 6261 #define GB_HISTORICAL_STRING_BEHAVIOR (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL) | |
| 6262 | |
| 6263 Charbpos get_buffer_pos_char (struct buffer *b, Lisp_Object pos, | |
| 6264 unsigned int flags); | |
| 6265 Bytebpos get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, | |
| 6266 unsigned int flags); | |
| 6267 void get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to, | |
| 6268 Charbpos *from_out, Charbpos *to_out, | |
| 6269 unsigned int flags); | |
| 6270 void get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to, | |
| 6271 Bytebpos *from_out, Bytebpos *to_out, | |
| 6272 unsigned int flags); | |
| 6273 Charcount get_string_pos_char (Lisp_Object string, Lisp_Object pos, | |
| 6274 unsigned int flags); | |
| 6275 Bytecount get_string_pos_byte (Lisp_Object string, Lisp_Object pos, | |
| 6276 unsigned int flags); | |
| 6277 void get_string_range_char (Lisp_Object string, Lisp_Object from, | |
| 6278 Lisp_Object to, Charcount *from_out, | |
| 6279 Charcount *to_out, unsigned int flags); | |
| 6280 void get_string_range_byte (Lisp_Object string, Lisp_Object from, | |
| 6281 Lisp_Object to, Bytecount *from_out, | |
| 6282 Bytecount *to_out, unsigned int flags); | |
| 826 | 6283 Charxpos get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos, |
| 6284 unsigned int flags); | |
| 6285 Bytexpos get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos, | |
| 6286 unsigned int flags); | |
| 771 | 6287 void get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from, |
| 826 | 6288 Lisp_Object to, Charxpos *from_out, |
| 6289 Charxpos *to_out, unsigned int flags); | |
| 771 | 6290 void get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from, |
| 826 | 6291 Lisp_Object to, Bytexpos *from_out, |
| 6292 Bytexpos *to_out, unsigned int flags); | |
| 6293 Charxpos buffer_or_string_accessible_begin_char (Lisp_Object object); | |
| 6294 Charxpos buffer_or_string_accessible_end_char (Lisp_Object object); | |
| 6295 Bytexpos buffer_or_string_accessible_begin_byte (Lisp_Object object); | |
| 6296 Bytexpos buffer_or_string_accessible_end_byte (Lisp_Object object); | |
| 6297 Charxpos buffer_or_string_absolute_begin_char (Lisp_Object object); | |
| 6298 Charxpos buffer_or_string_absolute_end_char (Lisp_Object object); | |
| 6299 Bytexpos buffer_or_string_absolute_begin_byte (Lisp_Object object); | |
| 6300 Bytexpos buffer_or_string_absolute_end_byte (Lisp_Object object); | |
| 6301 Charbpos charbpos_clip_to_bounds (Charbpos lower, Charbpos num, | |
| 6302 Charbpos upper); | |
| 6303 Bytebpos bytebpos_clip_to_bounds (Bytebpos lower, Bytebpos num, | |
| 6304 Bytebpos upper); | |
| 6305 Charxpos charxpos_clip_to_bounds (Charxpos lower, Charxpos num, | |
| 6306 Charxpos upper); | |
| 6307 Bytexpos bytexpos_clip_to_bounds (Bytexpos lower, Bytexpos num, | |
| 6308 Bytexpos upper); | |
| 6309 Charxpos buffer_or_string_clip_to_accessible_char (Lisp_Object object, | |
| 6310 Charxpos pos); | |
| 6311 Bytexpos buffer_or_string_clip_to_accessible_byte (Lisp_Object object, | |
| 6312 Bytexpos pos); | |
| 6313 Charxpos buffer_or_string_clip_to_absolute_char (Lisp_Object object, | |
| 6314 Charxpos pos); | |
| 6315 Bytexpos buffer_or_string_clip_to_absolute_byte (Lisp_Object object, | |
| 6316 Bytexpos pos); | |
| 6317 | |
| 771 | 6318 |
| 6319 #ifdef ENABLE_COMPOSITE_CHARS | |
| 6320 | |
| 867 | 6321 Ichar lookup_composite_char (Ibyte *str, int len); |
| 6322 Lisp_Object composite_char_string (Ichar ch); | |
| 771 | 6323 #endif /* ENABLE_COMPOSITE_CHARS */ |
| 6324 | |
| 6325 EXFUN (Ffind_charset, 1); | |
| 6326 EXFUN (Fget_charset, 1); | |
| 6327 EXFUN (Fcharset_list, 0); | |
| 6328 | |
| 6329 extern Lisp_Object Vcharset_ascii; | |
| 6330 extern Lisp_Object Vcharset_control_1; | |
| 6331 extern Lisp_Object Vcharset_latin_iso8859_1; | |
| 6332 extern Lisp_Object Vcharset_latin_iso8859_2; | |
| 6333 extern Lisp_Object Vcharset_latin_iso8859_3; | |
| 6334 extern Lisp_Object Vcharset_latin_iso8859_4; | |
| 6335 extern Lisp_Object Vcharset_thai_tis620; | |
| 6336 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
|
6337 extern Lisp_Object Vcharset_arabic_iso8859_6; |
| 771 | 6338 extern Lisp_Object Vcharset_hebrew_iso8859_8; |
| 6339 extern Lisp_Object Vcharset_katakana_jisx0201; | |
| 6340 extern Lisp_Object Vcharset_latin_jisx0201; | |
| 6341 extern Lisp_Object Vcharset_cyrillic_iso8859_5; | |
| 6342 extern Lisp_Object Vcharset_latin_iso8859_9; | |
| 3094 | 6343 extern Lisp_Object Vcharset_latin_iso8859_15; |
| 771 | 6344 extern Lisp_Object Vcharset_japanese_jisx0208_1978; |
| 6345 extern Lisp_Object Vcharset_chinese_gb2312; | |
| 6346 extern Lisp_Object Vcharset_japanese_jisx0208; | |
| 6347 extern Lisp_Object Vcharset_korean_ksc5601; | |
| 6348 extern Lisp_Object Vcharset_japanese_jisx0212; | |
| 6349 extern Lisp_Object Vcharset_chinese_cns11643_1; | |
| 6350 extern Lisp_Object Vcharset_chinese_cns11643_2; | |
| 6351 extern Lisp_Object Vcharset_chinese_big5_1; | |
| 6352 extern Lisp_Object Vcharset_chinese_big5_2; | |
| 6353 extern Lisp_Object Vcharset_composite; | |
| 6354 | |
| 867 | 6355 Ichar Lstream_get_ichar_1 (Lstream *stream, int first_char); |
| 6356 int Lstream_fput_ichar (Lstream *stream, Ichar ch); | |
| 6357 void Lstream_funget_ichar (Lstream *stream, Ichar ch); | |
| 6358 | |
| 6359 DECLARE_INLINE_HEADER (Ibyte *qxestrdup (const Ibyte *s)) | |
| 771 | 6360 { |
| 2367 | 6361 return (Ibyte *) xstrdup ((const Chbyte *) s); |
| 771 | 6362 } |
| 6363 | |
| 867 | 6364 DECLARE_INLINE_HEADER (Bytecount qxestrlen (const Ibyte *s)) |
| 771 | 6365 { |
| 2367 | 6366 return strlen ((const Chbyte *) s); |
| 771 | 6367 } |
| 6368 | |
| 867 | 6369 DECLARE_INLINE_HEADER (Charcount qxestrcharlen (const Ibyte *s)) |
| 771 | 6370 { |
| 6371 return bytecount_to_charcount (s, qxestrlen (s)); | |
| 6372 } | |
| 6373 | |
| 867 | 6374 DECLARE_INLINE_HEADER (int qxestrcmp (const Ibyte *s1, |
| 6375 const Ibyte *s2)) | |
| 771 | 6376 { |
| 2367 | 6377 return strcmp ((const Chbyte *) s1, (const Chbyte *) s2); |
| 771 | 6378 } |
| 6379 | |
| 2367 | 6380 DECLARE_INLINE_HEADER (int qxestrcmp_ascii (const Ibyte *s1, |
| 6381 const Ascbyte *s2)) | |
| 771 | 6382 { |
| 2367 | 6383 return strcmp ((const Chbyte *) s1, s2); |
| 771 | 6384 } |
| 6385 | |
| 867 | 6386 DECLARE_INLINE_HEADER (int qxestrncmp (const Ibyte *string1, |
| 6387 const Ibyte *string2, | |
| 771 | 6388 Bytecount count)) |
| 6389 { | |
| 2367 | 6390 return strncmp ((const Chbyte *) string1, (const Chbyte *) string2, |
| 771 | 6391 (size_t) count); |
| 6392 } | |
| 6393 | |
| 2367 | 6394 DECLARE_INLINE_HEADER (int qxestrncmp_ascii (const Ibyte *string1, |
| 6395 const Ascbyte *string2, | |
| 6396 Bytecount count)) | |
| 771 | 6397 { |
| 2367 | 6398 return strncmp ((const Chbyte *) string1, string2, (size_t) count); |
| 771 | 6399 } |
| 6400 | |
| 867 | 6401 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy (Ibyte *strDest, |
| 2367 | 6402 const Ibyte *strSource)) |
| 771 | 6403 { |
| 2367 | 6404 return (Ibyte *) strcpy ((Chbyte *) strDest, (const Chbyte *) strSource); |
| 771 | 6405 } |
| 6406 | |
| 2367 | 6407 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy_ascii (Ibyte *strDest, |
| 6408 const Ascbyte *strSource)) | |
| 771 | 6409 { |
| 2367 | 6410 return (Ibyte *) strcpy ((Chbyte *) strDest, strSource); |
| 771 | 6411 } |
| 6412 | |
| 867 | 6413 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy (Ibyte *strDest, |
| 2367 | 6414 const Ibyte *strSource, |
| 6415 Bytecount count)) | |
| 771 | 6416 { |
| 2367 | 6417 return (Ibyte *) strncpy ((Chbyte *) strDest, (const Chbyte *) strSource, |
| 771 | 6418 (size_t) count); |
| 6419 } | |
| 6420 | |
| 2367 | 6421 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy_ascii (Ibyte *strDest, |
| 6422 const Ascbyte *strSource, | |
| 6423 Bytecount count)) | |
| 771 | 6424 { |
| 2367 | 6425 return (Ibyte *) strncpy ((Chbyte *) strDest, strSource, (size_t) count); |
| 771 | 6426 } |
| 6427 | |
| 867 | 6428 DECLARE_INLINE_HEADER (Ibyte *qxestrcat (Ibyte *strDest, |
| 2367 | 6429 const Ibyte *strSource)) |
| 771 | 6430 { |
| 2367 | 6431 return (Ibyte *) strcat ((Chbyte *) strDest, (const Chbyte *) strSource); |
| 771 | 6432 } |
| 6433 | |
| 2367 | 6434 DECLARE_INLINE_HEADER (Ibyte *qxestrcat_ascii (Ibyte *strDest, |
| 6435 const Ascbyte *strSource)) | |
| 771 | 6436 { |
| 2367 | 6437 return (Ibyte *) strcat ((Chbyte *) strDest, strSource); |
| 771 | 6438 } |
| 6439 | |
| 867 | 6440 DECLARE_INLINE_HEADER (Ibyte *qxestrncat (Ibyte *strDest, |
| 2367 | 6441 const Ibyte *strSource, |
| 6442 Bytecount count)) | |
| 771 | 6443 { |
| 2367 | 6444 return (Ibyte *) strncat ((Chbyte *) strDest, (const Chbyte *) strSource, |
| 771 | 6445 (size_t) count); |
| 6446 } | |
| 6447 | |
| 2367 | 6448 DECLARE_INLINE_HEADER (Ibyte *qxestrncat_ascii (Ibyte *strDest, |
| 6449 const Ascbyte *strSource, | |
| 6450 Bytecount count)) | |
| 771 | 6451 { |
| 2367 | 6452 return (Ibyte *) strncat ((Chbyte *) strDest, strSource, (size_t) count); |
| 771 | 6453 } |
| 6454 | |
| 867 | 6455 DECLARE_INLINE_HEADER (Ibyte *qxestrchr (const Ibyte *s, Ichar c)) |
| 771 | 6456 { |
| 6457 assert (c >= 0 && c <= 255); | |
| 2367 | 6458 return (Ibyte *) strchr ((const Chbyte *) s, c); |
| 771 | 6459 } |
| 6460 | |
| 867 | 6461 DECLARE_INLINE_HEADER (Ibyte *qxestrrchr (const Ibyte *s, Ichar c)) |
| 771 | 6462 { |
| 6463 assert (c >= 0 && c <= 255); | |
| 2367 | 6464 return (Ibyte *) strrchr ((const Chbyte *) s, c); |
| 771 | 6465 } |
| 6466 | |
| 867 | 6467 DECLARE_INLINE_HEADER (Ibyte *qxestrstr (const Ibyte *string1, |
| 2367 | 6468 const Ibyte *string2)) |
| 771 | 6469 { |
| 2367 | 6470 return (Ibyte *) strstr ((const Chbyte *) string1, (const Chbyte *) string2); |
| 771 | 6471 } |
| 6472 | |
| 867 | 6473 DECLARE_INLINE_HEADER (Bytecount qxestrcspn (const Ibyte *string, |
| 6474 const CIbyte *strCharSet)) | |
| 771 | 6475 { |
| 2367 | 6476 return (Bytecount) strcspn ((const Chbyte *) string, strCharSet); |
| 771 | 6477 } |
| 6478 | |
| 867 | 6479 DECLARE_INLINE_HEADER (Bytecount qxestrspn (const Ibyte *string, |
| 6480 const CIbyte *strCharSet)) | |
| 771 | 6481 { |
| 2367 | 6482 return (Bytecount) strspn ((const Chbyte *) string, strCharSet); |
| 771 | 6483 } |
| 6484 | |
| 867 | 6485 DECLARE_INLINE_HEADER (Ibyte *qxestrpbrk (const Ibyte *string, |
| 2367 | 6486 const CIbyte *strCharSet)) |
| 771 | 6487 { |
| 2367 | 6488 return (Ibyte *) strpbrk ((const Chbyte *) string, strCharSet); |
| 771 | 6489 } |
| 6490 | |
| 867 | 6491 DECLARE_INLINE_HEADER (Ibyte *qxestrtok (Ibyte *strToken, |
| 2367 | 6492 const CIbyte *strDelimit)) |
| 771 | 6493 { |
| 2367 | 6494 return (Ibyte *) strtok ((Chbyte *) strToken, strDelimit); |
| 771 | 6495 } |
| 6496 | |
| 867 | 6497 DECLARE_INLINE_HEADER (double qxestrtod (const Ibyte *nptr, |
| 6498 Ibyte **endptr)) | |
| 771 | 6499 { |
| 2367 | 6500 return strtod ((const Chbyte *) nptr, (Chbyte **) endptr); |
| 771 | 6501 } |
| 6502 | |
| 867 | 6503 DECLARE_INLINE_HEADER (long qxestrtol (const Ibyte *nptr, Ibyte **endptr, |
| 771 | 6504 int base)) |
| 6505 { | |
| 2367 | 6506 return strtol ((const Chbyte *) nptr, (Chbyte **) endptr, base); |
| 771 | 6507 } |
| 6508 | |
| 867 | 6509 DECLARE_INLINE_HEADER (unsigned long qxestrtoul (const Ibyte *nptr, |
| 6510 Ibyte **endptr, | |
| 771 | 6511 int base)) |
| 6512 { | |
| 2367 | 6513 return strtoul ((const Chbyte *) nptr, (Chbyte **) endptr, base); |
| 771 | 6514 } |
| 6515 | |
| 867 | 6516 DECLARE_INLINE_HEADER (int qxeatoi (const Ibyte *string)) |
| 771 | 6517 { |
| 2367 | 6518 return atoi ((const Chbyte *) string); |
| 771 | 6519 } |
| 6520 | |
| 1204 | 6521 DECLARE_INLINE_HEADER (Ibyte *qxestrupr (Ibyte *s)) |
| 6522 { | |
| 2367 | 6523 return (Ibyte *) strupr ((Chbyte *) s); |
| 1204 | 6524 } |
| 6525 | |
| 6526 DECLARE_INLINE_HEADER (Ibyte *qxestrlwr (Ibyte *s)) | |
| 6527 { | |
| 2367 | 6528 return (Ibyte *) strlwr ((Chbyte *) s); |
| 1204 | 6529 } |
| 6530 | |
| 867 | 6531 int qxesprintf (Ibyte *buffer, const CIbyte *format, ...) |
| 771 | 6532 PRINTF_ARGS (2, 3); |
| 6533 | |
| 2367 | 6534 DECLARE_INLINE_HEADER (int qxesscanf_ascii_1 (Ibyte *buffer, |
| 6535 const Ascbyte *format, | |
| 6536 void *ptr)) | |
| 6537 { | |
| 6538 /* #### DAMNIT! No vsscanf! */ | |
| 6539 return sscanf ((Chbyte *) buffer, format, ptr); | |
| 6540 } | |
| 6541 | |
| 771 | 6542 /* Do not use POSIX locale routines. Not Mule-correct. */ |
| 6543 #define qxestrcoll DO NOT USE. | |
| 6544 #define qxestrxfrm DO NOT USE. | |
| 6545 | |
| 867 | 6546 int qxestrcasecmp (const Ibyte *s1, const Ibyte *s2); |
| 2367 | 6547 int qxestrcasecmp_ascii (const Ibyte *s1, const Ascbyte *s2); |
| 867 | 6548 int qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2); |
| 2367 | 6549 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
|
6550 int lisp_strcasecmp_ascii (Lisp_Object s1, Lisp_Object s2); |
| 771 | 6551 int lisp_strcasecmp_i18n (Lisp_Object s1, Lisp_Object s2); |
| 867 | 6552 int qxestrncasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 2367 | 6553 int qxestrncasecmp_ascii (const Ibyte *s1, const Ascbyte *s2, |
| 6554 Bytecount len); | |
| 867 | 6555 int qxestrncasecmp_i18n (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 2367 | 6556 int ascii_strncasecmp (const Ascbyte *s1, const Ascbyte *s2, |
| 771 | 6557 Bytecount len); |
| 867 | 6558 int qxememcmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 6559 int qxememcmp4 (const Ibyte *s1, Bytecount len1, | |
| 6560 const Ibyte *s2, Bytecount len2); | |
| 6561 int qxememcasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); | |
| 6562 int qxememcasecmp4 (const Ibyte *s1, Bytecount len1, | |
| 6563 const Ibyte *s2, Bytecount len2); | |
| 6564 int qxetextcmp (const Ibyte *s1, Bytecount len1, | |
| 6565 const Ibyte *s2, Bytecount len2); | |
| 6566 int qxetextcmp_matching (const Ibyte *s1, Bytecount len1, | |
| 6567 const Ibyte *s2, Bytecount len2, | |
| 801 | 6568 Charcount *matching); |
| 867 | 6569 int qxetextcasecmp (const Ibyte *s1, Bytecount len1, |
| 6570 const Ibyte *s2, Bytecount len2); | |
| 6571 int qxetextcasecmp_matching (const Ibyte *s1, Bytecount len1, | |
| 6572 const Ibyte *s2, Bytecount len2, | |
| 801 | 6573 Charcount *matching); |
| 771 | 6574 |
| 6575 void buffer_mule_signal_inserted_region (struct buffer *buf, Charbpos start, | |
| 6576 Bytecount bytelength, | |
| 6577 Charcount charlength); | |
| 6578 void buffer_mule_signal_deleted_region (struct buffer *buf, Charbpos start, | |
| 826 | 6579 Charbpos end, Bytebpos byte_start, |
| 6580 Bytebpos byte_end); | |
| 771 | 6581 |
| 2367 | 6582 typedef struct |
| 6583 { | |
| 6584 const char *srctext; | |
| 6585 void *dst; | |
| 6586 Bytecount dst_size; | |
| 6587 } alloca_convert_vals; | |
| 6588 | |
| 6589 typedef struct | |
| 6590 { | |
| 6591 Dynarr_declare (alloca_convert_vals); | |
| 6592 } alloca_convert_vals_dynarr; | |
| 6593 | |
| 6594 extern alloca_convert_vals_dynarr *active_alloca_convert; | |
| 6595 | |
| 6596 MODULE_API int find_pos_of_existing_active_alloca_convert (const char * | |
| 6597 srctext); | |
| 6598 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6599 /* Defined in undo.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6600 extern Lisp_Object Qinhibit_read_only; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6601 |
| 771 | 6602 /* Defined in unicode.c */ |
| 1204 | 6603 extern const struct sized_memory_description to_unicode_description; |
| 6604 extern const struct sized_memory_description from_unicode_description; | |
| 771 | 6605 void init_charset_unicode_tables (Lisp_Object charset); |
| 6606 void free_charset_unicode_tables (Lisp_Object charset); | |
| 6607 void recalculate_unicode_precedence (void); | |
| 6608 extern Lisp_Object Qunicode; | |
| 4096 | 6609 extern Lisp_Object Qutf_16, Qutf_8, Qucs_4, Qutf_7, Qutf_32; |
| 771 | 6610 #ifdef MEMORY_USAGE_STATS |
| 6611 Bytecount compute_from_unicode_table_size (Lisp_Object charset, | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
6612 struct usage_stats *stats); |
| 771 | 6613 Bytecount compute_to_unicode_table_size (Lisp_Object charset, |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
6614 struct usage_stats *stats); |
| 771 | 6615 #endif /* MEMORY_USAGE_STATS */ |
| 6616 | |
| 428 | 6617 /* Defined in undo.c */ |
| 826 | 6618 EXFUN (Fundo_boundary, 0); |
| 6619 | |
| 428 | 6620 Lisp_Object truncate_undo_list (Lisp_Object, int, int); |
| 6621 void record_extent (Lisp_Object, int); | |
| 665 | 6622 void record_insert (struct buffer *, Charbpos, Charcount); |
| 6623 void record_delete (struct buffer *, Charbpos, Charcount); | |
| 6624 void record_change (struct buffer *, Charbpos, Charcount); | |
| 428 | 6625 |
| 6626 /* Defined in unex*.c */ | |
| 814 | 6627 #ifdef WIN32_NATIVE |
| 867 | 6628 int unexec (Ibyte *, Ibyte *, uintptr_t, uintptr_t, uintptr_t); |
| 814 | 6629 #else |
| 6630 int unexec (Extbyte *, Extbyte *, uintptr_t, uintptr_t, uintptr_t); | |
| 6631 #endif | |
| 428 | 6632 #ifdef RUN_TIME_REMAP |
| 6633 int run_time_remap (char *); | |
| 6634 #endif | |
| 6635 | |
| 6636 /* Defined in vm-limit.c */ | |
| 442 | 6637 void memory_warnings (void *, void (*) (const char *)); |
| 428 | 6638 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6639 /* Defined in win32.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6640 extern Lisp_Object Vmswindows_downcase_file_names; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6641 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6642 /* Defined in window.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6643 extern Lisp_Object Qwindow_live_p; |
| 1927 | 6644 |
| 1743 | 6645 END_C_DECLS |
| 1650 | 6646 |
| 440 | 6647 #endif /* INCLUDED_lisp_h_ */ |