Mercurial > hg > xemacs-beta
annotate src/lisp.h @ 5353:38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
lisp/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el:
* bytecomp.el (byte-compile-initial-macro-environment):
Shadow `block', `return-from' here, we implement them differently
when byte-compiling.
* bytecomp.el (byte-compile-active-blocks): New.
* bytecomp.el (byte-compile-block-1): New.
* bytecomp.el (byte-compile-return-from-1): New.
* bytecomp.el (return-from-1): New.
* bytecomp.el (block-1): New.
These are two aliases that exist to have their own associated
byte-compile functions, which functions implement `block' and
`return-from'.
* cl-extra.el (cl-macroexpand-all):
Fix a bug here when macros in the environment have been compiled.
* cl-macs.el (block):
* cl-macs.el (return):
* cl-macs.el (return-from):
Be more careful about lexical scope in these macros.
* cl.el:
* cl.el ('cl-block-wrapper): Removed.
* cl.el ('cl-block-throw): Removed.
These aren't needed in code generated by this XEmacs. They
shouldn't be needed in code generated by XEmacs 21.4, but if it
turns out the packages do need them, we can put them back.
2011-01-30 Mike Sperber <mike@xemacs.org>
* font-lock.el (font-lock-fontify-pending-extents): Don't fail if
`font-lock-mode' is unset, which can happen in the middle of
`revert-buffer'.
2011-01-23 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete):
* cl-macs.el (delq):
* cl-macs.el (remove):
* cl-macs.el (remq):
Don't use the compiler macro if these functions were given the
wrong number of arguments, as happens in lisp-tests.el.
* cl-seq.el (remove, remq): Removed.
I added these to subr.el, and forgot to remove them from here.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-setq, byte-compile-set):
Remove kludge allowing keywords' values to be set, all the code
that does that is gone.
* cl-compat.el (elt-satisfies-test-p):
* faces.el (set-face-parent):
* faces.el (face-doc-string):
* gtk-font-menu.el:
* gtk-font-menu.el (gtk-reset-device-font-menus):
* msw-font-menu.el:
* msw-font-menu.el (mswindows-reset-device-font-menus):
* package-get.el (package-get-installedp):
* select.el (select-convert-from-image-data):
* sound.el:
* sound.el (load-sound-file):
* x-font-menu.el (x-reset-device-font-menus-core):
Don't quote keywords, they're self-quoting, and the
win from backward-compatibility is sufficiently small now that the
style problem overrides it.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (block, return-from): Require that NAME be a symbol
in these macros, as always documented in the #'block docstring and
as required by Common Lisp.
* descr-text.el (unidata-initialize-unihan-database):
Correct the use of non-symbols in #'block and #'return-from in
this function.
2011-01-15 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (concatenate): Accept more complicated TYPEs in this
function, handing the sequences over to #'coerce if we don't
understand them here.
* cl-macs.el (inline): Don't proclaim #'concatenate as inline, its
compiler macro is more useful than doing that.
2011-01-11 Aidan Kehoe <kehoea@parhasard.net>
* subr.el (delete, delq, remove, remq): Move #'remove, #'remq
here, they don't belong in cl-seq.el; move #'delete, #'delq here
from fns.c, implement them in terms of #'delete*, allowing support
for sequences generally.
* update-elc.el (do-autoload-commands): Use #'delete*, not #'delq
here, now the latter's no longer dumped.
* cl-macs.el (delete, delq): Add compiler macros transforming
#'delete and #'delq to #'delete* calls.
2011-01-10 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box): Correct a misplaced parenthesis
here, thank you Mats Lidell in 87zkr9gqrh.fsf@mail.contactor.se !
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box):
* list-mode.el (display-completion-list):
These functions used to use cl-parsing-keywords; change them to
use defun* instead, fixing the build. (Not sure what led to me
not including this change in d1b17a33450b!)
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (define-star-compiler-macros):
Make sure the form has ITEM and LIST specified before attempting
to change to calls with explicit tests; necessary for some tests
in lisp-tests.el to compile correctly.
(stable-union, stable-intersection): Add compiler macros for these
functions, in the same way we do for most of the other functions
in cl-seq.el.
2011-01-01 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (dolist, dotimes, do-symbols, macrolet)
(symbol-macrolet):
Define these macros with defmacro* instead of parsing the argument
list by hand, for the sake of style and readability; use backquote
where appropriate, instead of calling #'list and and friends, for
the same reason.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* x-misc.el (device-x-display):
Provide this function, documented in the Lispref for years, but
not existing previously. Thank you Julian Bradfield, thank you
Jeff Mincy.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl-seq.el:
Move the heavy lifting from this file to C. Dump the
cl-parsing-keywords macro, but don't use defun* for the functions
we define that do take keywords, dynamic scope lossage makes that
not practical.
* subr.el (sort, fillarray): Move these aliases here.
(map-plist): #'nsublis is now built-in, but at this point #'eql
isn't necessarily available as a test; use #'eq.
* obsolete.el (cl-delete-duplicates): Make this available for old
compiler macros and old code.
(memql): Document that this is equivalent to #'member*, and worse.
* cl.el (adjoin, subst): Removed. These are in C.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* simple.el (assoc-ignore-case): Remove a duplicate definition of
this function (it's already in subr.el).
* iso8859-1.el (char-width):
On non-Mule, make this function equivalent to that produced by
(constantly 1), but preserve its docstring.
* subr.el (subst-char-in-string): Define this in terms of
#'substitute, #'nsubstitute.
(string-width): Define this using #'reduce and #'char-width.
(char-width): Give this a simpler definition, it makes far more
sense to check for mule at load time and redefine, as we do in
iso8859-1.el.
(store-substring): Implement this in terms of #'replace, now
#'replace is cheap.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* update-elc.el (lisp-files-needed-for-byte-compilation)
(lisp-files-needing-early-byte-compilation):
cl-macs belongs in the former, not the latter, it is as
fundamental as bytecomp.el.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl.el:
Provde the Common Lisp program-error, type-error as error
symbols. This doesn't nearly go far enough for anyone using the
Common Lisp errors.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete-duplicates):
If the form has an incorrect number of arguments, don't attempt a
compiler macroexpansion.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (cl-safe-expr-p):
Forms that start with the symbol lambda are also safe.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
For these functions' compiler macros, the optimisation is safe
even if the first and the last arguments have side effects, since
they're only used the once.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (inline-side-effect-free-compiler-macros):
Unroll a loop here at macro-expansion time, so these compiler
macros are compiled. Use #'eql instead of #'eq in a couple of
places for better style.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (notany, notevery): Avoid some dynamic scope
stupidity with local variable names in these functions, when they
weren't prefixed with cl-; go into some more detail in the doc
strings.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns): #'remove, #'remq are
free of side-effects.
(side-effect-and-error-free-fns):
Drop dot, dot-marker from the list.
2010-11-17 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (coerce):
In the argument list, name the first argument OBJECT, not X; the
former name was always used in the doc string and is clearer.
Handle vector type specifications which include the length of the
target sequence, error if there's a mismatch.
* cl-macs.el (cl-make-type-test): Handle type specifications
starting with the symbol 'eql.
2010-11-14 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (eql): Don't remove the byte-compile property of this
symbol. That was necessary to override a bug in bytecomp.el where
#'eql was confused with #'eq, which bug we no longer have.
If neither expression is constant, don't attempt to handle the
expression in this compiler macro, leave it to byte-compile-eql,
which produces better code anyway.
* bytecomp.el (eq): #'eql is not the function associated with the
byte-eq byte code.
(byte-compile-eql): Add an explicit compile method for this
function, for cases where the cl-macs compiler macro hasn't
reduced it to #'eq or #'equal.
2010-10-25 Aidan Kehoe <kehoea@parhasard.net>
Add compiler macros and compilation sanity-checking for various
functions that take keywords.
* byte-optimize.el (side-effect-free-fns): #'symbol-value is
side-effect free and not error free.
* bytecomp.el (byte-compile-normal-call): Check keyword argument
lists for sanity; store information about the positions where
keyword arguments start using the new byte-compile-keyword-start
property.
* cl-macs.el (cl-const-expr-val): Take a new optional argument,
cl-not-constant, defaulting to nil, in this function; return it if
the expression is not constant.
(cl-non-fixnum-number-p): Make this into a separate function, we
want to pass it to #'every.
(eql): Use it.
(define-star-compiler-macros): Use the same code to generate the
member*, assoc* and rassoc* compiler macros; special-case some
code in #'add-to-list in subr.el.
(remove, remq): Add compiler macros for these two functions, in
preparation for #'remove being in C.
(define-foo-if-compiler-macros): Transform (remove-if-not ...) calls to
(remove ... :if-not) at compile time, which will be a real win
once the latter is in C.
(define-substitute-if-compiler-macros)
(define-subst-if-compiler-macros): Similarly for these functions.
(delete-duplicates): Change this compiler macro to use
#'plists-equal; if we don't have information about the type of
SEQUENCE at compile time, don't bother attempting to inline the
call, the function will be in C soon enough.
(equalp): Remove an old commented-out compiler macro for this, if
we want to see it it's in version control.
(subst-char-in-string): Transform this to a call to nsubstitute or
nsubstitute, if that is appropriate.
* cl.el (ldiff): Don't call setf here, this makes for a load-time
dependency problem in cl-macs.el
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* term/vt100.el:
Refer to XEmacs, not GNU Emacs, in permissions.
* term/bg-mouse.el:
* term/sup-mouse.el:
Put copyright notice in canonical "Copyright DATE AUTHOR" form.
Refer to XEmacs, not GNU Emacs, in permissions.
* site-load.el:
Add permission boilerplate.
* mule/canna-leim.el:
* alist.el:
Refer to XEmacs, not APEL/this program, in permissions.
* mule/canna-leim.el:
Remove my copyright, I've assigned it to the FSF.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* gtk.el:
* gtk-widget-accessors.el:
* gtk-package.el:
* gtk-marshal.el:
* gtk-compose.el:
* gnome.el:
Add copyright notice based on internal evidence.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* easymenu.el: Add reference to COPYING to permission notice.
* gutter.el:
* gutter-items.el:
* menubar-items.el:
Fix typo "Xmacs" in permissions notice.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* auto-save.el:
* font.el:
* fontconfig.el:
* mule/kinsoku.el:
Add "part of XEmacs" text to permission notice.
2010-10-14 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns):
* cl-macs.el (remf, getf):
* cl-extra.el (tailp, cl-set-getf, cl-do-remf):
* cl.el (ldiff, endp):
Tighten up Common Lisp compatibility for #'ldiff, #'endp, #'tailp;
add circularity checking for the first two.
#'cl-set-getf and #'cl-do-remf were Lisp implementations of
#'plist-put and #'plist-remprop; change the names to aliases,
changes the macros that use them to using #'plist-put and
#'plist-remprop directly.
2010-10-12 Aidan Kehoe <kehoea@parhasard.net>
* abbrev.el (fundamental-mode-abbrev-table, global-abbrev-table):
Create both these abbrev tables using the usual
#'define-abbrev-table calls, rather than attempting to
special-case them.
* cl-extra.el: Force cl-macs to be loaded here, if cl-extra.el is
being loaded interpreted. Previously other, later files would
redundantly call (load "cl-macs") when interpreted, it's more
reasonable to do it here, once.
* cmdloop.el (read-quoted-char-radix): Use defcustom here, we
don't have any dump-order dependencies that would prevent that.
* custom.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling, rely on cl-extra.el in the
former case and the appropriate entry in bytecomp-load-hook in the
latter. Get rid of custom-declare-variable-list, we have no
dump-time dependencies that would require it.
* faces.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling.
* packages.el: Remove some inaccurate comments.
* post-gc.el (cleanup-simple-finalizers): Use #'delete-if-not
here, now the order of preloaded-file-list has been changed to
make it available.
* subr.el (custom-declare-variable-list): Remove. No need for it.
Also remove a stub define-abbrev-table from this file, given the
current order of preloaded-file-list there's no need for it.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-constp) Forms quoted with FUNCTION are
also constant.
(byte-compile-initial-macro-environment): In #'the, if FORM is
constant and does not match TYPE, warn at byte-compile time.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* backquote.el (bq-vector-contents, bq-list*): Remove; the former
is equivalent to (append VECTOR nil), the latter to (list* ...).
(bq-process-2): Use (append VECTOR nil) instead of using
#'bq-vector-contents to convert to a list.
(bq-process-1): Now we use list* instead of bq-list
* subr.el (list*): Moved from cl.el, since it is now required to
be available the first time a backquoted form is encountered.
* cl.el (list*): Move to subr.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* test-harness.el (Check-Message):
Add an omitted comma here, thank you the buildbot.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* hash-table.el (hash-table-key-list, hash-table-value-list)
(hash-table-key-value-alist, hash-table-key-value-plist):
Remove some useless #'nreverse calls in these files; our hash
tables have no order, it's not helpful to pretend they do.
* behavior.el (read-behavior):
Do the same in this file, in some code evidently copied from
hash-table.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* info.el (Info-insert-dir):
* format.el (format-deannotate-region):
* files.el (cd, save-buffers-kill-emacs):
Use #'some, #'every and related functions for applying boolean
operations to lists, instead of rolling our own ones that cons and
don't short-circuit.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-initial-macro-environment):
* cl-macs.el (the):
Rephrase the docstring, make its implementation when compiling
files a little nicer.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* descr-text.el (unidata-initialize-unicodedata-database)
(unidata-initialize-unihan-database, describe-char-unicode-data)
(describe-char-unicode-data):
Wrap calls to the database functions with (with-fboundp ...),
avoiding byte compile warnings on builds without support for the
database functions.
(describe-char): (reduce #'max ...), not (apply #'max ...), no
need to cons needlessly.
(describe-char): Remove a redundant lambda wrapping
#'extent-properties.
(describe-char-unicode-data): Call #'nsubst when replacing "" with
nil in the result of #'split-string, instead of consing inside
mapcar.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* x-faces.el (x-available-font-sizes):
* specifier.el (let-specifier):
* package-ui.el (pui-add-required-packages):
* msw-faces.el (mswindows-available-font-sizes):
* modeline.el (modeline-minor-mode-menu):
* minibuf.el (minibuf-directory-files):
Replace the O2N (delq nil (mapcar (lambda (W) (and X Y)) Z)) with
the ON (mapcan (lambda (W) (and X (list Y))) Z) in these files.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
When these functions are handed more than two arguments, and those
arguments have no side effects, transform to a series of two
argument calls, avoiding funcall in the byte-compiled code.
* mule/mule-cmds.el (finish-set-language-environment):
Take advantage of this change in a function called 256 times at
startup.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-function-form, byte-compile-quote)
(byte-compile-quote-form):
Warn at compile time, and error at runtime, if a (quote ...) or a
(function ...) form attempts to quote more than one object.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (byte-optimize-apply): Transform (apply 'nconc
(mapcar ...)) to (mapcan ...); warn about use of the first idiom.
* update-elc.el (do-autoload-commands):
* packages.el (packages-find-package-library-path):
* frame.el (frame-list):
* extents.el (extent-descendants):
* etags.el (buffer-tag-table-files):
* dumped-lisp.el (preloaded-file-list):
* device.el (device-list):
* bytecomp-runtime.el (proclaim-inline, proclaim-notinline)
Use #'mapcan, not (apply #'nconc (mapcar ...) in all these files.
* bytecomp-runtime.el (eval-when-compile, eval-and-compile):
In passing, mention that these macros also evaluate the body when
interpreted.
tests/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Test lexical scope for `block', `return-from'; add a
Known-Bug-Expect-Failure for a contorted example that fails when
byte-compiled.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Mon, 07 Feb 2011 12:01:24 +0000 |
| parents | 94bbd4792049 |
| children | 22c4e67a2e69 0af042a0c116 |
| rev | line source |
|---|---|
| 428 | 1 /* Fundamental definitions for XEmacs Lisp interpreter. |
| 2 Copyright (C) 1985-1987, 1992-1995 Free Software Foundation, Inc. | |
| 3 Copyright (C) 1993-1996 Richard Mlynarik. | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
4 Copyright (C) 1995, 1996, 2000-2005, 2009, 2010 Ben Wing. |
| 428 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
| 8 XEmacs is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 10 Free Software Foundation; either version 2, or (at your option) any | |
| 11 later version. | |
| 12 | |
| 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with XEmacs; see the file COPYING. If not, write to | |
| 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 21 Boston, MA 02111-1307, USA. */ | |
| 22 | |
| 23 /* Synched up with: FSF 19.30. */ | |
| 24 | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
25 #ifndef INCLUDED_lisp_h_ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
26 #define INCLUDED_lisp_h_ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
27 |
| 853 | 28 /* Authorship: |
| 29 | |
| 30 Based on code from pre-release FSF 19, c. 1991. | |
| 31 Various changes by Jamie Zawinski 1991-1994: | |
| 32 converting to ANSI C, splitting out function prototypes to a separate | |
| 33 file (later moved back for unknown reasons by Steve Baur?), debug-gcpro | |
| 34 stuff (now moribund). | |
| 35 ANSI-fication of DEFUN macros by Felix Lee, c. 1992? | |
| 36 NOT_REACHED, DOESNT_RETURN, PRINTF_ARGS by Richard Mlynarik, c. 1994. | |
| 37 Many changes over the years corresponding to Lisp_Object definition | |
| 38 changes, esp. by Richard Mlynarik (c. 1993) and Kyle Jones (c. 1998). | |
| 39 See alloc.c for more details. | |
| 40 Overhauled and reordered by Ben Wing, 1995-1996, and many things added: | |
| 41 Dynarrs, REALLOC macros, asserts, typedefs, inline header code, | |
| 42 first LIST_LOOP macros, CONCHECK_*, all error-checking code | |
| 43 (e.g. error-checking versions of XFOO macros), structure read syntax, | |
| 44 weak lists, lcrecord lists, reworking of quit handling, object hashing, | |
| 45 nested GCPRO, character objects and Ebola checking, memory usage stats, | |
| 46 others. | |
| 47 LOADHIST changes from Steve Baur, c. 1997? | |
| 48 Various macro-related changes by Martin Buchholz, 1998-1999: | |
| 49 LIST_LOOP macros greatly expanded and tortoise-hared; | |
| 50 RETURN_SANS_WARNINGS; reworked DEFUN macros; EXFUN macros (???). | |
| 1743 | 51 Various macro-related changes by Jerry James, 2003: |
| 52 MODULE_API introduced; | |
| 53 Compiler-specific definitions modernized and moved to compiler.h. | |
| 853 | 54 */ |
| 55 | |
| 2367 | 56 /* Conventions in comments: |
| 57 | |
| 58 "Mule-izing" is the process of going through a file and eliminating | |
| 59 assumptions that the internal format (Ibyte * text) is the same as the | |
| 60 external format used by library routines. Mule-ization should also | |
| 61 include replacing *ALL* raw references to `char' or `unsigned char' with | |
| 62 one of the self-documenting types created below. How exactly to do the | |
| 63 conversion, and how to write correctly Mule-ized code, is described in | |
| 64 the internals manual. Files that say "This file is Mule-ized" have | |
| 65 been reviewed at some point; that's not to say that incorrect code hasn't | |
| 66 crept in, though. | |
| 67 | |
| 68 "Unicode-splitting" is the process of fixing a file so that it will | |
| 69 handle external text in Unicode under Microsoft Windows, as appropriate. | |
| 70 ("splitting" because it needs to handle either Unicode or variable-width | |
| 71 multibyte depending on the OS -- NT or 9x). See intl-win32.c. | |
| 72 | |
| 73 #### is a way of marking problems of any sort. | |
| 74 | |
| 75 !!#### marks places that are not properly Mule-ized. | |
| 76 | |
| 77 &&#### marks places that need to be fixed in order for the "8-bit mule" | |
| 78 conversion to work correctly, i.e. in order to support multiple different | |
| 79 buffer formats under Mule, including a fixed 8-bit format. | |
| 80 | |
| 81 ^^#### marks places that need to be fixed in order to eliminate the | |
| 82 assumption that Ibyte * text is composed of 1-byte units (e.g. UTF-16 | |
| 83 is composed of 2-byte units and might be a possible format to consider | |
| 84 for Ibyte * text). | |
| 85 | |
| 86 %%#### marks places that need work for KKCC (the new garbage collector). | |
| 87 | |
| 5090 | 88 @@#### marks places that need work to get Unicode-internal working, |
| 89 i.e. using UTF-8 as the internal text format. | |
| 90 | |
| 91 #### BILL! marks places that need work for GTK. | |
| 92 | |
| 93 #### GEOM! marks places needing work to fix various bugs in the handling | |
| 94 of window and frame sizing and positioning. Often the root of the | |
| 95 problems is that the code was originally written before there was a | |
| 96 gutter and then not completely fixed up to accommodate the gutter. | |
| 97 | |
| 2367 | 98 */ |
| 99 | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
100 /************************************************************************/ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
101 /* include files */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
102 /************************************************************************/ |
| 442 | 103 |
| 428 | 104 /* We include the following generally useful header files so that you |
| 105 don't have to worry about prototypes when using the standard C | |
| 106 library functions and macros. These files shouldn't be excessively | |
| 107 large so they shouldn't cause that much of a slowdown. */ | |
| 108 | |
| 109 #include <stdlib.h> | |
|
5016
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
110 /* Evil, but ... -Wshadow is genuinely useful but also leads to spurious |
|
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
111 warnings when you have a local var named `index'. Avoid this by |
|
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
112 hacking around it. */ |
|
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
113 #define index old_index |
| 428 | 114 #include <string.h> /* primarily for memcpy, etc. */ |
|
5016
2ade80e8c640
enable more warnings and fix them
Ben Wing <ben@xemacs.org>
parents:
5015
diff
changeset
|
115 #undef index |
| 428 | 116 #include <stdio.h> /* NULL, etc. */ |
| 117 #include <ctype.h> | |
| 118 #include <stdarg.h> | |
| 119 #include <stddef.h> /* offsetof */ | |
| 120 #include <sys/types.h> | |
| 442 | 121 #include <limits.h> |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
122 #include <math.h> |
| 4932 | 123 #ifdef __cplusplus |
| 124 #include <limits> /* necessary for max()/min() under G++ 4 */ | |
| 125 #endif | |
| 126 | |
| 442 | 127 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
128 /************************************************************************/ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
129 /* error checking */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
130 /************************************************************************/ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
131 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
132 /* ------------------------- large categories ------------------------- */ |
| 853 | 133 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
134 /* How these work: |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
135 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
136 The most common classes will be `text' and `type', followed by `structure'. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
137 `text' is for problems related to bad textual format. `type' is for |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
138 problems related to wrongly typed arguments, structure fields, etc. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
139 `structure' is for bad data inside of a structure. Sometimes these are |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
140 used "incorrectly", e.g. `type' is often used for structure-checking. |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
141 Consider `text': |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
142 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
143 `text_checking_assert() will assert() only when ERROR_CHECK_TEXT is defined; |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
144 otherwise it's a no-op. text_checking_assert_at_line() is similar, but |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
145 allows you to override the file name and line number normally supplied in |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
146 the message. This is especially useful in inline header functions, and |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
147 so there's a special inline_text_checking_assert() for this; this works |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
148 like text_checking_assert() but supplies the file and line of the calling |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
149 function. In order for this to work, you need to declare your inline |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
150 function with INLINE_TEXT_CHECK_ARGS at the end of its argument list, |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
151 and give its function name a _1 extension or similar. Then create a |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
152 macro that calls your inline function and includes INLINE_TEXT_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
153 at the end of the parameter list. This will arrange to pass in and receive |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
154 the file and line (__FILE__, __LINE__) at place where the call occurs in |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
155 the calling function; but nothing will get passed in when ERROR_CHECK_TEXT |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
156 is not defined. |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
157 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
158 Currently the full bevy of *foo_checking_assert* macros are defined only |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
159 for `text' and `types'; for others, only the basic foo_checking_assert() |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
160 macro is defined. Writing out all the variations for all possible error |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
161 categories would produce too much clutter. If any of these become |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
162 needed, they can always be defined. */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
163 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
164 /* #### I suggest revamping these and making proper use of the |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
165 category/subcategory system. Here is one proposal: |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
166 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
167 Major category Minor categories |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
168 -------------------------------- |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
169 Allocation |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
170 Malloc |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
171 Dynarr |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
172 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
173 Display |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
174 Extents |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
175 Glyphs |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
176 Redisplay |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
177 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
178 Execution |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
179 Byte-Code |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
180 Catch |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
181 Garbage Collection |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
182 Trapping-Problems |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
183 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
184 Lisp Objects |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
185 Buffers |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
186 Char Tables |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
187 Events |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
188 Lstreams |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
189 Hash Tables |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
190 Range Tables |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
191 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
192 Types |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
193 Lrecord Types |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
194 Subtypes |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
195 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
196 Text |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
197 Byte Positions |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
198 Conversion |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
199 Eistrings |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
200 Itext |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
201 Lisp Strings |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
202 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
203 --ben |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
204 */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
205 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
206 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
207 #define INLINE_ERROR_CHECK_ARGS , const char *__file__, int __line__ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
208 #define INLINE_ERROR_CHECK_CALL , __FILE__, __LINE__ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
209 #define DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
210 #define DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
211 |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
212 /* For assertions in inline header functions which will report the file and |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
213 line of the calling function */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
214 #define inline_assert(assertion) assert_at_line (assertion, __file__, __line__) |
|
5021
4e784bfabae7
fix bad defn of disabled inline assert
Ben Wing <ben@xemacs.org>
parents:
5020
diff
changeset
|
215 /* The following should not use disabled_assert_at_line() because when the |
|
4e784bfabae7
fix bad defn of disabled inline assert
Ben Wing <ben@xemacs.org>
parents:
5020
diff
changeset
|
216 inline assert is disabled, params __file__ and __line__ do not exist. */ |
|
4e784bfabae7
fix bad defn of disabled inline assert
Ben Wing <ben@xemacs.org>
parents:
5020
diff
changeset
|
217 #define disabled_inline_assert(assertion) disabled_assert (assertion) |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
218 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
219 /* ------- the specific categories -------- */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
220 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
221 #if defined (ERROR_CHECK_BYTE_CODE) || defined (ERROR_CHECK_DISPLAY) || defined (ERROR_CHECK_EXTENTS) || defined (ERROR_CHECK_GC) || defined (ERROR_CHECK_GLYPHS) || defined (ERROR_CHECK_MALLOC) || defined (ERROR_CHECK_STRUCTURES) || defined (ERROR_CHECK_TEXT) || defined (ERROR_CHECK_TYPES) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
222 #define ERROR_CHECK_ANY |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
223 #endif |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
224 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
225 /* KEEP THESE SORTED! */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
226 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
227 #ifdef ERROR_CHECK_BYTE_CODE |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
228 #define byte_code_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
229 #else /* not ERROR_CHECK_BYTE_CODE */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
230 #define byte_code_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
231 #endif /* ERROR_CHECK_BYTE_CODE */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
232 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
233 #ifdef ERROR_CHECK_DISPLAY |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
234 #define display_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
235 #else /* not ERROR_CHECK_DISPLAY */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
236 #define display_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
237 #endif /* ERROR_CHECK_DISPLAY */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
238 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
239 #ifdef ERROR_CHECK_EXTENTS |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
240 #define extent_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
241 #else /* not ERROR_CHECK_EXTENTS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
242 #define extent_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
243 #endif /* ERROR_CHECK_EXTENTS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
244 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
245 #ifdef ERROR_CHECK_GC |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
246 #define gc_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
247 #else /* not ERROR_CHECK_GC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
248 #define gc_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
249 #endif /* ERROR_CHECK_GC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
250 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
251 #ifdef ERROR_CHECK_GLYPHS |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
252 #define glyph_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
253 #else /* not ERROR_CHECK_GLYPHS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
254 #define glyph_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
255 #endif /* ERROR_CHECK_GLYPHS */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
256 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
257 #ifdef ERROR_CHECK_MALLOC |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
258 #define malloc_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
259 #else /* not ERROR_CHECK_MALLOC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
260 #define malloc_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
261 #endif /* ERROR_CHECK_MALLOC */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
262 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
263 #ifdef ERROR_CHECK_STRUCTURES |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
264 #define structure_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
265 #else /* not ERROR_CHECK_STRUCTURES */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
266 #define structure_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
267 #endif /* ERROR_CHECK_STRUCTURES */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
268 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
269 #ifdef ERROR_CHECK_TEXT |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
270 #define text_checking_assert(assertion) assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
271 #define text_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
272 assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
273 #define inline_text_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
274 #define INLINE_TEXT_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
275 #define INLINE_TEXT_CHECK_CALL INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
276 #define text_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
277 assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
278 #else /* not ERROR_CHECK_TEXT */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
279 #define text_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
280 #define text_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
281 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
282 #define inline_text_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
283 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
284 #define INLINE_TEXT_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
285 #define INLINE_TEXT_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
286 #define text_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
287 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
288 #endif /* ERROR_CHECK_TEXT */ |
| 853 | 289 |
| 1318 | 290 #ifdef ERROR_CHECK_TYPES |
| 291 #define type_checking_assert(assertion) assert (assertion) | |
| 292 #define type_checking_assert_at_line(assertion, file, line) \ | |
| 293 assert_at_line (assertion, file, line) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
294 #define inline_type_checking_assert(assertion) inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
295 #define INLINE_TYPE_CHECK_ARGS INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
296 #define INLINE_TYPE_CHECK_CALL INLINE_ERROR_CHECK_CALL |
| 1318 | 297 #define type_checking_assert_with_message(assertion, msg) \ |
| 298 assert_with_message (assertion, msg) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
299 #else /* not ERROR_CHECK_TYPES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
300 #define type_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
301 #define type_checking_assert_at_line(assertion, file, line) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
302 disabled_assert_at_line (assertion, file, line) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
303 #define inline_type_checking_assert(assertion) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
304 disabled_inline_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
305 #define INLINE_TYPE_CHECK_ARGS DISABLED_INLINE_ERROR_CHECK_ARGS |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
306 #define INLINE_TYPE_CHECK_CALL DISABLED_INLINE_ERROR_CHECK_CALL |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
307 #define type_checking_assert_with_message(assertion, msg) \ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
308 disabled_assert_with_message (assertion, msg) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
309 #endif /* ERROR_CHECK_TYPES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
310 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
311 /* ------------------------- small categories ------------------------- */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
312 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
313 /* The large categories established by configure can be subdivided into |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
314 smaller subcategories, for problems in specific modules. You can't |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
315 control this using configure, but you can manually stick in a define as |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
316 necessary. |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
317 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
318 The idea is to go ahead and create a new type of error-checking and |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
319 have it turned on if the larger category it is a part of is also |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
320 turned on. For example, ERROR_CHECK_DYNARR is considered a subcategory |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
321 of ERROR_CHECK_STRUCTURES. |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
322 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
323 We also define foo_checking_assert() macros for convenience, but |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
324 generally don't define the many variations of this macro as for the |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
325 major types above, because it produces too much clutter. If any of |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
326 these become needed, they can always be defined. */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
327 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
328 #ifdef ERROR_CHECK_STRUCTURES |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
329 /* Check for problems with the catch list and specbind stack */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
330 #define ERROR_CHECK_CATCH |
| 5038 | 331 /* Check for incoherent dynarr structures, attempts to access Dynarr |
| 332 positions out of range, reentrant use of dynarrs through dynarr locking, | |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
333 etc. */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
334 #define ERROR_CHECK_DYNARR |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
335 /* Check for insufficient use of call_trapping_problems(), particularly |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
336 due to glyph-related changes causing eval or QUIT within redisplay */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
337 #define ERROR_CHECK_TRAPPING_PROBLEMS |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
338 #endif /* ERROR_CHECK_STRUCTURES */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
339 |
|
5023
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
340 #ifdef ERROR_CHECK_CATCH |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
341 #define catch_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
342 #else /* not ERROR_CHECK_CATCH */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
343 #define catch_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
344 #endif /* ERROR_CHECK_CATCH */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
345 |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
346 #ifdef ERROR_CHECK_DYNARR |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
347 #define dynarr_checking_assert(assertion) assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
348 #else /* not ERROR_CHECK_DYNARR */ |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
349 #define dynarr_checking_assert(assertion) disabled_assert (assertion) |
|
838630c0734f
error-checking, Windows shutdown changes
Ben Wing <ben@xemacs.org>
parents:
5021
diff
changeset
|
350 #endif /* ERROR_CHECK_DYNARR */ |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
351 |
| 1318 | 352 #ifdef ERROR_CHECK_TRAPPING_PROBLEMS |
| 353 #define trapping_problems_checking_assert(assertion) assert (assertion) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
354 #else /* not ERROR_CHECK_TRAPPING_PROBLEMS */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
355 #define trapping_problems_checking_assert(assertion) disabled_assert (assertion) |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
356 #endif /* ERROR_CHECK_TRAPPING_PROBLEMS */ |
| 1318 | 357 |
| 2367 | 358 /************************************************************************/ |
| 359 /** Definitions of basic types **/ | |
| 360 /************************************************************************/ | |
| 361 | |
| 362 /* ------------- generic 8/16/32/64/128-bit integral types ------------ */ | |
| 647 | 363 |
| 826 | 364 #if SIZEOF_SHORT == 2 |
| 365 #define INT_16_BIT short | |
| 366 #define UINT_16_BIT unsigned short | |
| 367 #elif SIZEOF_INT == 2 | |
| 368 /* Bwa ha ha. As if XEmacs could actually support such systems. */ | |
| 369 #define INT_16_BIT int | |
| 370 #define UINT_16_BIT unsigned int | |
| 371 #else | |
| 372 #error Unable to find a 16-bit integral type | |
| 373 #endif | |
| 374 | |
| 375 #if SIZEOF_INT == 4 | |
| 376 #define INT_32_BIT int | |
| 377 #define UINT_32_BIT unsigned int | |
| 378 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##U | |
| 379 #elif SIZEOF_LONG == 4 | |
| 380 /* Bwa ha ha again. */ | |
| 381 #define INT_32_BIT long | |
| 382 #define UINT_32_BIT unsigned long | |
| 383 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##UL | |
| 384 #elif SIZEOF_SHORT == 4 | |
| 385 /* And again. */ | |
| 386 #define INT_32_BIT short | |
| 387 #define UINT_32_BIT unsigned short | |
| 388 #define MAKE_32_BIT_UNSIGNED_CONSTANT(num) num##U | |
| 1429 | 389 #elif 1 /* Unable to find a 32-bit integral type! */ |
| 826 | 390 #error What kind of strange-ass system are you running on? |
| 391 #endif | |
| 392 | |
| 393 #if SIZEOF_LONG == 8 | |
| 394 #define INT_64_BIT long | |
| 395 #define UINT_64_BIT unsigned long | |
| 396 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##UL | |
| 397 #elif SIZEOF_LONG_LONG == 8 | |
| 398 #define INT_64_BIT long long | |
| 399 #define UINT_64_BIT unsigned long long | |
| 400 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##ULL | |
|
4682
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
401 #elif defined(WIN32_ANY) |
|
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
402 #define INT_64_BIT __int64 |
|
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
403 #define UINT_64_BIT unsigned __int64 |
|
648f4a0dac3e
Fix build problems on WIN32 platforms caused by the large image crash fix.
Jerry James <james@xemacs.org>
parents:
4678
diff
changeset
|
404 #define MAKE_64_BIT_UNSIGNED_CONSTANT(num) num##UI64 |
| 826 | 405 /* No error otherwise; just leave undefined */ |
| 406 #endif | |
| 407 | |
| 408 #if SIZEOF_LONG_LONG == 16 | |
| 409 #define INT_128_BIT long long | |
| 410 #define UINT_128_BIT unsigned long long | |
| 411 #define MAKE_128_BIT_UNSIGNED_CONSTANT(num) num##ULL | |
| 412 /* No error otherwise; just leave undefined */ | |
| 413 #endif | |
| 414 | |
| 415 /* #### Fill this in for other systems */ | |
| 416 #if defined (INT_64_BIT) && !(defined (i386) || defined (__i386__)) | |
| 417 #define EFFICIENT_INT_64_BIT INT_64_BIT | |
| 418 #define EFFICIENT_UINT_64_BIT UINT_64_BIT | |
| 419 #endif | |
| 420 | |
| 421 #if defined (INT_128_BIT) | |
| 422 #define EFFICIENT_INT_128_BIT INT_128_BIT | |
| 423 #define EFFICIENT_UINT_128_BIT UINT_128_BIT | |
| 424 #endif | |
| 425 | |
| 2367 | 426 #ifdef HAVE_INTTYPES_H |
| 427 #include <inttypes.h> | |
| 428 #elif defined (HAVE_INTPTR_T_IN_SYS_TYPES_H) | |
| 429 /* included elsewhere */ | |
| 430 #elif SIZEOF_VOID_P == SIZEOF_INT | |
| 431 typedef int intptr_t; | |
| 432 typedef unsigned int uintptr_t; | |
| 433 #elif SIZEOF_VOID_P == SIZEOF_LONG | |
| 434 typedef long intptr_t; | |
| 435 typedef unsigned long uintptr_t; | |
| 436 #elif defined (SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG | |
| 437 typedef long long intptr_t; | |
| 438 typedef unsigned long long uintptr_t; | |
| 439 #else | |
| 440 /* Just pray. May break, may not. */ | |
| 441 typedef long intptr_t; | |
| 442 typedef unsigned long uintptr_t; | |
| 443 #endif | |
| 444 | |
| 3988 | 445 #if SIZEOF_VOID_P == 8 |
| 446 #define DEADBEEF_CONSTANT 0xCAFEBABEDEADBEEF | |
| 447 #elif SIZEOF_VOID_P == 4 | |
| 448 #define DEADBEEF_CONSTANT 0xDEADBEEF | |
| 449 #else | |
| 450 #error "What size are your pointers, really?" | |
| 451 #endif /* SIZEOF_VOID_P == 8 */ | |
| 452 | |
| 2367 | 453 /* ---------------------- definition of EMACS_INT --------------------- */ |
| 454 | |
| 455 /* EMACS_INT is the underlying integral type into which a Lisp_Object must fit. | |
| 456 In particular, it must be large enough to contain a pointer. | |
| 457 config.h can override this, e.g. to use `long long' for bigger lisp ints. | |
| 458 | |
| 459 #### In point of fact, it would NOT be a good idea for config.h to mess | |
| 460 with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT | |
| 461 is the size of a pointer. */ | |
| 462 | |
| 463 #ifndef SIZEOF_EMACS_INT | |
| 464 # define SIZEOF_EMACS_INT SIZEOF_VOID_P | |
| 465 #endif | |
| 466 | |
| 467 #ifndef EMACS_INT | |
| 468 # if SIZEOF_EMACS_INT == SIZEOF_LONG | |
| 469 # define EMACS_INT long | |
| 470 # elif SIZEOF_EMACS_INT == SIZEOF_INT | |
| 471 # define EMACS_INT int | |
| 472 # elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG | |
| 473 # define EMACS_INT long long | |
| 474 # else | |
| 475 # error Unable to determine suitable type for EMACS_INT | |
| 476 # endif | |
| 477 #endif | |
| 478 | |
| 479 #ifndef EMACS_UINT | |
| 480 # define EMACS_UINT unsigned EMACS_INT | |
| 481 #endif | |
| 482 | |
| 483 #define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR) | |
| 484 | |
| 485 /* -------------------------- basic byte typedefs --------------------- */ | |
| 486 | |
| 487 /* The definitions we put here and in the next section use typedefs to | |
| 488 attribute specific meaning to types that by themselves are pretty | |
| 489 general. | |
| 490 | |
| 491 REMEMBER! These typedefs are purely for documentation purposes; from | |
| 647 | 492 the C code's perspective, they are exactly equivalent to `char *', |
| 493 `unsigned char *', etc., so you can freely use them with library | |
| 2367 | 494 functions declared as such. |
| 495 | |
| 496 (See also "Byte/Character Types" in text.c) | |
| 497 | |
| 498 The basic semantics for `char': | |
| 499 | |
| 500 a) [Ibyte] pointer to internally-formatted text | |
| 501 b) [Extbyte] pointer to text in some external format, which can be | |
| 502 defined as all formats other than the internal one | |
| 503 c) [Ascbyte] pure ASCII text | |
| 504 d) [Binbyte] binary data that is not meant to be interpreted as text | |
| 505 e) [Rawbyte] general data in memory, where we don't care about whether | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
506 it's text or binary; often used when computing memory- |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
507 based/byte-based offsets of pointers |
| 2367 | 508 f) [Boolbyte] a zero or a one |
| 509 g) [Bitbyte] a byte used for bit fields | |
| 510 h) [Chbyte] null-semantics `char *'; used when casting an argument to | |
| 511 an external API where the the other types may not be | |
| 512 appropriate | |
| 513 | |
| 514 | |
| 515 Prefixing codes: | |
| 516 | |
| 517 C = plain char, when the base type is unsigned | |
| 518 U = unsigned | |
| 519 S = signed | |
| 520 | |
| 521 Ideally, XEmacs code should NEVER directly use `char' or any type | |
| 522 derived from it. This is for Mule-cleanliness. If you find yourself | |
| 523 wanting or needing to use `char' and one of the above six semantics does | |
| 524 not apply, add a new type of semantics; don't use `char' directly. | |
| 525 | |
| 526 See text.c under "Byte Types", and following sections. | |
| 527 */ | |
| 647 | 528 |
| 529 /* The data representing the text in a buffer is logically a set | |
| 867 | 530 of Ibytes, declared as follows. */ |
| 531 | |
| 532 typedef unsigned char Ibyte; | |
| 647 | 533 |
| 534 /* The following should be used when you are working with internal data | |
| 535 but for whatever reason need to have it declared a "char *". Examples | |
| 536 are function arguments whose values are most commonly literal strings, | |
| 537 or where you have to apply a stdlib string function to internal data. | |
| 538 | |
| 2367 | 539 In general, you should avoid this where possible and use Ascbyte if the |
| 540 text is just ASCII (e.g. string literals) or otherwise Ibyte, for | |
| 541 consistency. For example, the new Mule workspace contains Ibyte | |
| 542 versions of the stdlib string functions. */ | |
| 867 | 543 |
| 544 typedef char CIbyte; | |
| 647 | 545 |
| 546 /* The data representing a string in "external" format (binary or any | |
| 547 external encoding) is logically a set of Extbytes, declared as | |
| 548 follows. Extbyte is guaranteed to be just a char, so for example | |
| 549 strlen (Extbyte *) is OK. Extbyte is only a documentation device | |
| 550 for referring to external text. */ | |
| 551 | |
| 552 typedef char Extbyte; | |
| 771 | 553 typedef unsigned char UExtbyte; |
| 647 | 554 |
| 2367 | 555 #define EXTTEXT_ZTERM_SIZE (sizeof (Extbyte)) |
| 647 | 556 |
| 557 /* A byte in a string in entirely US-ASCII format: (Nothing outside | |
| 558 the range 00 - 7F) */ | |
| 559 | |
| 2367 | 560 typedef char Ascbyte; |
| 561 typedef unsigned char UAscbyte; | |
| 562 | |
| 563 /* A generic memory pointer, no text or binary semantics assumed. | |
| 564 In general, there should be no manipulation of the memory pointed to | |
| 565 by these pointers other than just copying it around. */ | |
| 566 | |
| 567 typedef unsigned char Rawbyte; | |
| 568 typedef char CRawbyte; | |
| 569 | |
| 570 /* A byte in a string in binary (not meant as text) format: */ | |
| 571 | |
| 572 typedef unsigned char Binbyte; | |
| 573 typedef char CBinbyte; | |
| 574 typedef signed char SBinbyte; | |
| 575 | |
| 576 /* A byte used to represent a boolean value: 0 or 1. | |
| 577 Normally use plain Boolint, and only use Boolbyte to save space. */ | |
| 578 | |
| 579 typedef char Boolbyte; | |
| 580 | |
| 581 /* A byte composed of bitfields. Hardly ever used. */ | |
| 582 | |
| 583 typedef unsigned char Bitbyte; | |
| 584 | |
| 585 /* A no-semantics `char'. Used (pretty-much) ONLY for casting arguments to | |
| 586 functions accepting a `char *', `unsigned char *', etc. where the other | |
| 587 types don't exactly apply and what you are logically concerned with is | |
| 588 the type of the function's argument and not its semantics. | |
| 589 | |
| 590 DO NOT DO NOT DO NOT DO NOT use this as a sloppy replacement for one of | |
| 591 the other types. If you're not using this as part of casting an | |
| 592 argument to a function call, and you're not Ben Wing, you're using it | |
| 593 wrong. Go find another one of the types. */ | |
| 594 | |
| 595 typedef char Chbyte; | |
| 596 typedef unsigned char UChbyte; | |
| 597 typedef signed char SChbyte; | |
| 598 | |
| 599 /* ------------------------ other text-related typedefs ------------------- */ | |
| 647 | 600 |
| 826 | 601 /* To the user, a buffer is made up of characters. In the non-Mule world, |
| 867 | 602 characters and Ibytes are equivalent, restricted to the range 0 - 255. |
| 3498 | 603 In the Mule world, many more characters are possible (21 bits worth, |
| 867 | 604 more or less), and a character requires (typically) 1 to 4 Ibytes for |
| 826 | 605 its representation in a buffer or string. Note that the representation |
| 606 of a character by itself, in a variable, is very different from its | |
| 607 representation in a string of text (in a buffer or Lisp string). | |
| 608 | |
| 609 Under Mule, text can be represented in more than one way. The "default" | |
| 610 format is variable-width (1 to 4 bytes) and compatible with ASCII -- | |
| 611 ASCII chars are stored in one byte, as themselves, and all other chars | |
| 612 use only high bytes. The default format is currently the only format | |
| 613 used for text stored anywhere but in a buffer. In a buffer, other | |
| 614 formats -- fixed-width formats (1, 2, or 4 bytes) -- are possible, for | |
| 615 speed. | |
| 616 | |
| 617 See text.c/text.h for a detailed discussion of all of this. */ | |
| 618 | |
| 619 /* A character, as represented on its own. */ | |
| 647 | 620 |
| 867 | 621 typedef int Ichar; |
| 647 | 622 |
| 826 | 623 /* The "raw value" of a character as stored in the buffer. In the default |
| 624 format, this is just the same as the character. In fixed-width formats, | |
| 625 this is the actual value in the buffer, which will be limited to the | |
| 626 range as established by the format. This is used when searching for a | |
| 627 character in a buffer -- it's faster to convert the character to the raw | |
| 628 value and look for that, than repeatedly convert each raw value in the | |
| 629 buffer into a character. */ | |
| 630 | |
| 867 | 631 typedef int Raw_Ichar; |
| 826 | 632 |
| 2367 | 633 /* Internal text as a series of textual units (8-bit bytes in the old |
| 634 "Mule" encoding -- still the standard internal encoding -- and in UTF-8, | |
| 635 but 16-bit bytes in UTF-16 and 32-bit bytes in UTF-32). See text.c. */ | |
| 636 | |
| 637 #ifdef UTF16_IBYTE_FORMAT | |
| 638 #define NON_ASCII_INTERNAL_FORMAT | |
| 639 typedef unsigned short Itext; | |
| 640 #else | |
| 641 typedef Ibyte Itext; | |
| 642 #endif | |
| 643 typedef EMACS_INT Textcount; | |
| 644 | |
| 645 #define ITEXT_SIZE (sizeof (Itext)) | |
| 646 /* Use this to emphasize that we are adding space for the zero-terminator */ | |
| 647 #define ITEXT_ZTERM_SIZE ITEXT_SIZE | |
| 648 | |
| 649 /* Wexttext is wchar_t on WIN32_NATIVE (and perhaps other systems that | |
| 650 support wchar_t's in library functions), and Extbyte otherwise. This is | |
| 651 used whenever we have to do any sort of manipulation of | |
| 652 externally-encoded strings -- generally a very bad idea, and unsafe, but | |
| 653 in some cases we have no choice (especially at startup, and esp. prior | |
| 654 to pdump, where we haven't loaded the Unicode tables necessary for | |
| 655 conversion under Windows). On platforms where the external encoding may | |
| 656 be Unicode (i.e. Windows), we always do our manipulations in Unicode, | |
| 657 converting to and from multibyte if necessary -- otherwise we'd have to | |
| 658 conditionalize on Unicode vs. multibyte all over the place, which is | |
| 659 just a nightmare. */ | |
| 660 #ifdef WIN32_NATIVE | |
| 661 #define WEXTTEXT_IS_WIDE | |
| 662 typedef wchar_t Wexttext; | |
| 663 #else | |
| 664 typedef Extbyte Wexttext; | |
| 665 #endif | |
| 826 | 666 |
| 667 #if !defined (__cplusplus) || !defined (CPLUSPLUS_INTEGRAL_CLASSES_NOT_YET) | |
| 668 | |
| 669 /* Counts of bytes or chars */ | |
| 670 | |
| 671 typedef EMACS_INT Bytecount; | |
| 672 typedef EMACS_INT Charcount; | |
| 673 | |
| 647 | 674 /* Different ways of referring to a position in a buffer. We use |
| 675 the typedefs in preference to 'EMACS_INT' to make it clearer what | |
| 826 | 676 sort of position is being used. See text.c for a description |
| 677 of the different positions. | |
| 678 | |
| 679 Note that buffer positions are 1-based, and there's a gap in the middle | |
| 680 of a buffer; that's why we have separate typedefs. For Lisp strings and | |
| 681 other strings of text, we just use Bytecount and Charcount. */ | |
| 800 | 682 |
| 665 | 683 typedef EMACS_INT Charbpos; |
| 684 typedef EMACS_INT Bytebpos; | |
| 685 typedef EMACS_INT Membpos; | |
| 647 | 686 |
| 826 | 687 /* Different ways of referring to a position that can be either in a buffer |
| 688 or string; used when passing around an object that can be either a | |
| 689 buffer or string, and an associated position. Conceptually, they | |
| 690 resolve as follows: | |
| 691 | |
| 692 Typedef Buffer String | |
| 693 ------------------------------------------------------ | |
| 694 Charxpos Charbpos Charcount | |
| 695 Bytexpos Bytebpos Bytecount | |
| 696 Memxpos Membpos Bytecount | |
| 697 | |
| 698 */ | |
| 699 | |
| 814 | 700 typedef EMACS_INT Charxpos; |
| 701 typedef EMACS_INT Bytexpos; | |
| 702 typedef EMACS_INT Memxpos; | |
| 703 | |
| 704 #else /* __cplusplus */ | |
| 705 | |
| 706 /* Implement strong type-checking of the above integral types by declaring | |
| 707 them to be classes and using operator overloading. Unfortunately this | |
| 708 is a huge pain in the ass because C++ doesn't strongly distinguish | |
| 709 "bool" and "size_t" from int. The problem is especially bad with "bool" | |
| 2956 | 710 -- if you want to be able to say `if (len--)' where len is e.g. a |
| 814 | 711 Bytecount, you need to declare a conversion operator to bool(); and |
| 712 since bool is just an alias for int, you suddenly get tons and tons of | |
| 713 ambiguities, which need to be resolved by lots of laborious declarations | |
| 714 for every single possible type combination. Hence the multitude of | |
| 715 declarations in DECLARE_INTCLASS_ARITH_COMPARE(). The bool/int | |
| 716 equivalence also means that we have to forcibly block the combinations | |
| 717 we don't want by creating overloaded versions of them and declaring them | |
| 718 private. */ | |
| 719 | |
| 720 class Bytecount; | |
| 721 class Bytebpos; | |
| 722 class Bytexpos; | |
| 723 class Charcount; | |
| 724 class Charbpos; | |
| 725 class Charxpos; | |
| 726 class Membpos; | |
| 727 class Memxpos; | |
| 728 | |
| 729 /* Declare the arithmetic and comparison operations for an integral class, | |
| 730 i.e. one of the above classes. If this is a "position" class, where the | |
| 731 difference between two positions is a different class (a "count" class), | |
| 732 then use POSCL for the position class and COUNTCL for the count class. | |
| 733 If this is a simple class, where all operations yield the same class, | |
| 734 substitute the same class for POSCL and COUNTCL. */ | |
| 735 | |
| 736 #define DECLARE_INTCLASS_ARITH_COMPARE(poscl, countcl) \ | |
| 737 poscl operator += (const countcl& l) { data += l.data; return *this; } \ | |
| 738 poscl operator -= (const countcl& l) { data -= l.data; return *this; } \ | |
| 739 poscl operator + (const countcl& l) const { return poscl (data + l.data); } \ | |
| 740 poscl operator - (const countcl& l) const { return poscl (data - l.data); } \ | |
| 741 poscl operator += (const int& l) { data += l; return *this; } \ | |
| 742 poscl operator -= (const int& l) { data -= l; return *this; } \ | |
| 743 poscl operator + (const int& l) const { return poscl (data + l); } \ | |
| 744 poscl operator - (const int& l) const { return poscl (data - l); } \ | |
| 745 poscl operator += (const unsigned int& l) { data += l; return *this; } \ | |
| 746 poscl operator -= (const unsigned int& l) { data -= l; return *this; } \ | |
| 747 poscl operator + (const unsigned int& l) const \ | |
| 748 { return poscl (data + l); } \ | |
| 749 poscl operator - (const unsigned int& l) const \ | |
| 750 { return poscl (data - l); } \ | |
| 751 poscl operator += (const long& l) { data += l; return *this; } \ | |
| 752 poscl operator -= (const long& l) { data -= l; return *this; } \ | |
| 753 poscl operator + (const long& l) const { return poscl (data + l); } \ | |
| 754 poscl operator - (const long& l) const { return poscl (data - l); } \ | |
| 755 poscl operator += (const unsigned long& l) { data += l; return *this; } \ | |
| 756 poscl operator -= (const unsigned long& l) { data -= l; return *this; } \ | |
| 757 poscl operator + (const unsigned long& l) const \ | |
| 758 { return poscl (data + l); } \ | |
| 759 poscl operator - (const unsigned long& l) const \ | |
| 760 { return poscl (data - l); } \ | |
| 761 poscl operator += (const short& l) { data += l; return *this; } \ | |
| 762 poscl operator -= (const short& l) { data -= l; return *this; } \ | |
| 763 poscl operator + (const short& l) const { return poscl (data + l); } \ | |
| 764 poscl operator - (const short& l) const { return poscl (data - l); } \ | |
| 765 poscl operator += (const unsigned short& l) { data += l; return *this; } \ | |
| 766 poscl operator -= (const unsigned short& l) { data -= l; return *this; } \ | |
| 767 poscl operator + (const unsigned short& l) const \ | |
| 768 { return poscl (data + l); } \ | |
| 769 poscl operator - (const unsigned short& l) const \ | |
| 770 { return poscl (data - l); } \ | |
| 771 \ | |
| 772 poscl operator *= (const countcl& l) { data *= l.data; return *this; } \ | |
| 773 poscl operator /= (const countcl& l) { data /= l.data; return *this; } \ | |
| 774 poscl operator * (const countcl& l) const { return poscl (data * l.data); } \ | |
| 775 poscl operator / (const countcl& l) const { return poscl (data / l.data); } \ | |
| 776 poscl operator *= (const int& l) { data *= l; return *this; } \ | |
| 777 poscl operator /= (const int& l) { data /= l; return *this; } \ | |
| 778 poscl operator * (const int& l) const { return poscl (data * l); } \ | |
| 779 poscl operator / (const int& l) const { return poscl (data / l); } \ | |
| 780 poscl operator *= (const unsigned int& l) { data *= l; return *this; } \ | |
| 781 poscl operator /= (const unsigned int& l) { data /= l; return *this; } \ | |
| 782 poscl operator * (const unsigned int& l) const { return poscl (data * l); } \ | |
| 783 poscl operator / (const unsigned int& l) const { return poscl (data / l); } \ | |
| 784 poscl operator *= (const long& l) { data *= l; return *this; } \ | |
| 785 poscl operator /= (const long& l) { data /= l; return *this; } \ | |
| 786 poscl operator * (const long& l) const { return poscl (data * l); } \ | |
| 787 poscl operator / (const long& l) const { return poscl (data / l); } \ | |
| 788 poscl operator *= (const unsigned long& l) { data *= l; return *this; } \ | |
| 789 poscl operator /= (const unsigned long& l) { data /= l; return *this; } \ | |
| 790 poscl operator * (const unsigned long& l) const \ | |
| 791 { return poscl (data * l); } \ | |
| 792 poscl operator / (const unsigned long& l) const \ | |
| 793 { return poscl (data / l); } \ | |
| 794 poscl operator *= (const short& l) { data *= l; return *this; } \ | |
| 795 poscl operator /= (const short& l) { data /= l; return *this; } \ | |
| 796 poscl operator * (const short& l) const { return poscl (data * l); } \ | |
| 797 poscl operator / (const short& l) const { return poscl (data / l); } \ | |
| 798 poscl operator *= (const unsigned short& l) { data *= l; return *this; } \ | |
| 799 poscl operator /= (const unsigned short& l) { data /= l; return *this; } \ | |
| 800 poscl operator * (const unsigned short& l) const \ | |
| 801 { return poscl (data * l); } \ | |
| 802 poscl operator / (const unsigned short& l) const \ | |
| 803 { return poscl (data / l); } \ | |
| 804 \ | |
| 805 poscl operator &= (const countcl& l) { data &= l.data; return *this; } \ | |
| 806 poscl operator |= (const countcl& l) { data |= l.data; return *this; } \ | |
| 807 poscl operator & (const countcl& l) const { return poscl (data & l.data); } \ | |
| 808 poscl operator | (const countcl& l) const { return poscl (data | l.data); } \ | |
| 809 poscl operator &= (const int& l) { data &= l; return *this; } \ | |
| 810 poscl operator |= (const int& l) { data |= l; return *this; } \ | |
| 811 poscl operator & (const int& l) const { return poscl (data & l); } \ | |
| 812 poscl operator | (const int& l) const { return poscl (data | l); } \ | |
| 813 poscl operator &= (const unsigned int& l) { data &= l; return *this; } \ | |
| 814 poscl operator |= (const unsigned int& l) { data |= l; return *this; } \ | |
| 815 poscl operator & (const unsigned int& l) const { return poscl (data & l); } \ | |
| 816 poscl operator | (const unsigned int& l) const { return poscl (data | l); } \ | |
| 817 poscl operator &= (const long& l) { data &= l; return *this; } \ | |
| 818 poscl operator |= (const long& l) { data |= l; return *this; } \ | |
| 819 poscl operator & (const long& l) const { return poscl (data & l); } \ | |
| 820 poscl operator | (const long& l) const { return poscl (data | l); } \ | |
| 821 poscl operator &= (const unsigned long& l) { data &= l; return *this; } \ | |
| 822 poscl operator |= (const unsigned long& l) { data |= l; return *this; } \ | |
| 823 poscl operator & (const unsigned long& l) const \ | |
| 824 { return poscl (data & l); } \ | |
| 825 poscl operator | (const unsigned long& l) const \ | |
| 826 { return poscl (data | l); } \ | |
| 827 poscl operator &= (const short& l) { data &= l; return *this; } \ | |
| 828 poscl operator |= (const short& l) { data |= l; return *this; } \ | |
| 829 poscl operator & (const short& l) const { return poscl (data & l); } \ | |
| 830 poscl operator | (const short& l) const { return poscl (data | l); } \ | |
| 831 poscl operator &= (const unsigned short& l) { data &= l; return *this; } \ | |
| 832 poscl operator |= (const unsigned short& l) { data |= l; return *this; } \ | |
| 833 poscl operator & (const unsigned short& l) const \ | |
| 834 { return poscl (data & l); } \ | |
| 835 poscl operator | (const unsigned short& l) const \ | |
| 836 { return poscl (data | l); } \ | |
| 837 \ | |
| 838 poscl operator - () { return poscl (-data); } \ | |
| 839 poscl operator-- () { data--; return *this; } \ | |
| 840 poscl operator-- (int) { data--; return poscl (data + 1); } \ | |
| 841 poscl operator++ () { data++; return *this; } \ | |
| 842 poscl operator++ (int) { data++; return poscl (data - 1); } \ | |
| 843 \ | |
| 844 bool operator < (const poscl& l) const { return data < l.data; } \ | |
| 845 bool operator <= (const poscl& l) const { return data <= l.data; } \ | |
| 846 bool operator > (const poscl& l) const { return data > l.data; } \ | |
| 847 bool operator >= (const poscl& l) const { return data >= l.data; } \ | |
| 848 bool operator == (const poscl& l) const { return data == l.data; } \ | |
| 849 bool operator != (const poscl& l) const { return data != l.data; } \ | |
| 850 bool operator < (const int& l) const { return data < (EMACS_INT) l; } \ | |
| 851 bool operator <= (const int& l) const { return data <= (EMACS_INT) l; } \ | |
| 852 bool operator > (const int& l) const { return data > (EMACS_INT) l; } \ | |
| 853 bool operator >= (const int& l) const { return data >= (EMACS_INT) l; } \ | |
| 854 bool operator == (const int& l) const { return data == (EMACS_INT) l; } \ | |
| 855 bool operator != (const int& l) const { return data != (EMACS_INT) l; } \ | |
| 856 bool operator < (const unsigned int& l) const \ | |
| 857 { return data < (EMACS_INT) l; } \ | |
| 858 bool operator <= (const unsigned int& l) const \ | |
| 859 { return data <= (EMACS_INT) l; } \ | |
| 860 bool operator > (const unsigned int& l) const \ | |
| 861 { return data > (EMACS_INT) l; } \ | |
| 862 bool operator >= (const unsigned int& l) const \ | |
| 863 { return data >= (EMACS_INT) l; } \ | |
| 864 bool operator == (const unsigned int& l) const \ | |
| 865 { return data == (EMACS_INT) l; } \ | |
| 866 bool operator != (const unsigned int& l) const \ | |
| 867 { return data != (EMACS_INT) l; } \ | |
| 868 bool operator < (const long& l) const { return data < (EMACS_INT) l; } \ | |
| 869 bool operator <= (const long& l) const { return data <= (EMACS_INT) l; } \ | |
| 870 bool operator > (const long& l) const { return data > (EMACS_INT) l; } \ | |
| 871 bool operator >= (const long& l) const { return data >= (EMACS_INT) l; } \ | |
| 872 bool operator == (const long& l) const { return data == (EMACS_INT) l; } \ | |
| 873 bool operator != (const long& l) const { return data != (EMACS_INT) l; } \ | |
| 874 bool operator < (const unsigned long& l) const \ | |
| 875 { return data < (EMACS_INT) l; } \ | |
| 876 bool operator <= (const unsigned long& l) const \ | |
| 877 { return data <= (EMACS_INT) l; } \ | |
| 878 bool operator > (const unsigned long& l) const \ | |
| 879 { return data > (EMACS_INT) l; } \ | |
| 880 bool operator >= (const unsigned long& l) const \ | |
| 881 { return data >= (EMACS_INT) l; } \ | |
| 882 bool operator == (const unsigned long& l) const \ | |
| 883 { return data == (EMACS_INT) l; } \ | |
| 884 bool operator != (const unsigned long& l) const \ | |
| 885 { return data != (EMACS_INT) l; } \ | |
| 886 bool operator < (const short& l) const { return data < (EMACS_INT) l; } \ | |
| 887 bool operator <= (const short& l) const { return data <= (EMACS_INT) l; } \ | |
| 888 bool operator > (const short& l) const { return data > (EMACS_INT) l; } \ | |
| 889 bool operator >= (const short& l) const { return data >= (EMACS_INT) l; } \ | |
| 890 bool operator == (const short& l) const { return data == (EMACS_INT) l; } \ | |
| 891 bool operator != (const short& l) const { return data != (EMACS_INT) l; } \ | |
| 892 bool operator < (const unsigned short& l) const \ | |
| 893 { return data < (EMACS_INT) l; } \ | |
| 894 bool operator <= (const unsigned short& l) const \ | |
| 895 { return data <= (EMACS_INT) l; } \ | |
| 896 bool operator > (const unsigned short& l) const \ | |
| 897 { return data > (EMACS_INT) l; } \ | |
| 898 bool operator >= (const unsigned short& l) const \ | |
| 899 { return data >= (EMACS_INT) l; } \ | |
| 900 bool operator == (const unsigned short& l) const \ | |
| 901 { return data == (EMACS_INT) l; } \ | |
| 902 bool operator != (const unsigned short& l) const \ | |
| 903 { return data != (EMACS_INT) l; } \ | |
| 904 bool operator ! () const { return !data; } | |
| 905 | |
| 906 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 907 between class GOOD and class BAD. Meant to go inside the private | |
| 908 section of class GOOD. */ | |
| 909 | |
| 910 #define DECLARE_BAD_INTCLASS_ARITH_COMPARE(good, bad) \ | |
| 911 good operator += (const bad& l) { return badret; } \ | |
| 912 good operator -= (const bad& l) { return badret; } \ | |
| 913 good operator *= (const bad& l) { return badret; } \ | |
| 914 good operator /= (const bad& l) { return badret; } \ | |
| 915 good operator + (const bad& l) { return badret; } \ | |
| 916 good operator - (const bad& l) { return badret; } \ | |
| 917 good operator * (const bad& l) { return badret; } \ | |
| 918 good operator / (const bad& l) { return badret; } \ | |
| 919 \ | |
| 920 bool operator < (const bad& l) { return 0; } \ | |
| 921 bool operator <= (const bad& l) { return 0; } \ | |
| 922 bool operator > (const bad& l) { return 0; } \ | |
| 923 bool operator >= (const bad& l) { return 0; } \ | |
| 924 bool operator == (const bad& l) { return 0; } \ | |
| 925 bool operator != (const bad& l) { return 0; } | |
| 926 | |
| 927 /* Declare the "bad" or disallowed arithmetic operations between class GOOD | |
| 928 and another of the same class, for a position class. Meant to go inside | |
| 929 the private section of class GOOD. */ | |
| 930 | |
| 931 #define DECLARE_BAD_POS_CLASS_ARITH(good) \ | |
| 932 good operator += (const good& l) { return badret; } \ | |
| 933 good operator -= (const good& l) { return badret; } \ | |
| 934 good operator *= (const good& l) { return badret; } \ | |
| 935 good operator /= (const good& l) { return badret; } \ | |
| 936 good operator + (const good& l) { return badret; } \ | |
| 937 good operator * (const good& l) { return badret; } \ | |
| 938 good operator / (const good& l) { return badret; } | |
| 939 | |
| 940 /* Basic declaration at the top of all integral classes. Don't call | |
| 941 directly, use one of the more specific versions below. */ | |
| 942 | |
| 943 #define DECLARE_INTCLASS(cl) \ | |
| 944 public: \ | |
| 945 EMACS_INT data; \ | |
| 946 cl () { data = 0xCDCDCDCD; } \ | |
| 947 cl (int i) { data = i; } \ | |
| 948 cl (unsigned int i) { data = i; } \ | |
| 949 cl (long i) { data = i; } \ | |
| 950 cl (unsigned long i) { data = i; } \ | |
| 951 cl (short i) { data = i; } \ | |
| 952 cl (unsigned short i) { data = i; } \ | |
| 953 operator EMACS_INT () const { return data; } | |
| 954 | |
| 955 /* Basic declaration at the top of all count classes. */ | |
| 956 | |
| 957 #define DECLARE_COUNT_CLASS(cl) \ | |
| 958 DECLARE_INTCLASS (cl) \ | |
| 959 DECLARE_INTCLASS_ARITH_COMPARE (cl, cl) \ | |
| 960 private: \ | |
| 961 static cl badret; | |
| 962 | |
| 963 /* Basic declaration at the bottom of the prelude of all position classes. | |
| 964 Don't call directly. */ | |
| 965 | |
| 966 #define DECLARE_POS_CLASS_SECOND_HALF(cl, countcl) \ | |
| 967 DECLARE_INTCLASS_ARITH_COMPARE (cl, countcl) \ | |
| 968 countcl operator - (const cl& l) const { return countcl (data - l.data); } \ | |
| 969 private: \ | |
| 970 static cl badret; \ | |
| 971 DECLARE_BAD_POS_INTCLASS_ARITH (cl) | |
| 972 | |
| 973 /* Basic declaration at the top of all buffer position classes. */ | |
| 974 | |
| 975 #define DECLARE_BPOS_CLASS(cl, countcl) \ | |
| 976 DECLARE_INTCLASS (cl) \ | |
| 977 DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) | |
| 978 | |
| 979 /* Basic declaration at the top of all X-position classes (that can refer | |
| 980 to buffers or strings). CL1 and CL2 are the equivalent more specific | |
| 1318 | 981 classes referring only to buffers or strings, respectively. */ |
| 814 | 982 |
| 983 #define DECLARE_XPOS_CLASS(cl, countcl, cl1, cl2) \ | |
| 984 DECLARE_INTCLASS (cl) \ | |
| 985 cl (const cl1& x) { data = x.data; } \ | |
| 986 cl (const cl2& x) { data = x.data; } \ | |
| 987 operator cl1 () const { return cl1 (data); } \ | |
| 988 operator cl2 () const { return cl2 (data); } \ | |
| 989 DECLARE_POS_CLASS_SECOND_HALF (cl, countcl) | |
| 990 | |
| 991 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 992 between class CHARCL (a character class) and various non-character | |
| 993 classes. Meant to go inside the private section of class GOOD. */ | |
| 994 | |
| 995 #define DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE(charcl) \ | |
| 996 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytecount) \ | |
| 997 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytebpos) \ | |
| 998 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Bytexpos) \ | |
| 999 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Membpos) \ | |
| 1000 DECLARE_BAD_INTCLASS_ARITH_COMPARE (charcl, Memxpos) | |
| 1001 | |
| 1002 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1003 between class BYTECL (a byte class) and various non-byte classes. | |
| 1004 Meant to go inside the private section of class GOOD. */ | |
| 1005 | |
| 1006 #define DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE(bytecl) \ | |
| 1007 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ | |
| 1008 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ | |
| 1009 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ | |
| 1010 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Membpos) \ | |
| 1011 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Memxpos) | |
| 1012 | |
| 1013 /* Declare the "bad" or disallowed arithmetic and comparion operations | |
| 1014 between class BYTECL (a mem class) and various non-mem classes. | |
| 1015 Meant to go inside the private section of class GOOD. */ | |
| 1016 | |
| 1017 #define DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE(bytecl) \ | |
| 1018 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charcount) \ | |
| 1019 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charbpos) \ | |
| 1020 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Charxpos) \ | |
| 1021 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytebpos) \ | |
| 1022 DECLARE_BAD_INTCLASS_ARITH_COMPARE (bytecl, Bytexpos) | |
| 1023 | |
| 1024 class Charcount | |
| 1025 { | |
| 1026 DECLARE_COUNT_CLASS (Charcount) | |
| 1027 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charcount) | |
| 1028 }; | |
| 1029 | |
| 1030 class Charbpos | |
| 1031 { | |
| 1032 DECLARE_BPOS_CLASS (Charbpos, Charcount) | |
| 1033 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charbpos) | |
| 1034 }; | |
| 1035 | |
| 1036 class Charxpos | |
| 1037 { | |
| 1038 DECLARE_XPOS_CLASS (Charxpos, Charcount, Charbpos, Charcount) | |
| 1039 DECLARE_BAD_CHAR_INTCLASS_ARITH_COMPARE (Charxpos) | |
| 1040 }; | |
| 1041 | |
| 1042 class Bytecount | |
| 1043 { | |
| 1044 DECLARE_COUNT_CLASS (Bytecount) | |
| 1045 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytecount) | |
| 1046 }; | |
| 1047 | |
| 1048 class Bytebpos | |
| 1049 { | |
| 1050 DECLARE_BPOS_CLASS (Bytebpos, Bytecount) | |
| 1051 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytebpos) | |
| 1052 }; | |
| 1053 | |
| 1054 class Bytexpos | |
| 1055 { | |
| 1056 DECLARE_XPOS_CLASS (Bytexpos, Bytecount, Bytebpos, Bytecount) | |
| 1057 DECLARE_BAD_BYTE_INTCLASS_ARITH_COMPARE (Bytexpos) | |
| 1058 }; | |
| 1059 | |
| 1060 class Membpos | |
| 1061 { | |
| 1062 DECLARE_BPOS_CLASS (Membpos, Bytecount) | |
| 1063 DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Membpos) | |
| 1064 }; | |
| 1065 | |
| 1066 class Memxpos | |
| 1067 { | |
| 1068 DECLARE_XPOS_CLASS (Memxpos, Bytecount, Membpos, Bytecount) | |
| 1069 DECLARE_BAD_MEM_INTCLASS_ARITH_COMPARE (Memxpos) | |
| 1070 }; | |
| 1071 | |
| 826 | 1072 #define DECLARE_POINTER_TYPE_ARITH_COUNT(pointer, countcl) \ |
| 1073 inline pointer operator += (const pointer & x, const countcl& y) \ | |
| 1074 { x += y.data; return x; } \ | |
| 1075 inline pointer operator -= (const pointer & x, const countcl& y) \ | |
| 1076 { x -= y.data; return x; } \ | |
| 1077 inline pointer operator + (const pointer x, const countcl& y) \ | |
| 1078 { return x + y.data; } \ | |
| 1079 inline pointer operator - (const pointer x, const countcl& y) \ | |
| 814 | 1080 { return x - y.data; } |
| 1081 | |
| 1082 #define DECLARE_INTEGRAL_TYPE_ARITH_COUNT(integral, countcl) \ | |
| 1083 inline integral operator += (integral & x, const countcl& y) \ | |
| 1084 { x += y.data; return x; } \ | |
| 1085 inline integral operator -= (integral & x, const countcl& y) \ | |
| 1086 { x -= y.data; return x; } \ | |
| 1087 inline countcl operator + (integral x, const countcl& y) \ | |
| 1088 { return countcl (x + y.data); } \ | |
| 1089 inline countcl operator - (integral x, const countcl& y) \ | |
| 1090 { return countcl (x - y.data); } | |
| 1091 | |
| 1092 #define DECLARE_INTEGRAL_TYPE_COMPARE(integral, cl) \ | |
| 1093 inline bool operator < (integral x, const cl& y) \ | |
| 1094 { return (EMACS_INT) x < y.data; } \ | |
| 1095 inline bool operator <= (integral x, const cl& y) \ | |
| 1096 { return (EMACS_INT) x <= y.data; } \ | |
| 1097 inline bool operator > (integral x, const cl& y) \ | |
| 1098 { return (EMACS_INT) x > y.data; } \ | |
| 1099 inline bool operator >= (integral x, const cl& y) \ | |
| 1100 { return (EMACS_INT) x >= y.data; } \ | |
| 1101 inline bool operator == (integral x, const cl& y) \ | |
| 1102 { return (EMACS_INT) x == y.data; } \ | |
| 1103 inline bool operator != (integral x, const cl& y) \ | |
| 1104 { return (EMACS_INT) x != y.data; } | |
| 1105 | |
| 1106 #if 0 | |
| 1107 /* Unfortunately C++ doesn't let you overload the ?: operator, so we have | |
| 1108 to manually deal with ambiguities using casting */ | |
| 1109 #define DECLARE_INTEGRAL_TYPE_TRISTATE(integral, cl) \ | |
| 1110 inline cl operator ?: (bool b, integral x, const cl& y) \ | |
| 1111 { return b ? cl (x) : y; } \ | |
| 1112 inline cl operator ?: (bool b, const cl& x, integral y) \ | |
| 1113 { return b ? x : cl (y); } | |
| 1114 #endif /* 0 */ | |
| 1115 | |
| 867 | 1116 /* DECLARE_POINTER_TYPE_ARITH_COUNT (const Ibyte *, Bytecount); |
| 826 | 1117 DECLARE_POINTER_TYPE_ARITH_COUNT (const Extbyte *, Bytecount); */ |
| 867 | 1118 DECLARE_POINTER_TYPE_ARITH_COUNT (Ibyte *, Bytecount); |
| 814 | 1119 DECLARE_POINTER_TYPE_ARITH_COUNT (Extbyte *, Bytecount); |
| 1120 | |
| 1121 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Bytecount); | |
| 1122 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (int, Charcount); | |
| 1123 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Bytecount); | |
| 1124 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned int, Charcount); | |
| 1125 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Bytecount); | |
| 1126 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (long, Charcount); | |
| 1127 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Bytecount); | |
| 1128 DECLARE_INTEGRAL_TYPE_ARITH_COUNT (unsigned long, Charcount); | |
| 1129 | |
| 1130 DECLARE_INTEGRAL_TYPE_COMPARE (int, Bytecount); | |
| 1131 DECLARE_INTEGRAL_TYPE_COMPARE (int, Charcount); | |
| 1132 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Bytecount); | |
| 1133 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned int, Charcount); | |
| 1134 DECLARE_INTEGRAL_TYPE_COMPARE (long, Bytecount); | |
| 1135 DECLARE_INTEGRAL_TYPE_COMPARE (long, Charcount); | |
| 1136 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Bytecount); | |
| 1137 DECLARE_INTEGRAL_TYPE_COMPARE (unsigned long, Charcount); | |
| 1138 | |
| 1139 #if 0 /* doesn't work */ | |
| 867 | 1140 inline Bytecount operator - (const Ibyte *x, const Ibyte *y) \ |
| 814 | 1141 { return Bytecount (x - y); } |
| 1142 #endif | |
| 1143 | |
| 1144 #endif /* __cplusplus */ | |
| 1145 | |
| 665 | 1146 /* Counts of elements */ |
| 1147 typedef EMACS_INT Elemcount; | |
| 1148 /* Hash codes */ | |
| 1149 typedef unsigned long Hashcode; | |
| 2367 | 1150 /* Booleans */ |
| 1151 typedef int Boolint; | |
| 771 | 1152 |
| 793 | 1153 /* ------------------------ basic compiler defines ------------------- */ |
| 428 | 1154 |
| 1743 | 1155 #include "compiler.h" |
| 1632 | 1156 |
| 793 | 1157 /* ------------------------ alignment definitions ------------------- */ |
| 1158 | |
| 454 | 1159 /* No type has a greater alignment requirement than max_align_t. |
| 1160 (except perhaps for types we don't use, like long double) */ | |
| 1161 typedef union | |
| 1162 { | |
| 1163 struct { long l; } l; | |
| 1164 struct { void *p; } p; | |
| 1165 struct { void (*f)(void); } f; | |
| 1166 struct { double d; } d; | |
| 1167 } max_align_t; | |
| 1168 | |
| 771 | 1169 /* ALIGNOF returns the required alignment of a type -- i.e. a value such |
| 1170 that data of this type must begin at a memory address which is a | |
| 1171 multiple of that value. For simple types, this is often the same size | |
| 1172 as the type itself. */ | |
| 1173 | |
| 428 | 1174 #ifndef ALIGNOF |
| 1175 # if defined (__GNUC__) && (__GNUC__ >= 2) | |
| 454 | 1176 /* gcc has an extension that gives us exactly what we want. */ |
| 1177 # define ALIGNOF(type) __alignof__ (type) | |
| 1178 # elif ! defined (__cplusplus) | |
| 1179 /* The following is mostly portable, except that: | |
| 1180 - it doesn't work for inside out declarations like void (*) (void). | |
| 1181 (so just call ALIGNOF with a typedef'ed name) | |
| 1182 - it doesn't work with C++. The C++ committee has decided, | |
| 1183 in its infinite wisdom, that: | |
| 1184 "Types must be declared in declarations, not in expressions." */ | |
| 1185 # define ALIGNOF(type) offsetof (struct { char c; type member; }, member) | |
| 428 | 1186 # else |
| 456 | 1187 /* C++ is annoying, but it has a big bag of tricks. |
| 1188 The following doesn't have the "inside out" declaration bug C does. */ | |
| 458 | 1189 template<typename T> struct alignment_trick { char c; T member; }; |
| 456 | 1190 # define ALIGNOF(type) offsetof (alignment_trick<type>, member) |
| 428 | 1191 # endif |
| 454 | 1192 #endif /* ALIGNOF */ |
| 428 | 1193 |
| 771 | 1194 /* ALIGN_SIZE returns the smallest size greater than or equal to LEN which |
| 1195 is a multiple of UNIT. This can be used to assure that data that | |
| 1196 follows a block of the returned size is of correct alignment for a type | |
| 1197 whose alignment (as returned by ALIGNOF) is UNIT (provided that the | |
| 1198 block itself is correctly aligned for this type; memory returned by | |
| 1199 malloc() is guaranteed to be correctly aligned for all types). */ | |
| 1200 | |
| 428 | 1201 #define ALIGN_SIZE(len, unit) \ |
| 1202 ((((len) + (unit) - 1) / (unit)) * (unit)) | |
| 1203 | |
| 826 | 1204 /* ALIGN_FOR_TYPE returns the smallest size greater than or equal to LEN |
| 1205 which is aligned for the given type. This can be used to assure that | |
| 1206 data that follows a block of the returned size is of correct alignment | |
| 1207 for the type (provided that the block itself is correctly aligned for | |
| 1208 this type; memory returned by malloc() is guaranteed to be correctly | |
| 1209 aligned for all types). */ | |
| 1210 | |
| 1211 #define ALIGN_FOR_TYPE(len, type) ALIGN_SIZE (len, ALIGNOF (type)) | |
| 1212 | |
| 771 | 1213 /* MAX_ALIGN_SIZE returns the smallest size greater than or equal to LEN |
| 1214 which guarantees that data following a block of such size is correctly | |
| 1215 aligned for all types (provided that the block itself is so aligned, | |
| 1216 which is the case for memory returned by malloc()). */ | |
| 1217 | |
| 826 | 1218 #define MAX_ALIGN_SIZE(len) ALIGN_FOR_TYPE (len, max_align_t) |
| 1219 | |
| 1220 /* ALIGN_PTR returns the smallest pointer >= PTR which is aligned for | |
| 1221 data of TYPE. */ | |
| 1222 #define ALIGN_PTR(ptr, type) ((void *) ALIGN_FOR_TYPE ((size_t) (ptr), type)) | |
| 428 | 1223 |
| 1743 | 1224 BEGIN_C_DECLS |
| 1650 | 1225 |
| 793 | 1226 /* ------------------------ assertions ------------------- */ |
| 428 | 1227 |
| 1228 /* We define assert iff USE_ASSERTIONS or DEBUG_XEMACS is defined. | |
| 1229 Otherwise we define it to be empty. Quantify has shown that the | |
| 1230 time the assert checks take is measurable so let's not include them | |
| 771 | 1231 in production binaries. |
| 1232 | |
| 788 | 1233 If ASSERTIONS_DONT_ABORT defined, we will continue after assertion |
| 1234 failures. | |
| 1235 | |
| 1236 assert_at_line() is used for asserts inside of inline functions called | |
| 1237 from error-checking macros. If we're not tricky, we just get the file | |
| 1238 and line of the inline function, which is not very useful. */ | |
| 428 | 1239 |
| 1240 /* Highly dubious kludge */ | |
| 1241 /* (thanks, Jamie, I feel better now -- ben) */ | |
| 2367 | 1242 MODULE_API void assert_failed (const Ascbyte *, int, const Ascbyte *); |
| 5090 | 1243 void assert_equal_failed (const Ascbyte *file, int line, EMACS_INT x, |
| 1244 EMACS_INT y, const Ascbyte *exprx, | |
| 1245 const Ascbyte *expry); | |
|
4914
1628e3b9601a
When aborting due to unknown opcode, output more descriptive msg
Ben Wing <ben@xemacs.org>
parents:
4910
diff
changeset
|
1246 #define ABORT() assert_failed (__FILE__, __LINE__, "ABORT()") |
|
4921
17362f371cc2
add more byte-code assertions and better failure output
Ben Wing <ben@xemacs.org>
parents:
4914
diff
changeset
|
1247 #define abort_with_message(msg) assert_failed (__FILE__, __LINE__, msg) |
| 2535 | 1248 |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1249 /* This used to be ((void) (0)) but that triggers lots of unused variable |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
5023
diff
changeset
|
1250 warnings -- furthermore, if `x' has any side effects, e.g. |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
5023
diff
changeset
|
1251 assert (++depth <= 20);, we DEFINITELY want to execute the code inside of |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
5023
diff
changeset
|
1252 `x'. Any reasonable compiler will eliminate an expression with |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1253 no effects. We keep this abstracted out like this in case we want to |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1254 change it in the future. */ |
|
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1255 #define disabled_assert(x) ((void) (x)) |
| 4932 | 1256 #define disabled_assert_with_message(x, msg) ((void) msg, disabled_assert (x)) |
| 1257 #define disabled_assert_at_line(x, file, line) \ | |
| 1258 ((void) file, (void) line, disabled_assert (x)) | |
|
4843
715b15990d0a
add more foo_checking_assert macros
Ben Wing <ben@xemacs.org>
parents:
4841
diff
changeset
|
1259 |
| 2535 | 1260 #ifdef USE_ASSERTIONS |
| 428 | 1261 # define assert(x) ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, #x)) |
| 853 | 1262 # define assert_with_message(x, msg) \ |
| 1263 ((x) ? (void) 0 : assert_failed (__FILE__, __LINE__, msg)) | |
| 788 | 1264 # define assert_at_line(x, file, line) \ |
| 1265 ((x) ? (void) 0 : assert_failed (file, line, #x)) | |
| 5090 | 1266 # define assert_equal(x, y) \ |
| 1267 ((x) == (y) ? (void) 0 : \ | |
| 1268 assert_equal_failed (__FILE__, __LINE__, (EMACS_INT) x, (EMACS_INT) y, \ | |
| 1269 #x, #y)) | |
| 428 | 1270 #else |
| 2956 | 1271 /* This used to be ((void) (0)) but that triggers lots of unused variable |
| 1272 warnings. It's pointless to force all that code to be rewritten, with | |
| 1273 added ifdefs. Any reasonable compiler will eliminate an expression with | |
| 1274 no effects. */ | |
| 4932 | 1275 # define assert(x) disabled_assert (x) |
| 1276 # define assert_with_message(x, msg) disabled_assert_with_message (x, msg) | |
| 1277 # define assert_at_line(x, file, line) disabled_assert_at_line (x, file, line) | |
| 5090 | 1278 # define assert_equal(x, y) disabled_assert ((x) == (y)) |
| 428 | 1279 #endif |
| 1280 | |
| 2367 | 1281 /************************************************************************/ |
| 1282 /** Memory allocation **/ | |
| 1283 /************************************************************************/ | |
| 853 | 1284 |
| 793 | 1285 /* ------------------------ simple memory allocation ------------------- */ |
| 1286 | |
| 2367 | 1287 /* Basic memory allocation and freeing functions */ |
| 1288 void malloc_warning (const Ascbyte *); | |
| 1743 | 1289 MODULE_API void *xmalloc (Bytecount size) ATTRIBUTE_MALLOC; |
| 1290 MODULE_API void *xmalloc_and_zero (Bytecount size) ATTRIBUTE_MALLOC; | |
| 1291 MODULE_API void *xrealloc (void *, Bytecount size) ATTRIBUTE_MALLOC; | |
| 2367 | 1292 MODULE_API Chbyte *xstrdup (const Chbyte *) ATTRIBUTE_MALLOC; |
| 1293 | |
| 1294 /* Basic free function */ | |
| 1295 | |
| 1296 MODULE_API void xfree_1 (void *); | |
| 1297 #ifdef ERROR_CHECK_MALLOC | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1298 /* This used to use a temporary variable. But that triggered |
| 2367 | 1299 complaints under strict aliasing. #### There should be a better way. */ |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1300 #define xfree(lvalue) do \ |
| 2367 | 1301 { \ |
| 1302 xfree_1 (lvalue); \ | |
| 3988 | 1303 VOIDP_CAST (lvalue) = (void *) DEADBEEF_CONSTANT; \ |
| 2367 | 1304 } while (0) |
| 1305 #else | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
1306 #define xfree(lvalue) xfree_1 (lvalue) |
| 2367 | 1307 #endif /* ERROR_CHECK_MALLOC */ |
| 1308 | |
| 1309 /* ------------------------ stack allocation -------------------------- */ | |
| 1310 | |
| 1311 /* Allocating excessively large blocks on the stack can cause crashes. | |
| 851 | 1312 We provide MALLOC_OR_ALLOCA() below for places where it's likely that |
| 1313 large amounts will be allocated; it mallocs the block if it's too big. | |
| 1314 Unfortunately, that requires a call to unbind_to() at the end of the | |
| 1315 function, and it's not feasible to rewrite all calls to alloca() this | |
| 1316 way. | |
| 1317 | |
| 1318 Instead, we use the portable C alloca() substitute in alloca.c above a | |
| 1319 certain size. This actually uses malloc(), but checks the current stack | |
| 1320 pointer to see if data from previous alloca() calls needs to be freed. | |
| 1321 However, this can lead to large heap sizes -- especially since cleanup | |
| 1322 can only happen in a parent function, and will never happen if (as will | |
| 1323 often be the case) it's the same function in the same place in the code | |
| 1324 that keeps tripping the alloca() limit. | |
| 1325 | |
| 1326 So we set up a system to periodically force cleanup. Currently we | |
| 1327 do cleanup: | |
| 1328 | |
| 1329 -- Only when there's C alloca() data, and then | |
| 1330 -- Every stack alloca() or allocation of Lisp data, every call to | |
| 1331 next_event_internal() [typically near the top of the stack], | |
| 1332 or every 10th funcall | |
| 1333 | |
| 1334 This should not be a big penalty because | |
| 1335 | |
| 1336 (a) If there are few C alloca() chunks, checking them will be fast | |
| 1337 (b) If not, we've allocated a huge amount of heap space (remember, each | |
| 1338 chunk represents > 256K of heap), and we really want them gone | |
| 1339 */ | |
| 1340 | |
| 1341 /* We use a larger maximum when the choice is alloca() vs. the C alloca() | |
| 1342 substitute than when the choice is vs. malloc(), because in the former | |
| 1343 case, our alternative choice is less palatable because the memory may | |
| 1344 not be freed for awhile. */ | |
| 1345 | |
| 1346 #define MAX_ALLOCA_VS_C_ALLOCA 262144 | |
| 1347 #define MAX_ALLOCA_VS_MALLOC 65536 | |
| 1348 | |
| 1349 #define MAX_FUNCALLS_BETWEEN_ALLOCA_CLEANUP 10 | |
| 1350 | |
| 1632 | 1351 extern MODULE_API Bytecount __temp_alloca_size__; |
| 851 | 1352 extern Bytecount funcall_alloca_count; |
| 1353 | |
| 1333 | 1354 #ifdef ERROR_CHECK_MALLOC |
| 1632 | 1355 extern MODULE_API int regex_malloc_disallowed; |
| 1333 | 1356 #define REGEX_MALLOC_CHECK() assert (!regex_malloc_disallowed) |
| 1357 #else | |
| 1358 #define REGEX_MALLOC_CHECK() ((void) 0) | |
| 1359 #endif | |
| 1360 | |
| 851 | 1361 /* Do stack or heap alloca() depending on size. |
| 1362 | |
| 1363 NOTE: The use of a global temporary like this is unsafe if ALLOCA() occurs | |
| 1364 twice anywhere in the same expression; but that seems highly unlikely. The | |
| 1365 alternative is to force all callers to declare a local temporary if the | |
| 1366 expression has side effects -- something easy to forget. */ | |
| 1367 | |
| 1368 #define ALLOCA(size) \ | |
| 1333 | 1369 (REGEX_MALLOC_CHECK (), \ |
| 1370 __temp_alloca_size__ = (size), \ | |
| 851 | 1371 __temp_alloca_size__ > MAX_ALLOCA_VS_C_ALLOCA ? \ |
| 1372 xemacs_c_alloca (__temp_alloca_size__) : \ | |
| 1373 (need_to_check_c_alloca ? xemacs_c_alloca (0) : 0, \ | |
| 1374 alloca (__temp_alloca_size__))) | |
| 1375 | |
| 1318 | 1376 /* Version of ALLOCA() that is guaranteed to work inside of function calls |
| 1377 (i.e., we call the C alloca if regular alloca() is broken inside of | |
| 1378 function calls). */ | |
| 1379 #ifdef BROKEN_ALLOCA_IN_FUNCTION_CALLS | |
| 1380 #define ALLOCA_FUNCALL_OK(size) xemacs_c_alloca (size) | |
| 1381 #else | |
| 1382 #define ALLOCA_FUNCALL_OK(size) ALLOCA (size) | |
| 1383 #endif | |
| 1384 | |
| 2367 | 1385 MODULE_API void *xemacs_c_alloca (unsigned int size) ATTRIBUTE_MALLOC; |
| 1386 | |
| 1387 MODULE_API int record_unwind_protect_freeing (void *ptr); | |
| 1388 | |
| 1389 DECLARE_INLINE_HEADER ( | |
| 1390 void * | |
| 1391 xmalloc_and_record_unwind (Bytecount size) | |
| 1392 ) | |
| 1393 { | |
| 1394 void *ptr = xmalloc (size); | |
| 1395 record_unwind_protect_freeing (ptr); | |
| 1396 return ptr; | |
| 1397 } | |
| 1398 | |
| 851 | 1399 /* WARNING: If you use this, you must unbind_to() at the end of your |
| 1400 function! */ | |
| 1401 | |
| 1402 #define MALLOC_OR_ALLOCA(size) \ | |
| 1333 | 1403 (REGEX_MALLOC_CHECK (), \ |
| 1404 __temp_alloca_size__ = (size), \ | |
| 851 | 1405 __temp_alloca_size__ > MAX_ALLOCA_VS_MALLOC ? \ |
| 1406 xmalloc_and_record_unwind (__temp_alloca_size__) : \ | |
| 1407 (need_to_check_c_alloca ? xemacs_c_alloca (0) : 0, \ | |
| 1408 alloca (__temp_alloca_size__))) | |
| 793 | 1409 |
| 2367 | 1410 /* -------------- convenience functions for memory allocation ------------- */ |
| 1411 | |
| 1412 #define countof(x) ((int) (sizeof(x)/sizeof((x)[0]))) | |
| 1413 #define xnew(type) ((type *) xmalloc (sizeof (type))) | |
| 1414 #define xnew_array(type, len) ((type *) xmalloc ((len) * sizeof (type))) | |
| 1415 #define xnew_and_zero(type) ((type *) xmalloc_and_zero (sizeof (type))) | |
| 1416 #define xzero(lvalue) ((void) memset (&(lvalue), '\0', sizeof (lvalue))) | |
| 1417 #define xnew_array_and_zero(type, len) ((type *) xmalloc_and_zero ((len) * sizeof (type))) | |
| 1418 | |
| 1419 #define alloca_new(type) ((type *) ALLOCA (sizeof (type))) | |
| 1420 #define alloca_array(type, len) ((type *) ALLOCA ((len) * sizeof (type))) | |
| 1421 | |
| 1422 #define alloca_itexts(num) alloca_array (Itext, num) | |
| 1423 #define alloca_ibytes(num) alloca_array (Ibyte, num) | |
| 1424 #define alloca_extbytes(num) alloca_array (Extbyte, num) | |
| 1425 #define alloca_rawbytes(num) alloca_array (Rawbyte, num) | |
| 1426 #define alloca_binbytes(num) alloca_array (Binbyte, num) | |
| 1427 #define alloca_ascbytes(num) alloca_array (Ascbyte, num) | |
| 1428 #define xmalloc_itexts(num) xnew_array (Itext, num) | |
| 1429 #define xnew_ibytes(num) xnew_array (Ibyte, num) | |
| 1430 #define xnew_extbytes(num) xnew_array (Extbyte, num) | |
| 1431 #define xnew_rawbytes(num) xnew_array (Rawbyte, num) | |
| 1432 #define xnew_binbytes(num) xnew_array (Binbyte, num) | |
| 1433 #define xnew_ascbytes(num) xnew_array (Ascbyte, num) | |
| 1434 | |
| 1435 /* Make an alloca'd copy of a Ibyte * */ | |
| 1436 #define IBYTE_STRING_TO_ALLOCA(p, lval) \ | |
| 1437 do { \ | |
| 1438 Ibyte **_bsta_ = (Ibyte **) &(lval); \ | |
| 1439 const Ibyte *_bsta_2 = (p); \ | |
| 1440 Bytecount _bsta_3 = qxestrlen (_bsta_2); \ | |
| 1441 *_bsta_ = alloca_ibytes (1 + _bsta_3); \ | |
| 1442 memcpy (*_bsta_, _bsta_2, 1 + _bsta_3); \ | |
| 1443 } while (0) | |
| 1444 | |
|
5200
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1445 /* Make an alloca'd copy of a Extbyte * */ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1446 #define EXTBYTE_STRING_TO_ALLOCA(p, lval) \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1447 do { \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1448 Extbyte **_esta_ = (Extbyte **) &(lval); \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1449 const Extbyte *_esta_2 = (p); \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1450 Bytecount _esta_3 = strlen (_esta_2); \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1451 *_esta_ = alloca_extbytes (1 + _esta_3); \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1452 memcpy (*_esta_, _esta_2, 1 + _esta_3); \ |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1453 } while (0) |
|
70ed8a0d8da8
port Mule-ization of mule-wnnfns.c from ben-unicode-internal
Ben Wing <ben@xemacs.org>
parents:
5191
diff
changeset
|
1454 |
| 2367 | 1455 /* ----------------- convenience functions for reallocation --------------- */ |
| 1456 | |
| 1457 #define XREALLOC_ARRAY(ptr, type, len) \ | |
| 1458 ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type)))) | |
| 1459 | |
| 793 | 1460 /* also generally useful if you want to avoid arbitrary size limits |
| 1461 but don't need a full dynamic array. Assumes that BASEVAR points | |
| 1462 to a malloced array of TYPE objects (or possibly a NULL pointer, | |
| 1463 if SIZEVAR is 0), with the total size stored in SIZEVAR. This | |
| 1464 macro will realloc BASEVAR as necessary so that it can hold at | |
| 1465 least NEEDED_SIZE objects. The reallocing is done by doubling, | |
| 1466 which ensures constant amortized time per element. */ | |
| 1467 #define DO_REALLOC(basevar, sizevar, needed_size, type) do { \ | |
| 1468 Bytecount do_realloc_needed_size = (needed_size); \ | |
| 1333 | 1469 REGEX_MALLOC_CHECK (); \ |
| 793 | 1470 if ((sizevar) < do_realloc_needed_size) \ |
| 1471 { \ | |
| 1472 if ((sizevar) < 32) \ | |
| 1473 (sizevar) = 32; \ | |
| 1474 while ((sizevar) < do_realloc_needed_size) \ | |
| 1475 (sizevar) *= 2; \ | |
| 1476 XREALLOC_ARRAY (basevar, type, (sizevar)); \ | |
| 1477 } \ | |
| 1478 } while (0) | |
| 1479 | |
| 2367 | 1480 /************************************************************************/ |
| 1481 /** Definitions of more complex types **/ | |
| 1482 /************************************************************************/ | |
| 428 | 1483 |
| 647 | 1484 /* Note that the simplest typedefs are near the top of this file. */ |
| 1485 | |
| 428 | 1486 /* We put typedefs here so that prototype declarations don't choke. |
| 1487 Note that we don't actually declare the structures here (except | |
| 5038 | 1488 maybe for simple structures like dynarrs); that keeps them private |
| 428 | 1489 to the routines that actually use them. */ |
| 1490 | |
| 771 | 1491 /* ------------------------------- */ |
| 1492 /* Error_Behavior typedefs */ | |
| 1493 /* ------------------------------- */ | |
| 1494 | |
| 800 | 1495 #ifndef ERROR_CHECK_TYPES |
| 771 | 1496 |
| 1497 typedef enum error_behavior | |
| 428 | 1498 { |
| 771 | 1499 ERROR_ME, |
| 1500 ERROR_ME_NOT, | |
| 793 | 1501 ERROR_ME_WARN, |
| 1502 ERROR_ME_DEBUG_WARN | |
| 771 | 1503 } Error_Behavior; |
| 1504 | |
| 1505 #define ERRB_EQ(a, b) ((a) == (b)) | |
| 1506 | |
| 1507 #else | |
| 1508 | |
| 1509 /* By defining it like this, we provide strict type-checking | |
| 1510 for code that lazily uses ints. */ | |
| 1511 | |
| 1512 typedef struct _error_behavior_struct_ | |
| 428 | 1513 { |
| 771 | 1514 int really_unlikely_name_to_have_accidentally_in_a_non_errb_structure; |
| 1515 } Error_Behavior; | |
| 1516 | |
| 1517 extern Error_Behavior ERROR_ME; | |
| 1518 extern Error_Behavior ERROR_ME_NOT; | |
| 1519 extern Error_Behavior ERROR_ME_WARN; | |
| 793 | 1520 extern Error_Behavior ERROR_ME_DEBUG_WARN; |
| 771 | 1521 |
| 1522 #define ERRB_EQ(a, b) \ | |
| 1523 ((a).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure == \ | |
| 1524 (b).really_unlikely_name_to_have_accidentally_in_a_non_errb_structure) | |
| 1525 | |
| 1526 #endif | |
| 1527 | |
| 1528 /* ------------------------------- */ | |
| 1529 /* Empty structures and typedefs */ | |
| 1530 /* ------------------------------- */ | |
| 428 | 1531 |
| 1532 struct buffer; /* "buffer.h" */ | |
| 1533 struct console; /* "console.h" */ | |
| 1534 struct device; /* "device.h" */ | |
| 1535 struct extent_fragment; | |
| 1536 struct extent; | |
| 1537 struct frame; /* "frame.h" */ | |
| 1538 struct window; /* "window.h" */ | |
| 771 | 1539 struct utimbuf; /* "systime.h" or <utime.h> */ |
| 428 | 1540 struct display_line; |
| 1541 struct display_glyph_area; | |
| 1542 struct display_box; | |
| 1543 struct redisplay_info; | |
| 1544 struct window_mirror; | |
| 1545 struct scrollbar_instance; | |
| 1546 struct font_metric_info; | |
| 1547 struct face_cachel; | |
| 1548 struct console_type_entry; | |
| 1549 | |
| 771 | 1550 /* This is shared by process.h, events.h and others in future. |
| 1551 See events.h for description */ | |
| 4123 | 1552 typedef unsigned EMACS_INT USID; |
| 771 | 1553 typedef int face_index; |
| 1554 typedef int glyph_index; | |
| 1726 | 1555 typedef struct lstream Lstream; /* lstream.h */ |
| 872 | 1556 typedef struct extent *EXTENT; /* extents-impl.h */ |
| 771 | 1557 typedef struct Lisp_Event Lisp_Event; /* "events.h" */ |
| 872 | 1558 typedef struct Lisp_Face Lisp_Face; /* "faces-impl.h" */ |
| 771 | 1559 typedef struct Lisp_Process Lisp_Process; /* "procimpl.h" */ |
|
5176
8b2f75cecb89
rename objects* (.c, .h and .el files) to fontcolor*
Ben Wing <ben@xemacs.org>
parents:
5052
diff
changeset
|
1560 typedef struct Lisp_Color_Instance Lisp_Color_Instance; /* fontcolor-impl.h */ |
|
8b2f75cecb89
rename objects* (.c, .h and .el files) to fontcolor*
Ben Wing <ben@xemacs.org>
parents:
5052
diff
changeset
|
1561 typedef struct Lisp_Font_Instance Lisp_Font_Instance; /* fontcolor-impl.h */ |
| 1726 | 1562 typedef struct Lisp_Image_Instance Lisp_Image_Instance; /* glyphs.h */ |
| 771 | 1563 typedef struct Lisp_Gui_Item Lisp_Gui_Item; |
| 1564 | |
| 1565 /* ------------------------------- */ | |
| 1566 /* enum typedefs */ | |
| 1567 /* ------------------------------- */ | |
| 1568 | |
| 428 | 1569 enum run_hooks_condition |
| 1570 { | |
| 1571 RUN_HOOKS_TO_COMPLETION, | |
| 1572 RUN_HOOKS_UNTIL_SUCCESS, | |
| 1573 RUN_HOOKS_UNTIL_FAILURE | |
| 1574 }; | |
| 1575 | |
| 1576 enum edge_style | |
| 1577 { | |
| 1578 EDGE_ETCHED_IN, | |
| 1579 EDGE_ETCHED_OUT, | |
| 1580 EDGE_BEVEL_IN, | |
| 1581 EDGE_BEVEL_OUT | |
| 1582 }; | |
| 1583 | |
| 1584 enum munge_me_out_the_door | |
| 1585 { | |
| 1586 MUNGE_ME_FUNCTION_KEY, | |
| 1587 MUNGE_ME_KEY_TRANSLATION | |
| 1588 }; | |
| 1589 | |
|
5015
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1590 /* The various stages of font instantiation; initial means "find a font for |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1591 CHARSET that matches the charset's registries" and final means "find a |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1592 font for CHARSET that matches iso10646-1, since we haven't found a font |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1593 that matches its registry." |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1594 */ |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1595 enum font_specifier_matchspec_stages |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1596 { |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1597 STAGE_INITIAL, |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1598 STAGE_FINAL, |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1599 NUM_MATCHSPEC_STAGES, |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1600 }; |
|
d95c102a96d3
cleanups for specifier font stages, from ben-unicode-internal (preparation for eliminating shadowed warnings)
Ben Wing <ben@xemacs.org>
parents:
5013
diff
changeset
|
1601 |
| 771 | 1602 /* ------------------------------- */ |
| 1603 /* misc */ | |
| 1604 /* ------------------------------- */ | |
| 1605 | |
| 1606 /* This structure is used to keep statistics on the amount of memory | |
| 1607 in use. | |
| 1608 | |
| 1609 WAS_REQUESTED stores the actual amount of memory that was requested | |
| 1610 of the allocation function. The *_OVERHEAD fields store the | |
| 1611 additional amount of memory that was grabbed by the functions to | |
| 1612 facilitate allocation, reallocation, etc. MALLOC_OVERHEAD is for | |
| 1613 memory allocated with malloc(); DYNARR_OVERHEAD is for dynamic | |
| 1614 arrays; GAP_OVERHEAD is for gap arrays. Note that for (e.g.) | |
| 1615 dynamic arrays, there is both MALLOC_OVERHEAD and DYNARR_OVERHEAD | |
| 1616 memory: The dynamic array allocates memory above and beyond what | |
| 1617 was asked of it, and when it in turns allocates memory using | |
| 1618 malloc(), malloc() allocates memory beyond what it was asked | |
| 1619 to allocate. | |
| 1620 | |
| 1621 Functions that accept a structure of this sort do not initialize | |
| 1622 the fields to 0, and add any existing values to whatever was there | |
| 1623 before; this way, you can get a cumulative effect. */ | |
| 1624 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1625 struct usage_stats |
| 771 | 1626 { |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1627 Bytecount was_requested; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1628 Bytecount malloc_overhead; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1629 Bytecount dynarr_overhead; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1630 Bytecount gap_overhead; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1631 }; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1632 |
|
5170
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1633 /* Generic version of usage stats structure including extra non-Lisp and |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1634 Lisp storage associated with the object, but not including the memory |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1635 used to hold the object itself. Up to 32 statistics are allowed, |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1636 in addition to the statistics in `U', which store another slice onto the |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1637 ancillary non-Lisp storage. |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1638 |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1639 Normally, each object creates its own version of this structure, e.g. |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1640 `struct window_stats', which parallels the structure in beginning with |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1641 a `struct usage_stats' and followed by Bytecount fields, so that a |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1642 pointer to that structure can be cast to a pointer of this structure |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1643 and sensible results gotten. */ |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
1644 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1645 struct generic_usage_stats |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1646 { |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1647 struct usage_stats u; |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
1648 Bytecount othervals[32]; |
| 771 | 1649 }; |
| 1650 | |
| 428 | 1651 |
| 1652 /************************************************************************/ | |
| 1653 /* Definition of Lisp_Object data type */ | |
| 1654 /************************************************************************/ | |
| 1655 | |
| 1656 /* Define the fundamental Lisp data structures */ | |
| 1657 | |
| 1658 /* This is the set of Lisp data types */ | |
| 1659 | |
| 1660 enum Lisp_Type | |
| 1661 { | |
| 1662 Lisp_Type_Record, | |
| 1663 Lisp_Type_Int_Even, | |
| 1664 Lisp_Type_Char, | |
| 1665 Lisp_Type_Int_Odd | |
| 1666 }; | |
| 1667 | |
| 1668 #define POINTER_TYPE_P(type) ((type) == Lisp_Type_Record) | |
| 1669 | |
| 1670 /* Overridden by m/next.h */ | |
| 1671 #ifndef ASSERT_VALID_POINTER | |
| 1672 # define ASSERT_VALID_POINTER(pnt) (assert ((((EMACS_UINT) pnt) & 3) == 0)) | |
| 1673 #endif | |
| 1674 | |
| 1675 #define GCMARKBITS 0 | |
| 1676 #define GCTYPEBITS 2 | |
| 1677 #define GCBITS 2 | |
| 1678 #define INT_GCBITS 1 | |
| 1679 | |
| 1680 #define INT_VALBITS (BITS_PER_EMACS_INT - INT_GCBITS) | |
| 1681 #define VALBITS (BITS_PER_EMACS_INT - GCBITS) | |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
1682 /* This is badly named; it's not the maximum value that an EMACS_INT can |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
1683 have, it's the maximum value that a Lisp-visible fixnum can have (half |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
1684 the maximum value an EMACS_INT can have) and as such would be better |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
1685 called MOST_POSITIVE_FIXNUM. Similarly for MOST_NEGATIVE_FIXNUM. */ |
| 542 | 1686 #define EMACS_INT_MAX ((EMACS_INT) ((1UL << (INT_VALBITS - 1)) -1UL)) |
| 442 | 1687 #define EMACS_INT_MIN (-(EMACS_INT_MAX) - 1) |
| 802 | 1688 /* WARNING: evaluates its arg twice. */ |
| 1689 #define NUMBER_FITS_IN_AN_EMACS_INT(num) \ | |
| 1690 ((num) <= EMACS_INT_MAX && (num) >= EMACS_INT_MIN) | |
| 428 | 1691 |
| 1692 #ifdef USE_UNION_TYPE | |
| 1693 # include "lisp-union.h" | |
| 1694 #else /* !USE_UNION_TYPE */ | |
| 1695 # include "lisp-disunion.h" | |
| 1696 #endif /* !USE_UNION_TYPE */ | |
| 1697 | |
| 1698 #define XPNTR(x) ((void *) XPNTRVAL(x)) | |
| 1699 | |
| 1700 /* Close your eyes now lest you vomit or spontaneously combust ... */ | |
| 1701 | |
| 1702 #define HACKEQ_UNSAFE(obj1, obj2) \ | |
| 1703 (EQ (obj1, obj2) || (!POINTER_TYPE_P (XTYPE (obj1)) \ | |
| 1704 && !POINTER_TYPE_P (XTYPE (obj2)) \ | |
| 1705 && XCHAR_OR_INT (obj1) == XCHAR_OR_INT (obj2))) | |
| 1706 | |
| 1707 #ifdef DEBUG_XEMACS | |
| 1632 | 1708 extern MODULE_API int debug_issue_ebola_notices; |
| 1709 MODULE_API int eq_with_ebola_notice (Lisp_Object, Lisp_Object); | |
| 428 | 1710 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) \ |
| 1711 (debug_issue_ebola_notices ? eq_with_ebola_notice (obj1, obj2) \ | |
| 1712 : EQ (obj1, obj2)) | |
| 1713 #else | |
| 1714 #define EQ_WITH_EBOLA_NOTICE(obj1, obj2) EQ (obj1, obj2) | |
| 1715 #endif | |
| 1716 | |
| 1717 /* OK, you can open them again */ | |
| 1718 | |
| 1743 | 1719 END_C_DECLS |
| 1650 | 1720 |
| 4967 | 1721 #include "lrecord.h" |
| 1722 | |
| 5013 | 1723 /* Turn any void * pointer into a Lisp object. This is the counterpart of |
| 1724 STORE_LISP_IN_VOID, which works in the opposite direction. Note that | |
| 1725 you CANNOT use STORE_LISP_IN_VOID to undo the effects of STORE_VOID_IN_LISP! | |
| 1726 Instead, you GET_VOID_FROM_LISP: | |
| 1727 | |
| 1728 STORE_VOID_IN_LISP <--> GET_VOID_FROM_LISP vs. | |
| 1729 STORE_LISP_IN_VOID <--> GET_LISP_FROM_VOID | |
| 1730 | |
| 1731 STORE_VOID_IN_LISP has a restriction on the void * pointers it can | |
| 1732 handle -- the pointer must be an even address (lowest bit set to 0). | |
| 1733 Generally this is not a problem as nowadays virtually all allocation is | |
| 1734 at least 4-byte aligned, if not 8-byte. | |
| 1735 | |
| 1736 However, if this proves problematic, you can use make_opaque_ptr(), which | |
| 1737 is guaranteed to handle any kind of void * pointer but which does | |
| 1738 Lisp allocation. | |
| 1739 */ | |
| 1740 | |
| 1741 DECLARE_INLINE_HEADER ( | |
| 1742 Lisp_Object | |
| 1743 STORE_VOID_IN_LISP (void *ptr) | |
| 1744 ) | |
| 1745 { | |
| 1746 EMACS_UINT p = (EMACS_UINT) ptr; | |
| 1747 | |
| 1748 type_checking_assert ((p & 1) == 0); | |
| 1749 return make_int (p >> 1); | |
| 1750 } | |
| 1751 | |
| 1752 DECLARE_INLINE_HEADER ( | |
| 1753 void * | |
| 1754 GET_VOID_FROM_LISP (Lisp_Object obj) | |
| 1755 ) | |
| 1756 { | |
| 1757 EMACS_UINT p = XUINT (obj); | |
| 1758 return (void *) (p << 1); | |
| 1759 } | |
| 1760 | |
| 428 | 1761 /************************************************************************/ |
|
5168
cf900a2f1fa3
extract gap array from extents.c, use in range tables
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1762 /** Definitions of dynarrs and other allocators **/ |
| 4967 | 1763 /************************************************************************/ |
| 428 | 1764 |
|
5168
cf900a2f1fa3
extract gap array from extents.c, use in range tables
Ben Wing <ben@xemacs.org>
parents:
5160
diff
changeset
|
1765 #include "array.h" |
| 3092 | 1766 |
| 4967 | 1767 /************* Dynarr typedefs *************/ |
| 3092 | 1768 |
| 1769 /* Dynarr typedefs -- basic types first */ | |
| 1770 | |
| 1771 typedef struct | |
| 1772 { | |
| 1773 Dynarr_declare (Ibyte); | |
| 1774 } Ibyte_dynarr; | |
| 1775 | |
| 1776 typedef struct | |
| 1777 { | |
| 1778 Dynarr_declare (Extbyte); | |
| 1779 } Extbyte_dynarr; | |
| 1780 | |
| 1781 typedef struct | |
| 1782 { | |
| 1783 Dynarr_declare (Ichar); | |
| 1784 } Ichar_dynarr; | |
| 1785 | |
| 1786 typedef struct | |
| 1787 { | |
| 1788 Dynarr_declare (char); | |
| 1789 } char_dynarr; | |
| 1790 | |
| 1791 typedef struct | |
| 1792 { | |
| 1793 Dynarr_declare (char *); | |
| 1794 } char_ptr_dynarr; | |
| 1795 | |
| 1796 typedef unsigned char unsigned_char; | |
| 1797 typedef struct | |
| 1798 { | |
| 1799 Dynarr_declare (unsigned char); | |
| 1800 } unsigned_char_dynarr; | |
| 1801 | |
| 1802 typedef unsigned long unsigned_long; | |
| 1803 typedef struct | |
| 1804 { | |
| 1805 Dynarr_declare (unsigned long); | |
| 1806 } unsigned_long_dynarr; | |
| 1807 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1808 typedef const Ascbyte *const_Ascbyte_ptr; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1809 typedef struct |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1810 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1811 Dynarr_declare (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1812 } const_Ascbyte_ptr_dynarr; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1813 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1814 extern const struct sized_memory_description const_Ascbyte_ptr_description; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1815 extern const struct sized_memory_description const_Ascbyte_ptr_dynarr_description; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
1816 |
| 3092 | 1817 typedef struct |
| 1818 { | |
| 1819 Dynarr_declare (int); | |
| 1820 } int_dynarr; | |
| 1821 | |
| 1822 typedef struct | |
| 1823 { | |
| 1824 Dynarr_declare (Charbpos); | |
| 1825 } Charbpos_dynarr; | |
| 1826 | |
| 1827 typedef struct | |
| 1828 { | |
| 1829 Dynarr_declare (Bytebpos); | |
| 1830 } Bytebpos_dynarr; | |
| 1831 | |
| 1832 typedef struct | |
| 1833 { | |
| 1834 Dynarr_declare (Charcount); | |
| 1835 } Charcount_dynarr; | |
| 1836 | |
| 1837 typedef struct | |
| 1838 { | |
| 1839 Dynarr_declare (Bytecount); | |
| 1840 } Bytecount_dynarr; | |
| 1841 | |
| 1842 /* Dynarr typedefs -- more complex types */ | |
| 1843 | |
| 1844 typedef struct | |
| 1845 { | |
| 1846 Dynarr_declare (struct face_cachel); | |
| 1847 } face_cachel_dynarr; | |
| 1848 | |
| 3293 | 1849 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1850 DECLARE_LISP_OBJECT (face_cachel_dynarr, face_cachel_dynarr); |
| 3092 | 1851 #define XFACE_CACHEL_DYNARR(x) \ |
| 1852 XRECORD (x, face_cachel_dynarr, face_cachel_dynarr) | |
| 1853 #define wrap_face_cachel_dynarr(p) wrap_record (p, face_cachel_dynarr) | |
| 1854 #define FACE_CACHEL_DYNARRP(x) RECORDP (x, face_cachel_dynarr) | |
| 1855 #define CHECK_FACE_CACHEL_DYNARR(x) CHECK_RECORD (x, face_cachel_dynarr) | |
| 1856 #define CONCHECK_FACE_CACHEL_DYNARR(x) CONCHECK_RECORD (x, face_cachel_dynarr) | |
| 3293 | 1857 #endif /* NEW_GC */ |
| 3092 | 1858 |
| 1859 typedef struct | |
| 1860 { | |
| 1861 Dynarr_declare (struct glyph_cachel); | |
| 1862 } glyph_cachel_dynarr; | |
| 1863 | |
| 3293 | 1864 #ifdef NEW_GC |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
1865 DECLARE_LISP_OBJECT (glyph_cachel_dynarr, glyph_cachel_dynarr); |
| 3092 | 1866 #define XGLYPH_CACHEL_DYNARR(x) \ |
| 1867 XRECORD (x, glyph_cachel_dynarr, glyph_cachel_dynarr) | |
| 1868 #define wrap_glyph_cachel_dynarr(p) wrap_record (p, glyph_cachel_dynarr) | |
| 1869 #define GLYPH_CACHEL_DYNARRP(x) RECORDP (x, glyph_cachel_dynarr) | |
| 1870 #define CHECK_GLYPH_CACHEL_DYNARR(x) CHECK_RECORD (x, glyph_cachel_dynarr) | |
| 1871 #define CONCHECK_GLYPH_CACHEL_DYNARR(x) \ | |
| 1872 CONCHECK_RECORD (x, glyph_cachel_dynarr) | |
| 3293 | 1873 #endif /* NEW_GC */ |
| 3092 | 1874 |
| 1875 typedef struct | |
| 1876 { | |
| 1877 Dynarr_declare (struct console_type_entry); | |
| 1878 } console_type_entry_dynarr; | |
| 1879 | |
| 1880 /* WARNING WARNING WARNING. You must ensure on your own that proper | |
| 1881 GC protection is provided for the elements in this array. */ | |
| 1882 typedef struct | |
| 1883 { | |
| 1884 Dynarr_declare (Lisp_Object); | |
| 1885 } Lisp_Object_dynarr; | |
| 1886 | |
| 1887 typedef struct | |
| 1888 { | |
| 1889 Dynarr_declare (Lisp_Object *); | |
| 1890 } Lisp_Object_ptr_dynarr; | |
| 1891 | |
| 4967 | 1892 |
| 1893 /************************************************************************/ | |
| 1894 /** Definitions of other basic Lisp objects **/ | |
| 1895 /************************************************************************/ | |
| 1896 | |
| 442 | 1897 /*------------------------------ unbound -------------------------------*/ |
| 428 | 1898 |
| 1899 /* Qunbound is a special Lisp_Object (actually of type | |
| 1900 symbol-value-forward), that can never be visible to | |
| 1901 the Lisp caller and thus can be used in the C code | |
| 1902 to mean "no such value". */ | |
| 1903 | |
| 1904 #define UNBOUNDP(val) EQ (val, Qunbound) | |
| 1905 | |
| 771 | 1906 /* Evaluate expr, return it if it's not Qunbound. */ |
| 1907 #define RETURN_IF_NOT_UNBOUND(expr) do \ | |
| 1908 { \ | |
| 1909 Lisp_Object ret_nunb_val = (expr); \ | |
| 1910 if (!UNBOUNDP (ret_nunb_val)) \ | |
| 1911 RETURN_SANS_WARNINGS ret_nunb_val; \ | |
| 1912 } while (0) | |
| 1913 | |
| 442 | 1914 /*------------------------------- cons ---------------------------------*/ |
| 428 | 1915 |
| 1916 /* In a cons, the markbit of the car is the gc mark bit */ | |
| 1917 | |
| 1918 struct Lisp_Cons | |
| 1919 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1920 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 853 | 1921 Lisp_Object car_, cdr_; |
| 428 | 1922 }; |
| 1923 typedef struct Lisp_Cons Lisp_Cons; | |
| 1924 | |
| 1925 #if 0 /* FSFmacs */ | |
| 1926 /* Like a cons, but records info on where the text lives that it was read from */ | |
| 1927 /* This is not really in use now */ | |
| 1928 | |
| 1929 struct Lisp_Buffer_Cons | |
| 1930 { | |
| 1931 Lisp_Object car, cdr; | |
| 1932 struct buffer *buffer; | |
| 665 | 1933 int charbpos; |
| 428 | 1934 }; |
| 1935 #endif | |
| 1936 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
1937 DECLARE_MODULE_API_LISP_OBJECT (cons, Lisp_Cons); |
| 428 | 1938 #define XCONS(x) XRECORD (x, cons, Lisp_Cons) |
| 617 | 1939 #define wrap_cons(p) wrap_record (p, cons) |
| 428 | 1940 #define CONSP(x) RECORDP (x, cons) |
| 1941 #define CHECK_CONS(x) CHECK_RECORD (x, cons) | |
| 1942 #define CONCHECK_CONS(x) CONCHECK_RECORD (x, cons) | |
| 1943 | |
| 3263 | 1944 #ifdef NEW_GC |
| 2720 | 1945 #define CONS_MARKED_P(c) MARKED_P (&((c)->lheader)) |
| 1946 #define MARK_CONS(c) MARK (&((c)->lheader)) | |
| 3263 | 1947 #else /* not NEW_GC */ |
| 428 | 1948 #define CONS_MARKED_P(c) MARKED_RECORD_HEADER_P(&((c)->lheader)) |
| 1949 #define MARK_CONS(c) MARK_RECORD_HEADER (&((c)->lheader)) | |
| 3263 | 1950 #endif /* not NEW_GC */ |
| 428 | 1951 |
| 1632 | 1952 extern MODULE_API Lisp_Object Qnil; |
| 428 | 1953 |
| 1954 #define NILP(x) EQ (x, Qnil) | |
| 853 | 1955 #define cons_car(a) ((a)->car_) |
| 1956 #define cons_cdr(a) ((a)->cdr_) | |
| 1957 #define XCAR(a) (XCONS (a)->car_) | |
| 1958 #define XCDR(a) (XCONS (a)->cdr_) | |
| 1318 | 1959 #define XCADR(a) (XCAR (XCDR (a))) |
| 1960 #define XCDDR(a) (XCDR (XCDR (a))) | |
| 1961 #define XCADDR(a) (XCAR (XCDDR (a))) | |
| 1962 #define XCDDDR(a) (XCDR (XCDDR (a))) | |
| 1963 #define XCADDDR(a) (XCAR (XCDDDR (a))) | |
| 1964 #define XCDDDDR(a) (XCDR (XCDDDR (a))) | |
| 1965 #define XCADDDDR(a) (XCAR (XCDDDDR (a))) | |
| 1966 #define XCDDDDDR(a) (XCDR (XCDDDDR (a))) | |
| 1967 #define XCADDDDDR(a) (XCAR (XCDDDDDR (a))) | |
| 1968 #define XCDDDDDDR(a) (XCDR (XCDDDDDR (a))) | |
| 1969 #define X1ST(a) XCAR (a) | |
| 1970 #define X2ND(a) XCADR (a) | |
| 1971 #define X3RD(a) XCADDR (a) | |
| 1972 #define X4TH(a) XCADDDR (a) | |
| 1973 #define X5TH(a) XCADDDDR (a) | |
| 1974 #define X6TH(a) XCADDDDDR (a) | |
| 1975 | |
| 853 | 1976 #define XSETCAR(a, b) (XCONS (a)->car_ = (b)) |
| 1977 #define XSETCDR(a, b) (XCONS (a)->cdr_ = (b)) | |
| 428 | 1978 #define LISTP(x) (CONSP(x) || NILP(x)) |
| 1979 | |
| 1980 #define CHECK_LIST(x) do { \ | |
| 1981 if (!LISTP (x)) \ | |
| 1982 dead_wrong_type_argument (Qlistp, x); \ | |
| 1983 } while (0) | |
| 1984 | |
| 1985 #define CONCHECK_LIST(x) do { \ | |
| 1986 if (!LISTP (x)) \ | |
| 1987 x = wrong_type_argument (Qlistp, x); \ | |
| 1988 } while (0) | |
| 1989 | |
| 442 | 1990 /*---------------------- list traversal macros -------------------------*/ |
| 1991 | |
| 1992 /* Note: These macros are for traversing through a list in some format, | |
| 1993 and executing code that you specify on each member of the list. | |
| 1994 | |
| 1995 There are two kinds of macros, those requiring surrounding braces, and | |
| 1996 those not requiring this. Which type of macro will be indicated. | |
| 1997 The general format for using a brace-requiring macro is | |
| 1998 | |
| 1999 { | |
| 2000 LIST_LOOP_3 (elt, list, tail) | |
| 2001 execute_code_here; | |
| 2002 } | |
| 2003 | |
| 2004 or | |
| 2005 | |
| 2006 { | |
| 2007 LIST_LOOP_3 (elt, list, tail) | |
| 2008 { | |
| 2009 execute_code_here; | |
| 2010 } | |
| 2011 } | |
| 2012 | |
| 2013 You can put variable declarations between the brace and beginning of | |
| 2014 macro, but NOTHING ELSE. | |
| 2015 | |
| 2016 The brace-requiring macros typically declare themselves any arguments | |
| 2017 that are initialized and iterated by the macros. If for some reason | |
| 2018 you need to declare these arguments yourself (e.g. to do something on | |
| 2019 them before the iteration starts, use the _NO_DECLARE versions of the | |
| 2020 macros.) | |
| 2021 */ | |
| 2022 | |
| 2023 /* There are two basic kinds of macros: those that handle "internal" lists | |
| 2024 that are known to be correctly structured (i.e. first element is a cons | |
| 2025 or nil, and the car of each cons is also a cons or nil, and there are | |
| 2026 no circularities), and those that handle "external" lists, where the | |
| 2027 list may have any sort of invalid formation. This is reflected in | |
| 2028 the names: those with "EXTERNAL_" work with external lists, and those | |
| 2029 without this prefix work with internal lists. The internal-list | |
| 2030 macros will hit an assertion failure if the structure is ill-formed; | |
| 2031 the external-list macros will signal an error in this case, either a | |
| 2032 malformed-list error or a circular-list error. | |
| 2033 */ | |
| 2034 | |
| 2367 | 2035 /* LIST_LOOP is a simple, old-fashioned macro. It doesn't require brace |
| 2036 surrounding, and iterates through a list, which may or may not known to | |
| 2037 be syntactically correct. It accepts two args, TAIL (set progressively | |
| 2038 to each cons starting with the first), and LIST, the list to iterate | |
| 2039 over. TAIL needs to be defined by the caller. | |
| 442 | 2040 |
| 2041 In each iteration, you can retrieve the current list item using XCAR | |
| 2042 (tail), or destructively modify the list using XSETCAR (tail, | |
| 2043 ...). */ | |
| 2044 | |
| 428 | 2045 #define LIST_LOOP(tail, list) \ |
| 2046 for (tail = list; \ | |
| 2047 !NILP (tail); \ | |
| 2048 tail = XCDR (tail)) | |
| 2049 | |
| 442 | 2050 /* The following macros are the "core" macros for list traversal. |
| 2051 | |
| 2052 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2053 | |
| 2054 LIST_LOOP_2 and EXTERNAL_LIST_LOOP_2 are the standard, most-often used | |
| 2055 macros. They take two arguments, an element variable ELT and the list | |
| 2056 LIST. ELT is automatically declared, and set to each element in turn | |
| 2057 from LIST. | |
| 2058 | |
| 2059 LIST_LOOP_3 and EXTERNAL_LIST_LOOP_3 are the same, but they have a third | |
| 2060 argument TAIL, another automatically-declared variable. At each iteration, | |
| 2061 this one points to the cons cell for which ELT is the car. | |
| 2062 | |
| 2063 EXTERNAL_LIST_LOOP_4 is like EXTERNAL_LIST_LOOP_3 but takes an additional | |
| 2064 LEN argument, again automatically declared, which counts the number of | |
| 2065 iterations gone by. It is 0 during the first iteration. | |
| 2066 | |
| 2067 EXTERNAL_LIST_LOOP_4_NO_DECLARE is like EXTERNAL_LIST_LOOP_4 but none | |
| 2068 of the variables are automatically declared, and so you need to declare | |
| 2069 them yourself. (ELT and TAIL are Lisp_Objects, and LEN is an EMACS_INT.) | |
| 2070 */ | |
| 2071 | |
| 2072 #define LIST_LOOP_2(elt, list) \ | |
| 2073 LIST_LOOP_3(elt, list, unused_tail_##elt) | |
| 2074 | |
| 2075 #define LIST_LOOP_3(elt, list, tail) \ | |
| 2076 Lisp_Object elt, tail; \ | |
| 2077 for (tail = list; \ | |
| 2078 NILP (tail) ? \ | |
| 2079 0 : (elt = XCAR (tail), 1); \ | |
| 2080 tail = XCDR (tail)) | |
| 428 | 2081 |
| 2082 /* The following macros are for traversing lisp lists. | |
| 2083 Signal an error if LIST is not properly acyclic and nil-terminated. | |
| 2084 | |
| 2085 Use tortoise/hare algorithm to check for cycles, but only if it | |
| 2086 looks like the list is getting too long. Not only is the hare | |
| 2087 faster than the tortoise; it even gets a head start! */ | |
| 2088 | |
| 2089 /* Optimized and safe macros for looping over external lists. */ | |
| 2090 #define CIRCULAR_LIST_SUSPICION_LENGTH 1024 | |
| 2091 | |
| 2092 #define EXTERNAL_LIST_LOOP_1(list) \ | |
| 2093 Lisp_Object ELL1_elt, ELL1_hare, ELL1_tortoise; \ | |
| 442 | 2094 EMACS_INT ELL1_len; \ |
| 2095 PRIVATE_EXTERNAL_LIST_LOOP_6 (ELL1_elt, list, ELL1_len, ELL1_hare, \ | |
| 428 | 2096 ELL1_tortoise, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2097 | |
| 2098 #define EXTERNAL_LIST_LOOP_2(elt, list) \ | |
| 442 | 2099 Lisp_Object elt, hare_##elt, tortoise_##elt; \ |
| 2100 EMACS_INT len_##elt; \ | |
| 2101 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ | |
| 428 | 2102 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2103 | |
| 2367 | 2104 |
| 2105 #define GC_EXTERNAL_LIST_LOOP_2(elt, list) \ | |
| 2106 do { \ | |
| 2107 XGCDECL3 (elt); \ | |
| 2108 Lisp_Object elt, hare_##elt, tortoise_##elt; \ | |
| 2109 EMACS_INT len_##elt; \ | |
| 2110 XGCPRO3 (elt, elt, hare_##elt, tortoise_##elt); \ | |
| 2111 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ | |
| 2112 tortoise_##elt, \ | |
| 2113 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2114 | |
| 2115 #define END_GC_EXTERNAL_LIST_LOOP(elt) \ | |
| 2116 XUNGCPRO (elt); \ | |
| 2117 } \ | |
| 2118 while (0) | |
| 2119 | |
| 428 | 2120 #define EXTERNAL_LIST_LOOP_3(elt, list, tail) \ |
| 442 | 2121 Lisp_Object elt, tail, tortoise_##elt; \ |
| 2122 EMACS_INT len_##elt; \ | |
| 2123 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len_##elt, tail, \ | |
| 2124 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2125 | |
| 2126 #define EXTERNAL_LIST_LOOP_4_NO_DECLARE(elt, list, tail, len) \ | |
| 428 | 2127 Lisp_Object tortoise_##elt; \ |
| 442 | 2128 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail, \ |
| 428 | 2129 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2130 | |
| 2131 #define EXTERNAL_LIST_LOOP_4(elt, list, tail, len) \ | |
| 442 | 2132 Lisp_Object elt, tail, tortoise_##elt; \ |
| 2133 EMACS_INT len; \ | |
| 2134 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, tail, \ | |
| 428 | 2135 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 2136 | |
|
5179
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2137 #define PRIVATE_UNVERIFIED_LIST_LOOP_7(elt, list, len, hare, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2138 tortoise, suspicion_length, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2139 signalp) \ |
| 444 | 2140 for (tortoise = hare = list, len = 0; \ |
| 2141 \ | |
| 2142 (CONSP (hare) ? ((elt = XCAR (hare)), 1) : \ | |
| 2143 (NILP (hare) ? 0 : \ | |
| 5181 | 2144 ((signalp ? signal_malformed_list_error (list) : (void) 0), 0)));\ |
| 444 | 2145 \ |
| 2146 hare = XCDR (hare), \ | |
| 2147 (void) \ | |
| 2148 ((++len > suspicion_length) \ | |
| 2149 && \ | |
| 2150 ((((len & 1) != 0) && (tortoise = XCDR (tortoise), 0)), \ | |
|
5179
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2151 (EQ (hare, tortoise) && \ |
| 5181 | 2152 ((signalp ? signal_circular_list_error (list) : (void) 0), 0))))) |
|
5179
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2153 |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2154 #define PRIVATE_EXTERNAL_LIST_LOOP_6(elt, list, len, hare, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2155 tortoise, suspicion_length) \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2156 PRIVATE_UNVERIFIED_LIST_LOOP_7 (elt, list, len, hare, tortoise, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2157 suspicion_length, 1) |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2158 |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2159 #define PRIVATE_SAFE_LIST_LOOP_6(elt, list, len, hare, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2160 tortoise, suspicion_length) \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2161 PRIVATE_UNVERIFIED_LIST_LOOP_7 (elt, list, len, hare, tortoise, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2162 suspicion_length, 0) |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2163 |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2164 /* Similar to EXTERNAL_LIST_LOOP_2() but don't signal when an error |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2165 is detected, just stop. */ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2166 #define SAFE_LIST_LOOP_2(elt, list) \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2167 Lisp_Object elt, hare_##elt, tortoise_##elt; \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2168 EMACS_INT len_##elt; \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2169 PRIVATE_SAFE_LIST_LOOP_6 (elt, list, len_##elt, hare_##elt, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2170 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2171 |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2172 #define SAFE_LIST_LOOP_3(elt, list, tail) \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2173 Lisp_Object elt, tail, tortoise_##elt; \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2174 EMACS_INT len_##elt; \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2175 PRIVATE_SAFE_LIST_LOOP_6 (elt, list, len_##elt, tail, \ |
|
14fda1dbdb26
add memory usage info for specifiers
Ben Wing <ben@xemacs.org>
parents:
5170
diff
changeset
|
2176 tortoise_##elt, CIRCULAR_LIST_SUSPICION_LENGTH) |
| 428 | 2177 |
| 442 | 2178 /* GET_LIST_LENGTH and GET_EXTERNAL_LIST_LENGTH: |
| 2179 | |
| 2180 These two macros return the length of LIST (either an internal or external | |
| 2181 list, according to which macro is used), stored into LEN (which must | |
| 2182 be declared by the caller). Circularities are trapped in external lists | |
| 2183 (and cause errors). Neither macro need be declared inside brackets. */ | |
| 2184 | |
| 2185 #define GET_LIST_LENGTH(list, len) do { \ | |
| 2186 Lisp_Object GLL_tail; \ | |
| 2187 for (GLL_tail = list, len = 0; \ | |
| 2188 !NILP (GLL_tail); \ | |
| 2189 GLL_tail = XCDR (GLL_tail), ++len) \ | |
| 2190 DO_NOTHING; \ | |
| 2191 } while (0) | |
| 2192 | |
| 2193 #define GET_EXTERNAL_LIST_LENGTH(list, len) \ | |
| 2194 do { \ | |
| 2195 Lisp_Object GELL_elt, GELL_tail; \ | |
| 2196 EXTERNAL_LIST_LOOP_4_NO_DECLARE (GELL_elt, list, GELL_tail, len) \ | |
| 2197 ; \ | |
| 2198 } while (0) | |
| 2199 | |
| 2200 /* For a list that's known to be in valid list format, where we may | |
| 2201 be deleting the current element out of the list -- | |
| 2500 | 2202 will ABORT() if the list is not in valid format */ |
| 442 | 2203 #define LIST_LOOP_DELETING(consvar, nextconsvar, list) \ |
| 2204 for (consvar = list; \ | |
| 2205 !NILP (consvar) ? (nextconsvar = XCDR (consvar), 1) :0; \ | |
| 2206 consvar = nextconsvar) | |
| 2207 | |
| 2208 /* LIST_LOOP_DELETE_IF and EXTERNAL_LIST_LOOP_DELETE_IF: | |
| 2209 | |
| 2210 These two macros delete all elements of LIST (either an internal or | |
| 2211 external list, according to which macro is used) satisfying | |
| 2212 CONDITION, a C expression referring to variable ELT. ELT is | |
| 2213 automatically declared. Circularities are trapped in external | |
| 2214 lists (and cause errors). Neither macro need be declared inside | |
| 2215 brackets. */ | |
| 2216 | |
| 2217 #define LIST_LOOP_DELETE_IF(elt, list, condition) do { \ | |
| 2218 /* Do not use ##list when creating new variables because \ | |
| 2219 that may not be just a variable name. */ \ | |
| 2220 Lisp_Object prev_tail_##elt = Qnil; \ | |
| 2221 LIST_LOOP_3 (elt, list, tail_##elt) \ | |
| 2222 { \ | |
| 2223 if (condition) \ | |
| 2224 { \ | |
| 2225 if (NILP (prev_tail_##elt)) \ | |
| 2226 list = XCDR (tail_##elt); \ | |
| 2227 else \ | |
| 2228 XCDR (prev_tail_##elt) = XCDR (tail_##elt); \ | |
| 2229 } \ | |
| 2230 else \ | |
| 2231 prev_tail_##elt = tail_##elt; \ | |
| 2232 } \ | |
| 2233 } while (0) | |
| 2234 | |
| 2235 #define EXTERNAL_LIST_LOOP_DELETE_IF(elt, list, condition) do { \ | |
| 2236 Lisp_Object prev_tail_##elt = Qnil; \ | |
| 2237 EXTERNAL_LIST_LOOP_4 (elt, list, tail_##elt, len_##elt) \ | |
| 2238 { \ | |
| 2239 if (condition) \ | |
| 2240 { \ | |
| 2241 if (NILP (prev_tail_##elt)) \ | |
| 2242 list = XCDR (tail_##elt); \ | |
| 2243 else \ | |
| 2244 XCDR (prev_tail_##elt) = XCDR (tail_##elt); \ | |
| 2245 /* Keep tortoise from ever passing hare. */ \ | |
| 2246 len_##elt = 0; \ | |
| 2247 } \ | |
| 2248 else \ | |
| 2249 prev_tail_##elt = tail_##elt; \ | |
| 2250 } \ | |
| 2251 } while (0) | |
| 2252 | |
| 2253 | |
| 1204 | 2254 /* Macros for looping over internal alists. |
| 2255 | |
| 2256 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2257 | |
| 2258 ALIST_LOOP_3 loops over an alist, at each iteration setting CAR and CDR | |
| 2259 to the car and cdr of the acons. CAR and CDR are automatically | |
| 2260 declared. | |
| 2261 | |
| 2262 ALIST_LOOP_4 is similar to ALIST_LOOP_3 but contains an additional | |
| 2263 variable ACONS at the beginning for access to the acons itself.All of | |
| 2264 the variables ACONS, CAR and CDR are automatically declared. | |
| 2265 */ | |
| 2266 | |
| 2267 #define ALIST_LOOP_3(car, cdr, alist) \ | |
| 2268 Lisp_Object _al3_acons_##car, car, cdr, _al3_tail_##car; \ | |
| 2269 for (_al3_tail_##car = alist; \ | |
| 2270 NILP (_al3_tail_##car) ? \ | |
| 2271 0 : (_al3_acons_##car = XCAR (_al3_tail_##car), \ | |
| 2272 car = XCAR (_al3_acons_##car), \ | |
| 2273 cdr = XCDR (_al3_acons_##car), 1); \ | |
| 2274 _al3_tail_##car = XCDR (_al3_tail_##car)) | |
| 2275 | |
| 2276 #define ALIST_LOOP_4(acons, car, cdr, list) \ | |
| 2277 Lisp_Object acons, car, cdr, _al4_tail_##car; \ | |
| 2278 for (_al4_tail_##car = list; \ | |
| 2279 NILP (_al4_tail_##car) ? \ | |
| 2280 0 : (elt = XCAR (_al4_tail_##car), car = XCAR (elt), \ | |
| 2281 cdr = XCDR (elt), 1); \ | |
| 2282 _al4_tail_##car = XCDR (tail)) | |
| 2283 | |
| 442 | 2284 /* Macros for looping over external alists. |
| 2285 | |
| 2286 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2287 | |
| 2288 EXTERNAL_ALIST_LOOP_4 is similar to EXTERNAL_LIST_LOOP_2, but it | |
| 2289 assumes the elements are aconses (the elements in an alist) and | |
| 2290 sets two additional argument variables ELT_CAR and ELT_CDR to the | |
| 2291 car and cdr of the acons. All of the variables ELT, ELT_CAR and | |
| 2292 ELT_CDR are automatically declared. | |
| 2293 | |
| 2294 EXTERNAL_ALIST_LOOP_5 adds a TAIL argument to EXTERNAL_ALIST_LOOP_4, | |
| 2295 just like EXTERNAL_LIST_LOOP_3 does, and again TAIL is automatically | |
| 2296 declared. | |
| 2297 | |
| 2298 EXTERNAL_ALIST_LOOP_6 adds a LEN argument to EXTERNAL_ALIST_LOOP_5, | |
| 2299 just like EXTERNAL_LIST_LOOP_4 does, and again LEN is automatically | |
| 2300 declared. | |
| 2301 | |
| 2302 EXTERNAL_ALIST_LOOP_6_NO_DECLARE does not declare any of its arguments, | |
| 2303 just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these must be declared | |
| 2304 manually. | |
| 2305 */ | |
| 428 | 2306 |
| 2307 /* Optimized and safe macros for looping over external alists. */ | |
| 2308 #define EXTERNAL_ALIST_LOOP_4(elt, elt_car, elt_cdr, list) \ | |
| 442 | 2309 Lisp_Object elt, elt_car, elt_cdr; \ |
| 428 | 2310 Lisp_Object hare_##elt, tortoise_##elt; \ |
| 2311 EMACS_INT len_##elt; \ | |
| 442 | 2312 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2313 len_##elt, hare_##elt, tortoise_##elt, \ |
| 2314 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2315 | |
| 2316 #define EXTERNAL_ALIST_LOOP_5(elt, elt_car, elt_cdr, list, tail) \ | |
| 442 | 2317 Lisp_Object elt, elt_car, elt_cdr, tail; \ |
| 428 | 2318 Lisp_Object tortoise_##elt; \ |
| 2319 EMACS_INT len_##elt; \ | |
| 442 | 2320 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2321 len_##elt, tail, tortoise_##elt, \ |
| 2322 CIRCULAR_LIST_SUSPICION_LENGTH) \ | |
| 2323 | |
| 2324 #define EXTERNAL_ALIST_LOOP_6(elt, elt_car, elt_cdr, list, tail, len) \ | |
| 442 | 2325 Lisp_Object elt, elt_car, elt_cdr, tail; \ |
| 2326 EMACS_INT len; \ | |
| 428 | 2327 Lisp_Object tortoise_##elt; \ |
| 442 | 2328 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ |
| 428 | 2329 len, tail, tortoise_##elt, \ |
| 2330 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2331 | |
| 442 | 2332 #define EXTERNAL_ALIST_LOOP_6_NO_DECLARE(elt, elt_car, elt_cdr, list, \ |
| 2333 tail, len) \ | |
| 2334 Lisp_Object tortoise_##elt; \ | |
| 2335 PRIVATE_EXTERNAL_ALIST_LOOP_8 (elt, elt_car, elt_cdr, list, \ | |
| 2336 len, tail, tortoise_##elt, \ | |
| 2337 CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2338 | |
| 2339 | |
| 2340 #define PRIVATE_EXTERNAL_ALIST_LOOP_8(elt, elt_car, elt_cdr, list, len, \ | |
| 2341 hare, tortoise, suspicion_length) \ | |
| 2342 PRIVATE_EXTERNAL_LIST_LOOP_6 (elt, list, len, hare, tortoise, \ | |
| 2343 suspicion_length) \ | |
| 428 | 2344 if (CONSP (elt) ? (elt_car = XCAR (elt), elt_cdr = XCDR (elt), 0) :1) \ |
| 2345 continue; \ | |
| 2346 else | |
| 2347 | |
| 442 | 2348 /* Macros for looping over external property lists. |
| 2349 | |
| 2350 *** ALL OF THESE MACROS MUST BE DECLARED INSIDE BRACES -- SEE ABOVE. *** | |
| 2351 | |
| 2352 EXTERNAL_PROPERTY_LIST_LOOP_3 maps over an external list assumed to | |
| 2353 be a property list, consisting of alternating pairs of keys | |
| 2354 (typically symbols or keywords) and values. Each iteration | |
| 2355 processes one such pair out of LIST, assigning the two elements to | |
| 2356 KEY and VALUE respectively. Malformed lists and circularities are | |
| 2357 trapped as usual, and in addition, property lists with an odd number | |
| 2358 of elements also signal an error. | |
| 2359 | |
| 2360 EXTERNAL_PROPERTY_LIST_LOOP_4 adds a TAIL argument to | |
| 2361 EXTERNAL_PROPERTY_LIST_LOOP_3, just like EXTERNAL_LIST_LOOP_3 does, | |
| 2362 and again TAIL is automatically declared. | |
| 2363 | |
| 2364 EXTERNAL_PROPERTY_LIST_LOOP_5 adds a LEN argument to | |
| 2365 EXTERNAL_PROPERTY_LIST_LOOP_4, just like EXTERNAL_LIST_LOOP_4 does, | |
| 2366 and again LEN is automatically declared. Note that in this case, | |
| 2367 LEN counts the iterations, NOT the total number of list elements | |
| 2368 processed, which is 2 * LEN. | |
| 2369 | |
| 2370 EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE does not declare any of its | |
| 2371 arguments, just like EXTERNAL_LIST_LOOP_4_NO_DECLARE, and so these | |
| 2372 must be declared manually. */ | |
| 428 | 2373 |
| 2374 /* Optimized and safe macros for looping over external property lists. */ | |
| 2375 #define EXTERNAL_PROPERTY_LIST_LOOP_3(key, value, list) \ | |
| 2376 Lisp_Object key, value, hare_##key, tortoise_##key; \ | |
| 442 | 2377 EMACS_INT len_##key; \ |
| 428 | 2378 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, hare_##key, \ |
| 2379 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2380 | |
| 2381 #define EXTERNAL_PROPERTY_LIST_LOOP_4(key, value, list, tail) \ | |
| 2382 Lisp_Object key, value, tail, tortoise_##key; \ | |
| 442 | 2383 EMACS_INT len_##key; \ |
| 428 | 2384 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len_##key, tail, \ |
| 2385 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2386 | |
| 2387 #define EXTERNAL_PROPERTY_LIST_LOOP_5(key, value, list, tail, len) \ | |
| 2388 Lisp_Object key, value, tail, tortoise_##key; \ | |
| 2389 EMACS_INT len; \ | |
| 2390 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail, \ | |
| 2391 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2392 | |
| 442 | 2393 #define EXTERNAL_PROPERTY_LIST_LOOP_5_NO_DECLARE(key, value, list, \ |
| 2394 tail, len) \ | |
| 2395 Lisp_Object tortoise_##key; \ | |
| 2396 EXTERNAL_PROPERTY_LIST_LOOP_7 (key, value, list, len, tail, \ | |
| 2397 tortoise_##key, CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2398 | |
| 428 | 2399 |
| 2400 #define EXTERNAL_PROPERTY_LIST_LOOP_7(key, value, list, len, hare, \ | |
| 2401 tortoise, suspicion_length) \ | |
| 2402 for (tortoise = hare = list, len = 0; \ | |
| 2403 \ | |
| 2404 ((CONSP (hare) && \ | |
| 2405 (key = XCAR (hare), \ | |
| 2406 hare = XCDR (hare), \ | |
| 442 | 2407 (CONSP (hare) ? 1 : \ |
| 2408 (signal_malformed_property_list_error (list), 0)))) ? \ | |
| 428 | 2409 (value = XCAR (hare), 1) : \ |
| 2410 (NILP (hare) ? 0 : \ | |
| 2411 (signal_malformed_property_list_error (list), 0))); \ | |
| 2412 \ | |
| 2413 hare = XCDR (hare), \ | |
| 2414 ((++len < suspicion_length) ? \ | |
| 2415 ((void) 0) : \ | |
| 2416 (((len & 1) ? \ | |
| 2417 ((void) (tortoise = XCDR (XCDR (tortoise)))) : \ | |
| 2418 ((void) 0)) \ | |
| 2419 , \ | |
| 2420 (EQ (hare, tortoise) ? \ | |
| 2421 ((void) signal_circular_property_list_error (list)) : \ | |
| 2422 ((void) 0))))) | |
| 2423 | |
| 2421 | 2424 #define PRIVATE_PROPERTY_LIST_LOOP_4(tail, key, value, plist) \ |
| 2425 for (tail = plist; \ | |
| 2426 NILP (tail) ? 0 : \ | |
| 2427 (key = XCAR (tail), tail = XCDR (tail), \ | |
| 2428 value = XCAR (tail), tail = XCDR (tail), 1); \ | |
| 428 | 2429 ) |
| 2430 | |
| 2421 | 2431 #define PROPERTY_LIST_LOOP_3(key, value, plist) \ |
| 2432 Lisp_Object key, value, tail_##key; \ | |
| 2433 PRIVATE_PROPERTY_LIST_LOOP_4 (tail_##key, key, value, plist) | |
| 2434 | |
| 2435 #define GC_PROPERTY_LIST_LOOP_3(key, value, plist) \ | |
| 2436 do { \ | |
| 2437 XGCDECL3 (key); \ | |
| 2438 Lisp_Object key, value, tail_##key; \ | |
| 2439 XGCPRO3 (key, key, value, tail_##key); \ | |
| 2440 PRIVATE_PROPERTY_LIST_LOOP_4 (tail_##key, key, value, plist) | |
| 2441 | |
| 2442 #define END_GC_PROPERTY_LIST_LOOP(key) \ | |
| 2443 XUNGCPRO (key); \ | |
| 2444 } \ | |
| 2445 while (0) | |
| 2446 | |
| 428 | 2447 /* Return 1 if LIST is properly acyclic and nil-terminated, else 0. */ |
| 826 | 2448 DECLARE_INLINE_HEADER ( |
| 2449 int | |
| 428 | 2450 TRUE_LIST_P (Lisp_Object object) |
| 826 | 2451 ) |
| 428 | 2452 { |
| 2453 Lisp_Object hare, tortoise; | |
| 2454 EMACS_INT len; | |
| 2455 | |
| 2456 for (hare = tortoise = object, len = 0; | |
| 2457 CONSP (hare); | |
| 2458 hare = XCDR (hare), len++) | |
| 2459 { | |
| 2460 if (len < CIRCULAR_LIST_SUSPICION_LENGTH) | |
| 2461 continue; | |
| 2462 | |
| 2463 if (len & 1) | |
| 2464 tortoise = XCDR (tortoise); | |
| 2465 else if (EQ (hare, tortoise)) | |
| 2466 return 0; | |
| 2467 } | |
| 2468 | |
| 2469 return NILP (hare); | |
| 2470 } | |
| 2471 | |
| 2472 /* Signal an error if LIST is not properly acyclic and nil-terminated. */ | |
| 2473 #define CHECK_TRUE_LIST(list) do { \ | |
| 2474 Lisp_Object CTL_list = (list); \ | |
| 2475 Lisp_Object CTL_hare, CTL_tortoise; \ | |
| 436 | 2476 EMACS_INT CTL_len; \ |
| 428 | 2477 \ |
| 2478 for (CTL_hare = CTL_tortoise = CTL_list, CTL_len = 0; \ | |
| 2479 CONSP (CTL_hare); \ | |
| 2480 CTL_hare = XCDR (CTL_hare), CTL_len++) \ | |
| 2481 { \ | |
| 2482 if (CTL_len < CIRCULAR_LIST_SUSPICION_LENGTH) \ | |
| 2483 continue; \ | |
| 2484 \ | |
| 2485 if (CTL_len & 1) \ | |
| 2486 CTL_tortoise = XCDR (CTL_tortoise); \ | |
| 2487 else if (EQ (CTL_hare, CTL_tortoise)) \ | |
| 2488 Fsignal (Qcircular_list, list1 (CTL_list)); \ | |
| 2489 } \ | |
| 2490 \ | |
| 2491 if (! NILP (CTL_hare)) \ | |
| 2492 signal_malformed_list_error (CTL_list); \ | |
| 2493 } while (0) | |
| 2494 | |
| 442 | 2495 /*------------------------------ string --------------------------------*/ |
| 428 | 2496 |
| 3092 | 2497 #ifdef NEW_GC |
| 2498 struct Lisp_String_Direct_Data | |
| 2499 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2500 NORMAL_LISP_OBJECT_HEADER header; |
| 3092 | 2501 Bytecount size; |
| 2502 Ibyte data[1]; | |
| 2503 }; | |
| 2504 typedef struct Lisp_String_Direct_Data Lisp_String_Direct_Data; | |
| 2505 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2506 DECLARE_MODULE_API_LISP_OBJECT (string_direct_data, Lisp_String_Direct_Data); |
| 3092 | 2507 #define XSTRING_DIRECT_DATA(x) \ |
| 2508 XRECORD (x, string_direct_data, Lisp_String_Direct_Data) | |
| 2509 #define wrap_string_direct_data(p) wrap_record (p, string_direct_data) | |
| 2510 #define STRING_DIRECT_DATAP(x) RECORDP (x, string_direct_data) | |
| 2511 #define CHECK_STRING_DIRECT_DATA(x) CHECK_RECORD (x, string_direct_data) | |
| 2512 #define CONCHECK_STRING_DIRECT_DATA(x) CONCHECK_RECORD (x, string_direct_data) | |
| 2513 | |
| 2514 #define XSTRING_DIRECT_DATA_SIZE(x) XSTRING_DIRECT_DATA (x)->size | |
| 2515 #define XSTRING_DIRECT_DATA_DATA(x) XSTRING_DIRECT_DATA (x)->data | |
| 2516 | |
| 2517 | |
| 2518 struct Lisp_String_Indirect_Data | |
| 2519 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2520 NORMAL_LISP_OBJECT_HEADER header; |
| 3092 | 2521 Bytecount size; |
| 2522 Ibyte *data; | |
| 2523 }; | |
| 2524 typedef struct Lisp_String_Indirect_Data Lisp_String_Indirect_Data; | |
| 2525 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2526 DECLARE_MODULE_API_LISP_OBJECT (string_indirect_data, Lisp_String_Indirect_Data); |
| 3092 | 2527 #define XSTRING_INDIRECT_DATA(x) \ |
| 2528 XRECORD (x, string_indirect_data, Lisp_String_Indirect_Data) | |
| 2529 #define wrap_string_indirect_data(p) wrap_record (p, string_indirect_data) | |
| 2530 #define STRING_INDIRECT_DATAP(x) RECORDP (x, string_indirect_data) | |
| 2531 #define CHECK_STRING_INDIRECT_DATA(x) CHECK_RECORD (x, string_indirect_data) | |
| 2532 #define CONCHECK_STRING_INDIRECT_DATA(x) \ | |
| 2533 CONCHECK_RECORD (x, string_indirect_data) | |
| 2534 | |
| 2535 #define XSTRING_INDIRECT_DATA_SIZE(x) XSTRING_INDIRECT_DATA (x)->size | |
| 2536 #define XSTRING_INDIRECT_DATA_DATA(x) XSTRING_INDIRECT_DATA (x)->data | |
| 2537 | |
| 2538 | |
| 2539 #define XSTRING_DATA_SIZE(s) ((s)->indirect)? \ | |
| 2540 XSTRING_INDIRECT_DATA_SIZE ((s)->data_object): \ | |
| 2541 XSTRING_DIRECT_DATA_SIZE ((s)->data_object) | |
| 2542 #define XSTRING_DATA_DATA(s) ((s)->indirect)? \ | |
| 2543 XSTRING_INDIRECT_DATA_DATA ((s)->data_object): \ | |
| 2544 XSTRING_DIRECT_DATA_DATA ((s)->data_object) | |
| 2545 | |
| 2546 #define XSET_STRING_DATA_SIZE(s, len) \ | |
| 2547 if ((s)->indirect) \ | |
| 2548 XSTRING_INDIRECT_DATA_SIZE ((s)->data_object) = len; \ | |
| 2549 else \ | |
| 2550 XSTRING_DIRECT_DATA_SIZE ((s)->data_object) = len | |
| 2551 #define XSET_STRING_DATA_DATA(s, ptr) \ | |
| 2552 if ((s)->indirect) \ | |
| 2553 XSTRING_INDIRECT_DATA_DATA ((s)->data_object) = ptr; \ | |
| 2554 else \ | |
| 2555 XSTRING_DIRECT_DATA_DATA ((s)->data_object) = ptr | |
| 2556 #endif /* NEW_GC */ | |
| 2557 | |
| 428 | 2558 struct Lisp_String |
| 2559 { | |
| 771 | 2560 union |
| 2561 { | |
| 2562 struct lrecord_header lheader; | |
| 2563 struct | |
| 2564 { | |
| 2565 /* WARNING: Everything before ascii_begin must agree exactly with | |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
2566 struct lrecord_header. (Actually, the `free' field in old-GC |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
2567 overlaps with ascii_begin there; we can get away with this |
|
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
2568 because in old-GC the `free' field is used only for lcrecords. */ |
| 771 | 2569 unsigned int type :8; |
| 3263 | 2570 #ifdef NEW_GC |
| 2720 | 2571 unsigned int lisp_readonly :1; |
| 2572 unsigned int free :1; | |
| 2573 /* Number of chars at beginning of string that are one byte in length | |
| 2574 (byte_ascii_p) */ | |
| 2575 unsigned int ascii_begin :22; | |
| 3263 | 2576 #else /* not NEW_GC */ |
| 771 | 2577 unsigned int mark :1; |
| 2578 unsigned int c_readonly :1; | |
| 2579 unsigned int lisp_readonly :1; | |
| 2580 /* Number of chars at beginning of string that are one byte in length | |
| 826 | 2581 (byte_ascii_p) */ |
| 771 | 2582 unsigned int ascii_begin :21; |
| 3263 | 2583 #endif /* not NEW_GC */ |
| 771 | 2584 } v; |
| 2585 } u; | |
| 3092 | 2586 #ifdef NEW_GC |
| 2587 int indirect; | |
| 2588 Lisp_Object data_object; | |
| 2589 #else /* not NEW_GC */ | |
| 793 | 2590 Bytecount size_; |
| 867 | 2591 Ibyte *data_; |
| 3092 | 2592 #endif /* not NEW_GC */ |
| 428 | 2593 Lisp_Object plist; |
| 2594 }; | |
| 2595 typedef struct Lisp_String Lisp_String; | |
| 2596 | |
| 3263 | 2597 #ifdef NEW_GC |
| 3063 | 2598 #define MAX_STRING_ASCII_BEGIN ((1 << 22) - 1) |
| 3263 | 2599 #else /* not NEW_GC */ |
| 851 | 2600 #define MAX_STRING_ASCII_BEGIN ((1 << 21) - 1) |
| 3263 | 2601 #endif /* not NEW_GC */ |
| 771 | 2602 |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2603 DECLARE_MODULE_API_LISP_OBJECT (string, Lisp_String); |
| 428 | 2604 #define XSTRING(x) XRECORD (x, string, Lisp_String) |
| 617 | 2605 #define wrap_string(p) wrap_record (p, string) |
| 428 | 2606 #define STRINGP(x) RECORDP (x, string) |
| 2607 #define CHECK_STRING(x) CHECK_RECORD (x, string) | |
| 2608 #define CONCHECK_STRING(x) CONCHECK_RECORD (x, string) | |
| 2609 | |
| 826 | 2610 /* Most basic macros for strings -- basically just accessing or setting |
| 2611 fields -- are here. Everything else is in text.h, since they depend on | |
| 2612 stuff there. */ | |
| 428 | 2613 |
| 793 | 2614 /* Operations on Lisp_String *'s; only ones left */ |
| 3092 | 2615 #ifdef NEW_GC |
| 3304 | 2616 #define set_lispstringp_direct(s) ((s)->indirect = 0) |
| 3092 | 2617 #define set_lispstringp_indirect(s) ((s)->indirect = 1) |
| 2618 #define set_lispstringp_length(s, len) XSET_STRING_DATA_SIZE (s, len) | |
| 2619 #define set_lispstringp_data(s, ptr) XSET_STRING_DATA_DATA (s, ptr) | |
| 2620 #else /* not NEW_GC */ | |
| 826 | 2621 #define set_lispstringp_length(s, len) ((void) ((s)->size_ = (len))) |
| 2622 #define set_lispstringp_data(s, ptr) ((void) ((s)->data_ = (ptr))) | |
| 3092 | 2623 #endif /* not NEW_GC */ |
| 826 | 2624 |
| 2625 /* Operations on strings as Lisp_Objects. Don't manipulate Lisp_String *'s | |
| 2626 in any new code. */ | |
| 3092 | 2627 #ifdef NEW_GC |
| 2628 #define STRING_DATA_OBJECT(s) ((s)->data_object) | |
| 2629 #define XSTRING_DATA_OBJECT(s) (STRING_DATA_OBJECT (XSTRING (s))) | |
| 2630 #define XSTRING_LENGTH(s) (XSTRING_DATA_SIZE (XSTRING (s))) | |
| 2631 #else /* not NEW_GC */ | |
| 793 | 2632 #define XSTRING_LENGTH(s) (XSTRING (s)->size_) |
| 3092 | 2633 #endif /* not NEW_GC */ |
| 793 | 2634 #define XSTRING_PLIST(s) (XSTRING (s)->plist) |
| 3092 | 2635 #ifdef NEW_GC |
| 2636 #define XSTRING_DATA(s) (XSTRING_DATA_DATA (XSTRING (s))) | |
| 2637 #else /* not NEW_GC */ | |
| 793 | 2638 #define XSTRING_DATA(s) (XSTRING (s)->data_ + 0) |
| 3092 | 2639 #endif /* not NEW_GC */ |
| 793 | 2640 #define XSTRING_ASCII_BEGIN(s) (XSTRING (s)->u.v.ascii_begin + 0) |
| 826 | 2641 #define XSET_STRING_LENGTH(s, ptr) set_lispstringp_length (XSTRING (s), ptr) |
| 2642 #define XSET_STRING_DATA(s, ptr) set_lispstringp_data (XSTRING (s), ptr) | |
| 771 | 2643 /* WARNING: If you modify an existing string, you must call |
| 2644 bump_string_modiff() afterwards. */ | |
| 793 | 2645 #define XSET_STRING_ASCII_BEGIN(s, val) \ |
| 2646 ((void) (XSTRING (s)->u.v.ascii_begin = (val))) | |
| 826 | 2647 #define XSTRING_FORMAT(s) FORMAT_DEFAULT |
| 428 | 2648 |
| 456 | 2649 /* Return the true aligned size of a struct whose last member is a |
| 2650 variable-length array field. (this is known as the "struct hack") */ | |
| 2651 /* Implementation: in practice, structtype and fieldtype usually have | |
| 2652 the same alignment, but we can't be sure. We need to use | |
| 2653 ALIGN_SIZE to be absolutely sure of getting the correct alignment. | |
| 2654 To help the compiler's optimizer, we use a ternary expression that | |
| 2655 only a very stupid compiler would fail to correctly simplify. */ | |
| 2656 #define FLEXIBLE_ARRAY_STRUCT_SIZEOF(structtype, \ | |
| 2657 fieldtype, \ | |
| 2658 fieldname, \ | |
| 2659 array_length) \ | |
| 2660 (ALIGNOF (structtype) == ALIGNOF (fieldtype) \ | |
| 2661 ? (offsetof (structtype, fieldname) + \ | |
| 2662 (offsetof (structtype, fieldname[1]) - \ | |
| 2663 offsetof (structtype, fieldname[0])) * \ | |
| 2664 (array_length)) \ | |
| 826 | 2665 : (ALIGN_FOR_TYPE \ |
| 456 | 2666 ((offsetof (structtype, fieldname) + \ |
| 2667 (offsetof (structtype, fieldname[1]) - \ | |
| 2668 offsetof (structtype, fieldname[0])) * \ | |
| 2669 (array_length)), \ | |
| 826 | 2670 structtype))) |
| 442 | 2671 |
| 2672 /*------------------------------ vector --------------------------------*/ | |
| 428 | 2673 |
| 2674 struct Lisp_Vector | |
| 2675 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2676 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 2677 long size; |
| 2678 Lisp_Object contents[1]; | |
| 2679 }; | |
| 2680 typedef struct Lisp_Vector Lisp_Vector; | |
| 2681 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2682 DECLARE_LISP_OBJECT (vector, Lisp_Vector); |
| 428 | 2683 #define XVECTOR(x) XRECORD (x, vector, Lisp_Vector) |
| 617 | 2684 #define wrap_vector(p) wrap_record (p, vector) |
| 428 | 2685 #define VECTORP(x) RECORDP (x, vector) |
| 2686 #define CHECK_VECTOR(x) CHECK_RECORD (x, vector) | |
| 2687 #define CONCHECK_VECTOR(x) CONCHECK_RECORD (x, vector) | |
| 2688 | |
| 2689 #define vector_length(v) ((v)->size) | |
| 2690 #define XVECTOR_LENGTH(s) vector_length (XVECTOR (s)) | |
| 2691 #define vector_data(v) ((v)->contents) | |
| 2692 #define XVECTOR_DATA(s) vector_data (XVECTOR (s)) | |
| 2693 | |
| 442 | 2694 /*---------------------------- bit vectors -----------------------------*/ |
| 428 | 2695 |
| 2696 #if (LONGBITS < 16) | |
| 2697 #error What the hell?! | |
| 2698 #elif (LONGBITS < 32) | |
| 2699 # define LONGBITS_LOG2 4 | |
| 2700 # define LONGBITS_POWER_OF_2 16 | |
| 2701 #elif (LONGBITS < 64) | |
| 2702 # define LONGBITS_LOG2 5 | |
| 2703 # define LONGBITS_POWER_OF_2 32 | |
| 2704 #elif (LONGBITS < 128) | |
| 2705 # define LONGBITS_LOG2 6 | |
| 2706 # define LONGBITS_POWER_OF_2 64 | |
| 2707 #else | |
| 2708 #error You really have 128-bit integers?! | |
| 2709 #endif | |
| 2710 | |
| 2711 struct Lisp_Bit_Vector | |
| 2712 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2713 NORMAL_LISP_OBJECT_HEADER lheader; |
| 665 | 2714 Elemcount size; |
| 428 | 2715 unsigned long bits[1]; |
| 2716 }; | |
| 2717 typedef struct Lisp_Bit_Vector Lisp_Bit_Vector; | |
| 2718 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2719 DECLARE_LISP_OBJECT (bit_vector, Lisp_Bit_Vector); |
| 428 | 2720 #define XBIT_VECTOR(x) XRECORD (x, bit_vector, Lisp_Bit_Vector) |
| 617 | 2721 #define wrap_bit_vector(p) wrap_record (p, bit_vector) |
| 428 | 2722 #define BIT_VECTORP(x) RECORDP (x, bit_vector) |
| 2723 #define CHECK_BIT_VECTOR(x) CHECK_RECORD (x, bit_vector) | |
| 2724 #define CONCHECK_BIT_VECTOR(x) CONCHECK_RECORD (x, bit_vector) | |
| 2725 | |
| 2726 #define BITP(x) (INTP (x) && (XINT (x) == 0 || XINT (x) == 1)) | |
| 2727 | |
| 2728 #define CHECK_BIT(x) do { \ | |
| 2729 if (!BITP (x)) \ | |
| 2730 dead_wrong_type_argument (Qbitp, x);\ | |
| 2731 } while (0) | |
| 2732 | |
| 2733 #define CONCHECK_BIT(x) do { \ | |
| 2734 if (!BITP (x)) \ | |
| 2735 x = wrong_type_argument (Qbitp, x); \ | |
| 2736 } while (0) | |
| 2737 | |
| 2738 #define bit_vector_length(v) ((v)->size) | |
| 2739 | |
| 826 | 2740 DECLARE_INLINE_HEADER ( |
| 2741 int | |
| 665 | 2742 bit_vector_bit (Lisp_Bit_Vector *v, Elemcount n) |
| 826 | 2743 ) |
| 428 | 2744 { |
| 2745 return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1))) | |
| 2746 & 1); | |
| 2747 } | |
| 2748 | |
| 826 | 2749 DECLARE_INLINE_HEADER ( |
| 2750 void | |
| 665 | 2751 set_bit_vector_bit (Lisp_Bit_Vector *v, Elemcount n, int value) |
| 826 | 2752 ) |
| 428 | 2753 { |
| 2754 if (value) | |
| 2755 v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1))); | |
| 2756 else | |
| 2757 v->bits[n >> LONGBITS_LOG2] &= ~(1UL << (n & (LONGBITS_POWER_OF_2 - 1))); | |
| 2758 } | |
| 2759 | |
| 2760 /* Number of longs required to hold LEN bits */ | |
| 2761 #define BIT_VECTOR_LONG_STORAGE(len) \ | |
| 2762 (((len) + LONGBITS_POWER_OF_2 - 1) >> LONGBITS_LOG2) | |
| 2763 | |
| 3659 | 2764 /* For when we want to include a bit vector in another structure, and we |
| 2765 know it's of a fixed size. */ | |
| 2766 #define DECLARE_INLINE_LISP_BIT_VECTOR(numbits) struct { \ | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
2767 NORMAL_LISP_OBJECT_HEADER lheader; \ |
| 3659 | 2768 Elemcount size; \ |
| 2769 unsigned long bits[BIT_VECTOR_LONG_STORAGE(numbits)]; \ | |
| 2770 } | |
|
4995
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2771 /*---------------------- array, sequence -----------------------------*/ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2772 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2773 #define ARRAYP(x) (VECTORP (x) || STRINGP (x) || BIT_VECTORP (x)) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2774 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2775 #define CHECK_ARRAY(x) do { \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2776 if (!ARRAYP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2777 dead_wrong_type_argument (Qarrayp, x); \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2778 } while (0) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2779 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2780 #define CONCHECK_ARRAY(x) do { \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2781 if (!ARRAYP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2782 x = wrong_type_argument (Qarrayp, x); \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2783 } while (0) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2784 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2785 #define SEQUENCEP(x) (LISTP (x) || ARRAYP (x)) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2786 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2787 #define CHECK_SEQUENCE(x) do { \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2788 if (!SEQUENCEP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2789 dead_wrong_type_argument (Qsequencep, x); \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2790 } while (0) |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2791 |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2792 #define CONCHECK_SEQUENCE(x) do { \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2793 if (!SEQUENCEP (x)) \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2794 x = wrong_type_argument (Qsequencep, x); \ |
|
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
2795 } while (0) |
| 853 | 2796 |
| 442 | 2797 /*------------------------------ symbol --------------------------------*/ |
| 428 | 2798 |
| 440 | 2799 typedef struct Lisp_Symbol Lisp_Symbol; |
| 428 | 2800 struct Lisp_Symbol |
| 2801 { | |
|
5124
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
2802 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 428 | 2803 /* next symbol in this obarray bucket */ |
| 440 | 2804 Lisp_Symbol *next; |
| 793 | 2805 Lisp_Object name; |
| 428 | 2806 Lisp_Object value; |
| 2807 Lisp_Object function; | |
| 2808 Lisp_Object plist; | |
| 2809 }; | |
| 2810 | |
| 2811 #define SYMBOL_IS_KEYWORD(sym) \ | |
| 826 | 2812 ((string_byte (symbol_name (XSYMBOL (sym)), 0) == ':') \ |
| 428 | 2813 && EQ (sym, oblookup (Vobarray, \ |
| 793 | 2814 XSTRING_DATA (symbol_name (XSYMBOL (sym))), \ |
| 2815 XSTRING_LENGTH (symbol_name (XSYMBOL (sym)))))) | |
| 428 | 2816 #define KEYWORDP(obj) (SYMBOLP (obj) && SYMBOL_IS_KEYWORD (obj)) |
| 2817 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2818 DECLARE_MODULE_API_LISP_OBJECT (symbol, Lisp_Symbol); |
| 428 | 2819 #define XSYMBOL(x) XRECORD (x, symbol, Lisp_Symbol) |
| 617 | 2820 #define wrap_symbol(p) wrap_record (p, symbol) |
| 428 | 2821 #define SYMBOLP(x) RECORDP (x, symbol) |
| 2822 #define CHECK_SYMBOL(x) CHECK_RECORD (x, symbol) | |
| 2823 #define CONCHECK_SYMBOL(x) CONCHECK_RECORD (x, symbol) | |
| 2824 | |
| 2825 #define symbol_next(s) ((s)->next) | |
| 2826 #define symbol_name(s) ((s)->name) | |
| 2827 #define symbol_value(s) ((s)->value) | |
| 2828 #define symbol_function(s) ((s)->function) | |
| 2829 #define symbol_plist(s) ((s)->plist) | |
| 2830 | |
| 793 | 2831 #define XSYMBOL_NEXT(s) (XSYMBOL (s)->next) |
| 2832 #define XSYMBOL_NAME(s) (XSYMBOL (s)->name) | |
| 2833 #define XSYMBOL_VALUE(s) (XSYMBOL (s)->value) | |
| 2834 #define XSYMBOL_FUNCTION(s) (XSYMBOL (s)->function) | |
| 2835 #define XSYMBOL_PLIST(s) (XSYMBOL (s)->plist) | |
| 2836 | |
| 2837 | |
| 442 | 2838 /*------------------------------- subr ---------------------------------*/ |
| 428 | 2839 |
| 853 | 2840 /* A function that takes no arguments and returns a Lisp_Object. |
| 2841 We could define such types for n arguments, if needed. */ | |
| 428 | 2842 typedef Lisp_Object (*lisp_fn_t) (void); |
| 2843 | |
| 2844 struct Lisp_Subr | |
| 2845 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2846 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 442 | 2847 short min_args; |
| 2848 short max_args; | |
| 3379 | 2849 /* #### We should make these const Ascbyte * or const Ibyte *, not const |
| 2850 char *. */ | |
| 442 | 2851 const char *prompt; |
| 2852 const char *doc; | |
| 2853 const char *name; | |
| 428 | 2854 lisp_fn_t subr_fn; |
| 2855 }; | |
| 2856 typedef struct Lisp_Subr Lisp_Subr; | |
| 2857 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
2858 DECLARE_LISP_OBJECT (subr, Lisp_Subr); |
| 428 | 2859 #define XSUBR(x) XRECORD (x, subr, Lisp_Subr) |
| 617 | 2860 #define wrap_subr(p) wrap_record (p, subr) |
| 428 | 2861 #define SUBRP(x) RECORDP (x, subr) |
| 2862 #define CHECK_SUBR(x) CHECK_RECORD (x, subr) | |
| 2863 #define CONCHECK_SUBR(x) CONCHECK_RECORD (x, subr) | |
| 2864 | |
| 436 | 2865 #define subr_function(subr) ((subr)->subr_fn) |
| 2866 #define SUBR_FUNCTION(subr,max_args) \ | |
| 2867 ((Lisp_Object (*) (EXFUN_##max_args)) (subr)->subr_fn) | |
| 2868 #define subr_name(subr) ((subr)->name) | |
| 428 | 2869 |
| 442 | 2870 /*------------------------------ marker --------------------------------*/ |
| 2871 | |
| 428 | 2872 |
| 440 | 2873 typedef struct Lisp_Marker Lisp_Marker; |
| 428 | 2874 struct Lisp_Marker |
| 2875 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2876 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 440 | 2877 Lisp_Marker *next; |
| 2878 Lisp_Marker *prev; | |
| 428 | 2879 struct buffer *buffer; |
| 665 | 2880 Membpos membpos; |
| 428 | 2881 char insertion_type; |
| 2882 }; | |
| 2883 | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
2884 DECLARE_MODULE_API_LISP_OBJECT (marker, Lisp_Marker); |
| 428 | 2885 #define XMARKER(x) XRECORD (x, marker, Lisp_Marker) |
| 617 | 2886 #define wrap_marker(p) wrap_record (p, marker) |
| 428 | 2887 #define MARKERP(x) RECORDP (x, marker) |
| 2888 #define CHECK_MARKER(x) CHECK_RECORD (x, marker) | |
| 2889 #define CONCHECK_MARKER(x) CONCHECK_RECORD (x, marker) | |
| 2890 | |
| 2891 /* The second check was looking for GCed markers still in use */ | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
5023
diff
changeset
|
2892 /* assert (!INTP (XMARKER (x)->lheader.next.v)); */ |
| 428 | 2893 |
| 2894 #define marker_next(m) ((m)->next) | |
| 2895 #define marker_prev(m) ((m)->prev) | |
| 2896 | |
| 3063 | 2897 /*-------------------basic int (no connection to char)------------------*/ |
| 2898 | |
| 2899 #define ZEROP(x) EQ (x, Qzero) | |
| 428 | 2900 |
| 800 | 2901 #ifdef ERROR_CHECK_TYPES |
| 428 | 2902 |
| 3063 | 2903 #define XINT(x) XINT_1 (x, __FILE__, __LINE__) |
| 2904 | |
| 2905 DECLARE_INLINE_HEADER ( | |
| 2906 EMACS_INT | |
| 2907 XINT_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 2908 ) | |
| 2909 { | |
| 2910 assert_at_line (INTP (obj), file, line); | |
| 2911 return XREALINT (obj); | |
| 2912 } | |
| 2913 | |
| 5038 | 2914 #else /* not ERROR_CHECK_TYPES */ |
| 3063 | 2915 |
| 2916 #define XINT(obj) XREALINT (obj) | |
| 2917 | |
| 5038 | 2918 #endif /* (not) ERROR_CHECK_TYPES */ |
| 3063 | 2919 |
| 2920 #define CHECK_INT(x) do { \ | |
| 2921 if (!INTP (x)) \ | |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
2922 dead_wrong_type_argument (Qfixnump, x); \ |
| 3063 | 2923 } while (0) |
| 2924 | |
| 2925 #define CONCHECK_INT(x) do { \ | |
| 2926 if (!INTP (x)) \ | |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
2927 x = wrong_type_argument (Qfixnump, x); \ |
| 3063 | 2928 } while (0) |
| 2929 | |
|
5092
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2930 END_C_DECLS |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2931 |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2932 /* -------------- properties of internally-formatted text ------------- */ |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2933 |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2934 #include "text.h" |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2935 |
| 3063 | 2936 /*------------------------------- char ---------------------------------*/ |
| 2937 | |
|
5092
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2938 BEGIN_C_DECLS |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2939 |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2940 #ifdef ERROR_CHECK_TYPES |
|
3aa3888729c3
move inclusion point of text.h to clean things up a bit
Ben Wing <ben@xemacs.org>
parents:
5077
diff
changeset
|
2941 |
| 3063 | 2942 /* NOTE: There are basic functions for converting between a character and |
| 2943 the string representation of a character in text.h, as well as lots of | |
| 2944 other character-related stuff. There are other functions/macros for | |
| 2945 working with Ichars in charset.h, for retrieving the charset of an | |
| 2946 Ichar, the length of an Ichar when converted to text, etc. | |
| 2947 */ | |
| 2948 | |
| 2949 DECLARE_INLINE_HEADER ( | |
| 2950 int | |
| 2951 CHARP_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 2952 ) | |
| 2953 { | |
| 2954 if (XTYPE (obj) != Lisp_Type_Char) | |
| 2955 return 0; | |
| 2956 assert_at_line (valid_ichar_p (XCHARVAL (obj)), file, line); | |
| 2957 return 1; | |
| 2958 } | |
| 2959 | |
| 2960 #define CHARP(x) CHARP_1 (x, __FILE__, __LINE__) | |
| 2961 | |
| 826 | 2962 DECLARE_INLINE_HEADER ( |
| 867 | 2963 Ichar |
| 2367 | 2964 XCHAR_1 (Lisp_Object obj, const Ascbyte *file, int line) |
| 826 | 2965 ) |
| 428 | 2966 { |
| 3063 | 2967 Ichar ch; |
| 788 | 2968 assert_at_line (CHARP (obj), file, line); |
| 3063 | 2969 ch = XCHARVAL (obj); |
| 2970 assert_at_line (valid_ichar_p (ch), file, line); | |
| 2971 return ch; | |
| 428 | 2972 } |
| 2973 | |
| 788 | 2974 #define XCHAR(x) XCHAR_1 (x, __FILE__, __LINE__) |
| 2975 | |
| 3063 | 2976 #else /* not ERROR_CHECK_TYPES */ |
| 2977 | |
| 2978 #define CHARP(x) (XTYPE (x) == Lisp_Type_Char) | |
| 2979 #define XCHAR(x) ((Ichar) XCHARVAL (x)) | |
| 2980 | |
| 2981 #endif /* (else) not ERROR_CHECK_TYPES */ | |
| 2982 | |
| 2983 #define CONCHECK_CHAR(x) do { \ | |
| 2984 if (!CHARP (x)) \ | |
| 2985 x = wrong_type_argument (Qcharacterp, x); \ | |
| 2986 } while (0) | |
| 2987 | |
| 2988 #define CHECK_CHAR(x) do { \ | |
| 2989 if (!CHARP (x)) \ | |
| 2990 dead_wrong_type_argument (Qcharacterp, x); \ | |
| 2991 } while (0) | |
| 2992 | |
| 2993 | |
| 2994 DECLARE_INLINE_HEADER ( | |
| 2995 Lisp_Object | |
| 2996 make_char (Ichar val) | |
| 2997 ) | |
| 2998 { | |
| 2999 type_checking_assert (valid_ichar_p (val)); | |
| 3000 /* This is defined in lisp-union.h or lisp-disunion.h */ | |
| 3001 return make_char_1 (val); | |
| 3002 } | |
| 3003 | |
| 3004 /*------------------------- int-char connection ------------------------*/ | |
| 3005 | |
| 3006 #ifdef ERROR_CHECK_TYPES | |
| 3007 | |
| 3008 #define XCHAR_OR_INT(x) XCHAR_OR_INT_1 (x, __FILE__, __LINE__) | |
| 3009 | |
| 3010 DECLARE_INLINE_HEADER ( | |
| 3011 EMACS_INT | |
| 3012 XCHAR_OR_INT_1 (Lisp_Object obj, const Ascbyte *file, int line) | |
| 3013 ) | |
| 3014 { | |
| 3015 assert_at_line (INTP (obj) || CHARP (obj), file, line); | |
| 3016 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3017 } | |
| 3018 | |
| 788 | 3019 #else /* no error checking */ |
| 3020 | |
| 4134 | 3021 /* obj is multiply eval'ed and not an lvalue; use an inline function instead |
| 3022 of a macro. */ | |
| 3023 DECLARE_INLINE_HEADER ( | |
| 3024 EMACS_INT | |
| 3025 XCHAR_OR_INT (Lisp_Object obj) | |
| 3026 ) | |
| 3027 { | |
| 3028 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3029 } | |
| 788 | 3030 |
| 3031 #endif /* no error checking */ | |
| 428 | 3032 |
| 3063 | 3033 /* True of X is an integer whose value is the valid integral equivalent of a |
| 3034 character. */ | |
| 3035 | |
| 3036 #define CHAR_INTP(x) (INTP (x) && valid_ichar_p (XINT (x))) | |
| 3037 | |
| 3038 /* True of X is a character or an integral value that can be converted into a | |
| 3039 character. */ | |
| 3040 #define CHAR_OR_CHAR_INTP(x) (CHARP (x) || CHAR_INTP (x)) | |
| 3041 | |
| 3042 DECLARE_INLINE_HEADER ( | |
| 3043 Ichar | |
| 3044 XCHAR_OR_CHAR_INT (Lisp_Object obj) | |
| 3045 ) | |
| 3046 { | |
| 3047 return CHARP (obj) ? XCHAR (obj) : XINT (obj); | |
| 3048 } | |
| 3049 | |
| 3050 /* Signal an error if CH is not a valid character or integer Lisp_Object. | |
| 3051 If CH is an integer Lisp_Object, convert it to a character Lisp_Object, | |
| 3052 but merely by repackaging, without performing tests for char validity. | |
| 3053 */ | |
| 3054 | |
| 3055 #define CHECK_CHAR_COERCE_INT(x) do { \ | |
| 3056 if (CHARP (x)) \ | |
| 3057 ; \ | |
| 3058 else if (CHAR_INTP (x)) \ | |
| 3059 x = make_char (XINT (x)); \ | |
| 3060 else \ | |
| 3061 x = wrong_type_argument (Qcharacterp, x); \ | |
| 3062 } while (0) | |
| 3063 | |
| 3064 /* next three always continuable because they coerce their arguments. */ | |
| 3065 #define CHECK_INT_COERCE_CHAR(x) do { \ | |
| 3066 if (INTP (x)) \ | |
| 3067 ; \ | |
| 3068 else if (CHARP (x)) \ | |
| 3069 x = make_int (XCHAR (x)); \ | |
| 3070 else \ | |
| 3071 x = wrong_type_argument (Qinteger_or_char_p, x); \ | |
| 3072 } while (0) | |
| 3073 | |
| 3074 #define CHECK_INT_COERCE_MARKER(x) do { \ | |
| 3075 if (INTP (x)) \ | |
| 3076 ; \ | |
| 3077 else if (MARKERP (x)) \ | |
| 3078 x = make_int (marker_position (x)); \ | |
| 3079 else \ | |
| 3080 x = wrong_type_argument (Qinteger_or_marker_p, x); \ | |
| 3081 } while (0) | |
| 3082 | |
| 3083 #define CHECK_INT_COERCE_CHAR_OR_MARKER(x) do { \ | |
| 3084 if (INTP (x)) \ | |
| 3085 ; \ | |
| 3086 else if (CHARP (x)) \ | |
| 3087 x = make_int (XCHAR (x)); \ | |
| 3088 else if (MARKERP (x)) \ | |
| 3089 x = make_int (marker_position (x)); \ | |
| 3090 else \ | |
| 3091 x = wrong_type_argument (Qinteger_char_or_marker_p, x); \ | |
| 3092 } while (0) | |
| 428 | 3093 |
| 442 | 3094 /*------------------------------ float ---------------------------------*/ |
| 428 | 3095 |
| 3096 /* Note: the 'unused_next_' field exists only to ensure that the | |
| 3097 `next' pointer fits within the structure, for the purposes of the | |
| 3098 free list. This makes a difference in the unlikely case of | |
| 3099 sizeof(double) being smaller than sizeof(void *). */ | |
| 3100 | |
| 3101 struct Lisp_Float | |
| 3102 { | |
|
5120
d1247f3cc363
latest work on lisp-object workspace;
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
3103 FROB_BLOCK_LISP_OBJECT_HEADER lheader; |
| 428 | 3104 union { double d; struct Lisp_Float *unused_next_; } data; |
| 3105 }; | |
| 3106 typedef struct Lisp_Float Lisp_Float; | |
| 3107 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3108 DECLARE_LISP_OBJECT (float, Lisp_Float); |
| 428 | 3109 #define XFLOAT(x) XRECORD (x, float, Lisp_Float) |
| 617 | 3110 #define wrap_float(p) wrap_record (p, float) |
| 428 | 3111 #define FLOATP(x) RECORDP (x, float) |
| 3112 #define CHECK_FLOAT(x) CHECK_RECORD (x, float) | |
| 3113 #define CONCHECK_FLOAT(x) CONCHECK_RECORD (x, float) | |
| 3114 | |
| 3115 #define float_data(f) ((f)->data.d) | |
| 3116 #define XFLOAT_DATA(x) float_data (XFLOAT (x)) | |
| 3117 | |
| 3118 #define XFLOATINT(n) extract_float (n) | |
| 3119 | |
| 3120 #define CHECK_INT_OR_FLOAT(x) do { \ | |
| 3121 if (!INT_OR_FLOATP (x)) \ | |
| 3122 dead_wrong_type_argument (Qnumberp, x); \ | |
| 3123 } while (0) | |
| 3124 | |
| 3125 #define CONCHECK_INT_OR_FLOAT(x) do { \ | |
| 3126 if (!INT_OR_FLOATP (x)) \ | |
| 3127 x = wrong_type_argument (Qnumberp, x); \ | |
| 3128 } while (0) | |
| 3129 | |
| 3130 # define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x)) | |
| 3131 | |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3132 /* #### change for 64-bit machines */ |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3133 #define FLOAT_HASHCODE_FROM_DOUBLE(dbl) \ |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3134 (unsigned long)(fmod (dbl, 4e9)) |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3135 |
| 442 | 3136 /*--------------------------- readonly objects -------------------------*/ |
| 440 | 3137 |
| 3263 | 3138 #ifndef NEW_GC |
| 428 | 3139 #define CHECK_C_WRITEABLE(obj) \ |
| 3140 do { if (c_readonly (obj)) c_write_error (obj); } while (0) | |
| 3141 | |
| 2720 | 3142 #define C_READONLY(obj) (C_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj))) |
| 3263 | 3143 #endif /* not NEW_GC */ |
| 2720 | 3144 |
| 428 | 3145 #define CHECK_LISP_WRITEABLE(obj) \ |
| 3146 do { if (lisp_readonly (obj)) lisp_write_error (obj); } while (0) | |
| 3147 | |
| 3148 #define LISP_READONLY(obj) (LISP_READONLY_RECORD_HEADER_P(XRECORD_LHEADER (obj))) | |
| 3149 | |
| 980 | 3150 /*----------------------------- structures ----------------------------*/ |
| 428 | 3151 |
| 3152 typedef struct structure_keyword_entry structure_keyword_entry; | |
| 3153 struct structure_keyword_entry | |
| 3154 { | |
| 3155 Lisp_Object keyword; | |
| 3156 int (*validate) (Lisp_Object keyword, Lisp_Object value, | |
| 578 | 3157 Error_Behavior errb); |
| 428 | 3158 }; |
| 3159 | |
| 3160 typedef struct | |
| 3161 { | |
| 3162 Dynarr_declare (structure_keyword_entry); | |
| 3163 } structure_keyword_entry_dynarr; | |
| 3164 | |
| 3165 typedef struct structure_type structure_type; | |
| 3166 struct structure_type | |
| 3167 { | |
| 3168 Lisp_Object type; | |
| 3169 structure_keyword_entry_dynarr *keywords; | |
| 578 | 3170 int (*validate) (Lisp_Object data, Error_Behavior errb); |
| 428 | 3171 Lisp_Object (*instantiate) (Lisp_Object data); |
| 3172 }; | |
| 3173 | |
| 3174 typedef struct | |
| 3175 { | |
| 3176 Dynarr_declare (structure_type); | |
| 3177 } structure_type_dynarr; | |
| 3178 | |
| 3179 struct structure_type *define_structure_type (Lisp_Object type, | |
| 3180 int (*validate) | |
| 3181 (Lisp_Object data, | |
| 578 | 3182 Error_Behavior errb), |
| 428 | 3183 Lisp_Object (*instantiate) |
| 3184 (Lisp_Object data)); | |
| 3185 void define_structure_type_keyword (struct structure_type *st, | |
| 3186 Lisp_Object keyword, | |
| 3187 int (*validate) (Lisp_Object keyword, | |
| 3188 Lisp_Object value, | |
| 578 | 3189 Error_Behavior errb)); |
| 428 | 3190 |
| 858 | 3191 /*---------------------------- weak boxes ------------------------------*/ |
| 3192 | |
| 3193 struct weak_box | |
| 3194 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3195 NORMAL_LISP_OBJECT_HEADER header; |
| 858 | 3196 Lisp_Object value; |
| 3197 | |
| 3198 Lisp_Object next_weak_box; /* don't mark through this! */ | |
| 3199 }; | |
| 3200 | |
| 3201 void prune_weak_boxes (void); | |
| 3202 Lisp_Object make_weak_box (Lisp_Object value); | |
| 3203 Lisp_Object weak_box_ref (Lisp_Object value); | |
| 3204 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3205 DECLARE_LISP_OBJECT (weak_box, struct weak_box); |
| 858 | 3206 #define XWEAK_BOX(x) XRECORD (x, weak_box, struct weak_box) |
| 3207 #define XSET_WEAK_BOX(x, v) (XWEAK_BOX (x)->value = (v)) | |
| 3208 #define wrap_weak_box(p) wrap_record (p, weak_box) | |
| 3209 #define WEAK_BOXP(x) RECORDP (x, weak_box) | |
| 3210 #define CHECK_WEAK_BOX(x) CHECK_RECORD (x, weak_box) | |
| 3211 #define CONCHECK_WEAK_BOX(x) CONCHECK_RECORD (x, weak_box) | |
| 3212 | |
| 888 | 3213 /*--------------------------- ephemerons ----------------------------*/ |
| 3214 | |
| 3215 struct ephemeron | |
| 3216 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3217 NORMAL_LISP_OBJECT_HEADER header; |
| 888 | 3218 |
| 3219 Lisp_Object key; | |
| 3220 | |
| 3221 /* This field holds a pair. The cdr of this cons points to the next | |
| 3222 ephemeron in Vall_ephemerons. The car points to another pair | |
| 3223 whose car is the value and whose cdr is the finalizer. | |
| 3224 | |
| 3225 This representation makes it very easy to unlink an ephemeron | |
| 3226 from Vall_ephemerons and chain it into | |
| 3227 Vall_ephemerons_to_finalize. */ | |
| 3228 | |
| 3229 Lisp_Object cons_chain; | |
| 3230 | |
| 3231 Lisp_Object value; | |
| 3232 }; | |
| 3233 | |
| 3234 void prune_ephemerons (void); | |
| 3235 Lisp_Object ephemeron_value(Lisp_Object ephi); | |
| 1590 | 3236 void init_marking_ephemerons(void); |
| 3237 int continue_marking_ephemerons(void); | |
| 888 | 3238 int finish_marking_ephemerons(void); |
| 3239 Lisp_Object zap_finalize_list(void); | |
| 3240 Lisp_Object make_ephemeron(Lisp_Object key, Lisp_Object value, Lisp_Object finalizer); | |
| 3241 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3242 DECLARE_LISP_OBJECT(ephemeron, struct ephemeron); |
| 888 | 3243 #define XEPHEMERON(x) XRECORD (x, ephemeron, struct ephemeron) |
| 3244 #define XEPHEMERON_REF(x) (XEPHEMERON (x)->value) | |
| 3245 #define XEPHEMERON_NEXT(x) (XCDR (XEPHEMERON(x)->cons_chain)) | |
| 3246 #define XEPHEMERON_FINALIZER(x) (XCDR (XCAR (XEPHEMERON (x)->cons_chain))) | |
| 3247 #define XSET_EPHEMERON_NEXT(x, n) (XSETCDR (XEPHEMERON(x)->cons_chain, n)) | |
| 3248 #define XSET_EPHEMERON_VALUE(x, v) (XEPHEMERON(x)->value = (v)) | |
| 3249 #define XSET_EPHEMERON_KEY(x, k) (XEPHEMERON(x)->key = (k)) | |
| 3250 #define wrap_ephemeron(p) wrap_record (p, ephemeron) | |
| 3251 #define EPHEMERONP(x) RECORDP (x, ephemeron) | |
| 3252 #define CHECK_EPHEMERON(x) CHECK_RECORD (x, ephemeron) | |
| 3253 #define CONCHECK_EPHEMERON(x) CONCHECK_RECORD (x, ephemeron) | |
| 3254 | |
| 858 | 3255 |
| 442 | 3256 /*---------------------------- weak lists ------------------------------*/ |
| 428 | 3257 |
| 3258 enum weak_list_type | |
| 3259 { | |
| 3260 /* element disappears if it's unmarked. */ | |
| 3261 WEAK_LIST_SIMPLE, | |
| 3262 /* element disappears if it's a cons and either its car or | |
| 3263 cdr is unmarked. */ | |
| 3264 WEAK_LIST_ASSOC, | |
| 3265 /* element disappears if it's a cons and its car is unmarked. */ | |
| 3266 WEAK_LIST_KEY_ASSOC, | |
| 3267 /* element disappears if it's a cons and its cdr is unmarked. */ | |
| 442 | 3268 WEAK_LIST_VALUE_ASSOC, |
| 3269 /* element disappears if it's a cons and neither its car nor | |
| 3270 its cdr is marked. */ | |
| 3271 WEAK_LIST_FULL_ASSOC | |
| 428 | 3272 }; |
| 3273 | |
| 3274 struct weak_list | |
| 3275 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
3276 NORMAL_LISP_OBJECT_HEADER header; |
| 428 | 3277 Lisp_Object list; /* don't mark through this! */ |
| 3278 enum weak_list_type type; | |
| 3279 Lisp_Object next_weak; /* don't mark through this! */ | |
| 3280 }; | |
| 3281 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
3282 DECLARE_LISP_OBJECT (weak_list, struct weak_list); |
| 428 | 3283 #define XWEAK_LIST(x) XRECORD (x, weak_list, struct weak_list) |
| 617 | 3284 #define wrap_weak_list(p) wrap_record (p, weak_list) |
| 428 | 3285 #define WEAK_LISTP(x) RECORDP (x, weak_list) |
| 3286 #define CHECK_WEAK_LIST(x) CHECK_RECORD (x, weak_list) | |
| 3287 #define CONCHECK_WEAK_LIST(x) CONCHECK_RECORD (x, weak_list) | |
| 3288 | |
| 3289 #define weak_list_list(w) ((w)->list) | |
| 3290 #define XWEAK_LIST_LIST(w) (XWEAK_LIST (w)->list) | |
| 3291 | |
| 3292 Lisp_Object make_weak_list (enum weak_list_type type); | |
| 3293 /* The following two are only called by the garbage collector */ | |
| 3294 int finish_marking_weak_lists (void); | |
| 3295 void prune_weak_lists (void); | |
| 3296 | |
| 1743 | 3297 END_C_DECLS |
| 428 | 3298 |
| 3299 /************************************************************************/ | |
| 3300 /* Definitions of primitive Lisp functions and variables */ | |
| 3301 /************************************************************************/ | |
| 3302 | |
| 3303 | |
| 3304 /* DEFUN - Define a built-in Lisp-visible C function or `subr'. | |
| 3305 `lname' should be the name to give the function in Lisp, | |
| 3306 as a null-terminated C string. | |
| 3307 `Fname' should be the C equivalent of `lname', using only characters | |
| 3308 valid in a C identifier, with an "F" prepended. | |
| 3309 The name of the C constant structure that records information | |
| 3310 on this function for internal use is "S" concatenated with Fname. | |
| 3311 `min_args' should be a number, the minimum number of arguments allowed. | |
| 3312 `max_args' should be a number, the maximum number of arguments allowed, | |
| 3313 or else MANY or UNEVALLED. | |
| 3314 MANY means pass a vector of evaluated arguments, | |
| 3315 in the form of an integer number-of-arguments | |
| 3316 followed by the address of a vector of Lisp_Objects | |
| 3317 which contains the argument values. | |
| 3318 UNEVALLED means pass the list of unevaluated arguments. | |
| 3319 `prompt' says how to read arguments for an interactive call. | |
| 3320 See the doc string for `interactive'. | |
| 3321 A null string means call interactively with no arguments. | |
| 3322 `arglist' are the comma-separated arguments (always Lisp_Objects) for | |
| 3323 the function. | |
| 3324 The docstring for the function is placed as a "C" comment between | |
| 3325 the prompt and the `args' argument. make-docfile reads the | |
| 3326 comment and creates the DOC file from it. | |
| 3327 */ | |
| 3328 | |
| 3329 #define EXFUN_0 void | |
| 3330 #define EXFUN_1 Lisp_Object | |
| 3331 #define EXFUN_2 Lisp_Object,Lisp_Object | |
| 3332 #define EXFUN_3 Lisp_Object,Lisp_Object,Lisp_Object | |
| 3333 #define EXFUN_4 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object | |
| 3334 #define EXFUN_5 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object | |
| 3335 #define EXFUN_6 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3336 Lisp_Object | |
| 3337 #define EXFUN_7 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3338 Lisp_Object,Lisp_Object | |
| 3339 #define EXFUN_8 Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object,Lisp_Object, \ | |
| 3340 Lisp_Object,Lisp_Object,Lisp_Object | |
| 3341 #define EXFUN_MANY int, Lisp_Object* | |
| 3342 #define EXFUN_UNEVALLED Lisp_Object | |
| 3343 #define EXFUN(sym, max_args) Lisp_Object sym (EXFUN_##max_args) | |
| 2268 | 3344 #define EXFUN_NORETURN(sym, max_args) \ |
| 3345 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, sym (EXFUN_##max_args)) | |
| 428 | 3346 |
| 3347 #define SUBR_MAX_ARGS 8 | |
| 3348 #define MANY -2 | |
| 3349 #define UNEVALLED -1 | |
| 3350 | |
| 3351 /* Can't be const, because then subr->doc is read-only and | |
| 3352 Snarf_documentation chokes */ | |
| 3353 | |
| 3263 | 3354 #ifdef NEW_GC |
| 2720 | 3355 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3356 Lisp_Object Fname (EXFUN_##max_args); \ | |
| 3357 static struct Lisp_Subr MC_ALLOC_S##Fname = \ | |
| 3358 { \ | |
| 3359 { /* struct lrecord_header */ \ | |
| 3360 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3361 1, /* lisp_readonly bit */ \ | |
| 3362 0, /* free */ \ | |
| 3363 0 /* uid */ \ | |
| 3364 }, \ | |
| 3365 min_args, \ | |
| 3366 max_args, \ | |
| 3367 prompt, \ | |
| 3368 0, /* doc string */ \ | |
| 3369 lname, \ | |
| 3370 (lisp_fn_t) Fname \ | |
| 3371 }; \ | |
| 2814 | 3372 static struct Lisp_Subr *S##Fname; \ |
| 2720 | 3373 Lisp_Object Fname (DEFUN_##max_args arglist) |
| 3374 | |
| 3375 #define DEFUN_NORETURN(lname, Fname, min_args, max_args, prompt, arglist) \ | |
| 3376 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, Fname (EXFUN_##max_args)); \ | |
| 3377 static struct Lisp_Subr MC_ALLOC_S##Fname = \ | |
| 3378 { \ | |
| 3379 { /* struct lrecord_header */ \ | |
| 3380 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3381 1, /* lisp_readonly bit */ \ | |
| 3382 0, /* free */ \ | |
| 3383 0 /* uid */ \ | |
| 3384 }, \ | |
| 3385 min_args, \ | |
| 3386 max_args, \ | |
| 3387 prompt, \ | |
| 3388 0, /* doc string */ \ | |
| 3389 lname, \ | |
| 3390 (lisp_fn_t) Fname \ | |
| 3391 }; \ | |
| 2814 | 3392 static struct Lisp_Subr *S##Fname; \ |
| 2720 | 3393 DOESNT_RETURN_TYPE (Lisp_Object) Fname (DEFUN_##max_args arglist) |
| 2834 | 3394 #define GET_DEFUN_LISP_OBJECT(Fname) \ |
|
5280
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3395 wrap_subr (&MC_ALLOC_S##Fname) |
| 3263 | 3396 #else /* not NEW_GC */ |
| 428 | 3397 #define DEFUN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3398 Lisp_Object Fname (EXFUN_##max_args); \ | |
| 442 | 3399 static struct Lisp_Subr S##Fname = \ |
| 3400 { \ | |
| 3401 { /* struct lrecord_header */ \ | |
| 3402 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3403 1, /* mark bit */ \ | |
| 3404 1, /* c_readonly bit */ \ | |
| 1111 | 3405 1, /* lisp_readonly bit */ \ |
| 442 | 3406 }, \ |
| 3407 min_args, \ | |
| 3408 max_args, \ | |
| 3409 prompt, \ | |
| 3410 0, /* doc string */ \ | |
| 3411 lname, \ | |
| 3412 (lisp_fn_t) Fname \ | |
| 3413 }; \ | |
| 428 | 3414 Lisp_Object Fname (DEFUN_##max_args arglist) |
| 3415 | |
| 2268 | 3416 #define DEFUN_NORETURN(lname, Fname, min_args, max_args, prompt, arglist) \ |
| 3417 DECLARE_DOESNT_RETURN_TYPE (Lisp_Object, Fname (EXFUN_##max_args)); \ | |
| 3418 static struct Lisp_Subr S##Fname = \ | |
| 3419 { \ | |
| 3420 { /* struct lrecord_header */ \ | |
| 3421 lrecord_type_subr, /* lrecord_type_index */ \ | |
| 3422 1, /* mark bit */ \ | |
| 3423 1, /* c_readonly bit */ \ | |
| 3424 1, /* lisp_readonly bit */ \ | |
| 3425 }, \ | |
| 3426 min_args, \ | |
| 3427 max_args, \ | |
| 3428 prompt, \ | |
| 3429 0, /* doc string */ \ | |
| 3430 lname, \ | |
| 3431 (lisp_fn_t) Fname \ | |
| 3432 }; \ | |
| 3433 DOESNT_RETURN_TYPE (Lisp_Object) Fname (DEFUN_##max_args arglist) | |
| 2834 | 3434 #define GET_DEFUN_LISP_OBJECT(Fname) \ |
|
5280
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3435 wrap_subr (&S##Fname) |
| 3263 | 3436 #endif /* not NEW_GC */ |
| 2268 | 3437 |
| 428 | 3438 /* Heavy ANSI C preprocessor hackery to get DEFUN to declare a |
| 3439 prototype that matches max_args, and add the obligatory | |
| 3440 `Lisp_Object' type declaration to the formal C arguments. */ | |
| 3441 | |
| 3442 #define DEFUN_MANY(named_int, named_Lisp_Object) named_int, named_Lisp_Object | |
| 3443 #define DEFUN_UNEVALLED(args) Lisp_Object args | |
| 3444 #define DEFUN_0() void | |
| 3445 #define DEFUN_1(a) Lisp_Object a | |
| 3446 #define DEFUN_2(a,b) DEFUN_1(a), Lisp_Object b | |
| 3447 #define DEFUN_3(a,b,c) DEFUN_2(a,b), Lisp_Object c | |
| 3448 #define DEFUN_4(a,b,c,d) DEFUN_3(a,b,c), Lisp_Object d | |
| 3449 #define DEFUN_5(a,b,c,d,e) DEFUN_4(a,b,c,d), Lisp_Object e | |
| 3450 #define DEFUN_6(a,b,c,d,e,f) DEFUN_5(a,b,c,d,e), Lisp_Object f | |
| 3451 #define DEFUN_7(a,b,c,d,e,f,g) DEFUN_6(a,b,c,d,e,f), Lisp_Object g | |
| 3452 #define DEFUN_8(a,b,c,d,e,f,g,h) DEFUN_7(a,b,c,d,e,f,g),Lisp_Object h | |
| 3453 | |
| 3454 /* WARNING: If you add defines here for higher values of max_args, | |
| 3455 make sure to also fix the clauses in PRIMITIVE_FUNCALL(), | |
| 3456 and change the define of SUBR_MAX_ARGS above. */ | |
| 3457 | |
| 3458 #include "symeval.h" | |
| 3459 | |
| 1743 | 3460 BEGIN_C_DECLS |
| 1650 | 3461 |
| 428 | 3462 /* `specpdl' is the special binding/unwind-protect stack. |
| 3463 | |
| 3464 Knuth says (see the Jargon File): | |
| 3465 At MIT, `pdl' [abbreviation for `Push Down List'] used to | |
| 3466 be a more common synonym for `stack'. | |
| 3467 Everywhere else `stack' seems to be the preferred term. | |
| 3468 | |
| 3469 specpdl_depth is the current depth of `specpdl'. | |
| 771 | 3470 Save this for use later as arg to `unbind_to_1'. */ |
| 1632 | 3471 extern MODULE_API int specpdl_depth_counter; |
| 428 | 3472 #define specpdl_depth() specpdl_depth_counter |
| 3473 | |
| 442 | 3474 |
| 3475 #define CHECK_FUNCTION(fun) do { \ | |
| 3476 while (NILP (Ffunctionp (fun))) \ | |
| 3477 signal_invalid_function_error (fun); \ | |
| 3478 } while (0) | |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3479 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3480 /************************************************************************/ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3481 /* Parsing keyword arguments */ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3482 /************************************************************************/ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3483 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3484 /* The C subr must have been declared with MANY as its max args, and this |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3485 PARSE_KEYWORDS call must come before any statements. Equivalently, it |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3486 can appear within braces. |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3487 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3488 FUNCTION is the C name of the current DEFUN. If there is no current |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3489 DEFUN, use the PARSE_KEYWORDS_8 macro, not PARSE_KEYWORDS. If the |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3490 current DEFUN has optional arguments that are not keywords, you also need |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3491 to use the PARSE_KEYWORDS_8 macro. This is also the case if there are |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3492 optional arguments that come before the keywords, as Common Lisp |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3493 specifies for #'parse-integer. |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3494 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3495 NARGS is the count of arguments supplied to FUNCTION. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3496 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3497 ARGS is a pointer to the argument vector (not a Lisp vector) supplied to |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3498 FUNCTION. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3499 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3500 KEYWORD_COUNT is the number of keywords FUNCTION is normally prepared to |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3501 handle. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3502 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3503 KEYWORDS is a parenthesised list of those keywords, without the initial |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3504 Q_. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3505 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3506 KEYWORD_DEFAULTS allows you to set non-nil defaults. Put (keywordname = |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3507 initial_value) in this parameter, a collection of C statements surrounded |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3508 by parentheses and separated by the comma operator. If you don't need |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3509 this, supply NULL as KEYWORD_DEFAULTS. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3510 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3511 For keywords which appear multiple times in the called argument list, the |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3512 leftmost one overrides, as specified in section 7.1.1 of the CLHS. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3513 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3514 If you want to check whether a given keyword argument was set (as in the |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3515 SVAR argument to defun*), supply Qunbound as its default in |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3516 KEYWORD_DEFAULTS, and examine it once PARSE_KEYWORDS is done. Lisp code |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3517 cannot supply Qunbound as an argument, so if it is still Qunbound, it was |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3518 not set. |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3519 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3520 There is no elegant way with this macro to have one name for the keyword |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3521 and an unrelated name for the local variable, as is possible with the |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3522 ((:keyword unrelated-var)) syntax in defun* and in Common Lisp. That |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3523 shouldn't matter in practice. */ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3524 #if defined (DEBUG_XEMACS) && defined (__STDC_VERSION__) && \ |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3525 __STDC_VERSION__ >= 199901L |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3526 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3527 /* This version has the advantage that DEFUN without DEFSUBR still provokes |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3528 a defined but not used warning, and it provokes an assertion failure at |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3529 runtime if someone has copied and pasted the PARSE_KEYWORDS macro from |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3530 another function without changing FUNCTION; that would lead to an |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3531 incorrect determination of KEYWORDS_OFFSET. */ |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3532 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3533 #define PARSE_KEYWORDS(function, nargs, args, keyword_count, keywords, \ |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3534 keyword_defaults) \ |
|
5280
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3535 PARSE_KEYWORDS_8 (intern_massaging_name (1 + #function), nargs, args, \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3536 keyword_count, keywords, keyword_defaults, \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3537 /* Can't XSUBR (Fsymbol_function (...))->min_args, \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3538 the function may be advised. */ \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3539 XINT (Ffunction_min_args \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3540 (intern_massaging_name (1 + #function))), \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3541 0); \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3542 assert (0 == strcmp (__func__, #function)) |
|
5279
d0bc331e433f
Turns out #elsif is not valid preprocessor syntax, who knew!
Aidan Kehoe <kehoea@parhasard.net>
parents:
5278
diff
changeset
|
3543 #else /* defined (DEBUG_XEMACS) && ... */ |
|
5278
d9e65b48e2bf
Correct the NEW_GC non-DEBUG_XEMACS version of PARSE_KEYWORDS().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5277
diff
changeset
|
3544 #define PARSE_KEYWORDS(function, nargs, args, keyword_count, keywords, \ |
|
d9e65b48e2bf
Correct the NEW_GC non-DEBUG_XEMACS version of PARSE_KEYWORDS().
Aidan Kehoe <kehoea@parhasard.net>
parents:
5277
diff
changeset
|
3545 keyword_defaults) \ |
|
5280
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3546 PARSE_KEYWORDS_8 (intern (subr_name (XSUBR \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3547 (GET_DEFUN_LISP_OBJECT (function)))), \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3548 nargs, args, keyword_count, keywords, \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3549 keyword_defaults, \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3550 XSUBR (GET_DEFUN_LISP_OBJECT (function))->min_args, \ |
|
59a6419f7504
Use GET_DEFUN_LISP_OBJECT() in PARSE_KEYWORDS(), fix former under NEW_GC.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5279
diff
changeset
|
3551 0) |
|
5279
d0bc331e433f
Turns out #elsif is not valid preprocessor syntax, who knew!
Aidan Kehoe <kehoea@parhasard.net>
parents:
5278
diff
changeset
|
3552 #endif /* defined (DEBUG_XEMACS) && defined (__STDC_VERSION__) ... */ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3553 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3554 /* PARSE_KEYWORDS_8 is a more fine-grained version of PARSE_KEYWORDS. The |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3555 differences are as follows: |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3556 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3557 FUNC_SYM is a symbol reflecting the name of the function for which |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3558 keywords are being parsed. In PARSE_KEYWORDS, it is the Lisp-visible |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3559 name of C_FUNC, interned as a symbol in obarray. |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3560 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3561 KEYWORDS_OFFSET is the offset into ARGS where the keyword arguments |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3562 start. In PARSE_KEYWORDS, this is the index of the first optional |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3563 argument, determined from the information known about C_FUNC. |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3564 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3565 ALLOW_OTHER_KEYS corresponds to the &allow-other-keys argument list entry |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3566 in defun*; it is 1 if other keys are normally allowed, 0 otherwise. This |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3567 may be overridden in the caller by specifying :allow-other-keys t in the |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3568 argument list. In PARSE_KEYWORDS, ALLOW_OTHER_KEYS is always 0. */ |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3569 |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3570 #define PARSE_KEYWORDS_8(func_sym, nargs, args, \ |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3571 keyword_count, keywords, keyword_defaults, \ |
|
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3572 keywords_offset, allow_other_keys) \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3573 DECLARE_N_KEYWORDS_##keyword_count keywords; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3574 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3575 do \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3576 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3577 Lisp_Object pk_key, pk_value; \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3578 Elemcount pk_i = nargs - 1, pk_offset = keywords_offset; \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3579 Boolint pk_allow_other_keys = allow_other_keys; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3580 \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3581 if ((nargs - pk_offset) & 1) \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3582 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3583 if (!allow_other_keys \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3584 && !(pk_allow_other_keys \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3585 = non_nil_allow_other_keys_p (pk_offset, \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3586 nargs, args))) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3587 { \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3588 signal_wrong_number_of_arguments_error (func_sym, nargs); \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3589 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3590 else \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3591 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3592 /* Ignore the trailing arg; so below always sees an even \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3593 number of arguments. */ \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3594 pk_i -= 1; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3595 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3596 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3597 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3598 (void)(keyword_defaults); \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3599 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3600 /* Start from the end, because the leftmost element overrides. */ \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3601 while (pk_i > pk_offset) \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3602 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3603 pk_value = args[pk_i--]; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3604 pk_key = args[pk_i--]; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3605 \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3606 if (0) {} \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3607 CHECK_N_KEYWORDS_##keyword_count keywords \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3608 else if (allow_other_keys || pk_allow_other_keys) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3609 { \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3610 continue; \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3611 } \ |
|
5241
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3612 else if ((pk_allow_other_keys \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3613 = non_nil_allow_other_keys_p (pk_offset, \ |
|
5241
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3614 nargs, args))) \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3615 { \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3616 continue; \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3617 } \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3618 else if (EQ (pk_key, Q_allow_other_keys) && \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3619 NILP (pk_value)) \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3620 { \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3621 continue; \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3622 } \ |
|
d579d76f3dcc
Be more careful about side-effects from Lisp code, #'reduce
Aidan Kehoe <kehoea@parhasard.net>
parents:
5214
diff
changeset
|
3623 else \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3624 { \ |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
3625 invalid_keyword_argument (func_sym, pk_key); \ |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3626 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3627 } \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3628 } while (0) |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3629 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3630 #define DECLARE_N_KEYWORDS_1(a) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3631 Lisp_Object a = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3632 #define DECLARE_N_KEYWORDS_2(a,b) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3633 DECLARE_N_KEYWORDS_1(a), b = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3634 #define DECLARE_N_KEYWORDS_3(a,b,c) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3635 DECLARE_N_KEYWORDS_2(a,b), c = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3636 #define DECLARE_N_KEYWORDS_4(a,b,c,d) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3637 DECLARE_N_KEYWORDS_3(a,b,c), d = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3638 #define DECLARE_N_KEYWORDS_5(a,b,c,d,e) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3639 DECLARE_N_KEYWORDS_4(a,b,c,d), e = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3640 #define DECLARE_N_KEYWORDS_6(a,b,c,d,e,f) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3641 DECLARE_N_KEYWORDS_5(a,b,c,d,e), f = Qnil |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3642 #define DECLARE_N_KEYWORDS_7(a,b,c,d,e,f,g) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3643 DECLARE_N_KEYWORDS_6(a,b,c,d,e,f), g = Qnil |
|
5322
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3644 #define DECLARE_N_KEYWORDS_8(a,b,c,d,e,f,g,h) \ |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3645 DECLARE_N_KEYWORDS_7(a,b,c,d,e,f,g), h = Qnil |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3646 #define DECLARE_N_KEYWORDS_9(a,b,c,d,e,f,g,h,i) \ |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3647 DECLARE_N_KEYWORDS_8(a,b,c,d,e,f,g,h), i = Qnil |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3648 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3649 #define CHECK_N_KEYWORDS_1(a) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3650 else if (EQ (pk_key, Q_##a)) { a = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3651 #define CHECK_N_KEYWORDS_2(a,b) CHECK_N_KEYWORDS_1(a) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3652 else if (EQ (pk_key, Q_##b)) { b = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3653 #define CHECK_N_KEYWORDS_3(a,b,c) CHECK_N_KEYWORDS_2(a,b) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3654 else if (EQ (pk_key, Q_##c)) { c = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3655 #define CHECK_N_KEYWORDS_4(a,b,c,d) CHECK_N_KEYWORDS_3(a,b,c) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3656 else if (EQ (pk_key, Q_##d)) { d = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3657 #define CHECK_N_KEYWORDS_5(a,b,c,d,e) CHECK_N_KEYWORDS_4(a,b,c,d) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3658 else if (EQ (pk_key, Q_##e)) { e = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3659 #define CHECK_N_KEYWORDS_6(a,b,c,d,e,f) CHECK_N_KEYWORDS_5(a,b,c,d,e) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3660 else if (EQ (pk_key, Q_##f)) { f = pk_value; } |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3661 #define CHECK_N_KEYWORDS_7(a,b,c,d,e,f,g) CHECK_N_KEYWORDS_6(a,b,c,d,e,f) \ |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3662 else if (EQ (pk_key, Q_##g)) { g = pk_value; } |
|
5322
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3663 #define CHECK_N_KEYWORDS_8(a,b,c,d,e,f,g,h) \ |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3664 CHECK_N_KEYWORDS_7(a,b,c,d,e,f,g) \ |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3665 else if (EQ (pk_key, Q_##h)) { h = pk_value; } |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3666 #define CHECK_N_KEYWORDS_9(a,b,c,d,e,f,g,h,i) \ |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3667 CHECK_N_KEYWORDS_8(a,b,c,d,e,f,g,h) \ |
|
df125a42c50c
Support up to nine keywords in the PARSE_KEYWORDS() macro.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5320
diff
changeset
|
3668 else if (EQ (pk_key, Q_##i)) { i = pk_value; } |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3669 |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3670 Boolint non_nil_allow_other_keys_p (Elemcount offset, int nargs, |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
3671 Lisp_Object *args); |
| 442 | 3672 |
| 428 | 3673 |
| 3674 /************************************************************************/ | |
| 3675 /* Checking for QUIT */ | |
| 3676 /************************************************************************/ | |
| 3677 | |
| 1123 | 3678 /* NOTE NOTE NOTE: Invoking QUIT can cause random Lisp code to be executed! |
| 3679 This can happen in numerous ways. For example, on many platforms, QUIT | |
| 3680 needs to drain the event queue to see whether there's a C-g in the works. | |
| 3681 A side effect of this is that, if there's a menu-press event, menu filters | |
| 3682 (i.e. Lisp code) will be invoked. Lisp code could also happen if there's | |
| 3683 an asynchronous timeout, or if the debugger is invoked as a result of | |
| 3684 debug-on-quit and the user returns by hitting `r', etc. etc. | |
| 3685 | |
| 3686 However, GC CANNOT HAPPEN. It is forbidden everywhere within the QUIT- | |
| 3687 processing code, because most callers cannot tolerate GC during QUIT | |
| 3688 since it's just too prevalent. */ | |
| 3689 | |
| 853 | 3690 /* The exact workings of this mechanism are described in detail in signal.c. */ |
| 3691 | |
| 428 | 3692 /* Asynchronous events set something_happened, and then are processed |
| 3693 within the QUIT macro. At this point, we are guaranteed to not be in | |
| 3694 any sensitive code. */ | |
| 3695 | |
| 1632 | 3696 extern MODULE_API volatile int something_happened; |
| 3697 extern MODULE_API int dont_check_for_quit; | |
| 3698 MODULE_API void check_what_happened (void); | |
| 3699 | |
| 3700 extern MODULE_API volatile int quit_check_signal_happened; | |
| 428 | 3701 extern volatile int quit_check_signal_tick_count; |
| 1632 | 3702 MODULE_API void check_quit (void); |
| 3703 | |
| 3704 MODULE_API void signal_quit (void); | |
| 428 | 3705 |
| 853 | 3706 int begin_dont_check_for_quit (void); |
| 3707 int begin_do_check_for_quit (void); | |
| 3708 | |
| 3709 /* Nonzero if the values of `quit-flag' and `inhibit-quit' indicate | |
| 3710 that a quit should be signalled. */ | |
| 771 | 3711 #define QUIT_FLAG_SAYS_SHOULD_QUIT \ |
| 3712 (!NILP (Vquit_flag) && \ | |
| 3713 (NILP (Vinhibit_quit) \ | |
| 3714 || (EQ (Vquit_flag, Qcritical) && !dont_check_for_quit))) | |
| 3715 | |
| 853 | 3716 /* Nonzero if ought to quit now. This is the "efficient" version, which |
| 3717 respects the flags set to indicate whether the full quit check should | |
| 3718 be done. Therefore it may be inaccurate (i.e. lagging reality), esp. | |
| 3719 when poll for quit is used. | |
| 3720 | |
| 3721 This is defined for code that wants to allow quitting, but needs to | |
| 3722 do some cleanup if that happens. (You could always register the cleanup | |
| 3723 code using record_unwind_protect(), but sometimes it makes more sense | |
| 3724 to do it using QUITP.) To use this macro, just call it at the | |
| 3725 appropriate time, and if its value is non-zero, do your cleanup code | |
| 3726 and then call QUIT. | |
| 3727 | |
| 3728 A different version (below) is used for the actual QUIT macro. */ | |
| 428 | 3729 #define QUITP \ |
| 853 | 3730 ((quit_check_signal_happened ? check_quit () : (void) 0), \ |
| 771 | 3731 QUIT_FLAG_SAYS_SHOULD_QUIT) |
| 428 | 3732 |
| 853 | 3733 /* This is the version actually called by QUIT. The difference |
| 3734 between it and QUITP is that it also has side effects in that it | |
| 3735 will handle anything else that has recently signalled itself | |
| 3736 asynchronously and wants to be handled now. Currently this | |
| 3737 includes executing asynchronous timeouts that may have been set | |
| 3738 from Lisp or from the poll-for-quit or poll-for-sigchld | |
| 3739 timers. (#### It seems that, to be slightly more accurate, we | |
| 3740 should also process poll-for-quit timers in the above version. | |
| 3741 However, this mechanism is inherently approximate, so it really | |
| 3742 doesn't matter much.) In the future, it might also include doing a | |
| 3743 thread context switch. Callers of QUITP generally don't except | |
| 1123 | 3744 random side effects to happen (#### unfortunately, random side effects |
| 3745 can happen anyway, e.g. through menu filters -- see comment above), | |
| 3746 so we have this different version. */ | |
| 428 | 3747 #define INTERNAL_QUITP \ |
| 853 | 3748 ((something_happened ? check_what_happened () : (void) 0), \ |
| 771 | 3749 QUIT_FLAG_SAYS_SHOULD_QUIT) |
| 428 | 3750 |
| 3751 /* Check quit-flag and quit if it is non-nil. Also do any other things | |
| 853 | 3752 that are triggered by asynchronous events and might want to be |
| 3753 handled. */ | |
| 428 | 3754 #define QUIT do { if (INTERNAL_QUITP) signal_quit (); } while (0) |
| 3755 | |
| 3756 | |
| 3757 /************************************************************************/ | |
| 3758 /* hashing */ | |
| 3759 /************************************************************************/ | |
| 3760 | |
| 3761 /* #### for a 64-bit machine, we should substitute a prime just over 2^32 */ | |
| 3762 #define GOOD_HASH 65599 /* prime number just over 2^16; Dragon book, p. 435 */ | |
| 3763 #define HASH2(a,b) (GOOD_HASH * (a) + (b)) | |
| 3764 #define HASH3(a,b,c) (GOOD_HASH * HASH2 (a,b) + (c)) | |
| 3765 #define HASH4(a,b,c,d) (GOOD_HASH * HASH3 (a,b,c) + (d)) | |
| 3766 #define HASH5(a,b,c,d,e) (GOOD_HASH * HASH4 (a,b,c,d) + (e)) | |
| 3767 #define HASH6(a,b,c,d,e,f) (GOOD_HASH * HASH5 (a,b,c,d,e) + (f)) | |
| 3768 #define HASH7(a,b,c,d,e,f,g) (GOOD_HASH * HASH6 (a,b,c,d,e,f) + (g)) | |
| 3769 #define HASH8(a,b,c,d,e,f,g,h) (GOOD_HASH * HASH7 (a,b,c,d,e,f,g) + (h)) | |
| 3770 #define HASH9(a,b,c,d,e,f,g,h,i) (GOOD_HASH * HASH8 (a,b,c,d,e,f,g,h) + (i)) | |
| 3771 | |
| 5013 | 3772 #define LISP_HASH(obj) ((unsigned long) STORE_LISP_IN_VOID (obj)) |
| 2516 | 3773 Hashcode memory_hash (const void *xv, Bytecount size); |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3774 Hashcode internal_hash (Lisp_Object obj, int depth, Boolint equalp); |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3775 Hashcode internal_array_hash (Lisp_Object *arr, int size, int depth, |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
3776 Boolint equalp); |
| 428 | 3777 |
| 3778 | |
| 3779 /************************************************************************/ | |
| 3780 /* String translation */ | |
| 3781 /************************************************************************/ | |
| 3782 | |
| 771 | 3783 /* When support for message translation exists, GETTEXT() translates a |
| 3784 string from English into the language defined by | |
| 3785 `current-language-environment'. This is done by looking the string | |
| 3786 up in a large predefined table; if no translation is found, the | |
| 3787 original string is returned, and the failure is possibly logged so | |
| 3788 that the translation can later be entered into the table. | |
| 3789 | |
| 3790 In addition to this, there is a mechanism to snarf message strings | |
| 3791 out of the source code so that they can be entered into the tables. | |
| 3792 This is what make-msgfile.lex does. | |
| 3793 | |
| 3794 Handling `format' strings is more difficult: The format string | |
| 3795 should get translated, but not under all circumstances. When the | |
| 3796 format string is a Lisp string, what should happen is that | |
| 3797 Fformat() should format the untranslated args[0] and return that, | |
| 3798 and also call Fgettext() on args[0] and, if that is different, | |
| 3799 format it and store it in the `string-translatable' property of the | |
| 3800 returned string. See Fgettext(). | |
| 3801 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3802 The variations IGETTEXT, CIGETTEXT and ASCGETTEXT operate on |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3803 Ibyte *, CIbyte *, and Ascbyte * strings, respectively. The |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3804 ASCGETTEXT version has an assert check to verify that its string |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3805 really is pure-ASCII. Plain GETTEXT is defined as ASCGETTEXT, and |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3806 so works the same way. (There are no versions that work for Extbyte *. |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3807 Translate to internal format before working on it.) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3808 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3809 There are similar functions for building a Lisp string from a C |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3810 string and translating in the process. They again come in three |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3811 variants: build_msg_istring(), build_msg_cistring(), and |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3812 build_msg_ascstring(). Again, build_msg_ascstring() asserts that |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3813 its text is pure-ASCII, and build_msg_string() is the same as |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3814 build_msg_ascstring(). |
| 771 | 3815 */ |
| 3816 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3817 /* Return value NOT Ascbyte, because the result in general will have been |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3818 translated into a foreign language. */ |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3819 DECLARE_INLINE_HEADER (const CIbyte *ASCGETTEXT (const Ascbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3820 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3821 ASSERT_ASCTEXT_ASCII (s); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3822 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3823 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3824 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3825 DECLARE_INLINE_HEADER (const Ibyte *IGETTEXT (const Ibyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3826 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3827 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3828 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3829 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3830 DECLARE_INLINE_HEADER (const CIbyte *CIGETTEXT (const CIbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3831 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3832 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3833 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3834 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3835 DECLARE_INLINE_HEADER (Lisp_Object LISP_GETTEXT (Lisp_Object s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3836 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3837 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3838 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3839 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3840 #define GETTEXT ASCGETTEXT |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3841 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3842 MODULE_API Lisp_Object build_msg_istring (const Ibyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3843 MODULE_API Lisp_Object build_msg_cistring (const CIbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3844 MODULE_API Lisp_Object build_msg_ascstring (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3845 #define build_msg_string build_msg_ascstring |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3846 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3847 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3848 /* DEFER_GETTEXT() and variants are used to identify strings which are not |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3849 meant to be translated immediately, but instead at some later time. |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3850 This is used in strings that are stored somewhere at dump or |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3851 initialization time, at a time when the current language environment is |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3852 not set. It is the duty of the user of the string to call GETTEXT or |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3853 some variant at the appropriate time. DEFER_GETTTEXT() serves only as a |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3854 marker that the string is translatable, and will as a result be snarfed |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3855 during message snarfing (see above). |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3856 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3857 build_defer_string() and variants are the deferred equivalents of |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3858 build_msg_string() and variants. Similarly to DEFER_GETTEXT(), they |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3859 don't actually do any translation, but serve as place markers for |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3860 message snarfing. However, they may do something more than just build |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3861 a Lisp string -- in particular, they may store a string property |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3862 indicating that the string is translatable (see discussion above about |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3863 this property). |
| 428 | 3864 */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3865 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3866 DECLARE_INLINE_HEADER (const Ascbyte *DEFER_ASCGETTEXT (const Ascbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3867 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3868 ASSERT_ASCTEXT_ASCII (s); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3869 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3870 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3871 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3872 DECLARE_INLINE_HEADER (const Ibyte *DEFER_IGETTEXT (const Ibyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3873 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3874 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3875 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3876 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3877 DECLARE_INLINE_HEADER (const CIbyte *DEFER_CIGETTEXT (const CIbyte *s)) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3878 { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3879 return s; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3880 } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3881 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3882 #define DEFER_GETTEXT DEFER_ASCGETTEXT |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3883 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3884 MODULE_API Lisp_Object build_defer_istring (const Ibyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3885 MODULE_API Lisp_Object build_defer_cistring (const CIbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3886 MODULE_API Lisp_Object build_defer_ascstring (const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3887 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3888 #define build_defer_string build_defer_ascstring |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3889 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3890 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3891 void write_msg_istring (Lisp_Object stream, const Ibyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3892 void write_msg_cistring (Lisp_Object stream, const CIbyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3893 void write_msg_ascstring (Lisp_Object stream, const Ascbyte *str); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3894 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
3895 #define write_msg_string write_msg_ascstring |
| 428 | 3896 |
| 3897 | |
| 3898 /************************************************************************/ | |
| 3899 /* Garbage collection / GC-protection */ | |
| 3900 /************************************************************************/ | |
| 3901 | |
| 3902 /* Structure for recording stack slots that need marking */ | |
| 3903 | |
| 3904 /* This is a chain of structures, each of which points at a Lisp_Object | |
| 3905 variable whose value should be marked in garbage collection. | |
| 3906 Normally every link of the chain is an automatic variable of a function, | |
| 3907 and its `val' points to some argument or local variable of the function. | |
| 3908 On exit to the function, the chain is set back to the value it had on | |
| 3909 entry. This way, no link remains in the chain when the stack frame | |
| 3910 containing the link disappears. | |
| 3911 | |
| 3912 Every function that can call Feval must protect in this fashion all | |
| 3913 Lisp_Object variables whose contents will be used again. */ | |
| 3914 | |
| 1632 | 3915 extern MODULE_API struct gcpro *gcprolist; |
| 428 | 3916 |
| 1743 | 3917 END_C_DECLS |
| 1650 | 3918 |
| 1204 | 3919 /* #### Catching insufficient gcpro: |
| 3920 | |
| 3921 The C++ code below catches GCPRO without UNGCPRO or vice-versa. | |
| 3922 Catching cases where there's no GCPRO or UNGCPRO but should be, however, | |
| 3923 is much harder, but could be done: | |
| 3924 | |
| 3925 1. Lisp_Object becomes a real object. Its creator and destructor need to | |
| 3926 figure out whether the object is on the stack (by looking at the range | |
| 3927 that `this' is within), and if so, add the pointer to a list of all | |
| 3928 stack-based Lisp_Objects. | |
| 3929 | |
| 3930 2. The assignment method needs to do reference-counting on actual Lisp | |
| 3931 objects -- in particular, we need to know if there are any references | |
| 3932 to a Lisp object that are *NOT* from stack-based Lisp_Objects. | |
| 3933 | |
| 3934 3. When we get to a point in the code where we might garbage collect -- | |
| 3935 i.e. Ffuncall(), Feval(), or Fgarbage_collect() is called -- we look | |
| 3936 at our list of stack-based Lisp_Objects, and if there are any that | |
| 3937 point to Lisp objects with no non-stack references, see if there are | |
| 3938 any gcpros pointing to the object, and if not, set a flag indicating | |
| 3939 that the object is "destroyed". (Don't abort yet because the function | |
| 3940 might not use the object any more.) | |
| 3941 | |
| 3942 4. When we detag a pointer using XFOO(), abort if its "destroyed" flag | |
| 3943 is set. | |
| 3944 | |
| 3945 --ben | |
| 3946 */ | |
| 3947 | |
| 428 | 3948 struct gcpro |
| 3949 { | |
| 3950 struct gcpro *next; | |
| 771 | 3951 const Lisp_Object *var; /* Address of first protected variable */ |
| 428 | 3952 int nvars; /* Number of consecutive protected variables */ |
| 1204 | 3953 #if defined (__cplusplus) && defined (ERROR_CHECK_GC) |
| 3954 /* Try to catch GCPRO without UNGCPRO, or vice-versa. G++ complains (at | |
| 3955 least with sufficient numbers of warnings enabled, i.e. -Weffc++) if a | |
| 3956 copy constructor or assignment operator is not defined. */ | |
| 3957 gcpro () : next (0), var (0), nvars (0) { } | |
| 3958 gcpro (const gcpro& g) : next (g.next), var (g.var), nvars (g.nvars) { } | |
| 3959 gcpro& operator= (const gcpro& g) { next = g.next; var = g.var; | |
| 3960 nvars = g.nvars; | |
| 3961 return *this;} | |
| 3962 ~gcpro () { assert (!next); } | |
| 3963 #endif /* defined (__cplusplus) && defined (ERROR_CHECK_GC) */ | |
| 428 | 3964 }; |
| 3965 | |
| 3966 /* Normally, you declare variables gcpro1, gcpro2, ... and use the | |
| 3967 GCPROn() macros. However, if you need to have nested gcpro's, | |
| 3968 declare ngcpro1, ngcpro2, ... and use NGCPROn(). If you need | |
| 3969 to nest another level, use nngcpro1, nngcpro2, ... and use | |
| 3970 NNGCPROn(). If you need to nest yet another level, create | |
| 3971 the appropriate macros. */ | |
| 3972 | |
| 1123 | 3973 /* NOTE: About comments like "This function does not GC": These are there to |
| 3974 try to track whether GCPROing is necessary. Strictly speaking, some | |
| 3975 functions that say this might actually GC, but only when it is never | |
| 3976 possible to return (more specifically, in the process of signalling an | |
| 3977 error, the debugger may be invoked, and could GC). For GCPRO purposes, | |
| 3978 you only have to worry about functions that can GC and then return. | |
| 3979 The QUIT macro cannot GC any more, although this wasn't true at some point, | |
| 3980 and so some "This function can GC" comments may be inaccurate. | |
| 3981 */ | |
| 3982 | |
| 1743 | 3983 BEGIN_C_DECLS |
| 1650 | 3984 |
| 2367 | 3985 #define XGCDECL1(x) struct gcpro x##cpro1 |
| 3986 #define XGCDECL2(x) struct gcpro x##cpro1, x##cpro2 | |
| 3987 #define XGCDECL3(x) struct gcpro x##cpro1, x##cpro2, x##cpro3 | |
| 3988 #define XGCDECL4(x) struct gcpro x##cpro1, x##cpro2, x##cpro3, x##cpro4 | |
| 3989 #define XGCDECL5(x) struct gcpro x##cpro1, x##cpro2, x##cpro3, x##cpro4, x##cpro5 | |
| 3990 | |
| 428 | 3991 #ifdef DEBUG_GCPRO |
| 3992 | |
| 2367 | 3993 MODULE_API void debug_gcpro1 (Ascbyte *, int, struct gcpro *, Lisp_Object *); |
| 3994 MODULE_API void debug_gcpro2 (Ascbyte *, int, struct gcpro *, struct gcpro *, | |
| 1632 | 3995 Lisp_Object *, Lisp_Object *); |
| 2367 | 3996 MODULE_API void debug_gcpro3 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 3997 struct gcpro *, Lisp_Object *, Lisp_Object *, |
| 3998 Lisp_Object *); | |
| 2367 | 3999 MODULE_API void debug_gcpro4 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4000 struct gcpro *, struct gcpro *, Lisp_Object *, |
| 4001 Lisp_Object *, Lisp_Object *, Lisp_Object *); | |
| 2367 | 4002 MODULE_API void debug_gcpro5 (Ascbyte *, int, struct gcpro *, struct gcpro *, |
| 1632 | 4003 struct gcpro *, struct gcpro *, struct gcpro *, |
| 4004 Lisp_Object *, Lisp_Object *, Lisp_Object *, | |
| 4005 Lisp_Object *, Lisp_Object *); | |
| 2367 | 4006 MODULE_API void debug_ungcpro(Ascbyte *, int, struct gcpro *); |
| 4007 | |
| 4008 #define XGCPRO1(x,v) \ | |
| 4009 debug_gcpro1 (__FILE__, __LINE__,&x##cpro1,&v) | |
| 4010 #define XGCPRO2(x,v1,v2) \ | |
| 4011 debug_gcpro2 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&v1,&v2) | |
| 4012 #define XGCPRO3(x,v1,v2,v3) \ | |
| 4013 debug_gcpro3 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4014 &v1,&v2,&v3) | |
| 4015 #define XGCPRO4(x,v1,v2,v3,v4) \ | |
| 4016 debug_gcpro4 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4017 &x##cpro4, \ | |
| 428 | 4018 &v1,&v2,&v3,&v4) |
| 2367 | 4019 #define XGCPRO5(x,v1,v2,v3,v4,v5) \ |
| 4020 debug_gcpro5 (__FILE__, __LINE__,&x##cpro1,&x##cpro2,&x##cpro3, \ | |
| 4021 &x##cpro4,&x##cpro5, \ | |
| 428 | 4022 &v1,&v2,&v3,&v4,&v5) |
| 2367 | 4023 #define XUNGCPRO(x) \ |
| 4024 debug_ungcpro(__FILE__, __LINE__,&x##cpro1) | |
| 428 | 4025 |
| 4026 #else /* ! DEBUG_GCPRO */ | |
| 4027 | |
| 2367 | 4028 #define XGCPRO1(x, var1) ((void) ( \ |
| 4029 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4030 gcprolist = &x##cpro1 )) | |
| 4031 | |
| 4032 #define XGCPRO2(x, var1, var2) ((void) ( \ | |
| 4033 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4034 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4035 gcprolist = &x##cpro2 )) | |
| 4036 | |
| 4037 #define XGCPRO3(x, var1, var2, var3) ((void) ( \ | |
| 4038 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4039 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4040 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4041 gcprolist = &x##cpro3 )) | |
| 4042 | |
| 4043 #define XGCPRO4(x, var1, var2, var3, var4) ((void) ( \ | |
| 4044 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4045 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4046 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4047 x##cpro4.next = &x##cpro3, x##cpro4.var = &var4, x##cpro4.nvars = 1, \ | |
| 4048 gcprolist = &x##cpro4 )) | |
| 4049 | |
| 4050 #define XGCPRO5(x, var1, var2, var3, var4, var5) ((void) ( \ | |
| 4051 x##cpro1.next = gcprolist, x##cpro1.var = &var1, x##cpro1.nvars = 1, \ | |
| 4052 x##cpro2.next = &x##cpro1, x##cpro2.var = &var2, x##cpro2.nvars = 1, \ | |
| 4053 x##cpro3.next = &x##cpro2, x##cpro3.var = &var3, x##cpro3.nvars = 1, \ | |
| 4054 x##cpro4.next = &x##cpro3, x##cpro4.var = &var4, x##cpro4.nvars = 1, \ | |
| 4055 x##cpro5.next = &x##cpro4, x##cpro5.var = &var5, x##cpro5.nvars = 1, \ | |
| 4056 gcprolist = &x##cpro5 )) | |
| 4057 | |
| 4058 #define XGCPRO1_ARRAY(x, array, n) ((void) ( \ | |
| 4059 x##cpro1.next = gcprolist, x##cpro1.var = array, x##cpro1.nvars = n, \ | |
| 4060 gcprolist = &x##cpro1 )) | |
| 4061 | |
| 4062 #define XGCPRO2_ARRAY(x, array1, n1, array2, n2) ((void) ( \ | |
| 4063 x##cpro1.next = gcprolist, x##cpro1.var = array1, x##cpro1.nvars = n1, \ | |
| 4064 x##cpro2.next = &x##cpro1, x##cpro2.var = array2, x##cpro2.nvars = n2, \ | |
| 4065 gcprolist = &x##cpro2 )) | |
| 4066 | |
| 4067 #define XGCPRO3_ARRAY(x, array1, n1, array2, n2, array3, n3) ((void) ( \ | |
| 4068 x##cpro1.next = gcprolist, x##cpro1.var = array1, x##cpro1.nvars = n1, \ | |
| 4069 x##cpro2.next = &x##cpro1, x##cpro2.var = array2, x##cpro2.nvars = n2, \ | |
| 4070 x##cpro3.next = &x##cpro2, x##cpro3.var = array3, x##cpro3.nvars = n3, \ | |
| 4071 gcprolist = &x##cpro3 )) | |
| 853 | 4072 |
| 1204 | 4073 #if defined (__cplusplus) && defined (ERROR_CHECK_GC) |
| 4074 /* We need to reset each gcpro to avoid triggering the assert() in | |
| 4075 ~gcpro(). This happens in UNGCPRO and longjmp(). */ | |
| 4076 #define UNWIND_GCPRO_TO(val) \ | |
| 4077 do \ | |
| 4078 { \ | |
| 4079 struct gcpro *__gcpro_stop = (val); \ | |
| 4080 /* Try to catch UNGCPRO without GCPRO. We arrange for there to be a \ | |
| 4081 sentinel at the end of the gcprolist, so it should never be NULL. */ \ | |
| 4082 assert (__gcpro_stop); \ | |
| 4083 while (gcprolist != __gcpro_stop) \ | |
| 4084 { \ | |
| 4085 struct gcpro *__gcpro_next = gcprolist->next; \ | |
| 4086 gcprolist->next = 0; \ | |
| 4087 gcprolist = __gcpro_next; \ | |
| 4088 assert (gcprolist); \ | |
| 4089 } \ | |
| 4090 } while (0) | |
| 4091 #else | |
| 4092 #define UNWIND_GCPRO_TO(val) (gcprolist = (val)) | |
| 4093 #endif /* defined (__cplusplus) && defined (ERROR_CHECK_GC) */ | |
| 4094 | |
| 2367 | 4095 #define XUNGCPRO(x) UNWIND_GCPRO_TO (x##cpro1.next) |
| 428 | 4096 |
| 4097 #endif /* ! DEBUG_GCPRO */ | |
| 4098 | |
| 2367 | 4099 #define GCDECL1 XGCDECL1 (g) |
| 4100 #define GCDECL2 XGCDECL2 (g) | |
| 4101 #define GCDECL3 XGCDECL3 (g) | |
| 4102 #define GCDECL4 XGCDECL4 (g) | |
| 4103 #define GCDECL5 XGCDECL5 (g) | |
| 4104 | |
| 4105 #define GCPRO1(a) XGCPRO1 (g,a) | |
| 4106 #define GCPRO2(a,b) XGCPRO2 (g,a,b) | |
| 4107 #define GCPRO3(a,b,c) XGCPRO3 (g,a,b,c) | |
| 4108 #define GCPRO4(a,b,c,d) XGCPRO4 (g,a,b,c,d) | |
| 4109 #define GCPRO5(a,b,c,d,e) XGCPRO5 (g,a,b,c,d,e) | |
| 4110 | |
| 4111 #define GCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(g,a1,n1) | |
| 4112 #define GCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (g,a1,n1,a2,n2) | |
| 4113 #define GCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (g,a1,n1,a2,n2,a3,n3) | |
| 4114 | |
| 4115 #define UNGCPRO XUNGCPRO (g) | |
| 4116 | |
| 4117 #define NGCDECL1 XGCDECL1 (ng) | |
| 4118 #define NGCDECL2 XGCDECL2 (ng) | |
| 4119 #define NGCDECL3 XGCDECL3 (ng) | |
| 4120 #define NGCDECL4 XGCDECL4 (ng) | |
| 4121 #define NGCDECL5 XGCDECL5 (ng) | |
| 4122 | |
| 4123 #define NGCPRO1(a) XGCPRO1 (ng,a) | |
| 4124 #define NGCPRO2(a,b) XGCPRO2 (ng,a,b) | |
| 4125 #define NGCPRO3(a,b,c) XGCPRO3 (ng,a,b,c) | |
| 4126 #define NGCPRO4(a,b,c,d) XGCPRO4 (ng,a,b,c,d) | |
| 4127 #define NGCPRO5(a,b,c,d,e) XGCPRO5 (ng,a,b,c,d,e) | |
| 4128 | |
| 4129 #define NGCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(ng,a1,n1) | |
| 4130 #define NGCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (ng,a1,n1,a2,n2) | |
| 4131 #define NGCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (ng,a1,n1,a2,n2,a3,n3) | |
| 4132 | |
| 4133 #define NUNGCPRO XUNGCPRO (ng) | |
| 4134 | |
| 4135 #define NNGCDECL1 XGCDECL1 (nng) | |
| 4136 #define NNGCDECL2 XGCDECL2 (nng) | |
| 4137 #define NNGCDECL3 XGCDECL3 (nng) | |
| 4138 #define NNGCDECL4 XGCDECL4 (nng) | |
| 4139 #define NNGCDECL5 XGCDECL5 (nng) | |
| 4140 | |
| 4141 #define NNGCPRO1(a) XGCPRO1 (nng,a) | |
| 4142 #define NNGCPRO2(a,b) XGCPRO2 (nng,a,b) | |
| 4143 #define NNGCPRO3(a,b,c) XGCPRO3 (nng,a,b,c) | |
| 4144 #define NNGCPRO4(a,b,c,d) XGCPRO4 (nng,a,b,c,d) | |
| 4145 #define NNGCPRO5(a,b,c,d,e) XGCPRO5 (nng,a,b,c,d,e) | |
| 4146 | |
| 4147 #define NNGCPRO1_ARRAY(a1,n1) XGCPRO1_ARRAY(nng,a1,n1) | |
| 4148 #define NNGCPRO2_ARRAY(a1,n1,a2,n2) XGCPRO2_ARRAY (nng,a1,n1,a2,n2) | |
| 4149 #define NNGCPRO3_ARRAY(a1,n1,a2,n2,a3,n3) XGCPRO3_ARRAY (nng,a1,n1,a2,n2,a3,n3) | |
| 4150 | |
| 4151 #define NNUNGCPRO XUNGCPRO (nng) | |
| 4152 | |
| 428 | 4153 /* Evaluate expr, UNGCPRO, and then return the value of expr. */ |
| 4154 #define RETURN_UNGCPRO(expr) do \ | |
| 4155 { \ | |
| 4156 Lisp_Object ret_ungc_val = (expr); \ | |
| 4157 UNGCPRO; \ | |
| 4158 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4159 } while (0) | |
| 4160 | |
| 4161 /* Evaluate expr, NUNGCPRO, UNGCPRO, and then return the value of expr. */ | |
| 4162 #define RETURN_NUNGCPRO(expr) do \ | |
| 4163 { \ | |
| 4164 Lisp_Object ret_ungc_val = (expr); \ | |
| 4165 NUNGCPRO; \ | |
| 4166 UNGCPRO; \ | |
| 4167 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4168 } while (0) | |
| 4169 | |
| 4170 /* Evaluate expr, NNUNGCPRO, NUNGCPRO, UNGCPRO, and then return the | |
| 4171 value of expr. */ | |
| 4172 #define RETURN_NNUNGCPRO(expr) do \ | |
| 4173 { \ | |
| 4174 Lisp_Object ret_ungc_val = (expr); \ | |
| 4175 NNUNGCPRO; \ | |
| 4176 NUNGCPRO; \ | |
| 4177 UNGCPRO; \ | |
| 4178 RETURN_SANS_WARNINGS ret_ungc_val; \ | |
| 4179 } while (0) | |
| 4180 | |
| 452 | 4181 extern Lisp_Object_ptr_dynarr *staticpros; |
| 3092 | 4182 extern Lisp_Object_ptr_dynarr *staticpros_nodump; |
| 771 | 4183 #ifdef DEBUG_XEMACS |
| 4184 | |
| 4185 /* Help debug crashes gc-marking a staticpro'ed object. */ | |
| 4186 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4187 MODULE_API void staticpro_1 (Lisp_Object *, const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4188 MODULE_API void staticpro_nodump_1 (Lisp_Object *, const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4189 #define staticpro(ptr) staticpro_1 (ptr, #ptr) |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4190 #define staticpro_nodump(ptr) staticpro_nodump_1 (ptr, #ptr) |
| 771 | 4191 |
| 996 | 4192 #ifdef HAVE_SHLIB |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4193 MODULE_API void unstaticpro_nodump_1 (Lisp_Object *, const Ascbyte *); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4194 #define unstaticpro_nodump(ptr) unstaticpro_nodump_1 (ptr, #ptr) |
| 996 | 4195 #endif |
| 4196 | |
| 771 | 4197 #else |
| 611 | 4198 |
| 428 | 4199 /* Call staticpro (&var) to protect static variable `var'. */ |
| 1632 | 4200 MODULE_API void staticpro (Lisp_Object *); |
|
4979
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4201 /* staticpro_1 (varptr, name) is used when we're not directly calling |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4202 staticpro() on the address of a Lisp variable, but on a pointer we |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4203 got from elsewhere. In that case, NAME is a string describing the |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4204 actual variable in question. NAME is used only for debugging purposes, |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4205 and hence when not DEBUG_XEMACS, staticpro_1() just calls staticpro(). |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4206 With DEBUG_XEMACS, however, it's the reverse -- staticpro() calls |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4207 staticpro_1(), using the ANSI "stringize" operator to construct a string |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4208 out of the variable name. */ |
|
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4209 #define staticpro_1(ptr, name) staticpro (ptr) |
| 428 | 4210 |
| 4211 /* Call staticpro_nodump (&var) to protect static variable `var'. */ | |
| 4212 /* var will not be saved at dump time */ | |
| 1632 | 4213 MODULE_API void staticpro_nodump (Lisp_Object *); |
|
4979
4234fd5a7b17
fix bug #668 (compile error, not --with-debug)
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4214 #define staticpro_nodump_1(ptr, name) staticpro_nodump (ptr) |
| 428 | 4215 |
| 996 | 4216 #ifdef HAVE_SHLIB |
| 4217 /* Call unstaticpro_nodump (&var) to stop protecting static variable `var'. */ | |
| 1632 | 4218 MODULE_API void unstaticpro_nodump (Lisp_Object *); |
| 996 | 4219 #endif |
| 4220 | |
| 771 | 4221 #endif |
| 4222 | |
| 3263 | 4223 #ifdef NEW_GC |
| 2720 | 4224 extern Lisp_Object_dynarr *mcpros; |
| 4225 #ifdef DEBUG_XEMACS | |
| 4226 /* Help debug crashes gc-marking a mcpro'ed object. */ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4227 MODULE_API void mcpro_1 (Lisp_Object, const Ascbyte *); |
| 2720 | 4228 #define mcpro(ptr) mcpro_1 (ptr, #ptr) |
| 4229 #else /* not DEBUG_XEMACS */ | |
| 4230 /* Call mcpro (&var) to protect mc variable `var'. */ | |
| 4231 MODULE_API void mcpro (Lisp_Object); | |
| 4232 #endif /* not DEBUG_XEMACS */ | |
| 3263 | 4233 #endif /* NEW_GC */ |
| 2720 | 4234 |
| 771 | 4235 void register_post_gc_action (void (*fun) (void *), void *arg); |
| 4236 int begin_gc_forbidden (void); | |
| 4237 void end_gc_forbidden (int count); | |
| 1957 | 4238 extern int gc_currently_forbidden; |
| 771 | 4239 |
| 1743 | 4240 END_C_DECLS |
| 1650 | 4241 |
| 771 | 4242 |
| 4243 /************************************************************************/ | |
| 4244 /* Misc definitions */ | |
| 4245 /************************************************************************/ | |
| 442 | 4246 |
| 4247 /************************************************************************/ | |
| 1983 | 4248 /* Other numeric types */ |
| 4249 /************************************************************************/ | |
| 4250 #include "number.h" | |
| 4251 | |
| 4252 | |
| 4253 /************************************************************************/ | |
| 442 | 4254 /* prototypes */ |
| 4255 /************************************************************************/ | |
| 4256 | |
| 4257 /* NOTE: Prototypes should go HERE, not in various header files, unless | |
| 4258 they specifically reference a type that's not defined in lisp.h. | |
| 4259 (And even then, you might consider adding the type to lisp.h.) | |
| 4260 | |
| 4261 The idea is that header files typically contain the innards of objects, | |
| 4262 and we want to minimize the number of "dependencies" of one file on | |
| 4263 the specifics of such objects. Putting prototypes here minimizes the | |
| 4264 number of header files that need to be included -- good for a number | |
| 4265 of reasons. --ben */ | |
| 4266 | |
| 4267 /* Prototypes for all init/syms_of/vars_of initialization functions. */ | |
| 4268 #include "symsinit.h" | |
| 4269 | |
| 1743 | 4270 BEGIN_C_DECLS |
| 1650 | 4271 |
| 826 | 4272 /* Defined in abbrev.c */ |
| 1632 | 4273 MODULE_API EXFUN (Fexpand_abbrev, 0); |
| 826 | 4274 |
| 428 | 4275 /* Defined in alloc.c */ |
| 1632 | 4276 MODULE_API EXFUN (Fcons, 2); |
| 4277 MODULE_API EXFUN (Flist, MANY); | |
|
4995
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
4278 EXFUN (Fbit_vector, MANY); |
| 826 | 4279 EXFUN (Fmake_byte_code, MANY); |
| 1632 | 4280 MODULE_API EXFUN (Fmake_list, 2); |
| 4281 MODULE_API EXFUN (Fmake_string, 2); | |
|
4995
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
4282 EXFUN (Fstring, MANY); |
| 1632 | 4283 MODULE_API EXFUN (Fmake_symbol, 1); |
| 4284 MODULE_API EXFUN (Fmake_vector, 2); | |
| 4285 MODULE_API EXFUN (Fvector, MANY); | |
| 826 | 4286 |
|
5146
88bd4f3ef8e4
make lrecord UID's have a separate UID space for each object, resurrect debug SOE code in extents.c
Ben Wing <ben@xemacs.org>
parents:
5143
diff
changeset
|
4287 void deadbeef_memory (void *ptr, Bytecount size); |
| 3263 | 4288 #ifndef NEW_GC |
| 428 | 4289 void release_breathing_space (void); |
| 3263 | 4290 #endif /* not NEW_GC */ |
| 428 | 4291 Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object); |
| 1632 | 4292 MODULE_API Lisp_Object make_vector (Elemcount, Lisp_Object); |
| 4293 MODULE_API Lisp_Object vector1 (Lisp_Object); | |
| 4294 MODULE_API Lisp_Object vector2 (Lisp_Object, Lisp_Object); | |
| 4295 MODULE_API Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 665 | 4296 Lisp_Object make_bit_vector (Elemcount, Lisp_Object); |
| 4297 Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, Elemcount); | |
| 428 | 4298 Lisp_Object noseeum_make_marker (void); |
| 3092 | 4299 #ifndef NEW_GC |
| 428 | 4300 void garbage_collect_1 (void); |
| 3092 | 4301 #endif /* not NEW_GC */ |
| 1632 | 4302 MODULE_API Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object); |
| 4303 MODULE_API Lisp_Object cons3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4304 MODULE_API Lisp_Object list1 (Lisp_Object); | |
| 4305 MODULE_API Lisp_Object list2 (Lisp_Object, Lisp_Object); | |
| 4306 MODULE_API Lisp_Object list3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4307 MODULE_API Lisp_Object list4 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4308 Lisp_Object); | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4309 MODULE_API Lisp_Object list5 (Lisp_Object, Lisp_Object, Lisp_Object, |
| 1632 | 4310 Lisp_Object, Lisp_Object); |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4311 MODULE_API Lisp_Object list6 (Lisp_Object, Lisp_Object, Lisp_Object, |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4312 Lisp_Object, Lisp_Object, Lisp_Object); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4313 MODULE_API Lisp_Object listn (int numargs, ...); |
|
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4314 MODULE_API Lisp_Object listu (Lisp_Object, ...); |
| 428 | 4315 DECLARE_DOESNT_RETURN (memory_full (void)); |
| 4316 void disksave_object_finalization (void); | |
|
5158
9e0b43d3095c
more cleanups to object-memory-usage stuff
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
4317 void finish_object_memory_usage_stats (void); |
| 428 | 4318 extern int purify_flag; |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4319 #define ARRAY_DIMENSION_LIMIT EMACS_INT_MAX |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4320 extern Fixnum Varray_dimension_limit; |
| 3092 | 4321 #ifndef NEW_GC |
| 428 | 4322 extern EMACS_INT gc_generation_number[1]; |
| 3092 | 4323 #endif /* not NEW_GC */ |
| 428 | 4324 int c_readonly (Lisp_Object); |
| 4325 int lisp_readonly (Lisp_Object); | |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
4326 MODULE_API Lisp_Object build_istring (const Ibyte *); |
|
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
4327 MODULE_API Lisp_Object build_cistring (const CIbyte *); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4328 MODULE_API Lisp_Object build_ascstring (const Ascbyte *); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
4329 MODULE_API Lisp_Object build_extstring (const Extbyte *, Lisp_Object); |
| 1632 | 4330 MODULE_API Lisp_Object make_string (const Ibyte *, Bytecount); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
4331 MODULE_API Lisp_Object make_extstring (const Extbyte *, EMACS_INT, Lisp_Object); |
| 771 | 4332 void init_string_ascii_begin (Lisp_Object string); |
| 428 | 4333 Lisp_Object make_uninit_string (Bytecount); |
| 1632 | 4334 MODULE_API Lisp_Object make_float (double); |
| 867 | 4335 Lisp_Object make_string_nocopy (const Ibyte *, Bytecount); |
| 853 | 4336 void free_cons (Lisp_Object); |
| 428 | 4337 void free_list (Lisp_Object); |
| 4338 void free_alist (Lisp_Object); | |
| 1204 | 4339 void free_marker (Lisp_Object); |
| 428 | 4340 int object_dead_p (Lisp_Object); |
| 4341 void mark_object (Lisp_Object obj); | |
| 4342 int marked_p (Lisp_Object obj); | |
| 851 | 4343 extern int funcall_allocation_flag; |
| 814 | 4344 extern int need_to_garbage_collect; |
| 1632 | 4345 extern MODULE_API int need_to_check_c_alloca; |
| 888 | 4346 extern int need_to_signal_post_gc; |
| 1333 | 4347 extern Lisp_Object Qpost_gc_hook, Qgarbage_collecting; |
| 851 | 4348 void recompute_funcall_allocation_flag (void); |
| 428 | 4349 |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
4350 Bytecount malloced_storage_size (void *, Bytecount, struct usage_stats *); |
| 1204 | 4351 |
| 4352 #ifdef EVENT_DATA_AS_OBJECTS | |
| 4353 Lisp_Object make_key_data (void); | |
| 4354 Lisp_Object make_button_data (void); | |
| 4355 Lisp_Object make_motion_data (void); | |
| 4356 Lisp_Object make_process_data (void); | |
| 4357 Lisp_Object make_timeout_data (void); | |
| 4358 Lisp_Object make_magic_data (void); | |
| 4359 Lisp_Object make_magic_eval_data (void); | |
| 4360 Lisp_Object make_eval_data (void); | |
| 4361 Lisp_Object make_misc_user_data (void); | |
| 4362 void free_key_data (Lisp_Object); | |
| 4363 void free_button_data (Lisp_Object); | |
| 4364 void free_motion_data (Lisp_Object); | |
| 4365 void free_process_data (Lisp_Object); | |
| 4366 void free_timeout_data (Lisp_Object); | |
| 4367 void free_magic_data (Lisp_Object); | |
| 4368 void free_magic_eval_data (Lisp_Object); | |
| 4369 void free_eval_data (Lisp_Object); | |
| 4370 void free_misc_user_data (Lisp_Object); | |
| 4371 #endif /* EVENT_DATA_AS_OBJECTS */ | |
| 934 | 4372 |
| 428 | 4373 /* Defined in buffer.c */ |
| 4374 Lisp_Object get_truename_buffer (Lisp_Object); | |
| 4375 void switch_to_buffer (Lisp_Object, Lisp_Object); | |
| 4376 extern int find_file_compare_truenames; | |
| 4377 extern int find_file_use_truenames; | |
| 867 | 4378 Ibyte *get_initial_directory (Ibyte *pathname, Bytecount size); |
| 771 | 4379 void set_buffer_internal (struct buffer *b); |
| 4380 struct buffer *decode_buffer (Lisp_Object buffer, int allow_string); | |
| 4381 | |
| 4382 void record_buffer (Lisp_Object buf); | |
| 4383 Lisp_Object get_buffer (Lisp_Object name, | |
| 4384 int error_if_deleted_or_does_not_exist); | |
| 4385 int map_over_sharing_buffers (struct buffer *buf, | |
| 4386 int (*mapfun) (struct buffer *buf, | |
| 4387 void *closure), | |
| 4388 void *closure); | |
| 1204 | 4389 void cleanup_buffer_undo_lists (void); |
| 771 | 4390 |
| 4391 extern struct buffer *current_buffer; | |
| 4392 | |
| 4393 extern void init_initial_directory (void); /* initialize initial_directory */ | |
| 4394 | |
| 4395 EXFUN (Fbuffer_disable_undo, 1); | |
| 1632 | 4396 MODULE_API EXFUN (Fbuffer_modified_p, 1); |
| 4397 MODULE_API EXFUN (Fbuffer_name, 1); | |
| 4398 MODULE_API EXFUN (Fcurrent_buffer, 0); | |
| 771 | 4399 EXFUN (Ferase_buffer, 1); |
| 4400 EXFUN (Fget_buffer, 1); | |
| 4401 EXFUN (Fget_buffer_create, 1); | |
| 4402 EXFUN (Fget_file_buffer, 1); | |
| 1632 | 4403 MODULE_API EXFUN (Fkill_buffer, 1); |
| 771 | 4404 EXFUN (Fother_buffer, 3); |
| 4405 EXFUN (Frecord_buffer, 1); | |
| 1632 | 4406 MODULE_API EXFUN (Fset_buffer, 1); |
| 771 | 4407 EXFUN (Fset_buffer_modified_p, 2); |
| 4408 | |
| 4409 extern Lisp_Object QSscratch, Qafter_change_function, Qafter_change_functions; | |
| 4410 extern Lisp_Object Qbefore_change_function, Qbefore_change_functions; | |
| 4411 extern Lisp_Object Qbuffer_or_string_p, Qdefault_directory, Qfirst_change_hook; | |
| 4412 extern Lisp_Object Qpermanent_local, Vafter_change_function; | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4413 extern Lisp_Object Qbuffer_live_p; |
| 771 | 4414 extern Lisp_Object Vafter_change_functions, Vbefore_change_function; |
| 4415 extern Lisp_Object Vbefore_change_functions, Vbuffer_alist, Vbuffer_defaults; | |
| 4416 extern Lisp_Object Vinhibit_read_only, Vtransient_mark_mode; | |
| 428 | 4417 |
| 563 | 4418 /* Defined in bytecode.c */ |
| 826 | 4419 EXFUN (Fbyte_code, 3); |
| 4420 | |
| 593 | 4421 DECLARE_DOESNT_RETURN (invalid_byte_code |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4422 (const Ascbyte *reason, Lisp_Object frob)); |
| 563 | 4423 |
| 4932 | 4424 extern Lisp_Object Qbyte_code, Qinvalid_byte_code; |
| 563 | 4425 |
| 826 | 4426 /* Defined in callint.c */ |
| 4427 EXFUN (Fcall_interactively, 3); | |
| 4428 EXFUN (Fprefix_numeric_value, 1); | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4429 extern Lisp_Object Qcall_interactively; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4430 extern Lisp_Object Qmouse_leave_buffer_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4431 extern Lisp_Object Qread_from_minibuffer; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4432 extern Lisp_Object Vcommand_history; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4433 extern Lisp_Object Vcurrent_prefix_arg; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4434 extern Lisp_Object Vmark_even_if_inactive; |
| 826 | 4435 |
| 4436 /* Defined in casefiddle.c */ | |
| 4437 EXFUN (Fdowncase, 2); | |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4906
diff
changeset
|
4438 EXFUN (Fcanoncase, 2); |
| 826 | 4439 EXFUN (Fupcase, 2); |
| 4440 EXFUN (Fupcase_initials, 2); | |
| 4441 EXFUN (Fupcase_initials_region, 3); | |
| 4442 EXFUN (Fupcase_region, 3); | |
| 4443 | |
| 4444 /* Defined in casetab.c */ | |
| 4445 EXFUN (Fset_standard_case_table, 1); | |
| 4446 | |
| 4447 /* Defined in chartab.c */ | |
| 4448 EXFUN (Freset_char_table, 1); | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4449 extern Lisp_Object Qcategory_designator_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4450 extern Lisp_Object Qcategory_table_value_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4451 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4452 /* Defined in cmdloop.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4453 extern Lisp_Object Qdisabled_command_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4454 extern Lisp_Object Qreally_early_error_handler; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4455 extern Lisp_Object Qtop_level; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4456 extern Lisp_Object Vdisabled_command_hook; |
| 826 | 4457 |
| 4458 /* Defined in cmds.c */ | |
| 4459 EXFUN (Fbeginning_of_line, 2); | |
| 4460 EXFUN (Fend_of_line, 2); | |
| 4461 EXFUN (Fforward_char, 2); | |
| 4462 EXFUN (Fforward_line, 2); | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4463 extern Lisp_Object Qself_insert_command; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4464 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4465 /* Defined in console.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4466 extern Lisp_Object Qconsole_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4467 extern Lisp_Object Vconsole_list; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4468 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4469 /* Defined in console-stream.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4470 extern Lisp_Object Vstdio_str; |
| 826 | 4471 |
| 428 | 4472 /* Defined in data.c */ |
| 826 | 4473 EXFUN (Fadd1, 1); |
| 4474 EXFUN (Faref, 2); | |
| 4475 EXFUN (Faset, 3); | |
| 4476 EXFUN (Fcar, 1); | |
| 4477 EXFUN (Fcar_safe, 1); | |
| 4478 EXFUN (Fcdr, 1); | |
| 919 | 4479 EXFUN (Fcdr_safe, 1); |
| 826 | 4480 EXFUN (Fgeq, MANY); |
| 4481 EXFUN (Fgtr, MANY); | |
| 4482 EXFUN (Findirect_function, 1); | |
| 4483 EXFUN (Fleq, MANY); | |
| 4484 EXFUN (Flistp, 1); | |
| 4485 EXFUN (Flss, MANY); | |
| 4486 EXFUN (Fmax, MANY); | |
| 4487 EXFUN (Fmin, MANY); | |
| 4488 EXFUN (Fminus, MANY); | |
| 4489 EXFUN (Fnumber_to_string, 1); | |
| 4490 EXFUN (Fplus, MANY); | |
| 4491 EXFUN (Fquo, MANY); | |
| 4492 EXFUN (Frem, 2); | |
| 4493 EXFUN (Fsetcar, 2); | |
| 4494 EXFUN (Fsetcdr, 2); | |
| 4495 EXFUN (Fsub1, 1); | |
| 4496 EXFUN (Fsubr_max_args, 1); | |
| 4497 EXFUN (Fsubr_min_args, 1); | |
| 4498 EXFUN (Ftimes, MANY); | |
| 4499 | |
| 428 | 4500 DECLARE_DOESNT_RETURN (c_write_error (Lisp_Object)); |
| 4501 DECLARE_DOESNT_RETURN (lisp_write_error (Lisp_Object)); | |
| 4502 DECLARE_DOESNT_RETURN (args_out_of_range (Lisp_Object, Lisp_Object)); | |
| 4503 DECLARE_DOESNT_RETURN (args_out_of_range_3 (Lisp_Object, Lisp_Object, | |
| 4504 Lisp_Object)); | |
| 1632 | 4505 MODULE_API Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object); |
| 4506 MODULE_API | |
| 428 | 4507 DECLARE_DOESNT_RETURN (dead_wrong_type_argument (Lisp_Object, Lisp_Object)); |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4508 void check_integer_range (Lisp_Object, Lisp_Object, Lisp_Object); |
| 428 | 4509 |
| 771 | 4510 EXFUN (Fint_to_char, 1); |
| 4511 EXFUN (Fchar_to_int, 1); | |
| 4512 | |
| 428 | 4513 enum arith_comparison { |
| 4514 arith_equal, | |
| 4515 arith_notequal, | |
| 4516 arith_less, | |
| 4517 arith_grtr, | |
| 4518 arith_less_or_equal, | |
| 4519 arith_grtr_or_equal }; | |
| 4520 Lisp_Object arithcompare (Lisp_Object, Lisp_Object, enum arith_comparison); | |
| 4521 | |
| 707 | 4522 /* Do NOT use word_to_lisp or wasteful_word_to_lisp to decode time_t's |
| 4523 unless you KNOW arg is non-negative. They cannot return negative | |
| 4524 values! Use make_time. */ | |
| 428 | 4525 Lisp_Object word_to_lisp (unsigned int); |
| 4526 unsigned int lisp_to_word (Lisp_Object); | |
| 4527 | |
| 4932 | 4528 extern Lisp_Object Qarrayp, Qbitp, Qchar_or_string_p, Qcharacterp, |
| 4529 Qerror_conditions, Qerror_message, Qinteger_char_or_marker_p, | |
| 4530 Qinteger_or_char_p, Qinteger_or_marker_p, Qlambda, Qlistp, Qnatnump, | |
| 4531 Qnonnegativep, Qnumber_char_or_marker_p, Qnumberp, Qquote, Qtrue_list_p; | |
| 4532 extern MODULE_API Lisp_Object Qintegerp; | |
| 4533 | |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4534 extern Lisp_Object Qargs_out_of_range, Qarith_error, Qbeginning_of_buffer, |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4535 Qbuffer_read_only, Qcircular_list, Qcircular_property_list, |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4536 Qconversion_error, Qcyclic_variable_indirection, Qdomain_error, |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4537 Qediting_error, Qend_of_buffer, Qend_of_file, Qerror, Qfile_error, |
|
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4538 Qinternal_error, Qinvalid_change, Qinvalid_constant, Qinvalid_function, |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4539 Qinvalid_keyword_argument, Qinvalid_operation, |
| 4932 | 4540 Qinvalid_read_syntax, Qinvalid_state, Qio_error, Qlist_formation_error, |
| 4541 Qmalformed_list, Qmalformed_property_list, Qno_catch, Qout_of_memory, | |
| 4542 Qoverflow_error, Qprinting_unreadable_object, Qquit, Qrange_error, | |
| 4543 Qsetting_constant, Qsingularity_error, Qstack_overflow, | |
| 4544 Qstructure_formation_error, Qtext_conversion_error, Qunderflow_error, | |
| 4545 Qvoid_function, Qvoid_variable, Qwrong_number_of_arguments, | |
| 4546 Qwrong_type_argument; | |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
4547 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4548 extern Lisp_Object Qcdr; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4549 extern Lisp_Object Qerror_lacks_explanatory_string; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4550 extern Lisp_Object Qfile_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4551 extern Lisp_Object Qsequencep; |
| 4932 | 4552 extern MODULE_API Lisp_Object Qinvalid_argument, Qsyntax_error; |
| 4553 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4554 /* Defined in device.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4555 extern Lisp_Object Qdevice_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4556 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4557 /* Defined in device-x.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4558 extern Lisp_Object Vx_initial_argv_list; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4559 |
| 428 | 4560 /* Defined in dired.c */ |
|
5211
cdca98f2d36f
Move `default-file-system-ignore-case' to C; fix bug in directory hash tables
Aidan Kehoe <kehoea@parhasard.net>
parents:
5200
diff
changeset
|
4561 Lisp_Object make_directory_hash_table (Lisp_Object); |
| 428 | 4562 |
| 4563 /* Defined in doc.c */ | |
| 826 | 4564 EXFUN (Fsubstitute_command_keys, 1); |
| 4565 | |
| 814 | 4566 Lisp_Object unparesseuxify_doc_string (int fd, EMACS_INT position, |
| 867 | 4567 Ibyte *name_nonreloc, |
| 814 | 4568 Lisp_Object name_reloc, |
| 4569 int standard_doc_file); | |
| 428 | 4570 Lisp_Object read_doc_string (Lisp_Object); |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4571 extern Lisp_Object Vinternal_doc_file_name; |
| 428 | 4572 |
| 4573 /* Defined in doprnt.c */ | |
| 867 | 4574 Bytecount emacs_doprnt_va (Lisp_Object stream, const Ibyte *format_nonreloc, |
| 771 | 4575 Bytecount format_length, Lisp_Object format_reloc, |
| 4576 va_list vargs); | |
| 867 | 4577 Bytecount emacs_doprnt (Lisp_Object stream, const Ibyte *format_nonreloc, |
| 771 | 4578 Bytecount format_length, Lisp_Object format_reloc, |
| 4579 int nargs, const Lisp_Object *largs, ...); | |
| 867 | 4580 Lisp_Object emacs_vsprintf_string_lisp (const CIbyte *format_nonreloc, |
| 771 | 4581 Lisp_Object format_reloc, int nargs, |
| 4582 const Lisp_Object *largs); | |
| 867 | 4583 Lisp_Object emacs_sprintf_string_lisp (const CIbyte *format_nonreloc, |
| 771 | 4584 Lisp_Object format_reloc, int nargs, ...); |
| 867 | 4585 Ibyte *emacs_vsprintf_malloc_lisp (const CIbyte *format_nonreloc, |
| 771 | 4586 Lisp_Object format_reloc, int nargs, |
| 4587 const Lisp_Object *largs, | |
| 4588 Bytecount *len_out); | |
| 867 | 4589 Ibyte *emacs_sprintf_malloc_lisp (Bytecount *len_out, |
| 4590 const CIbyte *format_nonreloc, | |
| 771 | 4591 Lisp_Object format_reloc, int nargs, ...); |
| 867 | 4592 Lisp_Object emacs_vsprintf_string (const CIbyte *format, va_list vargs); |
| 4593 Lisp_Object emacs_sprintf_string (const CIbyte *format, ...) | |
| 771 | 4594 PRINTF_ARGS (1, 2); |
| 867 | 4595 Ibyte *emacs_vsprintf_malloc (const CIbyte *format, va_list vargs, |
| 771 | 4596 Bytecount *len_out); |
| 867 | 4597 Ibyte *emacs_sprintf_malloc (Bytecount *len_out, const CIbyte *format, ...) |
| 771 | 4598 PRINTF_ARGS (2, 3); |
| 867 | 4599 Bytecount emacs_vsprintf (Ibyte *output, const CIbyte *format, |
| 771 | 4600 va_list vargs); |
| 867 | 4601 Bytecount emacs_sprintf (Ibyte *output, const CIbyte *format, ...) |
| 771 | 4602 PRINTF_ARGS (2, 3); |
| 4603 | |
| 428 | 4604 |
| 4605 /* Defined in editfns.c */ | |
| 826 | 4606 EXFUN (Fbobp, 1); |
| 4607 EXFUN (Fbolp, 1); | |
| 4608 EXFUN (Fbuffer_substring, 3); | |
| 4609 EXFUN (Fchar_after, 2); | |
| 4610 EXFUN (Fchar_to_string, 1); | |
|
5214
0b4d355771bd
Import buffer-display-count, buffer-display-time; thank you, Jeff Sparkes.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5211
diff
changeset
|
4611 EXFUN (Fcurrent_time, 0); |
| 826 | 4612 EXFUN (Fdelete_region, 3); |
| 4613 EXFUN (Feobp, 1); | |
| 4614 EXFUN (Feolp, 1); | |
| 4615 EXFUN (Ffollowing_char, 1); | |
| 4616 EXFUN (Fformat, MANY); | |
| 4617 EXFUN (Fgoto_char, 2); | |
| 4618 EXFUN (Finsert, MANY); | |
| 4619 EXFUN (Finsert_buffer_substring, 3); | |
| 4620 EXFUN (Finsert_char, 4); | |
| 4621 EXFUN (Fnarrow_to_region, 3); | |
| 4622 EXFUN (Fpoint, 1); | |
| 4623 EXFUN (Fpoint_marker, 2); | |
| 4624 EXFUN (Fpoint_max, 1); | |
| 4625 EXFUN (Fpoint_min, 1); | |
| 4626 EXFUN (Fpreceding_char, 1); | |
| 4627 EXFUN (Fsystem_name, 0); | |
| 4628 EXFUN (Fuser_home_directory, 0); | |
| 4629 EXFUN (Fuser_login_name, 1); | |
| 4630 EXFUN (Fwiden, 1); | |
| 4631 | |
| 428 | 4632 void uncache_home_directory (void); |
| 867 | 4633 Ibyte *get_home_directory (void); |
| 4634 Ibyte *user_login_name (uid_t *); | |
| 428 | 4635 void buffer_insert1 (struct buffer *, Lisp_Object); |
| 665 | 4636 Lisp_Object make_string_from_buffer (struct buffer *, Charbpos, Charcount); |
| 4637 Lisp_Object make_string_from_buffer_no_extents (struct buffer *, Charbpos, Charcount); | |
| 707 | 4638 Lisp_Object make_time (time_t); |
| 428 | 4639 Lisp_Object save_excursion_save (void); |
| 844 | 4640 Lisp_Object save_restriction_save (struct buffer *buf); |
| 428 | 4641 Lisp_Object save_excursion_restore (Lisp_Object); |
| 4642 Lisp_Object save_restriction_restore (Lisp_Object); | |
| 771 | 4643 void widen_buffer (struct buffer *b, int no_clip); |
| 4644 int beginning_of_line_p (struct buffer *b, Charbpos pt); | |
| 428 | 4645 Lisp_Object save_current_buffer_restore (Lisp_Object); |
| 4646 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4647 extern Lisp_Object Qformat; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4648 extern Lisp_Object Qmark; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4649 extern Lisp_Object Qpoint; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4650 extern Lisp_Object Qregion_beginning; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4651 extern Lisp_Object Qregion_end; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4652 extern Lisp_Object Quser_files_and_directories; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4653 extern Lisp_Object Vsystem_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4654 |
| 428 | 4655 /* Defined in emacs.c */ |
| 2268 | 4656 EXFUN_NORETURN (Fkill_emacs, 1); |
| 826 | 4657 EXFUN (Frunning_temacs_p, 0); |
| 1123 | 4658 EXFUN (Fforce_debugging_signal, 1); |
| 826 | 4659 |
| 428 | 4660 SIGTYPE fatal_error_signal (int); |
| 2367 | 4661 Lisp_Object make_arg_list (int, Wexttext **); |
| 4662 void make_argc_argv (Lisp_Object, int *, Wexttext ***); | |
| 4663 void free_argc_argv (Wexttext **); | |
| 771 | 4664 Lisp_Object split_external_path (const Extbyte *path); |
| 867 | 4665 Lisp_Object split_env_path (const CIbyte *evarname, const Ibyte *default_); |
| 771 | 4666 |
| 428 | 4667 /* Nonzero means don't do interactive redisplay and don't change tty modes */ |
| 442 | 4668 extern int noninteractive, noninteractive1; |
| 2367 | 4669 extern int inhibit_non_essential_conversion_operations; |
| 428 | 4670 extern int preparing_for_armageddon; |
| 458 | 4671 extern Fixnum emacs_priority; |
| 428 | 4672 extern int suppress_early_error_handler_backtrace; |
| 771 | 4673 void debug_break (void); |
| 4854 | 4674 int debug_can_access_memory (const void *ptr, Bytecount len); |
| 2210 | 4675 DECLARE_DOESNT_RETURN (really_abort (void)); |
| 776 | 4676 void zero_out_command_line_status_vars (void); |
| 428 | 4677 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4678 extern Lisp_Object Qsave_buffers_kill_emacs; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4679 extern Lisp_Object Vcommand_line_args; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4680 extern Lisp_Object Vconfigure_info_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4681 extern Lisp_Object Vconfigure_site_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4682 extern Lisp_Object Vconfigure_site_module_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4683 extern Lisp_Object Vdata_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4684 extern Lisp_Object Vdoc_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4685 extern Lisp_Object Vemacs_major_version; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4686 extern Lisp_Object Vemacs_minor_version; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4687 extern Lisp_Object Vexec_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4688 extern Lisp_Object Vexec_path; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4689 extern Lisp_Object Vinvocation_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4690 extern Lisp_Object Vinvocation_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4691 extern Lisp_Object Vmodule_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4692 extern Lisp_Object Vsite_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4693 extern Lisp_Object Vsite_module_directory; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4694 |
| 826 | 4695 /* Defined in emodules.c */ |
| 996 | 4696 #ifdef HAVE_SHLIB |
| 826 | 4697 EXFUN (Flist_modules, 0); |
| 4698 EXFUN (Fload_module, 3); | |
| 996 | 4699 extern int unloading_module; |
| 4700 #endif | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4701 extern Lisp_Object Qdll_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
4702 extern Lisp_Object Qmodule; |
| 826 | 4703 |
| 428 | 4704 /* Defined in eval.c */ |
| 1706 | 4705 MODULE_API EXFUN (Fapply, MANY); |
| 826 | 4706 EXFUN (Fbacktrace, 2); |
| 4707 EXFUN (Fcommand_execute, 3); | |
| 4708 EXFUN (Fcommandp, 1); | |
|
4744
17f7e9191c0b
Rationalise duplicated functionality, #'custom-quote, #'quote-maybe.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4690
diff
changeset
|
4709 EXFUN (Fquote_maybe, 1); |
| 1706 | 4710 MODULE_API EXFUN (Feval, 1); |
| 4711 MODULE_API EXFUN (Ffuncall, MANY); | |
| 826 | 4712 EXFUN (Ffunctionp, 1); |
| 4713 EXFUN (Finteractive_p, 0); | |
| 4714 EXFUN (Fprogn, UNEVALLED); | |
| 1706 | 4715 MODULE_API EXFUN (Fsignal, 2); |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4716 MODULE_API EXFUN_NORETURN (Fthrow, UNEVALLED); |
| 1706 | 4717 MODULE_API EXFUN (Fcall_with_condition_handler, MANY); |
| 853 | 4718 EXFUN (Ffunction_max_args, 1); |
| 4719 EXFUN (Ffunction_min_args, 1); | |
| 826 | 4720 |
|
4677
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4721 MODULE_API DECLARE_DOESNT_RETURN (throw_or_bomb_out (Lisp_Object, |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4722 Lisp_Object, int, |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4723 Lisp_Object, Lisp_Object)); |
|
8f1ee2d15784
Support full Common Lisp multiple values in C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4512
diff
changeset
|
4724 |
|
5348
39304a35b6b3
Don't commit suicide when an X device dies.
Mike Sperber <sperber@deinprogramm.de>
parents:
5338
diff
changeset
|
4725 MODULE_API DECLARE_DOESNT_RETURN (throw_or_bomb_out_unsafe (Lisp_Object, |
|
39304a35b6b3
Don't commit suicide when an X device dies.
Mike Sperber <sperber@deinprogramm.de>
parents:
5338
diff
changeset
|
4726 Lisp_Object, int, |
|
39304a35b6b3
Don't commit suicide when an X device dies.
Mike Sperber <sperber@deinprogramm.de>
parents:
5338
diff
changeset
|
4727 Lisp_Object, Lisp_Object)); |
|
39304a35b6b3
Don't commit suicide when an X device dies.
Mike Sperber <sperber@deinprogramm.de>
parents:
5338
diff
changeset
|
4728 |
| 1632 | 4729 MODULE_API DECLARE_DOESNT_RETURN (signal_error_1 (Lisp_Object, Lisp_Object)); |
| 563 | 4730 void maybe_signal_error_1 (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 4731 Error_Behavior); |
| 563 | 4732 Lisp_Object maybe_signal_continuable_error_1 (Lisp_Object, Lisp_Object, |
| 578 | 4733 Lisp_Object, Error_Behavior); |
| 1743 | 4734 MODULE_API DECLARE_DOESNT_RETURN (signal_ferror (Lisp_Object, const CIbyte *, |
| 4735 ...)) PRINTF_ARGS(2, 3); | |
| 578 | 4736 void maybe_signal_ferror (Lisp_Object, Lisp_Object, Error_Behavior, |
| 867 | 4737 const CIbyte *, ...) PRINTF_ARGS (4, 5); |
| 4738 Lisp_Object signal_continuable_ferror (Lisp_Object, const CIbyte *, ...) | |
| 442 | 4739 PRINTF_ARGS (2, 3); |
| 563 | 4740 Lisp_Object maybe_signal_continuable_ferror (Lisp_Object, Lisp_Object, |
| 578 | 4741 Error_Behavior, |
| 867 | 4742 const CIbyte *, ...) |
| 442 | 4743 PRINTF_ARGS (4, 5); |
| 563 | 4744 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4745 Lisp_Object build_error_data (const Ascbyte *reason, Lisp_Object frob); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4746 DECLARE_DOESNT_RETURN (signal_error (Lisp_Object, const Ascbyte *, |
| 563 | 4747 Lisp_Object)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4748 void maybe_signal_error (Lisp_Object, const Ascbyte *, Lisp_Object, |
| 578 | 4749 Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4750 Lisp_Object signal_continuable_error (Lisp_Object, const Ascbyte *, |
| 563 | 4751 Lisp_Object); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4752 Lisp_Object maybe_signal_continuable_error (Lisp_Object, const Ascbyte *, |
| 563 | 4753 Lisp_Object, |
| 578 | 4754 Lisp_Object, Error_Behavior); |
| 1743 | 4755 DECLARE_DOESNT_RETURN (signal_ferror_with_frob (Lisp_Object, Lisp_Object, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4756 const Ascbyte *, ...)) |
| 1743 | 4757 PRINTF_ARGS(3, 4); |
| 563 | 4758 void maybe_signal_ferror_with_frob (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 4759 Error_Behavior, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4760 const Ascbyte *, ...) PRINTF_ARGS (5, 6); |
| 563 | 4761 Lisp_Object signal_continuable_ferror_with_frob (Lisp_Object, Lisp_Object, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4762 const Ascbyte *, |
| 563 | 4763 ...) PRINTF_ARGS (3, 4); |
| 4764 Lisp_Object maybe_signal_continuable_ferror_with_frob (Lisp_Object, | |
| 4765 Lisp_Object, | |
| 4766 Lisp_Object, | |
| 578 | 4767 Error_Behavior, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4768 const Ascbyte *, ...) |
| 442 | 4769 PRINTF_ARGS (5, 6); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4770 DECLARE_DOESNT_RETURN (signal_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 4771 Lisp_Object, Lisp_Object)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4772 void maybe_signal_error_2 (Lisp_Object, const Ascbyte *, Lisp_Object, |
| 578 | 4773 Lisp_Object, Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4774 Lisp_Object signal_continuable_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 4775 Lisp_Object, Lisp_Object); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4776 Lisp_Object maybe_signal_continuable_error_2 (Lisp_Object, const Ascbyte *, |
| 563 | 4777 Lisp_Object, Lisp_Object, |
| 4778 Lisp_Object, | |
| 578 | 4779 Error_Behavior); |
| 563 | 4780 |
| 4781 | |
| 1927 | 4782 MODULE_API DECLARE_DOESNT_RETURN (signal_malformed_list_error (Lisp_Object)); |
| 4783 MODULE_API DECLARE_DOESNT_RETURN (signal_malformed_property_list_error | |
| 4784 (Lisp_Object)); | |
| 4785 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_list_error (Lisp_Object)); | |
| 4786 MODULE_API DECLARE_DOESNT_RETURN (signal_circular_property_list_error | |
| 4787 (Lisp_Object)); | |
| 436 | 4788 |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4789 DECLARE_DOESNT_RETURN (syntax_error (const Ascbyte *reason, |
| 609 | 4790 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4791 DECLARE_DOESNT_RETURN (syntax_error_2 (const Ascbyte *reason, |
| 609 | 4792 Lisp_Object frob1, |
| 442 | 4793 Lisp_Object frob2)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4794 void maybe_syntax_error (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4795 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4796 DECLARE_DOESNT_RETURN (sferror (const Ascbyte *reason, Lisp_Object frob)); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4797 DECLARE_DOESNT_RETURN (sferror_2 (const Ascbyte *reason, Lisp_Object frob1, |
| 563 | 4798 Lisp_Object frob2)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4799 void maybe_sferror (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4800 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4801 MODULE_API DECLARE_DOESNT_RETURN (invalid_argument (const Ascbyte *reason, |
| 1632 | 4802 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4803 MODULE_API DECLARE_DOESNT_RETURN (invalid_argument_2 (const Ascbyte *reason, |
| 1632 | 4804 Lisp_Object frob1, |
| 4805 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4806 void maybe_invalid_argument (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4807 Error_Behavior); |
|
5084
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4808 MODULE_API DECLARE_DOESNT_RETURN (invalid_keyword_argument (Lisp_Object fun, |
|
6afe991b8135
Add a PARSE_KEYWORDS macro, use it in #'make-hash-table.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5077
diff
changeset
|
4809 Lisp_Object kw)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4810 MODULE_API DECLARE_DOESNT_RETURN (invalid_operation (const Ascbyte *reason, |
| 1632 | 4811 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4812 MODULE_API DECLARE_DOESNT_RETURN (invalid_operation_2 (const Ascbyte *reason, |
| 1632 | 4813 Lisp_Object frob1, |
| 4814 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4815 MODULE_API void maybe_invalid_operation (const Ascbyte *, Lisp_Object, |
| 1632 | 4816 Lisp_Object, Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4817 DECLARE_DOESNT_RETURN (invalid_state (const Ascbyte *reason, |
| 563 | 4818 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4819 DECLARE_DOESNT_RETURN (invalid_state_2 (const Ascbyte *reason, |
| 563 | 4820 Lisp_Object frob1, |
| 4821 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4822 void maybe_invalid_state (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 609 | 4823 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4824 DECLARE_DOESNT_RETURN (invalid_change (const Ascbyte *reason, |
| 563 | 4825 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4826 DECLARE_DOESNT_RETURN (invalid_change_2 (const Ascbyte *reason, |
| 563 | 4827 Lisp_Object frob1, |
| 4828 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4829 void maybe_invalid_change (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 609 | 4830 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4831 MODULE_API DECLARE_DOESNT_RETURN (invalid_constant (const Ascbyte *reason, |
| 1632 | 4832 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4833 DECLARE_DOESNT_RETURN (invalid_constant_2 (const Ascbyte *reason, |
| 563 | 4834 Lisp_Object frob1, |
| 4835 Lisp_Object frob2)); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4836 void maybe_invalid_constant (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 578 | 4837 Error_Behavior); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4838 DECLARE_DOESNT_RETURN (wtaerror (const Ascbyte *reason, Lisp_Object frob)); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4839 MODULE_API DECLARE_DOESNT_RETURN (out_of_memory (const Ascbyte *reason, |
| 1632 | 4840 Lisp_Object frob)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
4841 DECLARE_DOESNT_RETURN (stack_overflow (const Ascbyte *reason, |
| 442 | 4842 Lisp_Object frob)); |
| 4843 | |
| 436 | 4844 Lisp_Object signal_void_function_error (Lisp_Object); |
| 4845 Lisp_Object signal_invalid_function_error (Lisp_Object); | |
| 4846 Lisp_Object signal_wrong_number_of_arguments_error (Lisp_Object, int); | |
| 4847 | |
| 428 | 4848 Lisp_Object run_hook_with_args_in_buffer (struct buffer *, int, Lisp_Object *, |
| 4849 enum run_hooks_condition); | |
| 4850 Lisp_Object run_hook_with_args (int, Lisp_Object *, enum run_hooks_condition); | |
| 4851 void va_run_hook_with_args (Lisp_Object, int, ...); | |
| 4852 void va_run_hook_with_args_in_buffer (struct buffer *, Lisp_Object, int, ...); | |
| 4853 Lisp_Object run_hook (Lisp_Object); | |
| 1706 | 4854 MODULE_API Lisp_Object apply1 (Lisp_Object, Lisp_Object); |
| 4855 MODULE_API Lisp_Object call0 (Lisp_Object); | |
| 4856 MODULE_API Lisp_Object call1 (Lisp_Object, Lisp_Object); | |
| 4857 MODULE_API Lisp_Object call2 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4858 MODULE_API Lisp_Object call3 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4859 Lisp_Object); | |
| 4860 MODULE_API Lisp_Object call4 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4861 Lisp_Object, Lisp_Object); | |
| 4862 MODULE_API Lisp_Object call5 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4863 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4864 MODULE_API Lisp_Object call6 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4865 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4866 Lisp_Object); | |
| 4867 MODULE_API Lisp_Object call7 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4868 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4869 Lisp_Object, Lisp_Object); | |
| 4870 MODULE_API Lisp_Object call8 (Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4871 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4872 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 428 | 4873 Lisp_Object call0_in_buffer (struct buffer *, Lisp_Object); |
| 4874 Lisp_Object call1_in_buffer (struct buffer *, Lisp_Object, Lisp_Object); | |
| 4875 Lisp_Object call2_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4876 Lisp_Object); | |
| 4877 Lisp_Object call3_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4878 Lisp_Object, Lisp_Object); | |
| 4879 Lisp_Object call4_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4880 Lisp_Object, Lisp_Object, Lisp_Object); | |
| 4881 Lisp_Object call5_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4882 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4883 Lisp_Object); | |
| 4884 Lisp_Object call6_in_buffer (struct buffer *, Lisp_Object, Lisp_Object, | |
| 4885 Lisp_Object, Lisp_Object, Lisp_Object, | |
| 4886 Lisp_Object, Lisp_Object); | |
| 4887 Lisp_Object eval_in_buffer (struct buffer *, Lisp_Object); | |
| 853 | 4888 |
| 4889 struct call_trapping_problems_result | |
| 4890 { | |
| 4891 int caught_error, caught_throw; | |
| 4892 Lisp_Object error_conditions, data; | |
| 4893 Lisp_Object backtrace; | |
| 4894 Lisp_Object thrown_tag; | |
| 4895 Lisp_Object thrown_value; | |
| 4896 }; | |
| 4897 | |
| 4898 #define NO_INHIBIT_ERRORS (1<<0) | |
| 4899 #define NO_INHIBIT_THROWS (1<<1) | |
| 4900 #define INTERNAL_INHIBIT_ERRORS (1<<0) | |
| 4901 #define INTERNAL_INHIBIT_THROWS (1<<1) | |
| 4902 #define INHIBIT_WARNING_ISSUE (1<<2) | |
| 4903 #define ISSUE_WARNINGS_AT_DEBUG_LEVEL (1<<3) | |
| 4904 #define INHIBIT_QUIT (1<<4) | |
| 4905 #define UNINHIBIT_QUIT (1<<5) | |
| 4906 #define INHIBIT_GC (1<<6) | |
| 4907 #define INHIBIT_EXISTING_PERMANENT_DISPLAY_OBJECT_DELETION (1<<7) | |
| 4908 #define INHIBIT_EXISTING_CODING_SYSTEM_DELETION (1<<8) | |
| 4909 #define INHIBIT_EXISTING_CHARSET_DELETION (1<<9) | |
| 4910 #define INHIBIT_PERMANENT_DISPLAY_OBJECT_CREATION (1<<10) | |
| 4911 #define INHIBIT_CODING_SYSTEM_CREATION (1<<11) | |
| 4912 #define INHIBIT_CHARSET_CREATION (1<<12) | |
| 4913 #define INHIBIT_EXISTING_BUFFER_TEXT_MODIFICATION (1<<13) | |
| 4914 #define INHIBIT_ANY_CHANGE_AFFECTING_REDISPLAY (1<<14) | |
| 4915 #define INHIBIT_ENTERING_DEBUGGER (1<<15) | |
| 4916 #define CALL_WITH_SUSPENDED_ERRORS (1<<16) | |
| 1333 | 4917 #define POSTPONE_WARNING_ISSUE (1<<17) |
| 853 | 4918 |
| 4919 enum check_allowed_operation | |
| 4920 { | |
| 4921 OPERATION_DELETE_OBJECT, | |
| 4922 OPERATION_CREATE_OBJECT, | |
| 4923 OPERATION_MODIFY_BUFFER_TEXT, | |
| 1429 | 4924 OPERATION_MODIFY_OBJECT_PROPERTY |
| 853 | 4925 }; |
| 4926 | |
| 4927 int get_inhibit_flags (void); | |
| 4928 void check_allowed_operation (int what, Lisp_Object obj, Lisp_Object prop); | |
| 4929 void note_object_created (Lisp_Object obj); | |
| 4930 void note_object_deleted (Lisp_Object obj); | |
| 4931 Lisp_Object call_with_condition_handler (Lisp_Object (*handler) (Lisp_Object, | |
| 4932 Lisp_Object, | |
| 4933 Lisp_Object), | |
| 4934 Lisp_Object handler_arg, | |
| 4935 Lisp_Object (*fun) (Lisp_Object), | |
| 4936 Lisp_Object arg); | |
| 1318 | 4937 int set_trapping_problems_flags (int flags); |
| 853 | 4938 Lisp_Object call_trapping_problems (Lisp_Object warning_class, |
| 2367 | 4939 const Ascbyte *warning_string, |
| 853 | 4940 int flags, |
| 4941 struct call_trapping_problems_result | |
| 4942 *problem, | |
| 4943 Lisp_Object (*fun) (void *), | |
| 4944 void *arg); | |
| 4945 Lisp_Object va_call_trapping_problems (Lisp_Object warning_class, | |
| 2367 | 4946 const Ascbyte *warning_string, |
| 853 | 4947 int flags, |
| 4948 struct call_trapping_problems_result | |
| 4949 *problem, | |
| 4950 lisp_fn_t fun, int nargs, ...); | |
| 2367 | 4951 Lisp_Object call0_trapping_problems (const Ascbyte *, Lisp_Object, int); |
| 4952 Lisp_Object call1_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, | |
| 853 | 4953 int); |
| 2367 | 4954 Lisp_Object call2_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4955 Lisp_Object, int); |
| 2367 | 4956 Lisp_Object call3_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4957 Lisp_Object, Lisp_Object, int); |
| 2367 | 4958 Lisp_Object call4_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4959 Lisp_Object, Lisp_Object, Lisp_Object, |
| 4960 int); | |
| 2367 | 4961 Lisp_Object call5_trapping_problems (const Ascbyte *, Lisp_Object, Lisp_Object, |
| 853 | 4962 Lisp_Object, Lisp_Object, Lisp_Object, |
| 4963 Lisp_Object, int); | |
| 2367 | 4964 Lisp_Object eval_in_buffer_trapping_problems (const Ascbyte *, struct buffer *, |
| 853 | 4965 Lisp_Object, int); |
| 1333 | 4966 Lisp_Object run_hook_trapping_problems (Lisp_Object, Lisp_Object, int); |
| 4967 Lisp_Object safe_run_hook_trapping_problems (Lisp_Object, Lisp_Object, int); | |
| 4968 Lisp_Object run_hook_with_args_in_buffer_trapping_problems (Lisp_Object, | |
| 4969 struct buffer *, | |
| 4970 int nargs, | |
| 853 | 4971 Lisp_Object *args, |
| 4972 enum | |
| 4973 run_hooks_condition | |
| 4974 cond, int flags); | |
| 1333 | 4975 Lisp_Object run_hook_with_args_trapping_problems (Lisp_Object, |
| 853 | 4976 int nargs, |
| 4977 Lisp_Object *args, | |
| 4978 enum run_hooks_condition | |
| 4979 cond, | |
| 4980 int flags); | |
| 1333 | 4981 Lisp_Object va_run_hook_with_args_trapping_problems (Lisp_Object, |
| 853 | 4982 Lisp_Object hook_var, |
| 4983 int nargs, ...); | |
| 1333 | 4984 Lisp_Object va_run_hook_with_args_in_buffer_trapping_problems (Lisp_Object, |
| 4985 struct buffer *, | |
| 4986 Lisp_Object, | |
| 853 | 4987 int nargs, ...); |
| 4988 Lisp_Object call_with_suspended_errors (lisp_fn_t, Lisp_Object, | |
| 4989 Lisp_Object, | |
| 578 | 4990 Error_Behavior, int, ...); |
| 428 | 4991 /* C Code should be using internal_catch, record_unwind_p, condition_case_1 */ |
| 1318 | 4992 int proper_redisplay_wrapping_in_place (void); |
| 428 | 4993 Lisp_Object internal_catch (Lisp_Object, Lisp_Object (*) (Lisp_Object), |
| 853 | 4994 Lisp_Object, int * volatile, |
| 2532 | 4995 Lisp_Object * volatile, |
| 853 | 4996 Lisp_Object * volatile); |
| 428 | 4997 Lisp_Object condition_case_1 (Lisp_Object, |
| 4998 Lisp_Object (*) (Lisp_Object), | |
| 4999 Lisp_Object, | |
| 5000 Lisp_Object (*) (Lisp_Object, Lisp_Object), | |
| 5001 Lisp_Object); | |
| 5002 Lisp_Object condition_case_3 (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 1632 | 5003 MODULE_API Lisp_Object unbind_to_1 (int, Lisp_Object); |
| 771 | 5004 #define unbind_to(obj) unbind_to_1 (obj, Qnil) |
| 428 | 5005 void specbind (Lisp_Object, Lisp_Object); |
| 1632 | 5006 MODULE_API int record_unwind_protect (Lisp_Object (*) (Lisp_Object), |
| 5007 Lisp_Object); | |
| 771 | 5008 int record_unwind_protect_freeing_dynarr (void *ptr); |
| 1333 | 5009 int record_unwind_protect_restoring_int (int *addr, int val); |
| 802 | 5010 int internal_bind_int (int *addr, int newval); |
| 5011 int internal_bind_lisp_object (Lisp_Object *addr, Lisp_Object newval); | |
| 970 | 5012 void do_autoload (Lisp_Object, Lisp_Object); /* GCPROs both arguments */ |
| 428 | 5013 Lisp_Object un_autoload (Lisp_Object); |
| 5014 void warn_when_safe_lispobj (Lisp_Object, Lisp_Object, Lisp_Object); | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5015 MODULE_API void warn_when_safe (Lisp_Object, Lisp_Object, const Ascbyte *, |
| 1632 | 5016 ...) PRINTF_ARGS (3, 4); |
| 1292 | 5017 extern int backtrace_with_internal_sections; |
|
5307
c096d8051f89
Have NATNUMP give t for positive bignums; check limits appropriately.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5280
diff
changeset
|
5018 extern Fixnum Vmultiple_values_limit; |
| 428 | 5019 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5020 extern Lisp_Object Qand_optional; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5021 extern Lisp_Object Qand_rest; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5022 extern Lisp_Object Qautoload; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5023 extern Lisp_Object Qcommandp; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5024 extern Lisp_Object Qdefun; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5025 extern Lisp_Object Qexit; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5026 extern Lisp_Object Qinhibit_quit; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5027 extern Lisp_Object Qinteractive; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5028 extern Lisp_Object Qmacro; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5029 extern Lisp_Object Qprogn; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5030 extern Lisp_Object Qrun_hooks; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5031 extern Lisp_Object Qvalues; |
|
4841
3465c3161fea
when `debug', abort when lisp error during loadup
Ben Wing <ben@xemacs.org>
parents:
4805
diff
changeset
|
5032 extern Lisp_Object Vdebug_on_error; |
| 1315 | 5033 extern Lisp_Object Vstack_trace_on_error; |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5034 extern Lisp_Object Vautoload_queue; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5035 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5036 extern MODULE_API Lisp_Object Vinhibit_quit, Vquit_flag; |
| 428 | 5037 |
| 5038 /* Defined in event-stream.c */ | |
| 826 | 5039 EXFUN (Faccept_process_output, 3); |
| 5040 EXFUN (Fadd_timeout, 4); | |
| 5041 EXFUN (Fdisable_timeout, 1); | |
| 5042 EXFUN (Fdiscard_input, 0); | |
| 5043 EXFUN (Fdispatch_event, 1); | |
| 5044 EXFUN (Fenqueue_eval_event, 2); | |
| 5045 EXFUN (Fnext_event, 2); | |
| 5046 EXFUN (Fread_key_sequence, 3); | |
| 5047 EXFUN (Fsit_for, 2); | |
| 5048 EXFUN (Fsleep_for, 1); | |
| 5049 | |
| 428 | 5050 void wait_delaying_user_input (int (*) (void *), void *); |
| 1268 | 5051 int detect_input_pending (int how_many); |
| 428 | 5052 void reset_this_command_keys (Lisp_Object, int); |
| 5053 Lisp_Object enqueue_misc_user_event (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5054 Lisp_Object enqueue_misc_user_event_pos (Lisp_Object, Lisp_Object, | |
| 5055 Lisp_Object, int, int, int, int); | |
| 442 | 5056 extern int modifier_keys_are_sticky; |
| 428 | 5057 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5058 extern Lisp_Object Qdisabled; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5059 extern Lisp_Object Qsans_modifiers; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5060 extern Lisp_Object Qself_insert_defer_undo; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5061 extern Lisp_Object Vcontrolling_terminal; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5062 extern Lisp_Object Vcurrent_mouse_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5063 extern Lisp_Object Vlast_command; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5064 extern Lisp_Object Vlast_command_char; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5065 extern Lisp_Object Vlast_command_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5066 extern Lisp_Object Vlast_input_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5067 extern Lisp_Object Vrecent_keys_ring; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5068 extern Lisp_Object Vthis_command_keys; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5069 extern Lisp_Object Vunread_command_event; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5070 |
| 428 | 5071 /* Defined in event-Xt.c */ |
| 5072 void signal_special_Xt_user_event (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5073 | |
| 5074 | |
| 5075 /* Defined in events.c */ | |
| 826 | 5076 EXFUN (Fcopy_event, 2); |
| 2862 | 5077 EXFUN (Fevent_to_character, 4); |
| 826 | 5078 |
| 428 | 5079 void clear_event_resource (void); |
| 5080 Lisp_Object allocate_event (void); | |
| 5081 | |
| 771 | 5082 EXFUN (Fevent_x_pixel, 1); |
| 5083 EXFUN (Fevent_y_pixel, 1); | |
| 5084 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5085 extern Lisp_Object Qevent_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5086 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5087 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5088 /* Defined in extents.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5089 extern Lisp_Object Qend_open; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5090 extern Lisp_Object Qextent_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5091 extern Lisp_Object Qstart_open; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5092 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5093 /* Defined in faces.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5094 extern Lisp_Object Qbackground; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5095 extern Lisp_Object Qbackground_pixmap; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5096 extern Lisp_Object Qblinking; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5097 extern Lisp_Object Qdim; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5098 extern Lisp_Object Qdisplay_table; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5099 extern Lisp_Object Qforeground; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5100 extern Lisp_Object Qunderline; |
| 771 | 5101 |
| 5102 /* Defined in file-coding.c */ | |
| 5103 EXFUN (Fcoding_category_list, 0); | |
| 5104 EXFUN (Fcoding_category_system, 1); | |
| 5105 EXFUN (Fcoding_priority_list, 0); | |
| 5106 EXFUN (Fcoding_system_description, 1); | |
| 5107 EXFUN (Fcoding_system_documentation, 1); | |
| 5108 EXFUN (Fcoding_system_list, 1); | |
| 5109 EXFUN (Fcoding_system_name, 1); | |
| 5110 EXFUN (Fcoding_system_p, 1); | |
| 5111 EXFUN (Fcoding_system_property, 2); | |
| 5112 EXFUN (Fcoding_system_type, 1); | |
| 5113 EXFUN (Fcopy_coding_system, 2); | |
| 5114 EXFUN (Fdecode_big5_char, 1); | |
| 5115 EXFUN (Fdecode_coding_region, 4); | |
| 5116 EXFUN (Fdecode_shift_jis_char, 1); | |
| 5117 EXFUN (Fdefine_coding_system_alias, 2); | |
| 5118 EXFUN (Fdetect_coding_region, 3); | |
| 5119 EXFUN (Fdefault_encoding_detection_enabled_p, 0); | |
| 5120 EXFUN (Fencode_big5_char, 1); | |
| 5121 EXFUN (Fencode_coding_region, 4); | |
| 5122 EXFUN (Fencode_shift_jis_char, 1); | |
| 5123 EXFUN (Ffind_coding_system, 1); | |
| 5124 EXFUN (Fget_coding_system, 1); | |
|
4690
257b468bf2ca
Move the #'query-coding-region implementation to C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4682
diff
changeset
|
5125 EXFUN (Fmake_coding_system_internal, 4); |
| 771 | 5126 EXFUN (Fset_coding_category_system, 2); |
| 5127 EXFUN (Fset_coding_priority_list, 1); | |
| 5128 EXFUN (Fsubsidiary_coding_system, 2); | |
| 5129 | |
| 5130 extern Lisp_Object Qshift_jis, Qiso2022, Qbig5, Qccl; | |
| 5131 extern Lisp_Object Qcharset_g0; | |
| 5132 extern Lisp_Object Qcharset_g1, Qcharset_g2, Qcharset_g3, Qcoding_system_error; | |
| 5133 extern Lisp_Object Qcoding_systemp, Qcr, Qcrlf, Qdecode, Qencode; | |
| 5134 extern Lisp_Object Qeol_cr, Qeol_crlf, Qeol_lf, Qeol_type, Qescape_quoted; | |
| 5135 extern Lisp_Object Qforce_g0_on_output, Qforce_g1_on_output; | |
| 5136 extern Lisp_Object Qforce_g2_on_output, Qforce_g3_on_output; | |
| 5137 extern Lisp_Object Qinput_charset_conversion, Qlf, Qlock_shift; | |
| 5138 extern Lisp_Object Qmnemonic, Qno_ascii_cntl, Qno_ascii_eol; | |
| 5139 extern Lisp_Object Qno_conversion, Qraw_text; | |
| 5140 extern Lisp_Object Qno_iso6429, Qoutput_charset_conversion; | |
| 5141 extern Lisp_Object Qpost_read_conversion, Qpre_write_conversion, Qseven; | |
| 5142 extern Lisp_Object Qshort, Vcoding_system_for_read; | |
| 5143 extern Lisp_Object Vcoding_system_for_write; | |
| 5144 extern Lisp_Object Vfile_name_coding_system, Vkeyboard_coding_system; | |
| 5145 extern Lisp_Object Vterminal_coding_system; | |
| 5146 extern Lisp_Object Qcanonicalize_after_coding; | |
| 5147 int coding_system_is_for_text_file (Lisp_Object coding_system); | |
| 5148 Lisp_Object find_coding_system_for_text_file (Lisp_Object name, int eol_wrap); | |
| 1632 | 5149 MODULE_API Lisp_Object get_coding_system_for_text_file (Lisp_Object name, |
| 5150 int eol_wrap); | |
| 771 | 5151 int coding_system_is_binary (Lisp_Object coding_system); |
| 5152 | |
| 5153 | |
| 428 | 5154 /* Defined in fileio.c */ |
| 826 | 5155 EXFUN (Fdirectory_file_name, 1); |
| 5156 EXFUN (Fdo_auto_save, 2); | |
| 5157 EXFUN (Fexpand_file_name, 2); | |
| 5158 EXFUN (Ffile_accessible_directory_p, 1); | |
| 5159 EXFUN (Ffile_directory_p, 1); | |
| 5160 EXFUN (Ffile_executable_p, 1); | |
| 5161 EXFUN (Ffile_exists_p, 1); | |
| 5162 EXFUN (Ffile_name_absolute_p, 1); | |
| 5163 EXFUN (Ffile_name_as_directory, 1); | |
| 5164 EXFUN (Ffile_name_directory, 1); | |
| 5165 EXFUN (Ffile_name_nondirectory, 1); | |
| 5166 EXFUN (Ffile_readable_p, 1); | |
| 5167 EXFUN (Ffile_symlink_p, 1); | |
| 5168 EXFUN (Ffile_truename, 2); | |
| 5169 EXFUN (Ffind_file_name_handler, 2); | |
| 5170 EXFUN (Finsert_file_contents_internal, 7); | |
| 5171 EXFUN (Fmake_temp_name, 1); | |
| 5172 EXFUN (Fsubstitute_in_file_name, 1); | |
| 5173 EXFUN (Funhandled_file_name_directory, 1); | |
| 5174 EXFUN (Fverify_visited_file_modtime, 1); | |
| 5175 | |
| 428 | 5176 void record_auto_save (void); |
| 5177 void force_auto_save_soon (void); | |
| 563 | 5178 DECLARE_DOESNT_RETURN (report_error_with_errno (Lisp_Object errtype, |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5179 const Ascbyte *reason, |
| 563 | 5180 Lisp_Object data)); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5181 DECLARE_DOESNT_RETURN (report_file_error (const Ascbyte *, Lisp_Object)); |
| 428 | 5182 Lisp_Object lisp_strerror (int); |
| 5183 Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object); | |
| 5184 int internal_delete_file (Lisp_Object); | |
| 2526 | 5185 Ibyte *find_end_of_directory_component (const Ibyte *path, |
| 5186 Bytecount len); | |
| 428 | 5187 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5188 extern Lisp_Object Qfile_name_sans_extension; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5189 extern Lisp_Object Vdirectory_sep_char; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5190 |
| 428 | 5191 /* Defined in filelock.c */ |
| 826 | 5192 EXFUN (Funlock_buffer, 0); |
| 5193 | |
| 428 | 5194 void lock_file (Lisp_Object); |
| 5195 void unlock_file (Lisp_Object); | |
| 5196 void unlock_all_files (void); | |
| 5197 void unlock_buffer (struct buffer *); | |
| 5198 | |
| 5199 /* Defined in floatfns.c */ | |
|
4678
b5e1d4f6b66f
Make #'floor, #'ceiling, #'round, #'truncate conform to Common Lisp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4677
diff
changeset
|
5200 EXFUN (Ftruncate, 2); |
| 826 | 5201 |
| 428 | 5202 double extract_float (Lisp_Object); |
| 5203 | |
| 5204 /* Defined in fns.c */ | |
| 1632 | 5205 MODULE_API EXFUN (Fappend, MANY); |
| 826 | 5206 EXFUN (Fassoc, 2); |
| 5207 EXFUN (Fassq, 2); | |
| 5208 EXFUN (Fcanonicalize_lax_plist, 2); | |
| 5209 EXFUN (Fcanonicalize_plist, 2); | |
| 5210 EXFUN (Fcheck_valid_plist, 1); | |
| 5211 EXFUN (Fconcat, MANY); | |
| 5212 EXFUN (Fcopy_alist, 1); | |
| 5213 EXFUN (Fcopy_list, 1); | |
| 5214 EXFUN (Fcopy_sequence, 1); | |
| 5215 EXFUN (Fcopy_tree, 2); | |
| 5216 EXFUN (Fdestructive_alist_to_plist, 1); | |
| 5217 EXFUN (Felt, 2); | |
| 1632 | 5218 MODULE_API EXFUN (Fequal, 2); |
| 5219 MODULE_API EXFUN (Fget, 3); | |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4888
diff
changeset
|
5220 MODULE_API EXFUN (Feqlsign, MANY); |
|
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4888
diff
changeset
|
5221 MODULE_API EXFUN (Fequalp, 2); |
| 826 | 5222 EXFUN (Flast, 2); |
| 5223 EXFUN (Flax_plist_get, 3); | |
| 5224 EXFUN (Flax_plist_remprop, 2); | |
| 1632 | 5225 MODULE_API EXFUN (Flength, 1); |
|
4995
8431b52e43b1
Move the various map* functions to C; add #'map-into.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4888
diff
changeset
|
5226 EXFUN (FmapcarX, MANY); |
| 826 | 5227 EXFUN (Fmember, 2); |
| 5228 EXFUN (Fmemq, 2); | |
| 5229 EXFUN (Fnconc, MANY); | |
| 1632 | 5230 MODULE_API EXFUN (Fnreverse, 1); |
| 826 | 5231 EXFUN (Fnthcdr, 2); |
| 5232 EXFUN (Fold_assq, 2); | |
| 5233 EXFUN (Fold_equal, 2); | |
| 5234 EXFUN (Fold_member, 2); | |
| 5235 EXFUN (Fold_memq, 2); | |
| 5236 EXFUN (Fplist_get, 3); | |
| 5237 EXFUN (Fplist_member, 2); | |
| 5238 EXFUN (Fplist_put, 3); | |
| 1632 | 5239 MODULE_API EXFUN (Fprovide, 1); |
| 5240 MODULE_API EXFUN (Fput, 3); | |
| 826 | 5241 EXFUN (Frassq, 2); |
| 5242 EXFUN (Fremassq, 2); | |
| 5243 EXFUN (Freplace_list, 2); | |
| 1632 | 5244 MODULE_API EXFUN (Freverse, 1); |
| 1268 | 5245 EXFUN (Fsafe_length, 1); |
| 826 | 5246 EXFUN (Fstring_equal, 2); |
| 5247 EXFUN (Fstring_lessp, 2); | |
|
5089
99f8ebc082d9
Make #'substring an alias of #'subseq; give the latter the byte code.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5084
diff
changeset
|
5248 EXFUN (Fsubseq, 3); |
| 826 | 5249 EXFUN (Fvalid_plist_p, 1); |
| 5250 | |
|
5350
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5251 extern Boolint check_lss_key_car (Lisp_Object, Lisp_Object, Lisp_Object, |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5252 Lisp_Object); |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5253 extern Boolint check_string_lessp_nokey (Lisp_Object, Lisp_Object, |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5254 Lisp_Object, Lisp_Object); |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5255 |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5256 typedef Boolint (*check_test_func_t) (Lisp_Object test, Lisp_Object key, |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5257 Lisp_Object item, Lisp_Object elt); |
|
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5258 |
|
5182
2e528066e2fc
Move #'sort*, #'fill, #'merge to C from cl-seq.el.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5181
diff
changeset
|
5259 Lisp_Object list_merge (Lisp_Object org_l1, Lisp_Object org_l2, |
|
5350
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5260 check_test_func_t check_merge, |
|
5182
2e528066e2fc
Move #'sort*, #'fill, #'merge to C from cl-seq.el.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5181
diff
changeset
|
5261 Lisp_Object predicate, Lisp_Object key_func); |
|
2e528066e2fc
Move #'sort*, #'fill, #'merge to C from cl-seq.el.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5181
diff
changeset
|
5262 Lisp_Object list_sort (Lisp_Object list, |
|
5350
94bbd4792049
Have #'sort*, #'merge use the same test approach as functions from cl-seq.el
Aidan Kehoe <kehoea@parhasard.net>
parents:
5348
diff
changeset
|
5263 check_test_func_t check_merge, |
|
5182
2e528066e2fc
Move #'sort*, #'fill, #'merge to C from cl-seq.el.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5181
diff
changeset
|
5264 Lisp_Object predicate, Lisp_Object key_func); |
| 428 | 5265 |
| 5266 void bump_string_modiff (Lisp_Object); | |
| 5267 Lisp_Object memq_no_quit (Lisp_Object, Lisp_Object); | |
| 5268 Lisp_Object assoc_no_quit (Lisp_Object, Lisp_Object); | |
| 5269 Lisp_Object assq_no_quit (Lisp_Object, Lisp_Object); | |
| 5270 Lisp_Object rassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5271 Lisp_Object delq_no_quit (Lisp_Object, Lisp_Object); | |
| 5272 Lisp_Object delq_no_quit_and_free_cons (Lisp_Object, Lisp_Object); | |
| 5273 Lisp_Object remassoc_no_quit (Lisp_Object, Lisp_Object); | |
| 5274 Lisp_Object remassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5275 Lisp_Object remrassq_no_quit (Lisp_Object, Lisp_Object); | |
| 5276 | |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4888
diff
changeset
|
5277 int plists_differ (Lisp_Object, Lisp_Object, int, int, int, int); |
| 428 | 5278 Lisp_Object internal_plist_get (Lisp_Object, Lisp_Object); |
| 5279 void internal_plist_put (Lisp_Object *, Lisp_Object, Lisp_Object); | |
| 5280 int internal_remprop (Lisp_Object *, Lisp_Object); | |
| 5281 Lisp_Object external_plist_get (Lisp_Object *, Lisp_Object, | |
| 578 | 5282 int, Error_Behavior); |
| 428 | 5283 void external_plist_put (Lisp_Object *, Lisp_Object, |
| 578 | 5284 Lisp_Object, int, Error_Behavior); |
| 5285 int external_remprop (Lisp_Object *, Lisp_Object, int, Error_Behavior); | |
| 853 | 5286 int internal_equal_trapping_problems (Lisp_Object warning_class, |
| 2367 | 5287 const Ascbyte *warning_string, |
| 853 | 5288 int flags, |
| 5289 struct call_trapping_problems_result *p, | |
| 5290 int retval, | |
| 5291 Lisp_Object obj1, Lisp_Object obj2, | |
| 5292 int depth); | |
| 428 | 5293 int internal_equal (Lisp_Object, Lisp_Object, int); |
| 801 | 5294 int internal_equalp (Lisp_Object obj1, Lisp_Object obj2, int depth); |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5295 Lisp_Object MODULE_API concat2 (Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5296 Lisp_Object MODULE_API concat3 (Lisp_Object, Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5297 Lisp_Object MODULE_API vconcat2 (Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5298 Lisp_Object MODULE_API vconcat3 (Lisp_Object, Lisp_Object, Lisp_Object); |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5299 Lisp_Object MODULE_API nconc2 (Lisp_Object, Lisp_Object); |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4888
diff
changeset
|
5300 int internal_equal_0 (Lisp_Object, Lisp_Object, int, int); |
| 428 | 5301 Lisp_Object bytecode_nconc2 (Lisp_Object *); |
|
4910
6bc1f3f6cf0d
Make canoncase visible to Lisp; use it with chars in internal_equalp.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4906
diff
changeset
|
5302 int bytecode_arithcompare (Lisp_Object obj1, Lisp_Object obj2); |
|
5000
44d7bde26046
fix compile errors, fix revert-buffer bug on binary/Latin 1 files, Mule-ize some files
Ben Wing <ben@xemacs.org>
parents:
4982
diff
changeset
|
5303 void check_losing_bytecode (const Ascbyte *, Lisp_Object); |
| 428 | 5304 |
| 771 | 5305 Lisp_Object add_suffix_to_symbol (Lisp_Object symbol, |
| 2367 | 5306 const Ascbyte *ascii_string); |
| 5307 Lisp_Object add_prefix_to_symbol (const Ascbyte *ascii_string, | |
| 771 | 5308 Lisp_Object symbol); |
| 5309 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5310 extern Lisp_Object Qidentity; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5311 extern Lisp_Object Qstring_lessp; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5312 extern Lisp_Object Qyes_or_no_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5313 extern Lisp_Object Vfeatures; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5314 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5315 /* Defined in frame.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5316 extern Lisp_Object Qframe_live_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5317 |
| 826 | 5318 /* Defined in free-hook.c */ |
| 5319 EXFUN (Freally_free, 1); | |
| 5320 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5321 /* Defined in general.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5322 #define SYMBOL(fou) extern Lisp_Object fou |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5323 #define SYMBOL_MODULE_API(fou) extern MODULE_API Lisp_Object fou |
|
5320
31be2a3d121d
Move Qcount, Q_default, Q_test to general-slots.h; add SYMBOL_KEYWORD_GENERAL()
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
5324 #define SYMBOL_KEYWORD(la_cle_est_folle) extern Lisp_Object la_cle_est_folle |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5325 #define SYMBOL_GENERAL(tout_le_monde, est_fou) \ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5326 extern Lisp_Object tout_le_monde |
|
5320
31be2a3d121d
Move Qcount, Q_default, Q_test to general-slots.h; add SYMBOL_KEYWORD_GENERAL()
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
5327 #define SYMBOL_KEYWORD_GENERAL(y_compris_ben, mais_que_peut_on_faire) \ |
|
31be2a3d121d
Move Qcount, Q_default, Q_test to general-slots.h; add SYMBOL_KEYWORD_GENERAL()
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
5328 extern Lisp_Object y_compris_ben |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5329 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5330 #include "general-slots.h" |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5331 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5332 #undef SYMBOL |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5333 #undef SYMBOL_MODULE_API |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5334 #undef SYMBOL_KEYWORD |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5335 #undef SYMBOL_GENERAL |
|
5320
31be2a3d121d
Move Qcount, Q_default, Q_test to general-slots.h; add SYMBOL_KEYWORD_GENERAL()
Aidan Kehoe <kehoea@parhasard.net>
parents:
5307
diff
changeset
|
5336 #undef SYMBOL_KEYWORD_GENERAL |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5337 |
|
5191
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
5338 extern Lisp_Object Qeq; |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
5339 extern Lisp_Object Qeql; |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
5340 extern Lisp_Object Qequal; |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
5341 extern Lisp_Object Qequalp; |
|
71ee43b8a74d
Add #'equalp as a hash test by default; add #'define-hash-table-test, GNU API
Aidan Kehoe <kehoea@parhasard.net>
parents:
5190
diff
changeset
|
5342 |
| 428 | 5343 /* Defined in glyphs.c */ |
| 826 | 5344 EXFUN (Fmake_glyph_internal, 1); |
| 5345 | |
| 578 | 5346 Error_Behavior decode_error_behavior_flag (Lisp_Object); |
| 5347 Lisp_Object encode_error_behavior_flag (Error_Behavior); | |
| 428 | 5348 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5349 extern Lisp_Object Qbuffer_glyph_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5350 extern Lisp_Object Qcolor_pixmap_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5351 extern Lisp_Object Qicon_glyph_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5352 extern Lisp_Object Qmono_pixmap_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5353 extern Lisp_Object Qnothing_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5354 extern Lisp_Object Qpointer_glyph_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5355 extern Lisp_Object Qpointer_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5356 extern Lisp_Object Qsubwindow; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5357 extern Lisp_Object Qsubwindow_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5358 extern Lisp_Object Qtext_image_instance_p; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5359 |
| 563 | 5360 /* Defined in glyphs-shared.c */ |
| 5361 void shared_resource_validate (Lisp_Object instantiator); | |
| 5362 Lisp_Object shared_resource_normalize (Lisp_Object inst, | |
| 5363 Lisp_Object console_type, | |
| 5364 Lisp_Object dest_mask, | |
| 5365 Lisp_Object tag); | |
| 5366 extern Lisp_Object Q_resource_type, Q_resource_id; | |
| 5367 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5368 /* Defined in glyphs-widget.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5369 extern Lisp_Object Qlayout; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5370 extern Lisp_Object Qnative_layout; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5371 |
| 563 | 5372 /* Defined in gui.c */ |
| 2367 | 5373 DECLARE_DOESNT_RETURN (gui_error (const Ascbyte *reason, |
| 563 | 5374 Lisp_Object frob)); |
| 2367 | 5375 DECLARE_DOESNT_RETURN (gui_error_2 (const Ascbyte *reason, |
| 569 | 5376 Lisp_Object frob0, Lisp_Object frob1)); |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5377 extern Lisp_Object Qgui_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5378 |
| 428 | 5379 /* Defined in indent.c */ |
| 826 | 5380 EXFUN (Findent_to, 3); |
| 5381 EXFUN (Fvertical_motion, 3); | |
| 5382 | |
| 5383 int byte_spaces_at_point (struct buffer *, Bytebpos); | |
| 665 | 5384 int column_at_point (struct buffer *, Charbpos, int); |
| 793 | 5385 int string_column_at_point (Lisp_Object, Charbpos, int); |
| 428 | 5386 int current_column (struct buffer *); |
| 5387 void invalidate_current_column (void); | |
| 665 | 5388 Charbpos vmotion (struct window *, Charbpos, int, int *); |
| 5389 Charbpos vmotion_pixels (Lisp_Object, Charbpos, int, int, int *); | |
| 428 | 5390 |
| 771 | 5391 /* Defined in insdel.c */ |
| 5392 void set_buffer_point (struct buffer *buf, Charbpos pos, Bytebpos bipos); | |
| 5393 | |
| 826 | 5394 /* Defined in intl.c */ |
| 5395 EXFUN (Fgettext, 1); | |
| 5396 | |
| 428 | 5397 /* Defined in keymap.c */ |
| 826 | 5398 EXFUN (Fdefine_key, 3); |
| 5399 EXFUN (Fkey_description, 1); | |
| 5400 EXFUN (Flookup_key, 3); | |
| 5401 EXFUN (Fmake_sparse_keymap, 1); | |
| 5402 | |
| 793 | 5403 void where_is_to_char (Lisp_Object, Eistring *); |
| 428 | 5404 |
| 5405 /* Defined in lread.c */ | |
| 826 | 5406 EXFUN (Fread, 1); |
| 5407 | |
| 428 | 5408 void ebolify_bytecode_constants (Lisp_Object); |
| 5409 void close_load_descs (void); | |
| 5410 int locate_file (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, int); | |
| 5411 EXFUN (Flocate_file_clear_hashing, 1); | |
| 442 | 5412 int isfloat_string (const char *); |
| 1983 | 5413 int isratio_string (const char *); |
| 428 | 5414 |
| 5415 /* Well, I've decided to enable this. -- ben */ | |
| 5416 /* And I've decided to make it work right. -- sb */ | |
| 5417 #define LOADHIST | |
| 5418 /* Define the following symbol to enable load history of dumped files */ | |
| 5419 #define LOADHIST_DUMPED | |
| 5420 /* Define the following symbol to enable load history of C source */ | |
| 5421 #define LOADHIST_BUILTIN | |
| 5422 | |
| 5423 #ifdef LOADHIST /* this is just a stupid idea */ | |
| 5424 #define LOADHIST_ATTACH(x) \ | |
| 5425 do { if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); } \ | |
| 5426 while (0) | |
| 5427 #else /*! LOADHIST */ | |
| 5428 # define LOADHIST_ATTACH(x) | |
| 5429 #endif /*! LOADHIST */ | |
| 5430 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5431 extern Lisp_Object Qfeaturep; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5432 extern Lisp_Object Qload; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5433 extern Lisp_Object Qread_char; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5434 extern Lisp_Object Qstandard_input; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5435 extern Lisp_Object Vcurrent_load_list; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5436 extern Lisp_Object Vfile_domain; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5437 extern Lisp_Object Vload_file_name_internal; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5438 extern Lisp_Object Vload_history; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5439 extern Lisp_Object Vload_path; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5440 extern Lisp_Object Vstandard_input; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5441 |
| 826 | 5442 /* Defined in macros.c */ |
| 5443 EXFUN (Fexecute_kbd_macro, 2); | |
| 5444 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5445 extern Lisp_Object Vexecuting_macro; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5446 |
| 428 | 5447 /* Defined in marker.c */ |
| 826 | 5448 EXFUN (Fcopy_marker, 2); |
| 5449 EXFUN (Fmake_marker, 0); | |
| 5450 EXFUN (Fmarker_buffer, 1); | |
| 5451 EXFUN (Fmarker_position, 1); | |
| 5452 EXFUN (Fset_marker, 3); | |
| 5453 EXFUN (Fset_marker_insertion_type, 2); | |
| 5454 | |
| 5455 Bytebpos byte_marker_position (Lisp_Object); | |
| 665 | 5456 Charbpos marker_position (Lisp_Object); |
| 826 | 5457 void set_byte_marker_position (Lisp_Object, Bytebpos); |
| 665 | 5458 void set_marker_position (Lisp_Object, Charbpos); |
| 428 | 5459 void unchain_marker (Lisp_Object); |
| 5460 Lisp_Object noseeum_copy_marker (Lisp_Object, Lisp_Object); | |
| 5461 Lisp_Object set_marker_restricted (Lisp_Object, Lisp_Object, Lisp_Object); | |
| 5462 #ifdef MEMORY_USAGE_STATS | |
|
5170
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
5463 Bytecount compute_buffer_marker_usage (struct buffer *b); |
| 428 | 5464 #endif |
| 771 | 5465 void init_buffer_markers (struct buffer *b); |
| 5466 void uninit_buffer_markers (struct buffer *b); | |
| 428 | 5467 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5468 /* Defined in menubar.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5469 extern Lisp_Object Qactivate_menubar_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5470 extern Lisp_Object Qcurrent_menubar; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5471 extern Lisp_Object Vactivate_menubar_hook; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5472 extern Lisp_Object Vblank_menubar; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5473 extern Lisp_Object Vmenubar_configuration; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5474 |
| 428 | 5475 /* Defined in minibuf.c */ |
| 5476 extern int minibuf_level; | |
| 867 | 5477 Charcount scmp_1 (const Ibyte *, const Ibyte *, Charcount, int); |
| 428 | 5478 #define scmp(s1, s2, len) scmp_1 (s1, s2, len, completion_ignore_case) |
| 5479 extern int completion_ignore_case; | |
| 867 | 5480 int regexp_ignore_completion_p (const Ibyte *, Lisp_Object, |
| 428 | 5481 Bytecount, Bytecount); |
| 5482 Lisp_Object clear_echo_area (struct frame *, Lisp_Object, int); | |
| 5483 Lisp_Object clear_echo_area_from_print (struct frame *, Lisp_Object, int); | |
| 867 | 5484 void echo_area_append (struct frame *, const Ibyte *, Lisp_Object, |
| 428 | 5485 Bytecount, Bytecount, Lisp_Object); |
| 867 | 5486 void echo_area_message (struct frame *, const Ibyte *, Lisp_Object, |
| 428 | 5487 Bytecount, Bytecount, Lisp_Object); |
| 5488 Lisp_Object echo_area_status (struct frame *); | |
| 5489 int echo_area_active (struct frame *); | |
| 5490 Lisp_Object echo_area_contents (struct frame *); | |
| 867 | 5491 void message_internal (const Ibyte *, Lisp_Object, Bytecount, Bytecount); |
| 5492 void message_append_internal (const Ibyte *, Lisp_Object, | |
| 428 | 5493 Bytecount, Bytecount); |
| 1632 | 5494 MODULE_API void message (const char *, ...) PRINTF_ARGS (1, 2); |
| 442 | 5495 void message_append (const char *, ...) PRINTF_ARGS (1, 2); |
| 5496 void message_no_translate (const char *, ...) PRINTF_ARGS (1, 2); | |
| 428 | 5497 void clear_message (void); |
| 5498 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5499 extern Lisp_Object Qcompletion_ignore_case; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5500 extern Lisp_Object Vecho_area_buffer; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5501 extern Lisp_Object Vminibuf_preprompt; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5502 extern Lisp_Object Vminibuf_prompt; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5503 extern Lisp_Object Vminibuffer_zero; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5504 |
| 771 | 5505 /* Defined in mule-charset.c */ |
| 826 | 5506 EXFUN (Fmake_charset, 3); |
| 5507 | |
| 771 | 5508 extern Lisp_Object Ql2r, Qr2l; |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5509 extern Lisp_Object Qdirection; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5510 extern Lisp_Object Qfinal; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5511 extern Lisp_Object Qgraphic; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5512 extern Lisp_Object Qlong_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5513 extern Lisp_Object Qregistries; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5514 extern Lisp_Object Qreverse_direction_charset; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5515 extern Lisp_Object Qshort_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5516 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5517 /* Defined in nt.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5518 extern Lisp_Object Vmswindows_get_true_file_attributes; |
| 771 | 5519 |
| 428 | 5520 /* Defined in print.c */ |
| 826 | 5521 EXFUN (Fdisplay_error, 2); |
| 5522 EXFUN (Ferror_message_string, 1); | |
| 5523 EXFUN (Fprin1, 2); | |
| 5524 EXFUN (Fprin1_to_string, 2); | |
| 5525 EXFUN (Fprinc, 2); | |
| 5526 EXFUN (Fprint, 2); | |
| 5527 | |
|
4394
cacc942c0d0f
Avoid clearing print-gensym-alist inappropriately when printing hash tables.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4355
diff
changeset
|
5528 Lisp_Object prin1_to_string (Lisp_Object, int); |
| 771 | 5529 |
| 5530 /* Lower-level ways to output data: */ | |
| 3085 | 5531 void default_object_printer (Lisp_Object, Lisp_Object, int); |
| 771 | 5532 void print_internal (Lisp_Object, Lisp_Object, int); |
| 428 | 5533 void debug_print (Lisp_Object); |
| 1204 | 5534 void debug_p4 (Lisp_Object obj); |
| 5535 void debug_p3 (Lisp_Object obj); | |
| 5536 void debug_short_backtrace (int); | |
| 5537 void debug_backtrace (void); | |
| 428 | 5538 /* NOTE: Do not call this with the data of a Lisp_String. Use princ. |
| 5539 * Note: stream should be defaulted before calling | |
| 5540 * (eg Qnil means stdout, not Vstandard_output, etc) */ | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5541 MODULE_API void write_istring (Lisp_Object stream, const Ibyte *str); |
| 771 | 5542 /* Same goes for this function. */ |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
5543 MODULE_API void write_cistring (Lisp_Object stream, const CIbyte *str); |
| 771 | 5544 /* Same goes for this function. */ |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4932
diff
changeset
|
5545 MODULE_API void write_ascstring (Lisp_Object stream, const Ascbyte *str); |
| 428 | 5546 /* Same goes for this function. */ |
| 867 | 5547 void write_string_1 (Lisp_Object stream, const Ibyte *str, Bytecount size); |
| 826 | 5548 void write_eistring (Lisp_Object stream, const Eistring *ei); |
| 771 | 5549 |
| 5550 /* Higher-level (printf-style) ways to output data: */ | |
| 1632 | 5551 MODULE_API void write_fmt_string (Lisp_Object stream, const CIbyte *fmt, ...); |
| 5552 MODULE_API void write_fmt_string_lisp (Lisp_Object stream, const CIbyte *fmt, | |
| 5553 int nargs, ...); | |
| 867 | 5554 void stderr_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); |
| 5555 void stderr_out_lisp (const CIbyte *, int nargs, ...); | |
| 5556 void stdout_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); | |
| 1346 | 5557 void external_out (int dest, const CIbyte *fmt, ...) PRINTF_ARGS (2, 3); |
| 867 | 5558 void debug_out (const CIbyte *, ...) PRINTF_ARGS (1, 2); |
|
5189
b65692aa90d8
Cosmetic XFT-code fixes, some variable renamings
Ben Wing <ben@xemacs.org>
parents:
5181
diff
changeset
|
5559 void debug_out_lisp (const CIbyte *, int nargs, ...); |
| 1743 | 5560 DECLARE_DOESNT_RETURN (fatal (const CIbyte *, ...)) PRINTF_ARGS(1, 2); |
| 771 | 5561 |
| 5562 /* Internal functions: */ | |
| 1261 | 5563 Lisp_Object canonicalize_printcharfun (Lisp_Object printcharfun); |
| 771 | 5564 void temp_output_buffer_setup (Lisp_Object); |
| 5565 void temp_output_buffer_show (Lisp_Object, Lisp_Object); | |
| 428 | 5566 void print_cons (Lisp_Object, Lisp_Object, int); |
| 5567 void print_vector (Lisp_Object, Lisp_Object, int); | |
| 5568 void print_string (Lisp_Object, Lisp_Object, int); | |
| 771 | 5569 void print_symbol (Lisp_Object, Lisp_Object, int); |
| 5570 void print_float (Lisp_Object, Lisp_Object, int); | |
| 603 | 5571 /* The number of bytes required to store the decimal printed |
| 5572 representation of an integral type. Add a few bytes for truncation, | |
| 5573 optional sign prefix, and null byte terminator. | |
| 614 | 5574 2.40824 == log (256) / log (10). |
| 5575 | |
| 5576 We don't use floating point since Sun cc (buggily?) cannot use | |
| 5577 floating point computations to define a compile-time integral | |
| 5578 constant. */ | |
| 603 | 5579 #define DECIMAL_PRINT_SIZE(integral_type) \ |
| 614 | 5580 (((2410824 * sizeof (integral_type)) / 1000000) + 3) |
| 577 | 5581 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
|
5582 void ulong_to_bit_string (char *, unsigned long); |
| 428 | 5583 extern int print_escape_newlines; |
| 1632 | 5584 extern MODULE_API int print_readably; |
|
4880
ae81a2c00f4f
try harder to avoid crashing when debug-printing
Ben Wing <ben@xemacs.org>
parents:
4854
diff
changeset
|
5585 extern int in_debug_print; |
| 428 | 5586 Lisp_Object internal_with_output_to_temp_buffer (Lisp_Object, |
| 5587 Lisp_Object (*) (Lisp_Object), | |
| 5588 Lisp_Object, Lisp_Object); | |
| 5589 void float_to_string (char *, double); | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
5590 void internal_object_printer (Lisp_Object obj, Lisp_Object printcharfun, |
|
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
diff
changeset
|
5591 int UNUSED (escapeflag)); |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
5592 void external_object_printer (Lisp_Object obj, Lisp_Object printcharfun, |
|
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3063
diff
changeset
|
5593 int UNUSED (escapeflag)); |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
5594 MODULE_API DECLARE_DOESNT_RETURN (printing_unreadable_object_fmt (const CIbyte *, |
| 4846 | 5595 ...)) |
| 5596 PRINTF_ARGS (1, 2); | |
|
5142
f965e31a35f0
reduce lcrecord headers to 2 words, rename printing_unreadable_object
Ben Wing <ben@xemacs.org>
parents:
5128
diff
changeset
|
5597 DECLARE_DOESNT_RETURN (printing_unreadable_lisp_object (Lisp_Object obj, |
| 4846 | 5598 const Ibyte *name)); |
| 428 | 5599 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5600 extern Lisp_Object Qexternal_debugging_output; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5601 extern Lisp_Object Qprint_length; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5602 extern Lisp_Object Qprint_string_length; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5603 extern Lisp_Object Qstandard_output; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5604 extern Lisp_Object Vprint_length; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5605 extern Lisp_Object Vprint_level; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5606 extern Lisp_Object Vstandard_output; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5607 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5608 /* Defined in process.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5609 extern Lisp_Object Qnetwork_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5610 extern MODULE_API Lisp_Object Qprocess_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5611 extern Lisp_Object Vprocess_environment; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5612 extern Lisp_Object Vshell_file_name; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5613 |
| 428 | 5614 /* Defined in rangetab.c */ |
| 826 | 5615 EXFUN (Fclear_range_table, 1); |
| 5616 EXFUN (Fget_range_table, 3); | |
| 2421 | 5617 EXFUN (Fmake_range_table, 1); |
| 826 | 5618 EXFUN (Fput_range_table, 4); |
|
4690
257b468bf2ca
Move the #'query-coding-region implementation to C.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4682
diff
changeset
|
5619 EXFUN (Fcopy_range_table, 1); |
| 826 | 5620 |
| 2421 | 5621 extern Lisp_Object Qstart_closed_end_open; |
| 5622 extern Lisp_Object Qstart_open_end_open; | |
| 5623 extern Lisp_Object Qstart_closed_end_closed; | |
| 5624 extern Lisp_Object Qstart_open_end_closed; | |
| 5625 | |
| 428 | 5626 void put_range_table (Lisp_Object, EMACS_INT, EMACS_INT, Lisp_Object); |
| 5627 int unified_range_table_bytes_needed (Lisp_Object); | |
| 5628 int unified_range_table_bytes_used (void *); | |
| 5629 void unified_range_table_copy_data (Lisp_Object, void *); | |
| 5630 Lisp_Object unified_range_table_lookup (void *, EMACS_INT, Lisp_Object); | |
| 5631 int unified_range_table_nentries (void *); | |
| 5632 void unified_range_table_get_range (void *, int, EMACS_INT *, EMACS_INT *, | |
| 5633 Lisp_Object *); | |
| 5634 | |
| 5635 /* Defined in search.c */ | |
| 826 | 5636 EXFUN (Fmatch_beginning, 1); |
| 5637 EXFUN (Fmatch_end, 1); | |
| 5638 EXFUN (Fskip_chars_backward, 3); | |
| 5639 EXFUN (Fskip_chars_forward, 3); | |
| 5640 EXFUN (Fstring_match, 4); | |
|
4960
45b6288416e3
slight cleanup, move EXFUN of regexp-quote to lisp.h
Ben Wing <ben@xemacs.org>
parents:
4957
diff
changeset
|
5641 EXFUN (Fregexp_quote, 1); |
| 826 | 5642 |
| 428 | 5643 struct re_pattern_buffer; |
| 5644 struct re_registers; | |
| 867 | 5645 Charbpos scan_buffer (struct buffer *, Ichar, Charbpos, Charbpos, EMACS_INT, |
| 826 | 5646 EMACS_INT *, int); |
| 665 | 5647 Charbpos find_next_newline (struct buffer *, Charbpos, int); |
| 5648 Charbpos find_next_newline_no_quit (struct buffer *, Charbpos, int); | |
| 826 | 5649 Bytebpos byte_find_next_newline_no_quit (struct buffer *, Bytebpos, int); |
| 867 | 5650 Bytecount byte_find_next_ichar_in_string (Lisp_Object, Ichar, Bytecount, |
| 826 | 5651 EMACS_INT); |
| 665 | 5652 Charbpos find_before_next_newline (struct buffer *, Charbpos, Charbpos, int); |
| 826 | 5653 struct re_pattern_buffer *compile_pattern (Lisp_Object pattern, |
| 5654 struct re_registers *regp, | |
| 5655 Lisp_Object translate, | |
| 5656 Lisp_Object searchobj, | |
| 5657 struct buffer *searchbuf, | |
| 5658 int posix, Error_Behavior errb); | |
| 867 | 5659 Bytecount fast_string_match (Lisp_Object, const Ibyte *, |
| 428 | 5660 Lisp_Object, Bytecount, |
| 578 | 5661 Bytecount, int, Error_Behavior, int); |
| 428 | 5662 Bytecount fast_lisp_string_match (Lisp_Object, Lisp_Object); |
| 507 | 5663 extern Fixnum warn_about_possibly_incompatible_back_references; |
| 502 | 5664 |
| 428 | 5665 |
| 5666 /* Defined in signal.c */ | |
| 5667 void init_interrupts_late (void); | |
| 5668 | |
| 5669 /* Defined in sound.c */ | |
| 826 | 5670 EXFUN (Fding, 3); |
| 5671 | |
| 428 | 5672 void init_device_sound (struct device *); |
| 2367 | 5673 DECLARE_DOESNT_RETURN (report_sound_error (const Ascbyte *, Lisp_Object)); |
| 428 | 5674 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5675 extern Lisp_Object Qsound_error; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5676 extern Lisp_Object Vsynchronous_sounds; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5677 |
| 428 | 5678 /* Defined in specifier.c */ |
| 826 | 5679 EXFUN (Fadd_spec_to_specifier, 5); |
| 5680 EXFUN (Fspecifier_spec_list, 4); | |
| 5681 | |
| 428 | 5682 Lisp_Object specifier_instance (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 5683 Error_Behavior, int, int, Lisp_Object); |
| 428 | 5684 Lisp_Object specifier_instance_no_quit (Lisp_Object, Lisp_Object, Lisp_Object, |
| 578 | 5685 Error_Behavior, int, Lisp_Object); |
| 428 | 5686 |
| 5687 /* Defined in symbols.c */ | |
| 826 | 5688 EXFUN (Fboundp, 1); |
| 5689 EXFUN (Fbuilt_in_variable_type, 1); | |
| 5690 EXFUN (Fdefault_boundp, 1); | |
| 5691 EXFUN (Fdefault_value, 1); | |
| 5692 EXFUN (Ffboundp, 1); | |
| 5693 EXFUN (Ffset, 2); | |
| 5694 EXFUN (Fintern, 2); | |
|
4355
a2af1ff1761f
Provide a DEFAULT argument in #'intern-soft.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4329
diff
changeset
|
5695 EXFUN (Fintern_soft, 3); |
| 826 | 5696 EXFUN (Fkill_local_variable, 1); |
| 5697 EXFUN (Fset, 2); | |
| 5698 EXFUN (Fset_default, 2); | |
| 5699 EXFUN (Fsymbol_function, 1); | |
| 5700 EXFUN (Fsymbol_name, 1); | |
| 5701 EXFUN (Fsymbol_plist, 1); | |
| 5702 EXFUN (Fsymbol_value, 1); | |
| 5703 | |
| 867 | 5704 unsigned int hash_string (const Ibyte *, Bytecount); |
|
4953
304aebb79cd3
function renamings to track names of char typedefs
Ben Wing <ben@xemacs.org>
parents:
4952
diff
changeset
|
5705 Lisp_Object intern_istring (const Ibyte *str); |
| 1632 | 5706 MODULE_API Lisp_Object intern (const CIbyte *str); |
|
5277
d804e621add0
Simplify the API of PARSE_KEYWORDS for callers.
Aidan Kehoe <kehoea@parhasard.net>
parents:
5243
diff
changeset
|
5707 Lisp_Object intern_massaging_name (const CIbyte *str); |
| 867 | 5708 Lisp_Object oblookup (Lisp_Object, const Ibyte *, Bytecount); |
| 428 | 5709 void map_obarray (Lisp_Object, int (*) (Lisp_Object, void *), void *); |
| 5710 Lisp_Object indirect_function (Lisp_Object, int); | |
| 5711 Lisp_Object symbol_value_in_buffer (Lisp_Object, Lisp_Object); | |
| 5712 void kill_buffer_local_variables (struct buffer *); | |
| 5713 int symbol_value_buffer_local_info (Lisp_Object, struct buffer *); | |
| 5714 Lisp_Object find_symbol_value (Lisp_Object); | |
| 5715 Lisp_Object find_symbol_value_quickly (Lisp_Object, int); | |
| 5716 Lisp_Object top_level_value (Lisp_Object); | |
| 5717 void reject_constant_symbols (Lisp_Object sym, Lisp_Object newval, | |
| 5718 int function_p, | |
| 5719 Lisp_Object follow_past_lisp_magic); | |
| 5720 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5721 extern Lisp_Object Qconst_specifier; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5722 extern Lisp_Object Qmakunbound; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5723 extern Lisp_Object Qset; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5724 extern Lisp_Object Qvariable_documentation; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5725 extern Lisp_Object Qvariable_domain; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5726 extern MODULE_API Lisp_Object Qt, Qunbound; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5727 extern Lisp_Object Vobarray; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
5728 |
| 428 | 5729 /* Defined in syntax.c */ |
| 665 | 5730 Charbpos scan_words (struct buffer *, Charbpos, int); |
| 826 | 5731 EXFUN (Fchar_syntax, 2); |
| 5732 EXFUN (Fforward_word, 2); | |
| 5733 extern Lisp_Object Vstandard_syntax_table; | |
| 3250 | 5734 void signal_syntax_cache_extent_changed (EXTENT extent); |
| 5735 void signal_syntax_cache_extent_adjust (struct buffer *buf); | |
| 826 | 5736 void init_buffer_syntax_cache (struct buffer *buf); |
| 5737 void mark_buffer_syntax_cache (struct buffer *buf); | |
| 5738 void uninit_buffer_syntax_cache (struct buffer *buf); | |
| 5739 extern Lisp_Object Qsyntax_table; | |
| 428 | 5740 |
| 771 | 5741 /* Defined in sysdep.c */ |
| 5742 long get_random (void); | |
| 5743 void seed_random (long arg); | |
| 5744 | |
| 5745 /* Defined in text.c */ | |
| 867 | 5746 void find_charsets_in_ibyte_string (unsigned char *charsets, |
| 5747 const Ibyte *str, | |
| 771 | 5748 Bytecount len); |
| 867 | 5749 void find_charsets_in_ichar_string (unsigned char *charsets, |
| 5750 const Ichar *str, | |
| 771 | 5751 Charcount len); |
| 867 | 5752 int ibyte_string_displayed_columns (const Ibyte *str, Bytecount len); |
| 5753 int ichar_string_displayed_columns (const Ichar *str, Charcount len); | |
| 5754 Charcount ibyte_string_nonascii_chars (const Ibyte *str, Bytecount len); | |
| 5755 void convert_ibyte_string_into_ichar_dynarr (const Ibyte *str, | |
| 771 | 5756 Bytecount len, |
| 867 | 5757 Ichar_dynarr *dyn); |
| 5758 Charcount convert_ibyte_string_into_ichar_string (const Ibyte *str, | |
| 771 | 5759 Bytecount len, |
| 867 | 5760 Ichar *arr); |
| 5761 void convert_ichar_string_into_ibyte_dynarr (Ichar *arr, int nels, | |
| 5762 Ibyte_dynarr *dyn); | |
| 5763 Ibyte *convert_ichar_string_into_malloced_string (Ichar *arr, int nels, | |
| 771 | 5764 Bytecount *len_out); |
| 867 | 5765 Bytecount copy_text_between_formats (const Ibyte *src, Bytecount srclen, |
| 826 | 5766 Internal_Format srcfmt, |
| 5767 Lisp_Object srcobj, | |
| 867 | 5768 Ibyte *dst, Bytecount dstlen, |
| 826 | 5769 Internal_Format dstfmt, |
| 5770 Lisp_Object dstobj, | |
| 5771 Bytecount *src_used); | |
| 5772 Bytecount copy_buffer_text_out (struct buffer *buf, Bytebpos pos, | |
| 867 | 5773 Bytecount len, Ibyte *dst, Bytecount dstlen, |
| 826 | 5774 Internal_Format dstfmt, Lisp_Object dstobj, |
| 5775 Bytecount *src_used); | |
| 771 | 5776 |
| 5777 /* flags for get_buffer_pos_char(), get_buffer_range_char(), etc. */ | |
| 5778 /* At most one of GB_COERCE_RANGE and GB_NO_ERROR_IF_BAD should be | |
| 5779 specified. At most one of GB_NEGATIVE_FROM_END and GB_NO_ERROR_IF_BAD | |
| 5780 should be specified. */ | |
| 5781 | |
| 5782 #define GB_ALLOW_PAST_ACCESSIBLE (1 << 0) | |
| 5783 #define GB_ALLOW_NIL (1 << 1) | |
| 5784 #define GB_CHECK_ORDER (1 << 2) | |
| 5785 #define GB_COERCE_RANGE (1 << 3) | |
| 5786 #define GB_NO_ERROR_IF_BAD (1 << 4) | |
| 5787 #define GB_NEGATIVE_FROM_END (1 << 5) | |
| 5788 #define GB_HISTORICAL_STRING_BEHAVIOR (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL) | |
| 5789 | |
| 5790 Charbpos get_buffer_pos_char (struct buffer *b, Lisp_Object pos, | |
| 5791 unsigned int flags); | |
| 5792 Bytebpos get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, | |
| 5793 unsigned int flags); | |
| 5794 void get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to, | |
| 5795 Charbpos *from_out, Charbpos *to_out, | |
| 5796 unsigned int flags); | |
| 5797 void get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to, | |
| 5798 Bytebpos *from_out, Bytebpos *to_out, | |
| 5799 unsigned int flags); | |
| 5800 Charcount get_string_pos_char (Lisp_Object string, Lisp_Object pos, | |
| 5801 unsigned int flags); | |
| 5802 Bytecount get_string_pos_byte (Lisp_Object string, Lisp_Object pos, | |
| 5803 unsigned int flags); | |
| 5804 void get_string_range_char (Lisp_Object string, Lisp_Object from, | |
| 5805 Lisp_Object to, Charcount *from_out, | |
| 5806 Charcount *to_out, unsigned int flags); | |
| 5807 void get_string_range_byte (Lisp_Object string, Lisp_Object from, | |
| 5808 Lisp_Object to, Bytecount *from_out, | |
| 5809 Bytecount *to_out, unsigned int flags); | |
| 826 | 5810 Charxpos get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos, |
| 5811 unsigned int flags); | |
| 5812 Bytexpos get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos, | |
| 5813 unsigned int flags); | |
| 771 | 5814 void get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from, |
| 826 | 5815 Lisp_Object to, Charxpos *from_out, |
| 5816 Charxpos *to_out, unsigned int flags); | |
| 771 | 5817 void get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from, |
| 826 | 5818 Lisp_Object to, Bytexpos *from_out, |
| 5819 Bytexpos *to_out, unsigned int flags); | |
| 5820 Charxpos buffer_or_string_accessible_begin_char (Lisp_Object object); | |
| 5821 Charxpos buffer_or_string_accessible_end_char (Lisp_Object object); | |
| 5822 Bytexpos buffer_or_string_accessible_begin_byte (Lisp_Object object); | |
| 5823 Bytexpos buffer_or_string_accessible_end_byte (Lisp_Object object); | |
| 5824 Charxpos buffer_or_string_absolute_begin_char (Lisp_Object object); | |
| 5825 Charxpos buffer_or_string_absolute_end_char (Lisp_Object object); | |
| 5826 Bytexpos buffer_or_string_absolute_begin_byte (Lisp_Object object); | |
| 5827 Bytexpos buffer_or_string_absolute_end_byte (Lisp_Object object); | |
| 5828 Charbpos charbpos_clip_to_bounds (Charbpos lower, Charbpos num, | |
| 5829 Charbpos upper); | |
| 5830 Bytebpos bytebpos_clip_to_bounds (Bytebpos lower, Bytebpos num, | |
| 5831 Bytebpos upper); | |
| 5832 Charxpos charxpos_clip_to_bounds (Charxpos lower, Charxpos num, | |
| 5833 Charxpos upper); | |
| 5834 Bytexpos bytexpos_clip_to_bounds (Bytexpos lower, Bytexpos num, | |
| 5835 Bytexpos upper); | |
| 5836 Charxpos buffer_or_string_clip_to_accessible_char (Lisp_Object object, | |
| 5837 Charxpos pos); | |
| 5838 Bytexpos buffer_or_string_clip_to_accessible_byte (Lisp_Object object, | |
| 5839 Bytexpos pos); | |
| 5840 Charxpos buffer_or_string_clip_to_absolute_char (Lisp_Object object, | |
| 5841 Charxpos pos); | |
| 5842 Bytexpos buffer_or_string_clip_to_absolute_byte (Lisp_Object object, | |
| 5843 Bytexpos pos); | |
| 5844 | |
| 771 | 5845 |
| 5846 #ifdef ENABLE_COMPOSITE_CHARS | |
| 5847 | |
| 867 | 5848 Ichar lookup_composite_char (Ibyte *str, int len); |
| 5849 Lisp_Object composite_char_string (Ichar ch); | |
| 771 | 5850 #endif /* ENABLE_COMPOSITE_CHARS */ |
| 5851 | |
| 5852 EXFUN (Ffind_charset, 1); | |
| 5853 EXFUN (Fget_charset, 1); | |
| 5854 EXFUN (Fcharset_list, 0); | |
| 5855 | |
| 5856 extern Lisp_Object Vcharset_ascii; | |
| 5857 extern Lisp_Object Vcharset_control_1; | |
| 5858 extern Lisp_Object Vcharset_latin_iso8859_1; | |
| 5859 extern Lisp_Object Vcharset_latin_iso8859_2; | |
| 5860 extern Lisp_Object Vcharset_latin_iso8859_3; | |
| 5861 extern Lisp_Object Vcharset_latin_iso8859_4; | |
| 5862 extern Lisp_Object Vcharset_thai_tis620; | |
| 5863 extern Lisp_Object Vcharset_greek_iso8859_7; | |
|
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4744
diff
changeset
|
5864 extern Lisp_Object Vcharset_arabic_iso8859_6; |
| 771 | 5865 extern Lisp_Object Vcharset_hebrew_iso8859_8; |
| 5866 extern Lisp_Object Vcharset_katakana_jisx0201; | |
| 5867 extern Lisp_Object Vcharset_latin_jisx0201; | |
| 5868 extern Lisp_Object Vcharset_cyrillic_iso8859_5; | |
| 5869 extern Lisp_Object Vcharset_latin_iso8859_9; | |
| 3094 | 5870 extern Lisp_Object Vcharset_latin_iso8859_15; |
| 771 | 5871 extern Lisp_Object Vcharset_japanese_jisx0208_1978; |
| 5872 extern Lisp_Object Vcharset_chinese_gb2312; | |
| 5873 extern Lisp_Object Vcharset_japanese_jisx0208; | |
| 5874 extern Lisp_Object Vcharset_korean_ksc5601; | |
| 5875 extern Lisp_Object Vcharset_japanese_jisx0212; | |
| 5876 extern Lisp_Object Vcharset_chinese_cns11643_1; | |
| 5877 extern Lisp_Object Vcharset_chinese_cns11643_2; | |
| 5878 extern Lisp_Object Vcharset_chinese_big5_1; | |
| 5879 extern Lisp_Object Vcharset_chinese_big5_2; | |
| 5880 extern Lisp_Object Vcharset_composite; | |
| 5881 | |
| 867 | 5882 Ichar Lstream_get_ichar_1 (Lstream *stream, int first_char); |
| 5883 int Lstream_fput_ichar (Lstream *stream, Ichar ch); | |
| 5884 void Lstream_funget_ichar (Lstream *stream, Ichar ch); | |
| 5885 | |
| 5886 DECLARE_INLINE_HEADER (Ibyte *qxestrdup (const Ibyte *s)) | |
| 771 | 5887 { |
| 2367 | 5888 return (Ibyte *) xstrdup ((const Chbyte *) s); |
| 771 | 5889 } |
| 5890 | |
| 867 | 5891 DECLARE_INLINE_HEADER (Bytecount qxestrlen (const Ibyte *s)) |
| 771 | 5892 { |
| 2367 | 5893 return strlen ((const Chbyte *) s); |
| 771 | 5894 } |
| 5895 | |
| 867 | 5896 DECLARE_INLINE_HEADER (Charcount qxestrcharlen (const Ibyte *s)) |
| 771 | 5897 { |
| 5898 return bytecount_to_charcount (s, qxestrlen (s)); | |
| 5899 } | |
| 5900 | |
| 867 | 5901 DECLARE_INLINE_HEADER (int qxestrcmp (const Ibyte *s1, |
| 5902 const Ibyte *s2)) | |
| 771 | 5903 { |
| 2367 | 5904 return strcmp ((const Chbyte *) s1, (const Chbyte *) s2); |
| 771 | 5905 } |
| 5906 | |
| 2367 | 5907 DECLARE_INLINE_HEADER (int qxestrcmp_ascii (const Ibyte *s1, |
| 5908 const Ascbyte *s2)) | |
| 771 | 5909 { |
| 2367 | 5910 return strcmp ((const Chbyte *) s1, s2); |
| 771 | 5911 } |
| 5912 | |
| 867 | 5913 DECLARE_INLINE_HEADER (int qxestrncmp (const Ibyte *string1, |
| 5914 const Ibyte *string2, | |
| 771 | 5915 Bytecount count)) |
| 5916 { | |
| 2367 | 5917 return strncmp ((const Chbyte *) string1, (const Chbyte *) string2, |
| 771 | 5918 (size_t) count); |
| 5919 } | |
| 5920 | |
| 2367 | 5921 DECLARE_INLINE_HEADER (int qxestrncmp_ascii (const Ibyte *string1, |
| 5922 const Ascbyte *string2, | |
| 5923 Bytecount count)) | |
| 771 | 5924 { |
| 2367 | 5925 return strncmp ((const Chbyte *) string1, string2, (size_t) count); |
| 771 | 5926 } |
| 5927 | |
| 867 | 5928 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy (Ibyte *strDest, |
| 2367 | 5929 const Ibyte *strSource)) |
| 771 | 5930 { |
| 2367 | 5931 return (Ibyte *) strcpy ((Chbyte *) strDest, (const Chbyte *) strSource); |
| 771 | 5932 } |
| 5933 | |
| 2367 | 5934 DECLARE_INLINE_HEADER (Ibyte *qxestrcpy_ascii (Ibyte *strDest, |
| 5935 const Ascbyte *strSource)) | |
| 771 | 5936 { |
| 2367 | 5937 return (Ibyte *) strcpy ((Chbyte *) strDest, strSource); |
| 771 | 5938 } |
| 5939 | |
| 867 | 5940 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy (Ibyte *strDest, |
| 2367 | 5941 const Ibyte *strSource, |
| 5942 Bytecount count)) | |
| 771 | 5943 { |
| 2367 | 5944 return (Ibyte *) strncpy ((Chbyte *) strDest, (const Chbyte *) strSource, |
| 771 | 5945 (size_t) count); |
| 5946 } | |
| 5947 | |
| 2367 | 5948 DECLARE_INLINE_HEADER (Ibyte *qxestrncpy_ascii (Ibyte *strDest, |
| 5949 const Ascbyte *strSource, | |
| 5950 Bytecount count)) | |
| 771 | 5951 { |
| 2367 | 5952 return (Ibyte *) strncpy ((Chbyte *) strDest, strSource, (size_t) count); |
| 771 | 5953 } |
| 5954 | |
| 867 | 5955 DECLARE_INLINE_HEADER (Ibyte *qxestrcat (Ibyte *strDest, |
| 2367 | 5956 const Ibyte *strSource)) |
| 771 | 5957 { |
| 2367 | 5958 return (Ibyte *) strcat ((Chbyte *) strDest, (const Chbyte *) strSource); |
| 771 | 5959 } |
| 5960 | |
| 2367 | 5961 DECLARE_INLINE_HEADER (Ibyte *qxestrcat_ascii (Ibyte *strDest, |
| 5962 const Ascbyte *strSource)) | |
| 771 | 5963 { |
| 2367 | 5964 return (Ibyte *) strcat ((Chbyte *) strDest, strSource); |
| 771 | 5965 } |
| 5966 | |
| 867 | 5967 DECLARE_INLINE_HEADER (Ibyte *qxestrncat (Ibyte *strDest, |
| 2367 | 5968 const Ibyte *strSource, |
| 5969 Bytecount count)) | |
| 771 | 5970 { |
| 2367 | 5971 return (Ibyte *) strncat ((Chbyte *) strDest, (const Chbyte *) strSource, |
| 771 | 5972 (size_t) count); |
| 5973 } | |
| 5974 | |
| 2367 | 5975 DECLARE_INLINE_HEADER (Ibyte *qxestrncat_ascii (Ibyte *strDest, |
| 5976 const Ascbyte *strSource, | |
| 5977 Bytecount count)) | |
| 771 | 5978 { |
| 2367 | 5979 return (Ibyte *) strncat ((Chbyte *) strDest, strSource, (size_t) count); |
| 771 | 5980 } |
| 5981 | |
| 867 | 5982 DECLARE_INLINE_HEADER (Ibyte *qxestrchr (const Ibyte *s, Ichar c)) |
| 771 | 5983 { |
| 5984 assert (c >= 0 && c <= 255); | |
| 2367 | 5985 return (Ibyte *) strchr ((const Chbyte *) s, c); |
| 771 | 5986 } |
| 5987 | |
| 867 | 5988 DECLARE_INLINE_HEADER (Ibyte *qxestrrchr (const Ibyte *s, Ichar c)) |
| 771 | 5989 { |
| 5990 assert (c >= 0 && c <= 255); | |
| 2367 | 5991 return (Ibyte *) strrchr ((const Chbyte *) s, c); |
| 771 | 5992 } |
| 5993 | |
| 867 | 5994 DECLARE_INLINE_HEADER (Ibyte *qxestrstr (const Ibyte *string1, |
| 2367 | 5995 const Ibyte *string2)) |
| 771 | 5996 { |
| 2367 | 5997 return (Ibyte *) strstr ((const Chbyte *) string1, (const Chbyte *) string2); |
| 771 | 5998 } |
| 5999 | |
| 867 | 6000 DECLARE_INLINE_HEADER (Bytecount qxestrcspn (const Ibyte *string, |
| 6001 const CIbyte *strCharSet)) | |
| 771 | 6002 { |
| 2367 | 6003 return (Bytecount) strcspn ((const Chbyte *) string, strCharSet); |
| 771 | 6004 } |
| 6005 | |
| 867 | 6006 DECLARE_INLINE_HEADER (Bytecount qxestrspn (const Ibyte *string, |
| 6007 const CIbyte *strCharSet)) | |
| 771 | 6008 { |
| 2367 | 6009 return (Bytecount) strspn ((const Chbyte *) string, strCharSet); |
| 771 | 6010 } |
| 6011 | |
| 867 | 6012 DECLARE_INLINE_HEADER (Ibyte *qxestrpbrk (const Ibyte *string, |
| 2367 | 6013 const CIbyte *strCharSet)) |
| 771 | 6014 { |
| 2367 | 6015 return (Ibyte *) strpbrk ((const Chbyte *) string, strCharSet); |
| 771 | 6016 } |
| 6017 | |
| 867 | 6018 DECLARE_INLINE_HEADER (Ibyte *qxestrtok (Ibyte *strToken, |
| 2367 | 6019 const CIbyte *strDelimit)) |
| 771 | 6020 { |
| 2367 | 6021 return (Ibyte *) strtok ((Chbyte *) strToken, strDelimit); |
| 771 | 6022 } |
| 6023 | |
| 867 | 6024 DECLARE_INLINE_HEADER (double qxestrtod (const Ibyte *nptr, |
| 6025 Ibyte **endptr)) | |
| 771 | 6026 { |
| 2367 | 6027 return strtod ((const Chbyte *) nptr, (Chbyte **) endptr); |
| 771 | 6028 } |
| 6029 | |
| 867 | 6030 DECLARE_INLINE_HEADER (long qxestrtol (const Ibyte *nptr, Ibyte **endptr, |
| 771 | 6031 int base)) |
| 6032 { | |
| 2367 | 6033 return strtol ((const Chbyte *) nptr, (Chbyte **) endptr, base); |
| 771 | 6034 } |
| 6035 | |
| 867 | 6036 DECLARE_INLINE_HEADER (unsigned long qxestrtoul (const Ibyte *nptr, |
| 6037 Ibyte **endptr, | |
| 771 | 6038 int base)) |
| 6039 { | |
| 2367 | 6040 return strtoul ((const Chbyte *) nptr, (Chbyte **) endptr, base); |
| 771 | 6041 } |
| 6042 | |
| 867 | 6043 DECLARE_INLINE_HEADER (int qxeatoi (const Ibyte *string)) |
| 771 | 6044 { |
| 2367 | 6045 return atoi ((const Chbyte *) string); |
| 771 | 6046 } |
| 6047 | |
| 1204 | 6048 DECLARE_INLINE_HEADER (Ibyte *qxestrupr (Ibyte *s)) |
| 6049 { | |
| 2367 | 6050 return (Ibyte *) strupr ((Chbyte *) s); |
| 1204 | 6051 } |
| 6052 | |
| 6053 DECLARE_INLINE_HEADER (Ibyte *qxestrlwr (Ibyte *s)) | |
| 6054 { | |
| 2367 | 6055 return (Ibyte *) strlwr ((Chbyte *) s); |
| 1204 | 6056 } |
| 6057 | |
| 867 | 6058 int qxesprintf (Ibyte *buffer, const CIbyte *format, ...) |
| 771 | 6059 PRINTF_ARGS (2, 3); |
| 6060 | |
| 2367 | 6061 DECLARE_INLINE_HEADER (int qxesscanf_ascii_1 (Ibyte *buffer, |
| 6062 const Ascbyte *format, | |
| 6063 void *ptr)) | |
| 6064 { | |
| 6065 /* #### DAMNIT! No vsscanf! */ | |
| 6066 return sscanf ((Chbyte *) buffer, format, ptr); | |
| 6067 } | |
| 6068 | |
| 771 | 6069 /* Do not use POSIX locale routines. Not Mule-correct. */ |
| 6070 #define qxestrcoll DO NOT USE. | |
| 6071 #define qxestrxfrm DO NOT USE. | |
| 6072 | |
| 867 | 6073 int qxestrcasecmp (const Ibyte *s1, const Ibyte *s2); |
| 2367 | 6074 int qxestrcasecmp_ascii (const Ibyte *s1, const Ascbyte *s2); |
| 867 | 6075 int qxestrcasecmp_i18n (const Ibyte *s1, const Ibyte *s2); |
| 2367 | 6076 int ascii_strcasecmp (const Ascbyte *s1, const Ascbyte *s2); |
|
4906
6ef8256a020a
implement equalp in C, fix case-folding, add equal() method for keymaps
Ben Wing <ben@xemacs.org>
parents:
4888
diff
changeset
|
6077 int lisp_strcasecmp_ascii (Lisp_Object s1, Lisp_Object s2); |
| 771 | 6078 int lisp_strcasecmp_i18n (Lisp_Object s1, Lisp_Object s2); |
| 867 | 6079 int qxestrncasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 2367 | 6080 int qxestrncasecmp_ascii (const Ibyte *s1, const Ascbyte *s2, |
| 6081 Bytecount len); | |
| 867 | 6082 int qxestrncasecmp_i18n (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 2367 | 6083 int ascii_strncasecmp (const Ascbyte *s1, const Ascbyte *s2, |
| 771 | 6084 Bytecount len); |
| 867 | 6085 int qxememcmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); |
| 6086 int qxememcmp4 (const Ibyte *s1, Bytecount len1, | |
| 6087 const Ibyte *s2, Bytecount len2); | |
| 6088 int qxememcasecmp (const Ibyte *s1, const Ibyte *s2, Bytecount len); | |
| 6089 int qxememcasecmp4 (const Ibyte *s1, Bytecount len1, | |
| 6090 const Ibyte *s2, Bytecount len2); | |
| 6091 int qxetextcmp (const Ibyte *s1, Bytecount len1, | |
| 6092 const Ibyte *s2, Bytecount len2); | |
| 6093 int qxetextcmp_matching (const Ibyte *s1, Bytecount len1, | |
| 6094 const Ibyte *s2, Bytecount len2, | |
| 801 | 6095 Charcount *matching); |
| 867 | 6096 int qxetextcasecmp (const Ibyte *s1, Bytecount len1, |
| 6097 const Ibyte *s2, Bytecount len2); | |
| 6098 int qxetextcasecmp_matching (const Ibyte *s1, Bytecount len1, | |
| 6099 const Ibyte *s2, Bytecount len2, | |
| 801 | 6100 Charcount *matching); |
| 771 | 6101 |
| 6102 void buffer_mule_signal_inserted_region (struct buffer *buf, Charbpos start, | |
| 6103 Bytecount bytelength, | |
| 6104 Charcount charlength); | |
| 6105 void buffer_mule_signal_deleted_region (struct buffer *buf, Charbpos start, | |
| 826 | 6106 Charbpos end, Bytebpos byte_start, |
| 6107 Bytebpos byte_end); | |
| 771 | 6108 |
| 2367 | 6109 typedef struct |
| 6110 { | |
| 6111 const char *srctext; | |
| 6112 void *dst; | |
| 6113 Bytecount dst_size; | |
| 6114 } alloca_convert_vals; | |
| 6115 | |
| 6116 typedef struct | |
| 6117 { | |
| 6118 Dynarr_declare (alloca_convert_vals); | |
| 6119 } alloca_convert_vals_dynarr; | |
| 6120 | |
| 6121 extern alloca_convert_vals_dynarr *active_alloca_convert; | |
| 6122 | |
| 6123 MODULE_API int find_pos_of_existing_active_alloca_convert (const char * | |
| 6124 srctext); | |
| 6125 | |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6126 /* Defined in undo.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6127 extern Lisp_Object Qinhibit_read_only; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6128 |
| 771 | 6129 /* Defined in unicode.c */ |
| 1204 | 6130 extern const struct sized_memory_description to_unicode_description; |
| 6131 extern const struct sized_memory_description from_unicode_description; | |
| 771 | 6132 void init_charset_unicode_tables (Lisp_Object charset); |
| 6133 void free_charset_unicode_tables (Lisp_Object charset); | |
| 6134 void recalculate_unicode_precedence (void); | |
| 6135 extern Lisp_Object Qunicode; | |
| 4096 | 6136 extern Lisp_Object Qutf_16, Qutf_8, Qucs_4, Qutf_7, Qutf_32; |
| 771 | 6137 #ifdef MEMORY_USAGE_STATS |
| 6138 Bytecount compute_from_unicode_table_size (Lisp_Object charset, | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
6139 struct usage_stats *stats); |
| 771 | 6140 Bytecount compute_to_unicode_table_size (Lisp_Object charset, |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
5146
diff
changeset
|
6141 struct usage_stats *stats); |
| 771 | 6142 #endif /* MEMORY_USAGE_STATS */ |
| 6143 | |
| 428 | 6144 /* Defined in undo.c */ |
| 826 | 6145 EXFUN (Fundo_boundary, 0); |
| 6146 | |
| 428 | 6147 Lisp_Object truncate_undo_list (Lisp_Object, int, int); |
| 6148 void record_extent (Lisp_Object, int); | |
| 665 | 6149 void record_insert (struct buffer *, Charbpos, Charcount); |
| 6150 void record_delete (struct buffer *, Charbpos, Charcount); | |
| 6151 void record_change (struct buffer *, Charbpos, Charcount); | |
| 428 | 6152 |
| 6153 /* Defined in unex*.c */ | |
| 814 | 6154 #ifdef WIN32_NATIVE |
| 867 | 6155 int unexec (Ibyte *, Ibyte *, uintptr_t, uintptr_t, uintptr_t); |
| 814 | 6156 #else |
| 6157 int unexec (Extbyte *, Extbyte *, uintptr_t, uintptr_t, uintptr_t); | |
| 6158 #endif | |
| 428 | 6159 #ifdef RUN_TIME_REMAP |
| 6160 int run_time_remap (char *); | |
| 6161 #endif | |
| 6162 | |
| 6163 /* Defined in vm-limit.c */ | |
| 442 | 6164 void memory_warnings (void *, void (*) (const char *)); |
| 428 | 6165 |
|
5139
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6166 /* Defined in win32.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6167 extern Lisp_Object Vmswindows_downcase_file_names; |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6168 |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6169 /* Defined in window.c */ |
|
a48ef26d87ee
Clean up prototypes for Lisp variables/symbols. Put decls for them with
Ben Wing <ben@xemacs.org>
parents:
5097
diff
changeset
|
6170 extern Lisp_Object Qwindow_live_p; |
| 1927 | 6171 |
| 1743 | 6172 END_C_DECLS |
| 1650 | 6173 |
| 440 | 6174 #endif /* INCLUDED_lisp_h_ */ |