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