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