|
302
|
1 /* Fundamental definitions for GNU Emacs Lisp interpreter.
|
|
60897
|
2 Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
|
|
75348
|
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
|
|
302
|
4
|
|
|
5 This file is part of GNU Emacs.
|
|
|
6
|
|
|
7 GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
8 it under the terms of the GNU General Public License as published by
|
|
78260
|
9 the Free Software Foundation; either version 3, or (at your option)
|
|
302
|
10 any later version.
|
|
|
11
|
|
|
12 GNU Emacs is distributed in the hope that it will be useful,
|
|
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
15 GNU General Public License for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GNU Emacs; see the file COPYING. If not, write to
|
|
64084
|
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
20 Boston, MA 02110-1301, USA. */
|
|
302
|
21
|
|
52274
|
22 #ifndef EMACS_LISP_H
|
|
|
23 #define EMACS_LISP_H
|
|
|
24
|
|
25017
|
25 /* Declare the prototype for a general external function. */
|
|
28054
|
26 #if defined (PROTOTYPES) || defined (WINDOWSNT)
|
|
25017
|
27 #define P_(proto) proto
|
|
|
28 #else
|
|
|
29 #define P_(proto) ()
|
|
|
30 #endif
|
|
|
31
|
|
36941
|
32 #if 0
|
|
35184
|
33 /* Define this temporarily to hunt a bug. If defined, the size of
|
|
|
34 strings is redundantly recorded in sdata structures so that it can
|
|
|
35 be compared to the sizes recorded in Lisp strings. */
|
|
|
36
|
|
|
37 #define GC_CHECK_STRING_BYTES 1
|
|
58633
|
38
|
|
|
39 /* Define this to check for short string overrun. */
|
|
|
40
|
|
|
41 #define GC_CHECK_STRING_OVERRUN 1
|
|
|
42
|
|
|
43 /* Define this to check the string free list. */
|
|
|
44
|
|
|
45 #define GC_CHECK_STRING_FREE_LIST 1
|
|
|
46
|
|
|
47 /* Define this to check for malloc buffer overrun. */
|
|
|
48
|
|
|
49 #define XMALLOC_OVERRUN_CHECK 1
|
|
|
50
|
|
|
51 /* Define this to check for errors in cons list. */
|
|
|
52 /* #define GC_CHECK_CONS_LIST 1 */
|
|
|
53
|
|
51167
|
54 #endif /* 0 */
|
|
35184
|
55
|
|
60417
|
56 #ifdef GC_CHECK_CONS_LIST
|
|
|
57 #define CHECK_CONS_LIST() check_cons_list()
|
|
|
58 #else
|
81813
32d8fd242bb2
* lisp.h (struct Lisp_Hash_Table): Turn next_weak into a bare pointer.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
59 #define CHECK_CONS_LIST() ((void)0)
|
|
60417
|
60 #endif
|
|
302
|
61
|
|
8835
|
62 /* These are default choices for the types to use. */
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
63 #ifdef _LP64
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
64 #ifndef EMACS_INT
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
65 #define EMACS_INT long
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
66 #define BITS_PER_EMACS_INT BITS_PER_LONG
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
67 #endif
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
68 #ifndef EMACS_UINT
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
69 #define EMACS_UINT unsigned long
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
70 #endif
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
71 #else /* not _LP64 */
|
|
8835
|
72 #ifndef EMACS_INT
|
|
|
73 #define EMACS_INT int
|
|
16133
|
74 #define BITS_PER_EMACS_INT BITS_PER_INT
|
|
8835
|
75 #endif
|
|
|
76 #ifndef EMACS_UINT
|
|
|
77 #define EMACS_UINT unsigned int
|
|
|
78 #endif
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
79 #endif
|
|
8835
|
80
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
81 /* Extra internal type checking? */
|
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
82 extern int suppress_checking;
|
|
71063
|
83 extern void die P_((const char *, const char *, int)) NO_RETURN;
|
|
28430
|
84
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
85 #ifdef ENABLE_CHECKING
|
|
28430
|
86
|
|
83688
|
87 #define CHECK(check,msg) (((check) || suppress_checking \
|
|
|
88 ? (void) 0 \
|
|
|
89 : die ((msg), __FILE__, __LINE__)), \
|
|
28430
|
90 0)
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
91 #else
|
|
28430
|
92
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
93 /* Produce same side effects and result, but don't complain. */
|
|
83688
|
94 #define CHECK(check,msg) ((check),0)
|
|
28430
|
95
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
96 #endif
|
|
28430
|
97
|
|
31907
|
98 /* Used for making sure that Emacs is compilable in all
|
|
39194
|
99 configurations. */
|
|
31907
|
100
|
|
|
101 #ifdef USE_LISP_UNION_TYPE
|
|
|
102 #undef NO_UNION_TYPE
|
|
|
103 #endif
|
|
|
104
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
105 /* Define an Emacs version of "assert", since some system ones are
|
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
106 flaky. */
|
|
29337
|
107 #ifndef ENABLE_CHECKING
|
|
|
108 #define eassert(X) (void) 0
|
|
|
109 #else /* ENABLE_CHECKING */
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
110 #if defined (__GNUC__) && __GNUC__ >= 2 && defined (__STDC__)
|
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
111 #define eassert(cond) CHECK(cond,"assertion failed: " #cond)
|
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
112 #else
|
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
113 #define eassert(cond) CHECK(cond,"assertion failed")
|
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
114 #endif
|
|
29337
|
115 #endif /* ENABLE_CHECKING */
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
116
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
117 /***** Select the tagging scheme. *****/
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
118 /* There are basically two options that control the tagging scheme:
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
119 - NO_UNION_TYPE says that Lisp_Object should be an integer instead
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
120 of a union.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
121 - USE_LSB_TAG means that we can assume the least 3 bits of pointers are
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
122 always 0, and we can thus use them to hold tag bits, without
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
123 restricting our addressing space.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
124
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
125 If USE_LSB_TAG is not set, then we use the top 3 bits for tagging, thus
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
126 restricting our possible address range. Currently USE_LSB_TAG is not
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
127 allowed together with a union. This is not due to any fundamental
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
128 technical (or political ;-) problem: nobody wrote the code to do it yet.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
129
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
130 USE_LSB_TAG not only requires the least 3 bits of pointers returned by
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
131 malloc to be 0 but also needs to be able to impose a mult-of-8 alignment
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
132 on the few static Lisp_Objects used: all the defsubr as well
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
133 as the two special buffers buffer_defaults and buffer_local_symbols. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
134
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
135 /* First, try and define DECL_ALIGN(type,var) which declares a static
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
136 variable VAR of type TYPE with the added requirement that it be
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
137 TYPEBITS-aligned. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
138 #ifndef NO_DECL_ALIGN
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
139 # ifndef DECL_ALIGN
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
140 /* What compiler directive should we use for non-gcc compilers? -stef */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
141 # if defined (__GNUC__)
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
142 # define DECL_ALIGN(type, var) \
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
143 type __attribute__ ((__aligned__ (1 << GCTYPEBITS))) var
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
144 # endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
145 # endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
146 #endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
147
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
148 /* Let's USE_LSB_TAG on systems where we know malloc returns mult-of-8. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
149 #if defined GNU_MALLOC || defined DOUG_LEA_MALLOC || defined __GLIBC__ || defined MAC_OSX
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
150 /* We also need to be able to specify mult-of-8 alignment on static vars. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
151 # if defined DECL_ALIGN
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
152 /* We currently do not support USE_LSB_TAG with a union Lisp_Object. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
153 # if defined NO_UNION_TYPE
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
154 # define USE_LSB_TAG
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
155 # endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
156 # endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
157 #endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
158
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
159 /* If we cannot use 8-byte alignment, make DECL_ALIGN a no-op. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
160 #ifndef DECL_ALIGN
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
161 # ifdef USE_LSB_TAG
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
162 # error "USE_LSB_TAG used without defining DECL_ALIGN"
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
163 # endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
164 # define DECL_ALIGN(type, var) type var
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
165 #endif
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
166
|
28406
451721e784a8
Stop assuming interval pointers and lisp objects can be distinguished by
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
167
|
|
10316
|
168 /* Define the fundamental Lisp data structures. */
|
|
302
|
169
|
|
10316
|
170 /* This is the set of Lisp data types. */
|
|
302
|
171
|
|
|
172 enum Lisp_Type
|
|
|
173 {
|
|
10316
|
174 /* Integer. XINT (obj) is the integer value. */
|
|
302
|
175 Lisp_Int,
|
|
|
176
|
|
10316
|
177 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
|
|
302
|
178 Lisp_Symbol,
|
|
|
179
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
180 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
|
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
181 whose first member indicates the subtype. */
|
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
182 Lisp_Misc,
|
|
302
|
183
|
|
|
184 /* String. XSTRING (object) points to a struct Lisp_String.
|
|
10316
|
185 The length of the string, and its contents, are stored therein. */
|
|
302
|
186 Lisp_String,
|
|
|
187
|
|
10010
|
188 /* Vector of Lisp objects, or something resembling it.
|
|
10292
|
189 XVECTOR (object) points to a struct Lisp_Vector, which contains
|
|
10010
|
190 the size and contents. The size field also contains the type
|
|
|
191 information, if it's not a real vector object. */
|
|
|
192 Lisp_Vectorlike,
|
|
302
|
193
|
|
10316
|
194 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
|
|
302
|
195 Lisp_Cons,
|
|
|
196
|
|
2780
|
197 Lisp_Float,
|
|
10246
|
198
|
|
|
199 /* This is not a type code. It is for range checking. */
|
|
10321
|
200 Lisp_Type_Limit
|
|
302
|
201 };
|
|
|
202
|
|
39579
|
203 /* This is the set of data types that share a common structure.
|
|
10396
|
204 The first member of the structure is a type code from this set.
|
|
|
205 The enum values are arbitrary, but we'll use large numbers to make it
|
|
|
206 more likely that we'll spot the error if a random word in memory is
|
|
|
207 mistakenly interpreted as a Lisp_Misc. */
|
|
9392
|
208 enum Lisp_Misc_Type
|
|
|
209 {
|
|
10396
|
210 Lisp_Misc_Free = 0x5eab,
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
211 Lisp_Misc_Marker,
|
|
9462
|
212 Lisp_Misc_Intfwd,
|
|
|
213 Lisp_Misc_Boolfwd,
|
|
|
214 Lisp_Misc_Objfwd,
|
9891
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
215 Lisp_Misc_Buffer_Objfwd,
|
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
216 Lisp_Misc_Buffer_Local_Value,
|
|
9924
|
217 Lisp_Misc_Some_Buffer_Local_Value,
|
|
10316
|
218 Lisp_Misc_Overlay,
|
|
11012
|
219 Lisp_Misc_Kboard_Objfwd,
|
|
49056
|
220 Lisp_Misc_Save_Value,
|
|
10316
|
221 /* Currently floats are not a misc type,
|
|
|
222 but let's define this in case we want to change that. */
|
|
|
223 Lisp_Misc_Float,
|
|
|
224 /* This is not a type code. It is for range checking. */
|
|
|
225 Lisp_Misc_Limit
|
|
9392
|
226 };
|
|
|
227
|
|
51858
|
228 #ifndef GCTYPEBITS
|
|
|
229 #define GCTYPEBITS 3
|
|
|
230 #endif
|
|
|
231
|
|
10321
|
232 /* These values are overridden by the m- file on some machines. */
|
|
|
233 #ifndef VALBITS
|
|
52476
|
234 #define VALBITS (BITS_PER_EMACS_INT - GCTYPEBITS)
|
|
10321
|
235 #endif
|
|
|
236
|
|
302
|
237 #ifndef NO_UNION_TYPE
|
|
|
238
|
|
5241
|
239 #ifndef WORDS_BIG_ENDIAN
|
|
302
|
240
|
|
|
241 /* Definition of Lisp_Object for little-endian machines. */
|
|
|
242
|
|
|
243 typedef
|
|
|
244 union Lisp_Object
|
|
|
245 {
|
|
|
246 /* Used for comparing two Lisp_Objects;
|
|
10316
|
247 also, positive integers can be accessed fast this way. */
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
248 EMACS_UINT i;
|
|
302
|
249
|
|
|
250 struct
|
|
|
251 {
|
|
31901
|
252 EMACS_INT val : VALBITS;
|
54083
16821fe4a0bf
(union Lisp_Object): Give a more precise type for `type'.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
253 enum Lisp_Type type : GCTYPEBITS;
|
|
302
|
254 } s;
|
|
|
255 struct
|
|
|
256 {
|
|
31901
|
257 EMACS_UINT val : VALBITS;
|
54083
16821fe4a0bf
(union Lisp_Object): Give a more precise type for `type'.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
258 enum Lisp_Type type : GCTYPEBITS;
|
|
302
|
259 } u;
|
|
|
260 }
|
|
|
261 Lisp_Object;
|
|
|
262
|
|
5241
|
263 #else /* If WORDS_BIG_ENDIAN */
|
|
302
|
264
|
|
|
265 typedef
|
|
|
266 union Lisp_Object
|
|
|
267 {
|
|
|
268 /* Used for comparing two Lisp_Objects;
|
|
10316
|
269 also, positive integers can be accessed fast this way. */
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
270 EMACS_UINT i;
|
|
302
|
271
|
|
|
272 struct
|
|
|
273 {
|
54083
16821fe4a0bf
(union Lisp_Object): Give a more precise type for `type'.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
274 enum Lisp_Type type : GCTYPEBITS;
|
|
31901
|
275 EMACS_INT val : VALBITS;
|
|
302
|
276 } s;
|
|
|
277 struct
|
|
|
278 {
|
54083
16821fe4a0bf
(union Lisp_Object): Give a more precise type for `type'.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
279 enum Lisp_Type type : GCTYPEBITS;
|
|
31901
|
280 EMACS_UINT val : VALBITS;
|
|
302
|
281 } u;
|
|
|
282 }
|
|
|
283 Lisp_Object;
|
|
|
284
|
|
5241
|
285 #endif /* WORDS_BIG_ENDIAN */
|
|
302
|
286
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
287 #ifdef __GNUC__
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
288 static __inline__ Lisp_Object
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
289 LISP_MAKE_RVALUE (Lisp_Object o)
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
290 {
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
291 return o;
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
292 }
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
293 #else
|
|
45416
|
294 /* This isn't quite right - it keeps the argument as an lvalue.
|
|
|
295 Making it const via casting would help avoid code actually
|
|
|
296 modifying the location in question, but the casting could cover
|
|
|
297 other type-related bugs. */
|
|
|
298 #define LISP_MAKE_RVALUE(o) (o)
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
299 #endif
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
300
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
301 #else /* NO_UNION_TYPE */
|
|
302
|
302
|
|
18115
|
303 /* If union type is not wanted, define Lisp_Object as just a number. */
|
|
302
|
304
|
|
67029
|
305 typedef EMACS_INT Lisp_Object;
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
306 #define LISP_MAKE_RVALUE(o) (0+(o))
|
|
18115
|
307 #endif /* NO_UNION_TYPE */
|
|
302
|
308
|
|
51685
|
309 /* In the size word of a vector, this bit means the vector has been marked. */
|
|
6216
|
310
|
|
85022
|
311 #define ARRAY_MARK_FLAG ((EMACS_UINT) 1 << (BITS_PER_EMACS_INT - 1))
|
|
6216
|
312
|
|
10010
|
313 /* In the size word of a struct Lisp_Vector, this bit means it's really
|
|
|
314 some other vector-like object. */
|
|
85022
|
315 #define PSEUDOVECTOR_FLAG ((ARRAY_MARK_FLAG >> 1))
|
|
10010
|
316
|
|
10322
|
317 /* In a pseudovector, the size field actually contains a word with one
|
|
10010
|
318 PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
|
|
84689
|
319 indicate the actual type.
|
85012
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
320 We use a bitset, even tho only one of the bits can be set at any
|
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
321 particular time just so as to be able to use micro-optimizations such as
|
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
322 testing membership of a particular subset of pseudovectors in Fequal.
|
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
323 It is not crucial, but there are plenty of bits here, so why not do it? */
|
|
10316
|
324 enum pvec_type
|
|
|
325 {
|
|
|
326 PVEC_NORMAL_VECTOR = 0,
|
|
|
327 PVEC_PROCESS = 0x200,
|
|
|
328 PVEC_FRAME = 0x400,
|
|
|
329 PVEC_COMPILED = 0x800,
|
|
|
330 PVEC_WINDOW = 0x1000,
|
|
|
331 PVEC_WINDOW_CONFIGURATION = 0x2000,
|
|
|
332 PVEC_SUBR = 0x4000,
|
|
13149
|
333 PVEC_CHAR_TABLE = 0x8000,
|
|
|
334 PVEC_BOOL_VECTOR = 0x10000,
|
|
|
335 PVEC_BUFFER = 0x20000,
|
|
25017
|
336 PVEC_HASH_TABLE = 0x40000,
|
|
84689
|
337 PVEC_TERMINAL = 0x80000,
|
|
|
338 PVEC_TYPE_MASK = 0xffe00
|
|
45623
|
339
|
|
26569
|
340 #if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to
|
|
|
341 GDB. It doesn't work on OS Alpha. Moved to a variable in
|
|
|
342 emacs.c. */
|
|
12246
|
343 PVEC_FLAG = PSEUDOVECTOR_FLAG
|
|
26569
|
344 #endif
|
|
10316
|
345 };
|
|
10010
|
346
|
|
69871
|
347 /* For convenience, we also store the number of elements in these bits.
|
|
|
348 Note that this size is not necessarily the memory-footprint size, but
|
|
|
349 only the number of Lisp_Object fields (that need to be traced by the GC).
|
|
|
350 The distinction is used e.g. by Lisp_Process which places extra
|
|
|
351 non-Lisp_Object fields at the end of the structure. */
|
|
13149
|
352 #define PSEUDOVECTOR_SIZE_MASK 0x1ff
|
|
55157
|
353
|
|
|
354 /* Number of bits to put in each character in the internal representation
|
|
|
355 of bool vectors. This should not vary across implementations. */
|
|
|
356 #define BOOL_VECTOR_BITS_PER_CHAR 8
|
|
302
|
357
|
|
|
358 /* These macros extract various sorts of values from a Lisp_Object.
|
|
|
359 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
|
|
10316
|
360 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
|
|
302
|
361
|
|
|
362 #ifdef NO_UNION_TYPE
|
|
|
363
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
364 /* Return a perfect hash of the Lisp_Object representation. */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
365 #define XHASH(a) (a)
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
366
|
|
53654
|
367 #ifdef USE_LSB_TAG
|
|
|
368
|
|
|
369 #define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
|
|
|
370 #define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) & TYPEMASK))
|
|
|
371 #define XINT(a) (((EMACS_INT) (a)) >> GCTYPEBITS)
|
|
|
372 #define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
|
|
|
373 #define XSET(var, type, ptr) \
|
|
|
374 (eassert (XTYPE (ptr) == 0), /* Check alignment. */ \
|
|
|
375 (var) = ((EMACS_INT) (type)) | ((EMACS_INT) (ptr)))
|
|
|
376 #define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
|
|
|
377
|
|
|
378 /* XFASTINT and XSETFASTINT are for use when the integer is known to be
|
|
|
379 positive, in which case the implementation can sometimes be faster
|
|
|
380 depending on the tagging scheme. With USE_LSB_TAG, there's no benefit. */
|
|
|
381 #define XFASTINT(a) XINT (a)
|
|
|
382 #define XSETFASTINT(a, b) ((a) = make_number (b))
|
|
|
383
|
|
|
384 #define XPNTR(a) ((EMACS_INT) ((a) & ~TYPEMASK))
|
|
|
385
|
|
|
386 #else /* not USE_LSB_TAG */
|
|
|
387
|
|
53088
|
388 #define VALMASK ((((EMACS_INT) 1) << VALBITS) - 1)
|
|
|
389
|
|
302
|
390 /* One need to override this if there must be high bits set in data space
|
|
|
391 (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
|
|
39579
|
392 on all machines, but would penalize machines which don't need it)
|
|
302
|
393 */
|
|
52476
|
394 #define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) >> VALBITS))
|
|
302
|
395
|
|
9292
|
396 /* For integers known to be positive, XFASTINT provides fast retrieval
|
|
|
397 and XSETFASTINT provides fast storage. This takes advantage of the
|
|
53088
|
398 fact that Lisp_Int is 0. */
|
9328
4db4768d5857
(XFASTINT): Changed to non-lvalue syntax, to ensure that callers will use
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
399 #define XFASTINT(a) ((a) + 0)
|
|
9292
|
400 #define XSETFASTINT(a, b) ((a) = (b))
|
|
302
|
401
|
|
|
402 /* Extract the value of a Lisp_Object as a signed integer. */
|
|
|
403
|
|
|
404 #ifndef XINT /* Some machines need to do this differently. */
|
|
52998
|
405 #define XINT(a) ((((EMACS_INT) (a)) << (BITS_PER_EMACS_INT - VALBITS)) \
|
|
|
406 >> (BITS_PER_EMACS_INT - VALBITS))
|
|
302
|
407 #endif
|
|
|
408
|
|
|
409 /* Extract the value as an unsigned integer. This is a basis
|
|
|
410 for extracting it as a pointer to a structure in storage. */
|
|
|
411
|
|
|
412 #ifndef XUINT
|
|
31907
|
413 #define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
|
|
302
|
414 #endif
|
|
|
415
|
|
|
416 #ifndef XSET
|
|
|
417 #define XSET(var, type, ptr) \
|
|
8827
|
418 ((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
|
|
302
|
419 #endif
|
|
|
420
|
|
14306
|
421 /* Convert a C integer into a Lisp_Object integer. */
|
|
|
422
|
|
|
423 #define make_number(N) \
|
|
|
424 ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
|
|
|
425
|
|
53654
|
426 #endif /* not USE_LSB_TAG */
|
|
|
427
|
|
53088
|
428 #else /* not NO_UNION_TYPE */
|
|
302
|
429
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
430 #define XHASH(a) ((a).i)
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
431
|
|
302
|
432 #define XTYPE(a) ((enum Lisp_Type) (a).u.type)
|
|
|
433
|
|
9292
|
434 /* For integers known to be positive, XFASTINT provides fast retrieval
|
|
|
435 and XSETFASTINT provides fast storage. This takes advantage of the
|
|
|
436 fact that Lisp_Int is 0. */
|
9328
4db4768d5857
(XFASTINT): Changed to non-lvalue syntax, to ensure that callers will use
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
437 #define XFASTINT(a) ((a).i + 0)
|
|
9292
|
438 #define XSETFASTINT(a, b) ((a).i = (b))
|
|
302
|
439
|
|
|
440 #ifdef EXPLICIT_SIGN_EXTEND
|
|
|
441 /* Make sure we sign-extend; compilers have been known to fail to do so. */
|
|
55081
|
442 #define XINT(a) (((a).s.val << (BITS_PER_EMACS_INT - VALBITS)) \
|
|
31907
|
443 >> (BITS_PER_EMACS_INT - VALBITS))
|
|
302
|
444 #else
|
|
|
445 #define XINT(a) ((a).s.val)
|
|
|
446 #endif /* EXPLICIT_SIGN_EXTEND */
|
|
|
447
|
|
|
448 #define XUINT(a) ((a).u.val)
|
|
|
449
|
|
|
450 #define XSET(var, vartype, ptr) \
|
|
31901
|
451 (((var).s.val = ((EMACS_INT) (ptr))), ((var).s.type = ((char) (vartype))))
|
28508
a68042252425
* lisp.h (make_number) [!NO_UNION_TYPE && __GNUC__ >= 2 && __OPTIMIZE__]:
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
452
|
a68042252425
* lisp.h (make_number) [!NO_UNION_TYPE && __GNUC__ >= 2 && __OPTIMIZE__]:
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
453 #if __GNUC__ >= 2 && defined (__OPTIMIZE__)
|
a68042252425
* lisp.h (make_number) [!NO_UNION_TYPE && __GNUC__ >= 2 && __OPTIMIZE__]:
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
454 #define make_number(N) \
|
a68042252425
* lisp.h (make_number) [!NO_UNION_TYPE && __GNUC__ >= 2 && __OPTIMIZE__]:
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
455 (__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
|
a68042252425
* lisp.h (make_number) [!NO_UNION_TYPE && __GNUC__ >= 2 && __OPTIMIZE__]:
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
456 #else
|
|
60897
|
457 extern Lisp_Object make_number P_ ((EMACS_INT));
|
28508
a68042252425
* lisp.h (make_number) [!NO_UNION_TYPE && __GNUC__ >= 2 && __OPTIMIZE__]:
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
458 #endif
|
|
17404
|
459
|
|
53000
|
460 #endif /* NO_UNION_TYPE */
|
|
|
461
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
462 #define EQ(x, y) (XHASH (x) == XHASH (y))
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
463
|
|
302
|
464 /* During garbage collection, XGCTYPE must be used for extracting types
|
|
53000
|
465 so that the mark bit is ignored. XMARKBIT accesses the markbit.
|
|
302
|
466 Markbits are used only in particular slots of particular structure types.
|
|
|
467 Other markbits are always zero.
|
|
|
468 Outside of garbage collection, all mark bits are always zero. */
|
|
|
469
|
|
53000
|
470 #ifndef XGCTYPE
|
|
|
471 /* The distinction does not exist now that the MARKBIT has been eliminated. */
|
|
53088
|
472 #define XGCTYPE(a) XTYPE (a)
|
|
53000
|
473 #endif
|
|
302
|
474
|
|
46650
|
475 #ifndef XPNTR
|
|
|
476 #ifdef HAVE_SHM
|
|
|
477 /* In this representation, data is found in two widely separated segments. */
|
|
|
478 extern size_t pure_size;
|
|
|
479 #define XPNTR(a) \
|
|
|
480 (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
|
|
|
481 #else /* not HAVE_SHM */
|
|
|
482 #ifdef DATA_SEG_BITS
|
|
|
483 /* This case is used for the rt-pc.
|
|
|
484 In the diffs I was given, it checked for ptr = 0
|
|
|
485 and did not adjust it in that case.
|
|
|
486 But I don't think that zero should ever be found
|
|
|
487 in a Lisp object whose data type says it points to something. */
|
|
|
488 #define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
|
|
|
489 #else
|
68628
6c6e4e3cccc8
(XPNTR) [!NO_UNION_TYPE && !HAVE_SHM && !DATA_SEG_BITS]: Cast bitfield
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
490 /* Some versions of gcc seem to consider the bitfield width when
|
6c6e4e3cccc8
(XPNTR) [!NO_UNION_TYPE && !HAVE_SHM && !DATA_SEG_BITS]: Cast bitfield
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
491 issuing the "cast to pointer from integer of different size"
|
6c6e4e3cccc8
(XPNTR) [!NO_UNION_TYPE && !HAVE_SHM && !DATA_SEG_BITS]: Cast bitfield
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
492 warning, so the cast is here to widen the value back to its natural
|
6c6e4e3cccc8
(XPNTR) [!NO_UNION_TYPE && !HAVE_SHM && !DATA_SEG_BITS]: Cast bitfield
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
493 size. */
|
6c6e4e3cccc8
(XPNTR) [!NO_UNION_TYPE && !HAVE_SHM && !DATA_SEG_BITS]: Cast bitfield
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
494 #define XPNTR(a) ((EMACS_INT) XUINT (a))
|
|
46650
|
495 #endif
|
|
|
496 #endif /* not HAVE_SHM */
|
|
|
497 #endif /* no XPNTR */
|
|
|
498
|
|
39640
|
499 /* Largest and smallest representable fixnum values. These are the C
|
|
|
500 values. */
|
|
|
501
|
|
|
502 #define MOST_NEGATIVE_FIXNUM - ((EMACS_INT) 1 << (VALBITS - 1))
|
|
|
503 #define MOST_POSITIVE_FIXNUM (((EMACS_INT) 1 << (VALBITS - 1)) - 1)
|
|
53088
|
504 /* Mask indicating the significant bits of a Lisp_Int.
|
|
|
505 I.e. (x & INTMASK) == XUINT (make_number (x)). */
|
|
|
506 #define INTMASK ((((EMACS_INT) 1) << VALBITS) - 1)
|
|
39631
|
507
|
|
|
508 /* Value is non-zero if C integer I doesn't fit into a Lisp fixnum. */
|
|
|
509
|
|
|
510 #define FIXNUM_OVERFLOW_P(i) \
|
|
39779
|
511 ((EMACS_INT)(i) > MOST_POSITIVE_FIXNUM \
|
|
|
512 || (EMACS_INT) (i) < MOST_NEGATIVE_FIXNUM)
|
|
39631
|
513
|
|
10316
|
514 /* Extract a value or address from a Lisp_Object. */
|
|
302
|
515
|
28417
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
516 #define XCONS(a) (eassert (GC_CONSP(a)),(struct Lisp_Cons *) XPNTR(a))
|
38474
86bc182c8651
* lisp.h (XVECTOR): Verify correct object type before returning a pointer.
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
517 #define XVECTOR(a) (eassert (GC_VECTORLIKEP(a)),(struct Lisp_Vector *) XPNTR(a))
|
28417
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
518 #define XSTRING(a) (eassert (GC_STRINGP(a)),(struct Lisp_String *) XPNTR(a))
|
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
519 #define XSYMBOL(a) (eassert (GC_SYMBOLP(a)),(struct Lisp_Symbol *) XPNTR(a))
|
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
520 #define XFLOAT(a) (eassert (GC_FLOATP(a)),(struct Lisp_Float *) XPNTR(a))
|
|
10292
|
521
|
|
|
522 /* Misc types. */
|
|
30173
|
523
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
524 #define XMISC(a) ((union Lisp_Misc *) XPNTR(a))
|
|
11335
|
525 #define XMISCTYPE(a) (XMARKER (a)->type)
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
526 #define XMARKER(a) (&(XMISC(a)->u_marker))
|
|
9462
|
527 #define XINTFWD(a) (&(XMISC(a)->u_intfwd))
|
|
|
528 #define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
|
|
|
529 #define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
|
|
|
530 #define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
|
9891
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
531 #define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
|
|
9924
|
532 #define XOVERLAY(a) (&(XMISC(a)->u_overlay))
|
|
11012
|
533 #define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
|
|
49056
|
534 #define XSAVE_VALUE(a) (&(XMISC(a)->u_save_value))
|
|
302
|
535
|
|
10292
|
536 /* Pseudovector types. */
|
|
30173
|
537
|
28417
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
538 #define XPROCESS(a) (eassert (GC_PROCESSP(a)),(struct Lisp_Process *) XPNTR(a))
|
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
539 #define XWINDOW(a) (eassert (GC_WINDOWP(a)),(struct window *) XPNTR(a))
|
|
84689
|
540 #define XTERMINAL(a) (eassert (GC_TERMINALP(a)),(struct terminal *) XPNTR(a))
|
28417
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
541 #define XSUBR(a) (eassert (GC_SUBRP(a)),(struct Lisp_Subr *) XPNTR(a))
|
4b675266db04
* lisp.h (XCONS, XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XSUBR, XBUFFER):
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
542 #define XBUFFER(a) (eassert (GC_BUFFERP(a)),(struct buffer *) XPNTR(a))
|
85012
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
543 #define XCHAR_TABLE(a) (eassert (GC_CHAR_TABLE_P (a)), (struct Lisp_Char_Table *) XPNTR(a))
|
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
544 #define XBOOL_VECTOR(a) (eassert (GC_BOOL_VECTOR_P (a)), (struct Lisp_Bool_Vector *) XPNTR(a))
|
|
10316
|
545
|
|
|
546 /* Construct a Lisp_Object from a value or address. */
|
|
10292
|
547
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
548 #define XSETINT(a, b) (a) = make_number (b)
|
9287
781ada39b15c
(XSETINT, XSETCONS, XSETBUFFER, XSETVECTOR, XSETSUBR, XSETSTRING, XSETSYMBOL,
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
549 #define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
|
|
10010
|
550 #define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
|
9287
781ada39b15c
(XSETINT, XSETCONS, XSETBUFFER, XSETVECTOR, XSETSUBR, XSETSTRING, XSETSYMBOL,
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
551 #define XSETSTRING(a, b) XSET (a, Lisp_String, b)
|
781ada39b15c
(XSETINT, XSETCONS, XSETBUFFER, XSETVECTOR, XSETSUBR, XSETSTRING, XSETSYMBOL,
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
552 #define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
|
|
10292
|
553 #define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
|
|
|
554
|
|
|
555 /* Misc types. */
|
|
30173
|
556
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
557 #define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
|
|
11335
|
558 #define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
|
|
10292
|
559
|
|
|
560 /* Pseudovector types. */
|
|
30173
|
561
|
85012
3a31b2cfe77f
(ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG): Don't allow definition in m/*.h files.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
562 #define XSETPVECTYPE(v,code) ((v)->size |= PSEUDOVECTOR_FLAG | (code))
|
|
10292
|
563 #define XSETPSEUDOVECTOR(a, b, code) \
|
|
85105
|
564 (XSETVECTOR (a, b), \
|
|
|
565 eassert ((XVECTOR (a)->size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \
|
|
|
566 == (PSEUDOVECTOR_FLAG | (code))))
|
|
10292
|
567 #define XSETWINDOW_CONFIGURATION(a, b) \
|
|
|
568 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
|
|
|
569 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
|
|
|
570 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
|
|
84689
|
571 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
|
|
10292
|
572 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
|
|
|
573 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
|
|
10316
|
574 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
|
|
13149
|
575 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
|
|
|
576 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
|
|
30173
|
577
|
|
|
578 /* Convenience macros for dealing with Lisp arrays. */
|
|
|
579
|
|
|
580 #define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX]
|
|
|
581 #define ASET(ARRAY, IDX, VAL) (AREF ((ARRAY), (IDX)) = (VAL))
|
|
|
582 #define ASIZE(ARRAY) XVECTOR ((ARRAY))->size
|
|
|
583
|
|
43780
|
584 /* Convenience macros for dealing with Lisp strings. */
|
|
|
585
|
|
46416
|
586 #define SDATA(string) (XSTRING (string)->data + 0)
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
587 #define SREF(string, index) (SDATA (string)[index] + 0)
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
588 #define SSET(string, index, new) (SDATA (string)[index] = (new))
|
|
46372
|
589 #define SCHARS(string) (XSTRING (string)->size + 0)
|
|
|
590 #define SBYTES(string) (STRING_BYTES (XSTRING (string)) + 0)
|
|
|
591
|
|
|
592 #define STRING_SET_CHARS(string, newsize) \
|
|
|
593 (XSTRING (string)->size = (newsize))
|
|
43780
|
594
|
|
46552
|
595 #define STRING_COPYIN(string, index, new, count) \
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
596 bcopy (new, SDATA (string) + index, count)
|
|
46552
|
597
|
|
71822
|
598 /* Type checking. */
|
|
|
599
|
|
|
600 #define CHECK_TYPE(ok, Qxxxp, x) \
|
|
|
601 do { if (!(ok)) wrong_type_argument (Qxxxp, (x)); } while (0)
|
|
|
602
|
|
|
603
|
|
302
|
604
|
|
51858
|
605 /* See the macros in intervals.h. */
|
|
1290
|
606
|
|
|
607 typedef struct interval *INTERVAL;
|
|
|
608
|
|
|
609 /* Complain if object is not string or buffer type */
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
610 #define CHECK_STRING_OR_BUFFER(x) \
|
|
71822
|
611 CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x)
|
|
|
612
|
|
1290
|
613
|
|
302
|
614 /* In a cons, the markbit of the car is the gc mark bit */
|
|
|
615
|
|
|
616 struct Lisp_Cons
|
|
|
617 {
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
618 /* Please do not use the names of these elements in code other
|
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
619 than the core lisp implementation. Use XCAR and XCDR below. */
|
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
620 #ifdef HIDE_LISP_IMPLEMENTATION
|
|
66888
|
621 Lisp_Object car_;
|
|
|
622 union
|
|
|
623 {
|
|
|
624 Lisp_Object cdr_;
|
|
|
625 struct Lisp_Cons *chain;
|
|
|
626 } u;
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
627 #else
|
|
66888
|
628 Lisp_Object car;
|
|
|
629 union
|
|
|
630 {
|
|
|
631 Lisp_Object cdr;
|
|
|
632 struct Lisp_Cons *chain;
|
|
|
633 } u;
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
634 #endif
|
|
302
|
635 };
|
|
|
636
|
|
14306
|
637 /* Take the car or cdr of something known to be a cons cell. */
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
638 /* The _AS_LVALUE macros shouldn't be used outside of the minimal set
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
639 of code that has to know what a cons cell looks like. Other code not
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
640 part of the basic lisp implementation should assume that the car and cdr
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
641 fields are not accessible as lvalues. (What if we want to switch to
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
642 a copying collector someday? Cached cons cell field addresses may be
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
643 invalidated at arbitrary points.) */
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
644 #ifdef HIDE_LISP_IMPLEMENTATION
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
645 #define XCAR_AS_LVALUE(c) (XCONS ((c))->car_)
|
|
66888
|
646 #define XCDR_AS_LVALUE(c) (XCONS ((c))->u.cdr_)
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
647 #else
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
648 #define XCAR_AS_LVALUE(c) (XCONS ((c))->car)
|
|
66888
|
649 #define XCDR_AS_LVALUE(c) (XCONS ((c))->u.cdr)
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
650 #endif
|
|
14306
|
651
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
652 /* Use these from normal code. */
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
653 #define XCAR(c) LISP_MAKE_RVALUE(XCAR_AS_LVALUE(c))
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
654 #define XCDR(c) LISP_MAKE_RVALUE(XCDR_AS_LVALUE(c))
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
655
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
656 /* Use these to set the fields of a cons cell.
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
657
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
658 Note that both arguments may refer to the same object, so 'n'
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
659 should not be read after 'c' is first modified. Also, neither
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
660 argument should be evaluated more than once; side effects are
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
661 especially common in the second argument. */
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
662 #define XSETCAR(c,n) (XCAR_AS_LVALUE(c) = (n))
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
663 #define XSETCDR(c,n) (XCDR_AS_LVALUE(c) = (n))
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
664
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
665 /* For performance: Fast storage of positive integers into the
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
666 fields of a cons cell. See above caveats. */
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
667 #define XSETCARFASTINT(c,n) XSETFASTINT(XCAR_AS_LVALUE(c),(n))
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
668 #define XSETCDRFASTINT(c,n) XSETFASTINT(XCDR_AS_LVALUE(c),(n))
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
669
|
|
14306
|
670 /* Take the car or cdr of something whose type is not known. */
|
|
|
671 #define CAR(c) \
|
|
|
672 (CONSP ((c)) ? XCAR ((c)) \
|
|
|
673 : NILP ((c)) ? Qnil \
|
|
|
674 : wrong_type_argument (Qlistp, (c)))
|
|
|
675
|
|
|
676 #define CDR(c) \
|
|
|
677 (CONSP ((c)) ? XCDR ((c)) \
|
|
|
678 : NILP ((c)) ? Qnil \
|
|
|
679 : wrong_type_argument (Qlistp, (c)))
|
|
|
680
|
|
71822
|
681 /* Take the car or cdr of something whose type is not known. */
|
|
|
682 #define CAR_SAFE(c) \
|
|
|
683 (CONSP ((c)) ? XCAR ((c)) : Qnil)
|
|
|
684
|
|
|
685 #define CDR_SAFE(c) \
|
|
|
686 (CONSP ((c)) ? XCDR ((c)) : Qnil)
|
|
|
687
|
|
21276
|
688 /* Nonzero if STR is a multibyte string. */
|
|
|
689 #define STRING_MULTIBYTE(STR) \
|
|
|
690 (XSTRING (STR)->size_byte >= 0)
|
|
|
691
|
|
|
692 /* Return the length in bytes of STR. */
|
|
35184
|
693
|
|
|
694 #ifdef GC_CHECK_STRING_BYTES
|
|
|
695
|
|
|
696 struct Lisp_String;
|
|
|
697 extern int string_bytes P_ ((struct Lisp_String *));
|
|
|
698 #define STRING_BYTES(S) string_bytes ((S))
|
|
|
699
|
|
|
700 #else /* not GC_CHECK_STRING_BYTES */
|
|
|
701
|
|
21276
|
702 #define STRING_BYTES(STR) \
|
|
|
703 ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
|
|
|
704
|
|
35184
|
705 #endif /* not GC_CHECK_STRING_BYTES */
|
|
|
706
|
|
46369
|
707 /* Mark STR as a unibyte string. */
|
81269
5e310b8be81d
(STRING_SET_UNIBYTE): Return the canonical empty unibyte string, if appropriate.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
708 #define STRING_SET_UNIBYTE(STR) \
|
5e310b8be81d
(STRING_SET_UNIBYTE): Return the canonical empty unibyte string, if appropriate.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
709 do { if (EQ (STR, empty_multibyte_string)) \
|
5e310b8be81d
(STRING_SET_UNIBYTE): Return the canonical empty unibyte string, if appropriate.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
710 (STR) = empty_unibyte_string; \
|
5e310b8be81d
(STRING_SET_UNIBYTE): Return the canonical empty unibyte string, if appropriate.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
711 else XSTRING (STR)->size_byte = -1; } while (0)
|
|
46369
|
712
|
|
|
713 /* Get text properties. */
|
|
46377
|
714 #define STRING_INTERVALS(STR) (XSTRING (STR)->intervals + 0)
|
|
|
715
|
|
|
716 /* Set text properties. */
|
|
|
717 #define STRING_SET_INTERVALS(STR, INT) (XSTRING (STR)->intervals = (INT))
|
|
21276
|
718
|
|
302
|
719 /* In a string or vector, the sign bit of the `size' is the gc mark bit */
|
|
|
720
|
|
|
721 struct Lisp_String
|
|
|
722 {
|
|
8827
|
723 EMACS_INT size;
|
|
20625
|
724 EMACS_INT size_byte;
|
|
30934
|
725 INTERVAL intervals; /* text properties in this string */
|
|
27141
|
726 unsigned char *data;
|
|
302
|
727 };
|
|
|
728
|
|
69869
|
729 #ifdef offsetof
|
|
|
730 #define OFFSETOF(type,field) offsetof(type,field)
|
|
|
731 #else
|
|
|
732 #define OFFSETOF(type,field) \
|
|
|
733 ((int)((char*)&((type*)0)->field - (char*)0))
|
|
|
734 #endif
|
|
|
735
|
|
69874
|
736 struct Lisp_Vector
|
|
|
737 {
|
|
85022
|
738 EMACS_UINT size;
|
|
69874
|
739 struct Lisp_Vector *next;
|
|
|
740 Lisp_Object contents[1];
|
|
|
741 };
|
|
|
742
|
|
9971
|
743 /* If a struct is made to look like a vector, this macro returns the length
|
|
14473
|
744 of the shortest vector that would hold that struct. */
|
|
80829
|
745 #define VECSIZE(type) ((sizeof (type) \
|
|
|
746 - OFFSETOF (struct Lisp_Vector, contents[0]) \
|
|
|
747 + sizeof(Lisp_Object) - 1) /* round up */ \
|
|
9971
|
748 / sizeof (Lisp_Object))
|
|
|
749
|
|
69869
|
750 /* Like VECSIZE, but used when the pseudo-vector has non-Lisp_Object fields
|
|
|
751 at the end and we need to compute the number of Lisp_Object fields (the
|
|
|
752 ones that the GC needs to trace). */
|
|
|
753 #define PSEUDOVECSIZE(type, nonlispfield) \
|
|
69874
|
754 ((OFFSETOF(type, nonlispfield) - OFFSETOF(struct Lisp_Vector, contents[0])) \
|
|
69869
|
755 / sizeof (Lisp_Object))
|
|
|
756
|
|
17326
|
757 /* A char table is a kind of vectorlike, with contents are like a
|
|
|
758 vector but with a few other slots. For some purposes, it makes
|
|
|
759 sense to handle a chartable with type struct Lisp_Vector. An
|
|
|
760 element of a char table can be any Lisp objects, but if it is a sub
|
|
|
761 char-table, we treat it a table that contains information of a
|
|
|
762 group of characters of the same charsets or a specific character of
|
|
|
763 a charset. A sub char-table has the same structure as a char table
|
|
|
764 except for that the former omits several slots at the tail. A sub
|
|
|
765 char table appears only in an element of a char table, and there's
|
|
|
766 no way to access it directly from Emacs Lisp program. */
|
|
17404
|
767
|
|
17188
|
768 /* This is the number of slots that apply to characters or character
|
|
|
769 sets. The first 128 are for ASCII, the next 128 are for 8-bit
|
|
17326
|
770 European characters, and the last 128 are for multibyte characters.
|
|
|
771 The first 256 are indexed by the code itself, but the last 128 are
|
|
|
772 indexed by (charset-id + 128). */
|
|
17188
|
773 #define CHAR_TABLE_ORDINARY_SLOTS 384
|
|
|
774
|
|
61684
|
775 /* These are the slot of the default values for single byte
|
|
|
776 characters. As 0x9A is never be a charset-id, it is safe to use
|
|
|
777 that slot for ASCII. 0x9E and 0x80 are charset-ids of
|
|
|
778 eight-bit-control and eight-bit-graphic respectively. */
|
|
|
779 #define CHAR_TABLE_DEFAULT_SLOT_ASCII (0x9A + 128)
|
|
|
780 #define CHAR_TABLE_DEFAULT_SLOT_8_BIT_CONTROL (0x9E + 128)
|
|
|
781 #define CHAR_TABLE_DEFAULT_SLOT_8_BIT_GRAPHIC (0x80 + 128)
|
|
|
782
|
|
17188
|
783 /* This is the number of slots that apply to characters of ASCII and
|
|
|
784 8-bit Europeans only. */
|
|
|
785 #define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
|
|
13149
|
786
|
|
17326
|
787 /* This is the number of slots that every char table must have. This
|
|
|
788 counts the ordinary slots and the top, defalt, parent, and purpose
|
|
|
789 slots. */
|
|
|
790 #define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
|
|
|
791
|
|
|
792 /* This is the number of slots that apply to position-code-1 and
|
|
|
793 position-code-2 of a multibyte character at the 2nd and 3rd level
|
|
|
794 sub char tables respectively. */
|
|
|
795 #define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
|
|
|
796
|
|
|
797 /* This is the number of slots that every sub char table must have.
|
|
|
798 This counts the ordinary slots and the top and defalt slot. */
|
|
17404
|
799 #define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
|
|
13149
|
800
|
|
|
801 /* Return the number of "extra" slots in the char table CT. */
|
|
|
802
|
|
|
803 #define CHAR_TABLE_EXTRA_SLOTS(CT) \
|
|
|
804 (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
|
|
|
805
|
|
17188
|
806 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
|
|
18006
|
807 and 8-bit Europeans characters. For these characters, do not check
|
|
|
808 validity of CT. Do not follow parent. */
|
|
|
809 #define CHAR_TABLE_REF(CT, IDX) \
|
|
23721
|
810 ((IDX) >= 0 && (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
|
|
18613
|
811 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
|
|
|
812 ? XCHAR_TABLE (CT)->contents[IDX] \
|
|
18006
|
813 : XCHAR_TABLE (CT)->defalt) \
|
|
18613
|
814 : Faref (CT, make_number (IDX)))
|
|
17188
|
815
|
|
22239
|
816 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
|
|
|
817 and 8-bit Europeans characters. However, if the result is nil,
|
|
|
818 return IDX.
|
|
|
819
|
|
|
820 For these characters, do not check validity of CT
|
|
|
821 and do not follow parent. */
|
|
|
822 #define CHAR_TABLE_TRANSLATE(CT, IDX) \
|
|
|
823 ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
|
|
|
824 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
|
|
|
825 ? XINT (XCHAR_TABLE (CT)->contents[IDX]) \
|
|
|
826 : IDX) \
|
|
|
827 : char_table_translate (CT, IDX))
|
|
|
828
|
|
17188
|
829 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
|
|
18006
|
830 8-bit Europeans characters. Do not check validity of CT. */
|
|
|
831 #define CHAR_TABLE_SET(CT, IDX, VAL) \
|
|
|
832 do { \
|
|
|
833 if (XFASTINT (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS) \
|
|
|
834 XCHAR_TABLE (CT)->contents[XFASTINT (IDX)] = VAL; \
|
|
|
835 else \
|
|
|
836 Faset (CT, IDX, VAL); \
|
|
17188
|
837 } while (0)
|
|
|
838
|
|
13149
|
839 struct Lisp_Char_Table
|
|
|
840 {
|
|
|
841 /* This is the vector's size field, which also holds the
|
|
|
842 pseudovector type information. It holds the size, too.
|
|
17326
|
843 The size counts the top, defalt, purpose, and parent slots.
|
|
|
844 The last three are not counted if this is a sub char table. */
|
|
85022
|
845 EMACS_UINT size;
|
|
13149
|
846 struct Lisp_Vector *next;
|
|
17326
|
847 /* This holds a flag to tell if this is a top level char table (t)
|
|
|
848 or a sub char table (nil). */
|
|
|
849 Lisp_Object top;
|
|
13149
|
850 /* This holds a default value,
|
|
|
851 which is used whenever the value for a specific character is nil. */
|
|
|
852 Lisp_Object defalt;
|
|
17326
|
853 /* This holds an actual value of each element. A sub char table
|
|
|
854 has only SUB_CHAR_TABLE_ORDINARY_SLOTS number of elements. */
|
|
|
855 Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
|
|
|
856
|
|
|
857 /* A sub char table doesn't has the following slots. */
|
|
|
858
|
|
13149
|
859 /* This points to another char table, which we inherit from
|
|
|
860 when the value for a specific character is nil.
|
|
|
861 The `defalt' slot takes precedence over this. */
|
|
|
862 Lisp_Object parent;
|
|
13202
|
863 /* This should be a symbol which says what kind of use
|
|
|
864 this char-table is meant for.
|
|
|
865 Typically now the values can be `syntax-table' and `display-table'. */
|
|
|
866 Lisp_Object purpose;
|
|
13149
|
867 /* These hold additional data. */
|
|
|
868 Lisp_Object extras[1];
|
|
|
869 };
|
|
|
870
|
|
|
871 /* A boolvector is a kind of vectorlike, with contents are like a string. */
|
|
|
872 struct Lisp_Bool_Vector
|
|
|
873 {
|
|
|
874 /* This is the vector's size field. It doesn't have the real size,
|
|
|
875 just the subtype information. */
|
|
85022
|
876 EMACS_UINT vector_size;
|
|
13149
|
877 struct Lisp_Vector *next;
|
|
|
878 /* This is the size in bits. */
|
|
85022
|
879 EMACS_UINT size;
|
|
13149
|
880 /* This contains the actual bits, packed into bytes. */
|
|
|
881 unsigned char data[1];
|
|
|
882 };
|
|
|
883
|
|
10292
|
884 /* This structure describes a built-in function.
|
|
|
885 It is generated by the DEFUN macro only.
|
|
|
886 defsubr makes it into a Lisp object.
|
|
|
887
|
|
|
888 This type is treated in most respects as a pseudovector,
|
|
|
889 but since we never dynamically allocate or free them,
|
|
|
890 we don't need a next-vector field. */
|
|
17404
|
891
|
|
302
|
892 struct Lisp_Subr
|
|
|
893 {
|
|
85022
|
894 EMACS_UINT size;
|
|
302
|
895 Lisp_Object (*function) ();
|
|
|
896 short min_args, max_args;
|
|
|
897 char *symbol_name;
|
84434
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
898 char *intspec;
|
|
302
|
899 char *doc;
|
|
|
900 };
|
|
25017
|
901
|
|
|
902
|
|
|
903 /***********************************************************************
|
|
39579
|
904 Symbols
|
|
|
905 ***********************************************************************/
|
|
|
906
|
|
|
907 /* Interned state of a symbol. */
|
|
|
908
|
|
|
909 enum symbol_interned
|
|
|
910 {
|
|
|
911 SYMBOL_UNINTERNED = 0,
|
|
|
912 SYMBOL_INTERNED = 1,
|
|
|
913 SYMBOL_INTERNED_IN_INITIAL_OBARRAY = 2
|
|
|
914 };
|
|
|
915
|
|
|
916 /* In a symbol, the markbit of the plist is used as the gc mark bit */
|
|
|
917
|
|
|
918 struct Lisp_Symbol
|
|
|
919 {
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
920 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
921
|
|
39579
|
922 /* Non-zero means symbol serves as a variable alias. The symbol
|
|
|
923 holding the real value is found in the value slot. */
|
|
|
924 unsigned indirect_variable : 1;
|
|
|
925
|
|
|
926 /* Non-zero means symbol is constant, i.e. changing its value
|
|
|
927 should signal an error. */
|
|
|
928 unsigned constant : 1;
|
|
|
929
|
|
|
930 /* Interned state of the symbol. This is an enumerator from
|
|
|
931 enum symbol_interned. */
|
|
|
932 unsigned interned : 2;
|
|
|
933
|
45405
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
934 /* The symbol's name, as a Lisp string.
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
935
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
936 The name "xname" is used to intentionally break code referring to
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
937 the old field "name" of type pointer to struct Lisp_String. */
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
938 Lisp_Object xname;
|
|
39579
|
939
|
|
|
940 /* Value of the symbol or Qunbound if unbound. If this symbol is a
|
|
|
941 defvaralias, `value' contains the symbol for which it is an
|
|
|
942 alias. Use the SYMBOL_VALUE and SET_SYMBOL_VALUE macros to get
|
|
|
943 and set a symbol's value, to take defvaralias into account. */
|
|
|
944 Lisp_Object value;
|
|
|
945
|
|
41615
|
946 /* Function value of the symbol or Qunbound if not fboundp. */
|
|
39579
|
947 Lisp_Object function;
|
|
|
948
|
|
|
949 /* The symbol's property list. */
|
|
|
950 Lisp_Object plist;
|
|
45623
|
951
|
|
39579
|
952 /* Next symbol in obarray bucket, if the symbol is interned. */
|
|
|
953 struct Lisp_Symbol *next;
|
|
|
954 };
|
|
|
955
|
45405
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
956 /* Value is name of symbol. */
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
957
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
958 #define SYMBOL_NAME(sym) \
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
959 LISP_MAKE_RVALUE (XSYMBOL (sym)->xname)
|
13e858104d3b
* lisp.h (struct Lisp_Symbol): Replace field "name" with a lisp
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
960
|
|
39579
|
961 /* Value is non-zero if SYM is an interned symbol. */
|
|
|
962
|
|
|
963 #define SYMBOL_INTERNED_P(sym) \
|
|
|
964 (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
|
|
|
965
|
|
|
966 /* Value is non-zero if SYM is interned in initial_obarray. */
|
|
|
967
|
|
|
968 #define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
|
|
|
969 (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
|
|
|
970
|
|
|
971 /* Value is non-zero if symbol is considered a constant, i.e. its
|
|
|
972 value cannot be changed (there is an exception for keyword symbols,
|
|
|
973 whose value can be set to the keyword symbol itself). */
|
|
|
974
|
|
|
975 #define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
|
|
|
976
|
|
|
977 /* Value is the value of SYM, with defvaralias taken into
|
|
|
978 account. */
|
|
|
979
|
|
|
980 #define SYMBOL_VALUE(sym) \
|
|
|
981 (XSYMBOL (sym)->indirect_variable \
|
|
|
982 ? XSYMBOL (indirect_variable (sym))->value \
|
|
|
983 : XSYMBOL (sym)->value)
|
|
|
984
|
|
|
985 /* Set SYM's value to VAL, taking defvaralias into account. */
|
|
|
986
|
|
|
987 #define SET_SYMBOL_VALUE(sym, val) \
|
|
|
988 do { \
|
|
|
989 if (XSYMBOL (sym)->indirect_variable) \
|
|
|
990 XSYMBOL (indirect_variable ((sym)))->value = (val); \
|
|
|
991 else \
|
|
|
992 XSYMBOL (sym)->value = (val); \
|
|
|
993 } while (0)
|
|
45623
|
994
|
|
39579
|
995
|
|
|
996 /***********************************************************************
|
|
25017
|
997 Hash Tables
|
|
|
998 ***********************************************************************/
|
|
|
999
|
|
|
1000 /* The structure of a Lisp hash table. */
|
|
|
1001
|
|
|
1002 struct Lisp_Hash_Table
|
|
|
1003 {
|
|
|
1004 /* Vector fields. The hash table code doesn't refer to these. */
|
|
85022
|
1005 EMACS_UINT size;
|
|
25017
|
1006 struct Lisp_Vector *vec_next;
|
|
45623
|
1007
|
|
25017
|
1008 /* Function used to compare keys. */
|
|
|
1009 Lisp_Object test;
|
|
|
1010
|
|
|
1011 /* Nil if table is non-weak. Otherwise a symbol describing the
|
|
|
1012 weakness of the table. */
|
|
|
1013 Lisp_Object weak;
|
|
45623
|
1014
|
|
25017
|
1015 /* When the table is resized, and this is an integer, compute the
|
|
|
1016 new size by adding this to the old size. If a float, compute the
|
|
|
1017 new size by multiplying the old size with this factor. */
|
|
|
1018 Lisp_Object rehash_size;
|
|
|
1019
|
|
|
1020 /* Resize hash table when number of entries/ table size is >= this
|
|
|
1021 ratio, a float. */
|
|
|
1022 Lisp_Object rehash_threshold;
|
|
|
1023
|
|
|
1024 /* Vector of hash codes.. If hash[I] is nil, this means that that
|
|
|
1025 entry I is unused. */
|
|
|
1026 Lisp_Object hash;
|
|
|
1027
|
|
|
1028 /* Vector used to chain entries. If entry I is free, next[I] is the
|
|
|
1029 entry number of the next free item. If entry I is non-free,
|
|
|
1030 next[I] is the index of the next entry in the collision chain. */
|
|
|
1031 Lisp_Object next;
|
|
|
1032
|
|
|
1033 /* Index of first free entry in free list. */
|
|
|
1034 Lisp_Object next_free;
|
|
|
1035
|
|
|
1036 /* Bucket vector. A non-nil entry is the index of the first item in
|
|
|
1037 a collision chain. This vector's size can be larger than the
|
|
|
1038 hash table size to reduce collisions. */
|
|
|
1039 Lisp_Object index;
|
|
|
1040
|
|
|
1041 /* User-supplied hash function, or nil. */
|
|
|
1042 Lisp_Object user_hash_function;
|
|
|
1043
|
|
|
1044 /* User-supplied key comparison function, or nil. */
|
|
|
1045 Lisp_Object user_cmp_function;
|
|
|
1046
|
85021
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1047 /* Only the fields above are traced normally by the GC. The ones below
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1048 `count'. are special and are either ignored by the GC or traced in
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1049 a special way (e.g. because of weakness). */
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1050
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1051 /* Number of key/value entries in the table. */
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1052 unsigned int count;
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1053
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1054 /* Vector of keys and values. The key of item I is found at index
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1055 2 * I, the value is found at index 2 * I + 1.
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1056 This is gc_marked specially if the table is weak. */
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1057 Lisp_Object key_and_value;
|
a0c901e4e649
* lisp.h (struct Lisp_Hash_Table): Move non-traced elements at the end.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1058
|
81813
32d8fd242bb2
* lisp.h (struct Lisp_Hash_Table): Turn next_weak into a bare pointer.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1059 /* Next weak hash table if this is a weak hash table. The head
|
32d8fd242bb2
* lisp.h (struct Lisp_Hash_Table): Turn next_weak into a bare pointer.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1060 of the list is in weak_hash_tables. */
|
32d8fd242bb2
* lisp.h (struct Lisp_Hash_Table): Turn next_weak into a bare pointer.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1061 struct Lisp_Hash_Table *next_weak;
|
32d8fd242bb2
* lisp.h (struct Lisp_Hash_Table): Turn next_weak into a bare pointer.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1062
|
|
25017
|
1063 /* C function to compare two keys. */
|
|
|
1064 int (* cmpfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object,
|
|
|
1065 unsigned, Lisp_Object, unsigned));
|
|
|
1066
|
|
|
1067 /* C function to compute hash code. */
|
|
|
1068 unsigned (* hashfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object));
|
|
|
1069 };
|
|
|
1070
|
|
|
1071
|
|
|
1072 #define XHASH_TABLE(OBJ) \
|
|
|
1073 ((struct Lisp_Hash_Table *) XPNTR (OBJ))
|
|
|
1074
|
|
|
1075 #define XSET_HASH_TABLE(VAR, PTR) \
|
|
|
1076 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
|
|
|
1077
|
|
|
1078 #define HASH_TABLE_P(OBJ) PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE)
|
|
|
1079 #define GC_HASH_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_HASH_TABLE)
|
|
|
1080
|
|
71822
|
1081 #define CHECK_HASH_TABLE(x) \
|
|
|
1082 CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x)
|
|
25017
|
1083
|
46220
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1084 /* Value is the key part of entry IDX in hash table H. */
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1085
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1086 #define HASH_KEY(H, IDX) AREF ((H)->key_and_value, 2 * (IDX))
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1087
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1088 /* Value is the value part of entry IDX in hash table H. */
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1089
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1090 #define HASH_VALUE(H, IDX) AREF ((H)->key_and_value, 2 * (IDX) + 1)
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1091
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1092 /* Value is the index of the next entry following the one at IDX
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1093 in hash table H. */
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1094
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1095 #define HASH_NEXT(H, IDX) AREF ((H)->next, (IDX))
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1096
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1097 /* Value is the hash code computed for entry IDX in hash table H. */
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1098
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1099 #define HASH_HASH(H, IDX) AREF ((H)->hash, (IDX))
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1100
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1101 /* Value is the index of the element in hash table H that is the
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1102 start of the collision list at index IDX in the index vector of H. */
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1103
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1104 #define HASH_INDEX(H, IDX) AREF ((H)->index, (IDX))
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1105
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1106 /* Value is the size of hash table H. */
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1107
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1108 #define HASH_TABLE_SIZE(H) XVECTOR ((H)->next)->size
|
5abad41fb43b
(HASH_KEY, HASH_VALUE, HASH_NEXT, HASH_HASH, HASH_INDEX)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1109
|
|
25017
|
1110 /* Default size for hash tables if not specified. */
|
|
|
1111
|
|
|
1112 #define DEFAULT_HASH_SIZE 65
|
|
|
1113
|
|
|
1114 /* Default threshold specifying when to resize a hash table. The
|
|
|
1115 value gives the ratio of current entries in the hash table and the
|
|
|
1116 size of the hash table. */
|
|
|
1117
|
|
|
1118 #define DEFAULT_REHASH_THRESHOLD 0.8
|
|
|
1119
|
|
|
1120 /* Default factor by which to increase the size of a hash table. */
|
|
|
1121
|
|
|
1122 #define DEFAULT_REHASH_SIZE 1.5
|
|
|
1123
|
|
9462
|
1124
|
|
10292
|
1125 /* These structures are used for various misc types. */
|
|
|
1126
|
|
302
|
1127 struct Lisp_Marker
|
|
12890
|
1128 {
|
|
|
1129 int type : 16; /* = Lisp_Misc_Marker */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1130 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1131 int spacer : 14;
|
|
12890
|
1132 /* 1 means normal insertion at the marker's position
|
|
|
1133 leaves the marker after the inserted text. */
|
|
|
1134 unsigned int insertion_type : 1;
|
84979
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1135 /* This is the buffer that the marker points into, or 0 if it points nowhere.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1136 Note: a chain of markers can contain markers pointing into different
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1137 buffers (the chain is per buffer_text rather than per buffer, so it's
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1138 shared between indirect buffers). */
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1139 /* This is used for (other than NULL-checking):
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1140 - Fmarker_buffer
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1141 - Fset_marker: check eq(oldbuf, newbuf) to avoid unchain+rechain.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1142 - unchain_marker: to find the list from which to unchain.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1143 - Fkill_buffer: to unchain the markers of current indirect buffer.
|
79d85dce25a5
(DECL_ALIGN, USE_LSB_TAG): Move logic to before definition of
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1144 */
|
|
12890
|
1145 struct buffer *buffer;
|
|
20559
|
1146
|
|
|
1147 /* The remaining fields are meaningless in a marker that
|
|
|
1148 does not point anywhere. */
|
|
|
1149
|
|
|
1150 /* For markers that point somewhere,
|
|
|
1151 this is used to chain of all the markers in a given buffer. */
|
85011
1d35aa875508
* buffer.c (syms_of_buffer) <local-abbrev-table>: Move from abbrev.c.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1152 /* We could remove it and use an array in buffer_text instead.
|
1d35aa875508
* buffer.c (syms_of_buffer) <local-abbrev-table>: Move from abbrev.c.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1153 That would also allow to preserve it ordered. */
|
|
51666
|
1154 struct Lisp_Marker *next;
|
|
20559
|
1155 /* This is the char position where the marker points. */
|
|
51858
|
1156 EMACS_INT charpos;
|
|
20569
|
1157 /* This is the byte position. */
|
|
51858
|
1158 EMACS_INT bytepos;
|
|
12890
|
1159 };
|
|
302
|
1160
|
|
9462
|
1161 /* Forwarding pointer to an int variable.
|
|
|
1162 This is allowed only in the value cell of a symbol,
|
|
|
1163 and it means that the symbol's value really lives in the
|
|
|
1164 specified int variable. */
|
|
|
1165 struct Lisp_Intfwd
|
|
|
1166 {
|
|
10387
|
1167 int type : 16; /* = Lisp_Misc_Intfwd */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1168 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1169 int spacer : 15;
|
43713
f92c4d87863a
Change defvar_int def and vars to use EMACS_INT instead of just int.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1170 EMACS_INT *intvar;
|
|
9462
|
1171 };
|
|
|
1172
|
|
|
1173 /* Boolean forwarding pointer to an int variable.
|
|
|
1174 This is like Lisp_Intfwd except that the ostensible
|
|
|
1175 "value" of the symbol is t if the int variable is nonzero,
|
|
|
1176 nil if it is zero. */
|
|
|
1177 struct Lisp_Boolfwd
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1178 {
|
|
10387
|
1179 int type : 16; /* = Lisp_Misc_Boolfwd */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1180 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1181 int spacer : 15;
|
|
9462
|
1182 int *boolvar;
|
|
|
1183 };
|
|
|
1184
|
|
|
1185 /* Forwarding pointer to a Lisp_Object variable.
|
|
|
1186 This is allowed only in the value cell of a symbol,
|
|
|
1187 and it means that the symbol's value really lives in the
|
|
|
1188 specified variable. */
|
|
|
1189 struct Lisp_Objfwd
|
|
|
1190 {
|
|
10387
|
1191 int type : 16; /* = Lisp_Misc_Objfwd */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1192 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1193 int spacer : 15;
|
|
9462
|
1194 Lisp_Object *objvar;
|
|
|
1195 };
|
|
|
1196
|
|
|
1197 /* Like Lisp_Objfwd except that value lives in a slot in the
|
|
|
1198 current buffer. Value is byte index of slot within buffer. */
|
|
|
1199 struct Lisp_Buffer_Objfwd
|
|
|
1200 {
|
|
10387
|
1201 int type : 16; /* = Lisp_Misc_Buffer_Objfwd */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1202 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1203 int spacer : 15;
|
|
9462
|
1204 int offset;
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1205 };
|
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1206
|
|
27779
|
1207 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
|
|
|
1208 the symbol has buffer-local or frame-local bindings. (Exception:
|
|
|
1209 some buffer-local variables are built-in, with their values stored
|
|
|
1210 in the buffer structure itself. They are handled differently,
|
|
|
1211 using struct Lisp_Buffer_Objfwd.)
|
|
|
1212
|
|
|
1213 The `realvalue' slot holds the variable's current value, or a
|
|
|
1214 forwarding pointer to where that value is kept. This value is the
|
|
|
1215 one that corresponds to the loaded binding. To read or set the
|
|
|
1216 variable, you must first make sure the right binding is loaded;
|
|
|
1217 then you can access the value in (or through) `realvalue'.
|
|
45623
|
1218
|
|
27779
|
1219 `buffer' and `frame' are the buffer and frame for which the loaded
|
|
|
1220 binding was found. If those have changed, to make sure the right
|
|
|
1221 binding is loaded it is necessary to find which binding goes with
|
|
|
1222 the current buffer and selected frame, then load it. To load it,
|
|
|
1223 first unload the previous binding, then copy the value of the new
|
|
|
1224 binding into `realvalue' (or through it). Also update
|
|
|
1225 LOADED-BINDING to point to the newly loaded binding.
|
9891
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1226
|
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1227 Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
|
|
27779
|
1228 both use this kind of structure. With the former, merely setting
|
|
|
1229 the variable creates a local binding for the current buffer. With
|
|
|
1230 the latter, setting the variable does not do that; only
|
|
|
1231 make-local-variable does that. */
|
|
|
1232
|
9891
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1233 struct Lisp_Buffer_Local_Value
|
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1234 {
|
|
21147
|
1235 int type : 16; /* = Lisp_Misc_Buffer_Local_Value
|
|
|
1236 or Lisp_Misc_Some_Buffer_Local_Value */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1237 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1238 int spacer : 12;
|
|
27779
|
1239
|
|
|
1240 /* 1 means this variable is allowed to have frame-local bindings,
|
|
|
1241 so check for them when looking for the proper binding. */
|
|
21147
|
1242 unsigned int check_frame : 1;
|
|
27779
|
1243 /* 1 means that the binding now loaded was found
|
|
|
1244 as a local binding for the buffer in the `buffer' slot. */
|
|
21147
|
1245 unsigned int found_for_buffer : 1;
|
|
27779
|
1246 /* 1 means that the binding now loaded was found
|
|
|
1247 as a local binding for the frame in the `frame' slot. */
|
|
21147
|
1248 unsigned int found_for_frame : 1;
|
|
|
1249 Lisp_Object realvalue;
|
|
27779
|
1250 /* The buffer and frame for which the loaded binding was found. */
|
85011
1d35aa875508
* buffer.c (syms_of_buffer) <local-abbrev-table>: Move from abbrev.c.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1251 /* Having both is only needed if we want to allow variables that are
|
1d35aa875508
* buffer.c (syms_of_buffer) <local-abbrev-table>: Move from abbrev.c.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1252 both buffer local and frame local (in which case, we currently give
|
1d35aa875508
* buffer.c (syms_of_buffer) <local-abbrev-table>: Move from abbrev.c.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1253 precedence to the buffer-local binding). I don't think such
|
1d35aa875508
* buffer.c (syms_of_buffer) <local-abbrev-table>: Move from abbrev.c.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1254 a combination is desirable. --Stef */
|
|
21147
|
1255 Lisp_Object buffer, frame;
|
|
27779
|
1256
|
|
|
1257 /* A cons cell, (LOADED-BINDING . DEFAULT-VALUE).
|
|
|
1258
|
|
|
1259 LOADED-BINDING is the binding now loaded. It is a cons cell
|
|
|
1260 whose cdr is the binding's value. The cons cell may be an
|
|
|
1261 element of a buffer's local-variable alist, or an element of a
|
|
|
1262 frame's parameter alist, or it may be this cons cell.
|
|
|
1263
|
|
|
1264 DEFAULT-VALUE is the variable's default value, seen when the
|
|
|
1265 current buffer and selected frame do not have their own
|
|
|
1266 bindings for the variable. When the default binding is loaded,
|
|
|
1267 LOADED-BINDING is actually this very cons cell; thus, its car
|
|
|
1268 points to itself. */
|
|
21147
|
1269 Lisp_Object cdr;
|
9891
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1270 };
|
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1271
|
|
51858
|
1272 /* START and END are markers in the overlay's buffer, and
|
|
9924
|
1273 PLIST is the overlay's property list. */
|
|
|
1274 struct Lisp_Overlay
|
|
|
1275 {
|
|
10387
|
1276 int type : 16; /* = Lisp_Misc_Overlay */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1277 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1278 int spacer : 15;
|
|
51833
|
1279 struct Lisp_Overlay *next;
|
|
9924
|
1280 Lisp_Object start, end, plist;
|
|
|
1281 };
|
|
10387
|
1282
|
|
10580
|
1283 /* Like Lisp_Objfwd except that value lives in a slot in the
|
|
11012
|
1284 current kboard. */
|
|
|
1285 struct Lisp_Kboard_Objfwd
|
|
10580
|
1286 {
|
|
11012
|
1287 int type : 16; /* = Lisp_Misc_Kboard_Objfwd */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1288 unsigned gcmarkbit : 1;
|
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1289 int spacer : 15;
|
|
10580
|
1290 int offset;
|
|
|
1291 };
|
|
|
1292
|
|
49056
|
1293 /* Hold a C pointer for later use.
|
|
|
1294 This type of object is used in the arg to record_unwind_protect. */
|
|
|
1295 struct Lisp_Save_Value
|
|
|
1296 {
|
|
|
1297 int type : 16; /* = Lisp_Misc_Save_Value */
|
51657
7fb427e8d984
(struct interval, struct Lisp_Symbol, struct Lisp_Free)
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1298 unsigned gcmarkbit : 1;
|
|
56204
|
1299 int spacer : 14;
|
|
|
1300 /* If DOGC is set, POINTER is the address of a memory
|
|
|
1301 area containing INTEGER potential Lisp_Objects. */
|
|
|
1302 unsigned int dogc : 1;
|
|
49056
|
1303 void *pointer;
|
|
|
1304 int integer;
|
|
|
1305 };
|
|
|
1306
|
|
10387
|
1307
|
|
53088
|
1308 /* A miscellaneous object, when it's on the free list. */
|
|
|
1309 struct Lisp_Free
|
|
|
1310 {
|
|
|
1311 int type : 16; /* = Lisp_Misc_Free */
|
|
|
1312 unsigned gcmarkbit : 1;
|
|
|
1313 int spacer : 15;
|
|
|
1314 union Lisp_Misc *chain;
|
|
53654
|
1315 #ifdef USE_LSB_TAG
|
|
|
1316 /* Try to make sure that sizeof(Lisp_Misc) preserves TYPEBITS-alignment.
|
|
|
1317 This assumes that Lisp_Marker is the largest of the alternatives and
|
|
|
1318 that Lisp_Intfwd has the same size as "Lisp_Free w/o padding". */
|
|
|
1319 char padding[((((sizeof (struct Lisp_Marker) - 1) >> GCTYPEBITS) + 1)
|
|
|
1320 << GCTYPEBITS) - sizeof (struct Lisp_Intfwd)];
|
|
|
1321 #endif
|
|
53088
|
1322 };
|
|
|
1323
|
|
11335
|
1324 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
|
|
|
1325 It uses one of these struct subtypes to get the type field. */
|
|
|
1326
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1327 union Lisp_Misc
|
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1328 {
|
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1329 struct Lisp_Free u_free;
|
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1330 struct Lisp_Marker u_marker;
|
|
9462
|
1331 struct Lisp_Intfwd u_intfwd;
|
|
|
1332 struct Lisp_Boolfwd u_boolfwd;
|
|
|
1333 struct Lisp_Objfwd u_objfwd;
|
|
|
1334 struct Lisp_Buffer_Objfwd u_buffer_objfwd;
|
9891
f4a53f86853d
(enum Lisp_Misc_Type): Add new enumerations Lisp_Misc_Buffer_Local_Value and
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1335 struct Lisp_Buffer_Local_Value u_buffer_local_value;
|
|
9924
|
1336 struct Lisp_Overlay u_overlay;
|
|
11012
|
1337 struct Lisp_Kboard_Objfwd u_kboard_objfwd;
|
|
49056
|
1338 struct Lisp_Save_Value u_save_value;
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1339 };
|
|
10292
|
1340
|
|
27727
|
1341 /* Lisp floating point type */
|
|
302
|
1342 struct Lisp_Float
|
|
|
1343 {
|
|
66888
|
1344 union
|
|
|
1345 {
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1346 #ifdef HIDE_LISP_IMPLEMENTATION
|
|
66888
|
1347 double data_;
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1348 #else
|
|
66888
|
1349 double data;
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1350 #endif
|
|
66888
|
1351 struct Lisp_Float *chain;
|
|
|
1352 } u;
|
|
302
|
1353 };
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1354
|
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1355 #ifdef HIDE_LISP_IMPLEMENTATION
|
|
66888
|
1356 #define XFLOAT_DATA(f) (XFLOAT (f)->u.data_)
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1357 #else
|
|
66888
|
1358 #define XFLOAT_DATA(f) (XFLOAT (f)->u.data)
|
25421
65a7e9c02d4f
(struct Lisp_Cons, XCAR, XCDR, struct Lisp_Float): Change names of structure
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1359 #endif
|
|
302
|
1360
|
|
|
1361 /* A character, declared with the following typedef, is a member
|
|
10316
|
1362 of some character set associated with the current buffer. */
|
|
3324
|
1363 #ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
|
|
|
1364 #define _UCHAR_T
|
|
302
|
1365 typedef unsigned char UCHAR;
|
|
3324
|
1366 #endif
|
|
302
|
1367
|
|
|
1368 /* Meanings of slots in a Lisp_Compiled: */
|
|
|
1369
|
|
|
1370 #define COMPILED_ARGLIST 0
|
|
|
1371 #define COMPILED_BYTECODE 1
|
|
|
1372 #define COMPILED_CONSTANTS 2
|
|
|
1373 #define COMPILED_STACK_DEPTH 3
|
|
|
1374 #define COMPILED_DOC_STRING 4
|
|
|
1375 #define COMPILED_INTERACTIVE 5
|
|
2014
|
1376
|
|
2662
|
1377 /* Flag bits in a character. These also get used in termhooks.h.
|
|
|
1378 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
|
|
10292
|
1379 (MUlti-Lingual Emacs) might need 22 bits for the character value
|
|
|
1380 itself, so we probably shouldn't use any bits lower than 0x0400000. */
|
|
|
1381 #define CHAR_ALT (0x0400000)
|
|
|
1382 #define CHAR_SUPER (0x0800000)
|
|
|
1383 #define CHAR_HYPER (0x1000000)
|
|
|
1384 #define CHAR_SHIFT (0x2000000)
|
|
|
1385 #define CHAR_CTL (0x4000000)
|
|
|
1386 #define CHAR_META (0x8000000)
|
|
2728
|
1387
|
|
25252
|
1388 #define CHAR_MODIFIER_MASK \
|
|
|
1389 (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META)
|
|
|
1390
|
|
|
1391
|
|
17037
|
1392 /* Actually, the current Emacs uses 19 bits for the character value
|
|
|
1393 itself. */
|
|
|
1394 #define CHARACTERBITS 19
|
|
|
1395
|
|
26479
|
1396 /* The maximum byte size consumed by push_key_description.
|
|
|
1397 All callers should assure that at least this size of memory is
|
|
|
1398 allocated at the place pointed by the second argument.
|
|
|
1399
|
|
|
1400 Thers are 6 modifiers, each consumes 2 chars.
|
|
|
1401 The octal form of a character code consumes
|
|
|
1402 (1 + CHARACTERBITS / 3 + 1) chars (including backslash at the head).
|
|
|
1403 We need one more byte for string terminator `\0'. */
|
|
|
1404 #define KEY_DESCRIPTION_SIZE ((2 * 6) + 1 + (CHARACTERBITS / 3) + 1 + 1)
|
|
|
1405
|
|
2728
|
1406
|
|
|
1407 /* The glyph datatype, used to represent characters on the display. */
|
|
|
1408
|
|
26994
|
1409 /* Glyph code to use as an index to the glyph table. If it is out of
|
|
|
1410 range for the glyph table, or the corresonding element in the table
|
|
|
1411 is nil, the low 8 bits are the single byte character code, and the
|
|
|
1412 bits above are the numeric face ID. If FID is the face ID of a
|
|
|
1413 glyph on a frame F, then F->display.x->faces[FID] contains the
|
|
|
1414 description of that face. This is an int instead of a short, so we
|
|
|
1415 can support a good bunch of face ID's (2^(31 - 8)); given that we
|
|
17037
|
1416 have no mechanism for tossing unused frame face ID's yet, we'll
|
|
26994
|
1417 probably run out of 255 pretty quickly.
|
|
|
1418 This is always -1 for a multibyte character. */
|
|
|
1419 #define GLYPH int
|
|
|
1420
|
|
17037
|
1421 /* Mask bits for face. */
|
|
30447
|
1422 #define GLYPH_MASK_FACE 0x7FF80000
|
|
26994
|
1423 /* Mask bits for character code. */
|
|
30447
|
1424 #define GLYPH_MASK_CHAR 0x0007FFFF /* The lowest 19 bits */
|
|
17037
|
1425
|
6416
6f57787905d9
(MAKE_GLYPH, GLYPH_CHAR, GLYPH_FACE): Handle termcap frames as well as X.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1426 /* The FAST macros assume that we already know we're in an X window. */
|
6f57787905d9
(MAKE_GLYPH, GLYPH_CHAR, GLYPH_FACE): Handle termcap frames as well as X.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1427
|
|
26994
|
1428 /* Set a character code and a face ID in a glyph G. */
|
|
30447
|
1429 #define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS))
|
|
2728
|
1430
|
|
|
1431 /* Return a glyph's character code. */
|
|
17037
|
1432 #define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR)
|
|
2728
|
1433
|
|
|
1434 /* Return a glyph's face ID. */
|
|
30447
|
1435 #define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
|
6416
6f57787905d9
(MAKE_GLYPH, GLYPH_CHAR, GLYPH_FACE): Handle termcap frames as well as X.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1436
|
6f57787905d9
(MAKE_GLYPH, GLYPH_CHAR, GLYPH_FACE): Handle termcap frames as well as X.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1437 /* Slower versions that test the frame type first. */
|
|
25017
|
1438 #define MAKE_GLYPH(f, char, face) (FAST_MAKE_GLYPH (char, face))
|
|
|
1439 #define GLYPH_CHAR(f, g) (FAST_GLYPH_CHAR (g))
|
|
|
1440 #define GLYPH_FACE(f, g) (FAST_GLYPH_FACE (g))
|
|
2728
|
1441
|
|
78501
|
1442 /* Return 1 if GLYPH contains valid character code. */
|
|
37643
|
1443 #define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (FAST_GLYPH_CHAR (glyph), 1)
|
|
17188
|
1444
|
|
6277
|
1445 /* The ID of the mode line highlighting face. */
|
|
|
1446 #define GLYPH_MODE_LINE_FACE 1
|
|
302
|
1447
|
|
|
1448 /* Data type checking */
|
|
|
1449
|
|
58264
|
1450 #define NILP(x) EQ (x, Qnil)
|
|
1990
|
1451 #define GC_NILP(x) GC_EQ (x, Qnil)
|
|
621
|
1452
|
9150
642bbaf7c3fc
(BOOLFWDP, INTERNALP, INTFWDP, OBJFWDP, INTERNAL_STREAMP, BUFFER_LOCAL_VALUEP,
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1453 #define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
|
|
9947
|
1454 #define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
|
|
9943
|
1455 #define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
|
|
9947
|
1456 #define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
|
|
302
|
1457
|
|
2187
|
1458 #define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
|
|
53088
|
1459 #define GC_INTEGERP(x) INTEGERP (x)
|
|
2187
|
1460 #define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
|
|
9947
|
1461 #define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
|
9435
3a157cdf395c
(Lisp_Misc): new type code, replacing Lisp_Marker (and soon to replace other
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1462 #define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
|
|
9947
|
1463 #define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
|
|
10010
|
1464 #define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
|
|
|
1465 #define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
|
|
2187
|
1466 #define STRINGP(x) (XTYPE ((x)) == Lisp_String)
|
|
9947
|
1467 #define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
|
|
302
|
1468 #define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
|
|
9947
|
1469 #define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
|
|
10292
|
1470
|
|
2187
|
1471 #define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
|
|
9947
|
1472 #define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
|
|
10010
|
1473 #define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
|
|
|
1474 #define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
|
|
11335
|
1475 #define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
|
|
|
1476 #define GC_OVERLAYP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
|
|
|
1477 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
|
|
|
1478 #define GC_MARKERP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
|
|
|
1479 #define INTFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
|
|
|
1480 #define GC_INTFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
|
|
|
1481 #define BOOLFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
|
|
|
1482 #define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
|
|
|
1483 #define OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
|
|
|
1484 #define GC_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
|
|
|
1485 #define BUFFER_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
|
|
|
1486 #define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
|
|
|
1487 #define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
|
|
|
1488 #define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
|
|
|
1489 #define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
|
|
|
1490 #define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
|
|
|
1491 #define KBOARD_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
|
|
|
1492 #define GC_KBOARD_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
|
|
2187
|
1493
|
|
10292
|
1494
|
|
10322
|
1495 /* True if object X is a pseudovector whose code is CODE. */
|
|
10292
|
1496 #define PSEUDOVECTORP(x, code) \
|
|
|
1497 (VECTORLIKEP (x) \
|
|
|
1498 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
|
|
|
1499 == (PSEUDOVECTOR_FLAG | (code))))
|
|
|
1500
|
|
10322
|
1501 /* True if object X is a pseudovector whose code is CODE.
|
|
10292
|
1502 This one works during GC. */
|
|
|
1503 #define GC_PSEUDOVECTORP(x, code) \
|
|
|
1504 (GC_VECTORLIKEP (x) \
|
|
|
1505 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
|
|
|
1506 == (PSEUDOVECTOR_FLAG | (code))))
|
|
|
1507
|
|
|
1508 /* Test for specific pseudovector types. */
|
|
|
1509 #define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
|
|
|
1510 #define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
|
|
|
1511 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
|
|
|
1512 #define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
|
|
|
1513 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
|
|
|
1514 #define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
|
|
84689
|
1515 #define TERMINALP(x) PSEUDOVECTORP (x, PVEC_TERMINAL)
|
|
|
1516 #define GC_TERMINALP(x) GC_PSEUDOVECTORP (x, PVEC_TERMINAL)
|
|
10292
|
1517 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
|
|
|
1518 #define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
|
|
|
1519 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
|
|
|
1520 #define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
|
|
10316
|
1521 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
|
|
|
1522 #define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
|
|
13149
|
1523 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
|
|
|
1524 #define GC_CHAR_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
|
|
|
1525 #define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
|
|
|
1526 #define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
|
|
10292
|
1527 #define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
|
|
|
1528 #define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
|
|
17326
|
1529
|
|
|
1530 #define SUB_CHAR_TABLE_P(x) (CHAR_TABLE_P (x) && NILP (XCHAR_TABLE (x)->top))
|
|
53331
|
1531
|
|
|
1532 /* Test for image (image . spec) */
|
|
|
1533 #define IMAGEP(x) (CONSP (x) && EQ (XCAR (x), Qimage))
|
|
|
1534
|
|
71822
|
1535 /* Array types. */
|
|
|
1536
|
|
|
1537 #define ARRAYP(x) \
|
|
|
1538 (VECTORP (x) || STRINGP (x) || CHAR_TABLE_P (x) || BOOL_VECTOR_P (x))
|
|
10292
|
1539
|
|
53088
|
1540 #define GC_EQ(x, y) EQ (x, y)
|
|
621
|
1541
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1542 #define CHECK_LIST(x) \
|
|
71822
|
1543 CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x)
|
|
|
1544
|
|
|
1545 #define CHECK_LIST_CONS(x, y) \
|
|
|
1546 CHECK_TYPE (CONSP (x), Qlistp, y)
|
|
|
1547
|
|
|
1548 #define CHECK_LIST_END(x, y) \
|
|
|
1549 CHECK_TYPE (NILP (x), Qlistp, y)
|
|
302
|
1550
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1551 #define CHECK_STRING(x) \
|
|
71822
|
1552 CHECK_TYPE (STRINGP (x), Qstringp, x)
|
|
302
|
1553
|
|
40689
|
1554 #define CHECK_STRING_CAR(x) \
|
|
71822
|
1555 CHECK_TYPE (STRINGP (XCAR (x)), Qstringp, XCAR (x))
|
|
40689
|
1556
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1557 #define CHECK_CONS(x) \
|
|
71822
|
1558 CHECK_TYPE (CONSP (x), Qconsp, x)
|
|
302
|
1559
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1560 #define CHECK_SYMBOL(x) \
|
|
71822
|
1561 CHECK_TYPE (SYMBOLP (x), Qsymbolp, x)
|
|
302
|
1562
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1563 #define CHECK_CHAR_TABLE(x) \
|
|
71822
|
1564 CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x)
|
|
13149
|
1565
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1566 #define CHECK_VECTOR(x) \
|
|
71822
|
1567 CHECK_TYPE (VECTORP (x), Qvectorp, x)
|
|
|
1568
|
|
|
1569 #define CHECK_VECTOR_OR_STRING(x) \
|
|
|
1570 CHECK_TYPE (VECTORP (x) || STRINGP (x), Qarrayp, x)
|
|
|
1571
|
|
|
1572 #define CHECK_ARRAY(x, Qxxxp) \
|
|
|
1573 CHECK_TYPE (ARRAYP (x), Qxxxp, x)
|
|
|
1574
|
|
|
1575 #define CHECK_VECTOR_OR_CHAR_TABLE(x) \
|
|
|
1576 CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x)
|
|
13202
|
1577
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1578 #define CHECK_BUFFER(x) \
|
|
71822
|
1579 CHECK_TYPE (BUFFERP (x), Qbufferp, x)
|
|
302
|
1580
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1581 #define CHECK_WINDOW(x) \
|
|
71822
|
1582 CHECK_TYPE (WINDOWP (x), Qwindowp, x)
|
|
|
1583
|
|
|
1584 #define CHECK_WINDOW_CONFIGURATION(x) \
|
|
|
1585 CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x)
|
|
302
|
1586
|
|
1442
|
1587 /* This macro rejects windows on the interior of the window tree as
|
|
17404
|
1588 "dead", which is what we want; this is an argument-checking macro, and
|
|
1442
|
1589 the user should never get access to interior windows.
|
|
|
1590
|
|
78501
|
1591 A window of any sort, leaf or interior, is dead if the buffer,
|
|
1442
|
1592 vchild, and hchild members are all nil. */
|
|
|
1593
|
|
71822
|
1594 #define CHECK_LIVE_WINDOW(x) \
|
|
|
1595 CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer), Qwindow_live_p, x)
|
|
1442
|
1596
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1597 #define CHECK_PROCESS(x) \
|
|
71822
|
1598 CHECK_TYPE (PROCESSP (x), Qprocessp, x)
|
|
|
1599
|
|
|
1600 #define CHECK_SUBR(x) \
|
|
|
1601 CHECK_TYPE (SUBRP (x), Qsubrp, x)
|
|
302
|
1602
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1603 #define CHECK_NUMBER(x) \
|
|
71822
|
1604 CHECK_TYPE (INTEGERP (x), Qintegerp, x)
|
|
302
|
1605
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1606 #define CHECK_NATNUM(x) \
|
|
71822
|
1607 CHECK_TYPE (NATNUMP (x), Qwholenump, x)
|
|
302
|
1608
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1609 #define CHECK_MARKER(x) \
|
|
71822
|
1610 CHECK_TYPE (MARKERP (x), Qmarkerp, x)
|
|
302
|
1611
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1612 #define CHECK_NUMBER_COERCE_MARKER(x) \
|
|
9292
|
1613 do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
|
|
71822
|
1614 else CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); } while (0)
|
|
302
|
1615
|
|
|
1616 #define XFLOATINT(n) extract_float((n))
|
|
|
1617
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1618 #define CHECK_FLOAT(x) \
|
|
71822
|
1619 CHECK_TYPE (FLOATP (x), Qfloatp, x)
|
|
302
|
1620
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1621 #define CHECK_NUMBER_OR_FLOAT(x) \
|
|
71822
|
1622 CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x)
|
|
302
|
1623
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1624 #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \
|
|
9292
|
1625 do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
|
|
71822
|
1626 else CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); } while (0)
|
|
302
|
1627
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1628 #define CHECK_OVERLAY(x) \
|
|
71822
|
1629 CHECK_TYPE (OVERLAYP (x), Qoverlayp, x)
|
|
2780
|
1630
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1631 /* Since we can't assign directly to the CAR or CDR fields of a cons
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1632 cell, use these when checking that those fields contain numbers. */
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1633 #define CHECK_NUMBER_CAR(x) \
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1634 do { \
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1635 Lisp_Object tmp = XCAR (x); \
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1636 CHECK_NUMBER (tmp); \
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1637 XSETCAR ((x), tmp); \
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1638 } while (0)
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1639
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1640 #define CHECK_NUMBER_CDR(x) \
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1641 do { \
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1642 Lisp_Object tmp = XCDR (x); \
|
40653
6c48a4da1da5
(CHECK_STRING_OR_BUFFER, CHECK_HASH_TABLE, CHECK_LIST, CHECK_STRING,
Pavel Janík <Pavel@Janik.cz>
diff
changeset
|
1643 CHECK_NUMBER (tmp); \
|
39973
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1644 XSETCDR ((x), tmp); \
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1645 } while (0)
|
579177964efa
Avoid (most) uses of XCAR/XCDR as lvalues, for flexibility in experimenting
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
1646
|
|
302
|
1647 /* Cast pointers to this type to compare them. Some machines want int. */
|
|
|
1648 #ifndef PNTR_COMPARISON_TYPE
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
1649 #define PNTR_COMPARISON_TYPE EMACS_UINT
|
|
302
|
1650 #endif
|
|
|
1651
|
|
|
1652 /* Define a built-in function for calling from Lisp.
|
|
|
1653 `lname' should be the name to give the function in Lisp,
|
|
|
1654 as a null-terminated C string.
|
|
|
1655 `fnname' should be the name of the function in C.
|
|
|
1656 By convention, it starts with F.
|
|
|
1657 `sname' should be the name for the C constant structure
|
|
|
1658 that records information on this function for internal use.
|
|
|
1659 By convention, it should be the same as `fnname' but with S instead of F.
|
|
|
1660 It's too bad that C macros can't compute this from `fnname'.
|
|
|
1661 `minargs' should be a number, the minimum number of arguments allowed.
|
|
|
1662 `maxargs' should be a number, the maximum number of arguments allowed,
|
|
|
1663 or else MANY or UNEVALLED.
|
|
|
1664 MANY means pass a vector of evaluated arguments,
|
|
|
1665 in the form of an integer number-of-arguments
|
|
|
1666 followed by the address of a vector of Lisp_Objects
|
|
|
1667 which contains the argument values.
|
|
|
1668 UNEVALLED means pass the list of unevaluated arguments
|
84434
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1669 `intspec' says how interactive arguments are to be fetched.
|
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1670 If the string starts with a `(', `intspec' is evaluated and the resulting
|
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1671 list is the list of arguments.
|
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1672 If it's a string that doesn't start with `(', the value should follow
|
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1673 the one of the doc string for `interactive'.
|
|
302
|
1674 A null string means call interactively with no arguments.
|
|
9904
|
1675 `doc' is documentation for the user. */
|
|
302
|
1676
|
|
29443
|
1677 #if (!defined (__STDC__) && !defined (PROTOTYPES)) \
|
|
|
1678 || defined (USE_NONANSI_DEFUN)
|
|
39898
|
1679
|
84434
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1680 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
|
|
39898
|
1681 Lisp_Object fnname (); \
|
|
53654
|
1682 DECL_ALIGN (struct Lisp_Subr, sname) = \
|
|
39898
|
1683 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
|
84434
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1684 fnname, minargs, maxargs, lname, intspec, 0}; \
|
|
44065
|
1685 Lisp_Object fnname
|
|
39898
|
1686
|
|
5241
|
1687 #else
|
|
|
1688
|
|
|
1689 /* This version of DEFUN declares a function prototype with the right
|
|
10316
|
1690 arguments, so we can catch errors with maxargs at compile-time. */
|
84434
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1691 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc) \
|
|
10292
|
1692 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
|
|
53654
|
1693 DECL_ALIGN (struct Lisp_Subr, sname) = \
|
|
10292
|
1694 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
|
84434
83ebc6baeac5
(struct Lisp_Subr): Rename `prompt' field to `intspec'.
Michaël Cadilhac <michael.cadilhac@lrde.org>
diff
changeset
|
1695 fnname, minargs, maxargs, lname, intspec, 0}; \
|
|
5241
|
1696 Lisp_Object fnname
|
|
|
1697
|
|
|
1698 /* Note that the weird token-substitution semantics of ANSI C makes
|
|
10316
|
1699 this work for MANY and UNEVALLED. */
|
|
5241
|
1700 #define DEFUN_ARGS_MANY (int, Lisp_Object *)
|
|
|
1701 #define DEFUN_ARGS_UNEVALLED (Lisp_Object)
|
|
|
1702 #define DEFUN_ARGS_0 (void)
|
|
|
1703 #define DEFUN_ARGS_1 (Lisp_Object)
|
|
|
1704 #define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
|
|
|
1705 #define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
|
|
|
1706 #define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
|
|
|
1707 #define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
|
|
|
1708 Lisp_Object)
|
|
|
1709 #define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
|
|
|
1710 Lisp_Object, Lisp_Object)
|
|
|
1711 #define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
|
|
|
1712 Lisp_Object, Lisp_Object, Lisp_Object)
|
|
19547
|
1713 #define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
|
|
|
1714 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
|
|
5241
|
1715 #endif
|
|
|
1716
|
|
30218
|
1717 /* Non-zero if OBJ is a Lisp function. */
|
|
|
1718
|
|
|
1719 #define FUNCTIONP(OBJ) \
|
|
|
1720 ((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda)) \
|
|
|
1721 || (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ))) \
|
|
|
1722 || COMPILEDP (OBJ) \
|
|
|
1723 || SUBRP (OBJ))
|
|
45623
|
1724
|
|
302
|
1725 /* defsubr (Sname);
|
|
41080
|
1726 is how we define the symbol for function `name' at start-up time. */
|
|
20297
|
1727 extern void defsubr P_ ((struct Lisp_Subr *));
|
|
302
|
1728
|
|
|
1729 #define MANY -2
|
|
|
1730 #define UNEVALLED -1
|
|
|
1731
|
|
20297
|
1732 extern void defvar_lisp P_ ((char *, Lisp_Object *));
|
|
|
1733 extern void defvar_lisp_nopro P_ ((char *, Lisp_Object *));
|
|
|
1734 extern void defvar_bool P_ ((char *, int *));
|
43713
f92c4d87863a
Change defvar_int def and vars to use EMACS_INT instead of just int.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1735 extern void defvar_int P_ ((char *, EMACS_INT *));
|
|
20297
|
1736 extern void defvar_kboard P_ ((char *, int));
|
|
302
|
1737
|
|
|
1738 /* Macros we use to define forwarded Lisp variables.
|
|
|
1739 These are used in the syms_of_FILENAME functions. */
|
|
|
1740
|
|
|
1741 #define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
|
|
|
1742 #define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
|
|
|
1743 #define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
|
|
|
1744 #define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
|
|
59111
|
1745
|
|
11012
|
1746 #define DEFVAR_KBOARD(lname, vname, doc) \
|
|
|
1747 defvar_kboard (lname, \
|
|
|
1748 (int)((char *)(¤t_kboard->vname) \
|
|
|
1749 - (char *)current_kboard))
|
|
39898
|
1750
|
|
|
1751
|
|
302
|
1752
|
|
1197
|
1753 /* Structure for recording Lisp call stack for backtrace purposes. */
|
|
|
1754
|
|
|
1755 /* The special binding stack holds the outer values of variables while
|
|
|
1756 they are bound by a function application or a let form, stores the
|
|
|
1757 code to be executed for Lisp unwind-protect forms, and stores the C
|
|
|
1758 functions to be called for record_unwind_protect.
|
|
302
|
1759
|
|
1197
|
1760 If func is non-zero, undoing this binding applies func to old_value;
|
|
|
1761 This implements record_unwind_protect.
|
|
27292
|
1762
|
|
|
1763 Otherwise, the element is a variable binding.
|
|
45623
|
1764
|
|
27292
|
1765 If the symbol field is a symbol, it is an ordinary variable binding.
|
|
45623
|
1766
|
|
38289
|
1767 Otherwise, it should be a structure (SYMBOL WHERE
|
|
|
1768 . CURRENT-BUFFER), which means having bound a local value while
|
|
|
1769 CURRENT-BUFFER was active. If WHERE is nil this means we saw the
|
|
38275
|
1770 default value when binding SYMBOL. WHERE being a buffer or frame
|
|
38289
|
1771 means we saw a buffer-local or frame-local value. Other values of
|
|
|
1772 WHERE mean an internal error. */
|
|
27292
|
1773
|
|
51035
|
1774 typedef Lisp_Object (*specbinding_func) P_ ((Lisp_Object));
|
|
|
1775
|
|
302
|
1776 struct specbinding
|
|
|
1777 {
|
69157
76d55cdb7481
(struct specbinding, specpdl_ptr): Remove the volatile qualifier which was
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1778 Lisp_Object symbol, old_value;
|
76d55cdb7481
(struct specbinding, specpdl_ptr): Remove the volatile qualifier which was
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1779 specbinding_func func;
|
|
302
|
1780 Lisp_Object unused; /* Dividing by 16 is faster than by 12 */
|
|
|
1781 };
|
|
|
1782
|
|
|
1783 extern struct specbinding *specpdl;
|
69157
76d55cdb7481
(struct specbinding, specpdl_ptr): Remove the volatile qualifier which was
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1784 extern struct specbinding *specpdl_ptr;
|
|
302
|
1785 extern int specpdl_size;
|
|
|
1786
|
43713
f92c4d87863a
Change defvar_int def and vars to use EMACS_INT instead of just int.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1787 extern EMACS_INT max_specpdl_size;
|
|
42415
|
1788
|
46284
36c70758a8d7
(SPECPDL_INDEX): Rename from BINDING_STACK_SIZE. All callers updated.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
1789 #define SPECPDL_INDEX() (specpdl_ptr - specpdl)
|
|
33508
|
1790
|
|
1197
|
1791 /* Everything needed to describe an active condition case. */
|
|
302
|
1792 struct handler
|
|
|
1793 {
|
|
1197
|
1794 /* The handler clauses and variable from the condition-case form. */
|
|
46866
|
1795 /* For a handler set up in Lisp code, this is always a list.
|
|
|
1796 For an internal handler set up by internal_condition_case*,
|
|
|
1797 this can instead be the symbol t or `error'.
|
|
|
1798 t: handle all conditions.
|
|
|
1799 error: handle all conditions, and errors can run the debugger
|
|
|
1800 or display a backtrace. */
|
|
302
|
1801 Lisp_Object handler;
|
|
|
1802 Lisp_Object var;
|
|
6131
|
1803 /* Fsignal stores here the condition-case clause that applies,
|
|
|
1804 and Fcondition_case thus knows which clause to run. */
|
|
|
1805 Lisp_Object chosen_clause;
|
|
1197
|
1806
|
|
|
1807 /* Used to effect the longjump out to the handler. */
|
|
302
|
1808 struct catchtag *tag;
|
|
1197
|
1809
|
|
|
1810 /* The next enclosing handler. */
|
|
302
|
1811 struct handler *next;
|
|
|
1812 };
|
|
|
1813
|
|
|
1814 extern struct handler *handlerlist;
|
|
|
1815
|
|
|
1816 extern struct catchtag *catchlist;
|
|
|
1817 extern struct backtrace *backtrace_list;
|
|
|
1818
|
|
6131
|
1819 extern Lisp_Object memory_signal_data;
|
|
|
1820
|
|
302
|
1821 /* An address near the bottom of the stack.
|
|
|
1822 Tells GC how to save a copy of the stack. */
|
|
|
1823 extern char *stack_bottom;
|
|
|
1824
|
|
26296
|
1825 /* Check quit-flag and quit if it is non-nil.
|
|
|
1826 Typing C-g does not directly cause a quit; it only sets Vquit_flag.
|
|
|
1827 So the program needs to do QUIT at times when it is safe to quit.
|
|
|
1828 Every loop that might run for a long time or might not exit
|
|
|
1829 ought to do QUIT at least once, at a safe place.
|
|
|
1830 Unless that is impossible, of course.
|
|
|
1831 But it is very desirable to avoid creating loops where QUIT is impossible.
|
|
|
1832
|
|
|
1833 Exception: if you set immediate_quit to nonzero,
|
|
|
1834 then the handler that responds to the C-g does the quit itself.
|
|
|
1835 This is a good thing to do around a loop that has no side effects
|
|
|
1836 and (in particular) cannot call arbitrary Lisp code. */
|
|
302
|
1837
|
53658
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1838 #ifdef SYNC_INPUT
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1839 extern void handle_async_input P_ ((void));
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1840 extern int interrupt_input_pending;
|
|
58932
|
1841
|
53658
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1842 #define QUIT \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1843 do { \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1844 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1845 { \
|
|
58932
|
1846 Lisp_Object flag = Vquit_flag; \
|
53658
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1847 Vquit_flag = Qnil; \
|
|
58932
|
1848 if (EQ (Vthrow_on_input, flag)) \
|
|
64847
|
1849 Fthrow (Vthrow_on_input, Qt); \
|
53658
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1850 Fsignal (Qquit, Qnil); \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1851 } \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1852 else if (interrupt_input_pending) \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1853 handle_async_input (); \
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1854 } while (0)
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1855
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1856 #else /* not SYNC_INPUT */
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1857
|
|
26309
|
1858 #define QUIT \
|
|
|
1859 do { \
|
|
|
1860 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
|
|
|
1861 { \
|
|
58932
|
1862 Lisp_Object flag = Vquit_flag; \
|
|
26309
|
1863 Vquit_flag = Qnil; \
|
|
58932
|
1864 if (EQ (Vthrow_on_input, flag)) \
|
|
64981
|
1865 Fthrow (Vthrow_on_input, Qt); \
|
|
26309
|
1866 Fsignal (Qquit, Qnil); \
|
|
|
1867 } \
|
|
|
1868 } while (0)
|
|
302
|
1869
|
53658
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1870 #endif /* not SYNC_INPUT */
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1871
|
c6460069583e
(QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
1872
|
|
302
|
1873 /* Nonzero if ought to quit now. */
|
|
|
1874
|
|
493
|
1875 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
|
|
302
|
1876
|
|
18006
|
1877 /* Variables used locally in the following case handling macros. */
|
|
18613
|
1878 extern int case_temp1;
|
|
|
1879 extern Lisp_Object case_temp2;
|
|
18006
|
1880
|
|
17404
|
1881 /* Current buffer's map from characters to lower-case characters. */
|
|
|
1882
|
|
18006
|
1883 #define DOWNCASE_TABLE current_buffer->downcase_table
|
|
17404
|
1884
|
|
|
1885 /* Current buffer's map from characters to upper-case characters. */
|
|
|
1886
|
|
18006
|
1887 #define UPCASE_TABLE current_buffer->upcase_table
|
|
17404
|
1888
|
|
|
1889 /* Downcase a character, or make no change if that cannot be done. */
|
|
|
1890
|
|
18006
|
1891 #define DOWNCASE(CH) \
|
|
|
1892 ((case_temp1 = (CH), \
|
|
|
1893 case_temp2 = CHAR_TABLE_REF (DOWNCASE_TABLE, case_temp1), \
|
|
|
1894 NATNUMP (case_temp2)) \
|
|
|
1895 ? XFASTINT (case_temp2) : case_temp1)
|
|
17404
|
1896
|
|
302
|
1897 /* 1 if CH is upper case. */
|
|
|
1898
|
|
18111
|
1899 #define UPPERCASEP(CH) (DOWNCASE (CH) != (CH))
|
|
17404
|
1900
|
|
|
1901 /* 1 if CH is neither upper nor lower case. */
|
|
|
1902
|
|
18006
|
1903 #define NOCASEP(CH) (UPCASE1 (CH) == (CH))
|
|
302
|
1904
|
|
|
1905 /* 1 if CH is lower case. */
|
|
|
1906
|
|
17289
|
1907 #define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
|
|
302
|
1908
|
|
|
1909 /* Upcase a character, or make no change if that cannot be done. */
|
|
|
1910
|
|
17289
|
1911 #define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
|
|
302
|
1912
|
|
|
1913 /* Upcase a character known to be not upper case. */
|
|
|
1914
|
|
18006
|
1915 #define UPCASE1(CH) \
|
|
|
1916 ((case_temp1 = (CH), \
|
|
|
1917 case_temp2 = CHAR_TABLE_REF (UPCASE_TABLE, case_temp1), \
|
|
|
1918 NATNUMP (case_temp2)) \
|
|
|
1919 ? XFASTINT (case_temp2) : case_temp1)
|
|
302
|
1920
|
|
61187
|
1921 extern Lisp_Object Vascii_downcase_table, Vascii_upcase_table;
|
|
|
1922 extern Lisp_Object Vascii_canon_table, Vascii_eqv_table;
|
|
302
|
1923
|
|
10316
|
1924 /* Number of bytes of structure consed since last GC. */
|
|
302
|
1925
|
|
|
1926 extern int consing_since_gc;
|
|
|
1927
|
|
64612
|
1928 /* Thresholds for doing another gc. */
|
|
|
1929
|
|
|
1930 extern EMACS_INT gc_cons_threshold;
|
|
|
1931
|
|
|
1932 extern EMACS_INT gc_relative_threshold;
|
|
302
|
1933
|
|
66531
|
1934 extern EMACS_INT memory_full_cons_threshold;
|
|
|
1935
|
|
10316
|
1936 /* Structure for recording stack slots that need marking. */
|
|
302
|
1937
|
|
|
1938 /* This is a chain of structures, each of which points at a Lisp_Object variable
|
|
|
1939 whose value should be marked in garbage collection.
|
|
|
1940 Normally every link of the chain is an automatic variable of a function,
|
|
|
1941 and its `val' points to some argument or local variable of the function.
|
|
|
1942 On exit to the function, the chain is set back to the value it had on entry.
|
|
4826
|
1943 This way, no link remains in the chain when the stack frame containing the
|
|
|
1944 link disappears.
|
|
302
|
1945
|
|
|
1946 Every function that can call Feval must protect in this fashion all
|
|
10316
|
1947 Lisp_Object variables whose contents will be used again. */
|
|
302
|
1948
|
|
|
1949 extern struct gcpro *gcprolist;
|
|
|
1950
|
|
|
1951 struct gcpro
|
|
32065
|
1952 {
|
|
|
1953 struct gcpro *next;
|
|
45623
|
1954
|
|
32065
|
1955 /* Address of first protected variable. */
|
|
|
1956 volatile Lisp_Object *var;
|
|
45623
|
1957
|
|
32065
|
1958 /* Number of consecutive protected variables. */
|
|
|
1959 int nvars;
|
|
45623
|
1960
|
|
26296
|
1961 #ifdef DEBUG_GCPRO
|
|
32065
|
1962 int level;
|
|
26296
|
1963 #endif
|
|
32065
|
1964 };
|
|
302
|
1965
|
|
27741
|
1966 /* Values of GC_MARK_STACK during compilation:
|
|
|
1967
|
|
|
1968 0 Use GCPRO as before
|
|
|
1969 1 Do the real thing, make GCPROs and UNGCPRO no-ops.
|
|
|
1970 2 Mark the stack, and check that everything GCPRO'd is
|
|
|
1971 marked.
|
|
|
1972 3 Mark using GCPRO's, mark stack last, and count how many
|
|
|
1973 dead objects are kept alive. */
|
|
|
1974
|
|
|
1975
|
|
|
1976 #define GC_USE_GCPROS_AS_BEFORE 0
|
|
|
1977 #define GC_MAKE_GCPROS_NOOPS 1
|
|
|
1978 #define GC_MARK_STACK_CHECK_GCPROS 2
|
|
|
1979 #define GC_USE_GCPROS_CHECK_ZOMBIES 3
|
|
|
1980
|
|
|
1981 #ifndef GC_MARK_STACK
|
|
|
1982 #define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
|
|
|
1983 #endif
|
|
|
1984
|
|
|
1985 #if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
|
|
|
1986
|
|
41659
|
1987 /* Do something silly with gcproN vars just so gcc shuts up. */
|
|
48540
|
1988 /* You get warnings from MIPSPro... */
|
|
41659
|
1989
|
|
|
1990 #define GCPRO1(varname) ((void) gcpro1)
|
|
45623
|
1991 #define GCPRO2(varname1, varname2)(((void) gcpro2, (void) gcpro1))
|
|
41659
|
1992 #define GCPRO3(varname1, varname2, varname3) \
|
|
|
1993 (((void) gcpro3, (void) gcpro2, (void) gcpro1))
|
|
|
1994 #define GCPRO4(varname1, varname2, varname3, varname4) \
|
|
|
1995 (((void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
|
|
|
1996 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
|
|
|
1997 (((void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
|
|
43616
|
1998 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
|
|
|
1999 (((void) gcpro6, (void) gcpro5, (void) gcpro4, (void) gcpro3, (void) gcpro2, (void) gcpro1))
|
|
27741
|
2000 #define UNGCPRO ((void) 0)
|
|
|
2001
|
|
|
2002 #else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
|
|
|
2003
|
|
26296
|
2004 #ifndef DEBUG_GCPRO
|
|
|
2005
|
|
302
|
2006 #define GCPRO1(varname) \
|
|
|
2007 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
|
|
|
2008 gcprolist = &gcpro1; }
|
|
|
2009
|
|
|
2010 #define GCPRO2(varname1, varname2) \
|
|
|
2011 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2012 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2013 gcprolist = &gcpro2; }
|
|
|
2014
|
|
|
2015 #define GCPRO3(varname1, varname2, varname3) \
|
|
|
2016 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2017 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2018 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2019 gcprolist = &gcpro3; }
|
|
|
2020
|
|
|
2021 #define GCPRO4(varname1, varname2, varname3, varname4) \
|
|
|
2022 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2023 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2024 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2025 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
|
|
|
2026 gcprolist = &gcpro4; }
|
|
|
2027
|
|
8009
|
2028 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
|
|
|
2029 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2030 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2031 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2032 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
|
|
|
2033 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
|
|
|
2034 gcprolist = &gcpro5; }
|
|
|
2035
|
|
43616
|
2036 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
|
|
|
2037 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2038 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2039 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2040 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
|
|
|
2041 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
|
|
|
2042 gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
|
|
|
2043 gcprolist = &gcpro6; }
|
|
|
2044
|
|
302
|
2045 #define UNGCPRO (gcprolist = gcpro1.next)
|
|
|
2046
|
|
26296
|
2047 #else
|
|
|
2048
|
|
|
2049 extern int gcpro_level;
|
|
|
2050
|
|
|
2051 #define GCPRO1(varname) \
|
|
|
2052 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
|
|
|
2053 gcpro1.level = gcpro_level++; \
|
|
|
2054 gcprolist = &gcpro1; }
|
|
|
2055
|
|
|
2056 #define GCPRO2(varname1, varname2) \
|
|
|
2057 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2058 gcpro1.level = gcpro_level; \
|
|
|
2059 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2060 gcpro2.level = gcpro_level++; \
|
|
|
2061 gcprolist = &gcpro2; }
|
|
|
2062
|
|
|
2063 #define GCPRO3(varname1, varname2, varname3) \
|
|
|
2064 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2065 gcpro1.level = gcpro_level; \
|
|
|
2066 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2067 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2068 gcpro3.level = gcpro_level++; \
|
|
|
2069 gcprolist = &gcpro3; }
|
|
|
2070
|
|
|
2071 #define GCPRO4(varname1, varname2, varname3, varname4) \
|
|
|
2072 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2073 gcpro1.level = gcpro_level; \
|
|
|
2074 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2075 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2076 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
|
|
|
2077 gcpro4.level = gcpro_level++; \
|
|
|
2078 gcprolist = &gcpro4; }
|
|
|
2079
|
|
|
2080 #define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
|
|
|
2081 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2082 gcpro1.level = gcpro_level; \
|
|
|
2083 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2084 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2085 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
|
|
|
2086 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
|
|
|
2087 gcpro5.level = gcpro_level++; \
|
|
|
2088 gcprolist = &gcpro5; }
|
|
|
2089
|
|
43616
|
2090 #define GCPRO6(varname1, varname2, varname3, varname4, varname5, varname6) \
|
|
|
2091 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
|
|
|
2092 gcpro1.level = gcpro_level; \
|
|
|
2093 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
|
|
|
2094 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
|
|
|
2095 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
|
|
|
2096 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
|
|
|
2097 gcpro6.next = &gcpro5; gcpro6.var = &varname6; gcpro6.nvars = 1; \
|
|
|
2098 gcpro6.level = gcpro_level++; \
|
|
|
2099 gcprolist = &gcpro6; }
|
|
|
2100
|
|
26296
|
2101 #define UNGCPRO \
|
|
|
2102 ((--gcpro_level != gcpro1.level) \
|
|
|
2103 ? (abort (), 0) \
|
|
|
2104 : ((gcprolist = gcpro1.next), 0))
|
|
|
2105
|
|
|
2106 #endif /* DEBUG_GCPRO */
|
|
27741
|
2107 #endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
|
|
|
2108
|
|
26296
|
2109
|
|
8560
|
2110 /* Evaluate expr, UNGCPRO, and then return the value of expr. */
|
|
8009
|
2111 #define RETURN_UNGCPRO(expr) \
|
|
25769
|
2112 do \
|
|
8009
|
2113 { \
|
|
|
2114 Lisp_Object ret_ungc_val; \
|
|
|
2115 ret_ungc_val = (expr); \
|
|
|
2116 UNGCPRO; \
|
|
|
2117 return ret_ungc_val; \
|
|
|
2118 } \
|
|
25769
|
2119 while (0)
|
|
26296
|
2120
|
|
|
2121 /* Call staticpro (&var) to protect static variable `var'. */
|
|
|
2122
|
|
|
2123 void staticpro P_ ((Lisp_Object *));
|
|
302
|
2124
|
|
18732
|
2125 /* Declare a Lisp-callable function. The MAXARGS parameter has the same
|
|
|
2126 meaning as in the DEFUN macro, and is used to construct a prototype. */
|
|
29443
|
2127 #if (!defined (__STDC__) && !defined (PROTOTYPES)) \
|
|
|
2128 || defined (USE_NONANSI_DEFUN)
|
|
18732
|
2129 #define EXFUN(fnname, maxargs) \
|
|
|
2130 extern Lisp_Object fnname ()
|
|
|
2131 #else
|
|
|
2132 /* We can use the same trick as in the DEFUN macro to generate the
|
|
|
2133 appropriate prototype. */
|
|
|
2134 #define EXFUN(fnname, maxargs) \
|
|
|
2135 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
|
|
|
2136 #endif
|
|
|
2137
|
|
20297
|
2138 /* Forward declarations for prototypes. */
|
|
|
2139 struct window;
|
|
|
2140 struct frame;
|
|
18732
|
2141
|
|
302
|
2142 /* Defined in data.c */
|
|
|
2143 extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
|
|
|
2144 extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
|
|
|
2145 extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
|
|
|
2146 extern Lisp_Object Qvoid_variable, Qvoid_function;
|
|
|
2147 extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
|
|
|
2148 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
|
|
53111
|
2149 extern Lisp_Object Qend_of_file, Qarith_error, Qmark_inactive;
|
|
302
|
2150 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
|
|
53111
|
2151 extern Lisp_Object Qtext_read_only;
|
|
|
2152
|
|
|
2153 extern Lisp_Object Qintegerp, Qnatnump, Qwholenump, Qsymbolp, Qlistp, Qconsp;
|
|
|
2154 extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
|
|
|
2155 extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qinteger_or_marker_p, Qvectorp;
|
|
|
2156 extern Lisp_Object Qbuffer_or_string_p;
|
|
|
2157 extern Lisp_Object Qboundp, Qfboundp;
|
|
|
2158 extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
|
|
|
2159
|
|
|
2160 extern Lisp_Object Qcdr;
|
|
302
|
2161
|
|
2653
|
2162 extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
|
|
|
2163 extern Lisp_Object Qoverflow_error, Qunderflow_error;
|
|
2155
|
2164
|
|
53111
|
2165 extern Lisp_Object Qfloatp;
|
|
|
2166 extern Lisp_Object Qnumberp, Qnumber_or_marker_p;
|
|
|
2167
|
|
|
2168 extern Lisp_Object Qinteger;
|
|
302
|
2169
|
|
72005
|
2170 extern void circular_list_error P_ ((Lisp_Object)) NO_RETURN;
|
|
54628
|
2171 EXFUN (Finteractive_form, 1);
|
|
39766
|
2172
|
|
53111
|
2173 /* Defined in frame.c */
|
|
|
2174 extern Lisp_Object Qframep;
|
|
|
2175
|
|
18732
|
2176 EXFUN (Feq, 2);
|
|
|
2177 EXFUN (Fnull, 1);
|
|
|
2178 EXFUN (Flistp, 1);
|
|
|
2179 EXFUN (Fconsp, 1);
|
|
|
2180 EXFUN (Fatom, 1);
|
|
|
2181 EXFUN (Fnlistp, 1);
|
|
|
2182 EXFUN (Fintegerp, 1);
|
|
|
2183 EXFUN (Fnatnump, 1);
|
|
|
2184 EXFUN (Fsymbolp, 1);
|
|
|
2185 EXFUN (Fvectorp, 1);
|
|
|
2186 EXFUN (Fstringp, 1);
|
|
20625
|
2187 EXFUN (Fmultibyte_string_p, 1);
|
|
18732
|
2188 EXFUN (Farrayp, 1);
|
|
|
2189 EXFUN (Fsequencep, 1);
|
|
|
2190 EXFUN (Fbufferp, 1);
|
|
|
2191 EXFUN (Fmarkerp, 1);
|
|
|
2192 EXFUN (Fsubrp, 1);
|
|
|
2193 EXFUN (Fchar_or_string_p, 1);
|
|
|
2194 EXFUN (Finteger_or_marker_p, 1);
|
|
|
2195 EXFUN (Ffloatp, 1);
|
|
|
2196 EXFUN (Finteger_or_floatp, 1);
|
|
|
2197 EXFUN (Finteger_or_float_or_marker_p, 1);
|
|
302
|
2198
|
|
18732
|
2199 EXFUN (Fcar, 1);
|
|
|
2200 EXFUN (Fcar_safe, 1);
|
|
|
2201 EXFUN (Fcdr, 1);
|
|
|
2202 EXFUN (Fcdr_safe, 1);
|
|
|
2203 EXFUN (Fsetcar, 2);
|
|
|
2204 EXFUN (Fsetcdr, 2);
|
|
|
2205 EXFUN (Fboundp, 1);
|
|
|
2206 EXFUN (Ffboundp, 1);
|
|
|
2207 EXFUN (Fmakunbound, 1);
|
|
|
2208 EXFUN (Ffmakunbound, 1);
|
|
|
2209 EXFUN (Fsymbol_function, 1);
|
|
|
2210 EXFUN (Fsymbol_plist, 1);
|
|
|
2211 EXFUN (Fsymbol_name, 1);
|
|
|
2212 extern Lisp_Object indirect_function P_ ((Lisp_Object));
|
|
68758
|
2213 EXFUN (Findirect_function, 2);
|
|
18732
|
2214 EXFUN (Ffset, 2);
|
|
|
2215 EXFUN (Fsetplist, 2);
|
|
|
2216 EXFUN (Fsymbol_value, 1);
|
|
19224
|
2217 extern Lisp_Object find_symbol_value P_ ((Lisp_Object));
|
|
18732
|
2218 EXFUN (Fset, 2);
|
|
|
2219 EXFUN (Fdefault_value, 1);
|
|
|
2220 EXFUN (Fset_default, 2);
|
|
|
2221 EXFUN (Fdefault_boundp, 1);
|
|
|
2222 EXFUN (Fmake_local_variable, 1);
|
|
19224
|
2223 EXFUN (Flocal_variable_p, 2);
|
|
18732
|
2224 EXFUN (Flocal_variable_if_set_p, 2);
|
|
302
|
2225
|
|
18732
|
2226 EXFUN (Faref, 2);
|
|
|
2227 EXFUN (Faset, 3);
|
|
302
|
2228
|
|
18732
|
2229 EXFUN (Fstring_to_number, 2);
|
|
|
2230 EXFUN (Fnumber_to_string, 1);
|
|
|
2231 EXFUN (Feqlsign, 2);
|
|
|
2232 EXFUN (Fgtr, 2);
|
|
|
2233 EXFUN (Flss, 2);
|
|
|
2234 EXFUN (Fgeq, 2);
|
|
|
2235 EXFUN (Fleq, 2);
|
|
|
2236 EXFUN (Fneq, 2);
|
|
|
2237 EXFUN (Fzerop, 1);
|
|
|
2238 EXFUN (Fplus, MANY);
|
|
|
2239 EXFUN (Fminus, MANY);
|
|
|
2240 EXFUN (Ftimes, MANY);
|
|
|
2241 EXFUN (Fquo, MANY);
|
|
|
2242 EXFUN (Frem, 2);
|
|
|
2243 EXFUN (Fmax, MANY);
|
|
|
2244 EXFUN (Fmin, MANY);
|
|
|
2245 EXFUN (Flogand, MANY);
|
|
|
2246 EXFUN (Flogior, MANY);
|
|
|
2247 EXFUN (Flogxor, MANY);
|
|
|
2248 EXFUN (Flognot, 1);
|
|
|
2249 EXFUN (Flsh, 2);
|
|
|
2250 EXFUN (Fash, 2);
|
|
302
|
2251
|
|
18732
|
2252 EXFUN (Fadd1, 1);
|
|
|
2253 EXFUN (Fsub1, 1);
|
|
34154
|
2254 EXFUN (Fmake_variable_buffer_local, 1);
|
|
18732
|
2255
|
|
39579
|
2256 extern Lisp_Object indirect_variable P_ ((Lisp_Object));
|
|
18732
|
2257 extern Lisp_Object long_to_cons P_ ((unsigned long));
|
|
|
2258 extern unsigned long cons_to_long P_ ((Lisp_Object));
|
|
69883
|
2259 extern void args_out_of_range P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
|
|
|
2260 extern void args_out_of_range_3 P_ ((Lisp_Object, Lisp_Object,
|
|
|
2261 Lisp_Object)) NO_RETURN;
|
|
69928
|
2262 extern Lisp_Object wrong_type_argument P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
|
|
36816
|
2263 extern void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object,
|
|
|
2264 Lisp_Object, struct buffer *));
|
|
18732
|
2265 extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
|
|
27292
|
2266 extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, struct buffer *, int));
|
|
21931
|
2267 extern void syms_of_data P_ ((void));
|
|
|
2268 extern void init_data P_ ((void));
|
|
29925
|
2269 extern void swap_in_global_binding P_ ((Lisp_Object));
|
|
302
|
2270
|
|
11934
|
2271 /* Defined in cmds.c */
|
|
18732
|
2272 EXFUN (Fend_of_line, 1);
|
|
|
2273 EXFUN (Fforward_char, 1);
|
|
|
2274 EXFUN (Fforward_line, 1);
|
|
20297
|
2275 extern int internal_self_insert P_ ((int, int));
|
|
21931
|
2276 extern void syms_of_cmds P_ ((void));
|
|
|
2277 extern void keys_of_cmds P_ ((void));
|
|
11934
|
2278
|
|
17037
|
2279 /* Defined in coding.c */
|
|
18732
|
2280 EXFUN (Fcoding_system_p, 1);
|
|
|
2281 EXFUN (Fcheck_coding_system, 1);
|
|
19757
|
2282 EXFUN (Fread_coding_system, 2);
|
|
18732
|
2283 EXFUN (Fread_non_nil_coding_system, 1);
|
|
19224
|
2284 EXFUN (Ffind_operation_coding_system, MANY);
|
|
42756
|
2285 EXFUN (Fupdate_coding_systems_internal, 0);
|
|
20297
|
2286 EXFUN (Fencode_coding_string, 3);
|
|
|
2287 EXFUN (Fdecode_coding_string, 3);
|
|
46552
|
2288 extern Lisp_Object detect_coding_system P_ ((const unsigned char *, int, int,
|
|
|
2289 int));
|
|
22791
|
2290 extern void init_coding P_ ((void));
|
|
21931
|
2291 extern void init_coding_once P_ ((void));
|
|
|
2292 extern void syms_of_coding P_ ((void));
|
|
25769
|
2293 extern Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object,
|
|
|
2294 int));
|
|
17037
|
2295
|
|
19574
|
2296 /* Defined in charset.c */
|
43713
f92c4d87863a
Change defvar_int def and vars to use EMACS_INT instead of just int.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
2297 extern EMACS_INT nonascii_insert_offset;
|
|
22123
|
2298 extern Lisp_Object Vnonascii_translation_table;
|
|
19574
|
2299 EXFUN (Fchar_bytes, 1);
|
|
21515
|
2300 EXFUN (Fchar_width, 1);
|
|
27885
|
2301 EXFUN (Fstring, MANY);
|
|
46471
|
2302 extern int chars_in_text P_ ((const unsigned char *, int));
|
|
|
2303 extern int multibyte_chars_in_text P_ ((const unsigned char *, int));
|
|
20708
|
2304 extern int unibyte_char_to_multibyte P_ ((int));
|
|
22928
|
2305 extern int multibyte_char_to_unibyte P_ ((int, Lisp_Object));
|
|
21038
|
2306 extern Lisp_Object Qcharset;
|
|
21931
|
2307 extern void init_charset_once P_ ((void));
|
|
|
2308 extern void syms_of_charset P_ ((void));
|
|
19574
|
2309
|
|
11934
|
2310 /* Defined in syntax.c */
|
|
18732
|
2311 EXFUN (Fforward_word, 1);
|
|
|
2312 EXFUN (Fskip_chars_forward, 2);
|
|
|
2313 EXFUN (Fskip_chars_backward, 2);
|
|
20297
|
2314 EXFUN (Fsyntax_table_p, 1);
|
|
|
2315 EXFUN (Fsyntax_table, 0);
|
|
|
2316 EXFUN (Fset_syntax_table, 1);
|
|
21931
|
2317 extern void init_syntax_once P_ ((void));
|
|
|
2318 extern void syms_of_syntax P_ ((void));
|
|
11934
|
2319
|
|
302
|
2320 /* Defined in fns.c */
|
|
31015
|
2321 extern int use_dialog_box;
|
|
29978
|
2322 extern int next_almost_prime P_ ((int));
|
|
28480
|
2323 extern Lisp_Object larger_vector P_ ((Lisp_Object, int, Lisp_Object));
|
|
25765
|
2324 extern void sweep_weak_hash_tables P_ ((void));
|
|
302
|
2325 extern Lisp_Object Qstring_lessp;
|
|
29443
|
2326 EXFUN (Foptimize_char_table, 1);
|
|
302
|
2327 extern Lisp_Object Vfeatures;
|
|
26865
|
2328 extern Lisp_Object QCtest, QCweakness, Qequal;
|
|
25017
|
2329 unsigned sxhash P_ ((Lisp_Object, int));
|
|
|
2330 Lisp_Object make_hash_table P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
|
|
|
2331 Lisp_Object, Lisp_Object, Lisp_Object,
|
|
|
2332 Lisp_Object));
|
|
25366
|
2333 Lisp_Object copy_hash_table P_ ((struct Lisp_Hash_Table *));
|
|
25017
|
2334 int hash_lookup P_ ((struct Lisp_Hash_Table *, Lisp_Object, unsigned *));
|
|
26865
|
2335 int hash_put P_ ((struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
|
|
|
2336 unsigned));
|
|
25017
|
2337 void hash_remove P_ ((struct Lisp_Hash_Table *, Lisp_Object));
|
|
|
2338 void hash_clear P_ ((struct Lisp_Hash_Table *));
|
|
|
2339 void remove_hash_entry P_ ((struct Lisp_Hash_Table *, int));
|
|
25748
|
2340 extern void init_fns P_ ((void));
|
|
25017
|
2341 EXFUN (Fsxhash, 1);
|
|
|
2342 EXFUN (Fmake_hash_table, MANY);
|
|
25366
|
2343 EXFUN (Fcopy_hash_table, 1);
|
|
25017
|
2344 EXFUN (Fhash_table_count, 1);
|
|
|
2345 EXFUN (Fhash_table_rehash_size, 1);
|
|
|
2346 EXFUN (Fhash_table_rehash_threshold, 1);
|
|
|
2347 EXFUN (Fhash_table_size, 1);
|
|
|
2348 EXFUN (Fhash_table_test, 1);
|
|
|
2349 EXFUN (Fhash_table_weak, 1);
|
|
|
2350 EXFUN (Fhash_table_p, 1);
|
|
|
2351 EXFUN (Fclrhash, 1);
|
|
|
2352 EXFUN (Fgethash, 3);
|
|
|
2353 EXFUN (Fputhash, 3);
|
|
|
2354 EXFUN (Fremhash, 2);
|
|
|
2355 EXFUN (Fmaphash, 2);
|
|
|
2356 EXFUN (Fdefine_hash_table_test, 3);
|
|
|
2357
|
|
18732
|
2358 EXFUN (Fidentity, 1);
|
|
|
2359 EXFUN (Frandom, 1);
|
|
|
2360 EXFUN (Flength, 1);
|
|
|
2361 EXFUN (Fsafe_length, 1);
|
|
|
2362 EXFUN (Fappend, MANY);
|
|
|
2363 EXFUN (Fconcat, MANY);
|
|
|
2364 EXFUN (Fvconcat, MANY);
|
|
|
2365 EXFUN (Fcopy_sequence, 1);
|
|
21038
|
2366 EXFUN (Fstring_make_multibyte, 1);
|
|
|
2367 EXFUN (Fstring_make_unibyte, 1);
|
|
|
2368 EXFUN (Fstring_as_multibyte, 1);
|
|
|
2369 EXFUN (Fstring_as_unibyte, 1);
|
|
49866
|
2370 EXFUN (Fstring_to_multibyte, 1);
|
|
18732
|
2371 EXFUN (Fsubstring, 3);
|
|
20625
|
2372 extern Lisp_Object substring_both P_ ((Lisp_Object, int, int, int, int));
|
|
18732
|
2373 EXFUN (Fnth, 2);
|
|
|
2374 EXFUN (Fnthcdr, 2);
|
|
|
2375 EXFUN (Fmemq, 2);
|
|
|
2376 EXFUN (Fassq, 2);
|
|
|
2377 EXFUN (Fassoc, 2);
|
|
|
2378 EXFUN (Felt, 2);
|
|
|
2379 EXFUN (Fmember, 2);
|
|
|
2380 EXFUN (Frassq, 2);
|
|
|
2381 EXFUN (Fdelq, 2);
|
|
58092
|
2382 EXFUN (Fdelete, 2);
|
|
18732
|
2383 EXFUN (Fsort, 2);
|
|
|
2384 EXFUN (Freverse, 1);
|
|
|
2385 EXFUN (Fnreverse, 1);
|
|
|
2386 EXFUN (Fget, 2);
|
|
|
2387 EXFUN (Fput, 3);
|
|
|
2388 EXFUN (Fequal, 2);
|
|
|
2389 EXFUN (Ffillarray, 2);
|
|
|
2390 EXFUN (Fnconc, MANY);
|
|
|
2391 EXFUN (Fmapcar, 2);
|
|
|
2392 EXFUN (Fmapconcat, 3);
|
|
|
2393 EXFUN (Fy_or_n_p, 1);
|
|
|
2394 extern Lisp_Object do_yes_or_no_p P_ ((Lisp_Object));
|
|
23772
|
2395 EXFUN (Frequire, 3);
|
|
39860
|
2396 EXFUN (Fprovide, 2);
|
|
18732
|
2397 extern Lisp_Object concat2 P_ ((Lisp_Object, Lisp_Object));
|
|
|
2398 extern Lisp_Object concat3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
|
|
|
2399 extern Lisp_Object nconc2 P_ ((Lisp_Object, Lisp_Object));
|
|
|
2400 extern Lisp_Object assq_no_quit P_ ((Lisp_Object, Lisp_Object));
|
|
27885
|
2401 extern void clear_string_char_byte_cache P_ ((void));
|
|
20625
|
2402 extern int string_char_to_byte P_ ((Lisp_Object, int));
|
|
|
2403 extern int string_byte_to_char P_ ((Lisp_Object, int));
|
|
21515
|
2404 extern Lisp_Object string_make_multibyte P_ ((Lisp_Object));
|
|
58704
|
2405 extern Lisp_Object string_to_multibyte P_ ((Lisp_Object));
|
|
21515
|
2406 extern Lisp_Object string_make_unibyte P_ ((Lisp_Object));
|
|
18732
|
2407 EXFUN (Fcopy_alist, 1);
|
|
|
2408 EXFUN (Fplist_get, 2);
|
|
25017
|
2409 EXFUN (Fplist_put, 3);
|
|
44009
|
2410 EXFUN (Fplist_member, 2);
|
|
18732
|
2411 EXFUN (Fset_char_table_parent, 2);
|
|
|
2412 EXFUN (Fchar_table_extra_slot, 2);
|
|
20297
|
2413 EXFUN (Fset_char_table_extra_slot, 3);
|
|
18732
|
2414 EXFUN (Frassoc, 2);
|
|
|
2415 EXFUN (Fstring_equal, 2);
|
|
21842
|
2416 EXFUN (Fcompare_strings, 7);
|
|
18732
|
2417 EXFUN (Fstring_lessp, 2);
|
|
21515
|
2418 extern int char_table_translate P_ ((Lisp_Object, int));
|
|
20297
|
2419 extern void map_char_table P_ ((void (*) (Lisp_Object, Lisp_Object, Lisp_Object),
|
|
51035
|
2420 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, int,
|
81794
c1184a3d99c9
(map_char_table): Use an array of int for `indices' rather than
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
2421 int *));
|
|
30489
|
2422 extern Lisp_Object char_table_ref_and_index P_ ((Lisp_Object, int, int *));
|
|
21931
|
2423 extern void syms_of_fns P_ ((void));
|
|
18732
|
2424
|
|
|
2425 /* Defined in floatfns.c */
|
|
|
2426 extern double extract_float P_ ((Lisp_Object));
|
|
|
2427 EXFUN (Ffloat, 1);
|
|
|
2428 EXFUN (Ftruncate, 2);
|
|
21931
|
2429 extern void init_floatfns P_ ((void));
|
|
|
2430 extern void syms_of_floatfns P_ ((void));
|
|
302
|
2431
|
|
53884
|
2432 /* Defined in fringe.c */
|
|
|
2433 extern void syms_of_fringe P_ ((void));
|
|
|
2434 extern void init_fringe P_ ((void));
|
|
|
2435 extern void init_fringe_once P_ ((void));
|
|
|
2436
|
|
54340
|
2437 /* Defined in image.c */
|
|
56287
|
2438 EXFUN (Finit_image_library, 2);
|
|
54340
|
2439 extern void syms_of_image P_ ((void));
|
|
|
2440 extern void init_image P_ ((void));
|
|
|
2441
|
|
10396
|
2442 /* Defined in insdel.c */
|
|
39245
|
2443 extern Lisp_Object Qinhibit_modification_hooks;
|
|
18732
|
2444 extern void move_gap P_ ((int));
|
|
20559
|
2445 extern void move_gap_both P_ ((int, int));
|
|
18732
|
2446 extern void make_gap P_ ((int));
|
|
46471
|
2447 extern int copy_text P_ ((const unsigned char *, unsigned char *, int, int, int));
|
|
|
2448 extern int count_size_as_multibyte P_ ((const unsigned char *, int));
|
|
|
2449 extern int count_combining_before P_ ((const unsigned char *, int, int, int));
|
|
|
2450 extern int count_combining_after P_ ((const unsigned char *, int, int, int));
|
|
|
2451 extern void insert P_ ((const unsigned char *, int));
|
|
|
2452 extern void insert_and_inherit P_ ((const unsigned char *, int));
|
|
|
2453 extern void insert_1 P_ ((const unsigned char *, int, int, int, int));
|
|
|
2454 extern void insert_1_both P_ ((const unsigned char *, int, int, int, int, int));
|
|
20625
|
2455 extern void insert_from_string P_ ((Lisp_Object, int, int, int, int, int));
|
|
18732
|
2456 extern void insert_from_buffer P_ ((struct buffer *, int, int, int));
|
|
|
2457 extern void insert_char P_ ((int));
|
|
46471
|
2458 extern void insert_string P_ ((const char *));
|
|
|
2459 extern void insert_before_markers P_ ((const unsigned char *, int));
|
|
|
2460 extern void insert_before_markers_and_inherit P_ ((const unsigned char *, int));
|
|
20625
|
2461 extern void insert_from_string_before_markers P_ ((Lisp_Object, int, int, int, int, int));
|
|
18732
|
2462 extern void del_range P_ ((int, int));
|
26742
936b39bd05b4
* editfns.c (Fdelete_and_extract_region): New function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
2463 extern Lisp_Object del_range_1 P_ ((int, int, int, int));
|
|
20559
|
2464 extern void del_range_byte P_ ((int, int, int));
|
|
|
2465 extern void del_range_both P_ ((int, int, int, int, int));
|
26742
936b39bd05b4
* editfns.c (Fdelete_and_extract_region): New function.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
2466 extern Lisp_Object del_range_2 P_ ((int, int, int, int, int));
|
|
72592
|
2467 extern void modify_region P_ ((struct buffer *, int, int, int));
|
|
18732
|
2468 extern void prepare_to_modify_buffer P_ ((int, int, int *));
|
|
|
2469 extern void signal_before_change P_ ((int, int, int *));
|
|
|
2470 extern void signal_after_change P_ ((int, int, int));
|
|
21322
|
2471 extern void adjust_after_replace P_ ((int, int, Lisp_Object, int, int));
|
|
42756
|
2472 extern void adjust_after_replace_noundo P_ ((int, int, int, int, int, int));
|
|
21322
|
2473 extern void adjust_after_insert P_ ((int, int, int, int, int));
|
|
21276
|
2474 extern void replace_range P_ ((int, int, Lisp_Object, int, int, int));
|
|
58092
|
2475 extern void replace_range_2 P_ ((int, int, int, int, char *, int, int, int));
|
|
21931
|
2476 extern void syms_of_insdel P_ ((void));
|
|
10396
|
2477
|
|
16133
|
2478 /* Defined in dispnew.c */
|
|
25672
|
2479 extern Lisp_Object selected_frame;
|
43713
f92c4d87863a
Change defvar_int def and vars to use EMACS_INT instead of just int.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
2480 extern EMACS_INT baud_rate;
|
|
18732
|
2481 EXFUN (Fding, 1);
|
|
25450
|
2482 EXFUN (Fredraw_frame, 1);
|
|
18732
|
2483 EXFUN (Fredraw_display, 0);
|
|
|
2484 EXFUN (Fsleep_for, 2);
|
|
71796
|
2485 EXFUN (Fredisplay, 1);
|
|
|
2486 extern Lisp_Object sit_for P_ ((Lisp_Object, int, int));
|
|
21931
|
2487 extern void init_display P_ ((void));
|
|
|
2488 extern void syms_of_display P_ ((void));
|
|
46552
|
2489 extern void safe_bcopy P_ ((const char *, char *, int));
|
|
16133
|
2490
|
|
10396
|
2491 /* Defined in xdisp.c */
|
|
34796
|
2492 extern Lisp_Object Qinhibit_point_motion_hooks;
|
|
31447
|
2493 extern Lisp_Object Qinhibit_redisplay, Qdisplay;
|
|
37042
|
2494 extern Lisp_Object Qinhibit_eval_during_redisplay;
|
|
29636
|
2495 extern Lisp_Object Qmessage_truncate_lines;
|
|
53331
|
2496 extern Lisp_Object Qimage;
|
|
11191
|
2497 extern Lisp_Object Vmessage_log_max;
|
|
20625
|
2498 extern int message_enable_multibyte;
|
|
25353
|
2499 extern Lisp_Object echo_area_buffer[2];
|
|
25748
|
2500 extern void check_message_stack P_ ((void));
|
|
25353
|
2501 extern void setup_echo_area_for_printing P_ ((int));
|
|
|
2502 extern int push_message P_ ((void));
|
|
47393
|
2503 extern Lisp_Object pop_message_unwind P_ ((Lisp_Object));
|
|
|
2504 extern Lisp_Object restore_message_unwind P_ ((Lisp_Object));
|
|
25353
|
2505 extern void pop_message P_ ((void));
|
|
|
2506 extern void restore_message P_ ((void));
|
|
|
2507 extern Lisp_Object current_message P_ ((void));
|
|
46471
|
2508 extern void set_message P_ ((const char *s, Lisp_Object, int, int));
|
|
25353
|
2509 extern void clear_message P_ ((int, int));
|
|
18732
|
2510 extern void message P_ ((/* char *, ... */));
|
|
|
2511 extern void message_nolog P_ ((/* char *, ... */));
|
|
|
2512 extern void message1 P_ ((char *));
|
|
|
2513 extern void message1_nolog P_ ((char *));
|
|
46471
|
2514 extern void message2 P_ ((const char *, int, int));
|
|
|
2515 extern void message2_nolog P_ ((const char *, int, int));
|
|
25017
|
2516 extern void message3 P_ ((Lisp_Object, int, int));
|
|
|
2517 extern void message3_nolog P_ ((Lisp_Object, int, int));
|
|
46471
|
2518 extern void message_dolog P_ ((const char *, int, int, int));
|
|
20625
|
2519 extern void message_with_string P_ ((char *, Lisp_Object, int));
|
|
18732
|
2520 extern void message_log_maybe_newline P_ ((void));
|
|
20297
|
2521 extern void update_echo_area P_ ((void));
|
|
|
2522 extern void truncate_echo_area P_ ((int));
|
|
|
2523 extern void redisplay P_ ((void));
|
|
26865
|
2524 extern int check_point_in_composition
|
|
|
2525 P_ ((struct buffer *, int, struct buffer *, int));
|
|
35335
|
2526 extern void redisplay_preserve_echo_area P_ ((int));
|
|
20297
|
2527 extern void prepare_menu_bars P_ ((void));
|
|
48322
|
2528
|
|
47136
|
2529 void set_frame_cursor_types P_ ((struct frame *, Lisp_Object));
|
|
21931
|
2530 extern void syms_of_xdisp P_ ((void));
|
|
|
2531 extern void init_xdisp P_ ((void));
|
|
32173
|
2532 extern Lisp_Object safe_eval P_ ((Lisp_Object));
|
|
55024
|
2533 extern int pos_visible_p P_ ((struct window *, int, int *,
|
|
72662
|
2534 int *, int *, int *, int *, int *));
|
|
10396
|
2535
|
|
25748
|
2536 /* Defined in vm-limit.c. */
|
|
28054
|
2537 extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
|
|
|
2538
|
|
302
|
2539 /* Defined in alloc.c */
|
|
39579
|
2540 extern void check_pure_size P_ ((void));
|
|
27141
|
2541 extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
|
|
58818
|
2542 extern void reset_malloc_hooks P_ ((void));
|
|
25748
|
2543 extern void uninterrupt_malloc P_ ((void));
|
|
20297
|
2544 extern void malloc_warning P_ ((char *));
|
|
72005
|
2545 extern void memory_full P_ ((void)) NO_RETURN;
|
|
|
2546 extern void buffer_memory_full P_ ((void)) NO_RETURN;
|
|
25017
|
2547 extern int survives_gc_p P_ ((Lisp_Object));
|
51766
eee1bdf9de54
(mark_object): Change prototype to only pass Lisp_Object.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
2548 extern void mark_object P_ ((Lisp_Object));
|
|
302
|
2549 extern Lisp_Object Vpurify_flag;
|
|
46304
|
2550 extern Lisp_Object Vmemory_full;
|
|
18732
|
2551 EXFUN (Fcons, 2);
|
|
71983
|
2552 EXFUN (list1, 1);
|
|
21038
|
2553 EXFUN (list2, 2);
|
|
|
2554 EXFUN (list3, 3);
|
|
|
2555 EXFUN (list4, 4);
|
|
|
2556 EXFUN (list5, 5);
|
|
18732
|
2557 EXFUN (Flist, MANY);
|
|
|
2558 EXFUN (Fmake_list, 2);
|
|
|
2559 extern Lisp_Object allocate_misc P_ ((void));
|
|
|
2560 EXFUN (Fmake_vector, 2);
|
|
|
2561 EXFUN (Fvector, MANY);
|
|
|
2562 EXFUN (Fmake_symbol, 1);
|
|
|
2563 EXFUN (Fmake_marker, 0);
|
|
|
2564 EXFUN (Fmake_string, 2);
|
|
46471
|
2565 extern Lisp_Object build_string P_ ((const char *));
|
|
|
2566 extern Lisp_Object make_string P_ ((const char *, int));
|
|
|
2567 extern Lisp_Object make_unibyte_string P_ ((const char *, int));
|
|
|
2568 extern Lisp_Object make_multibyte_string P_ ((const char *, int, int));
|
|
18732
|
2569 extern Lisp_Object make_event_array P_ ((int, Lisp_Object *));
|
|
|
2570 extern Lisp_Object make_uninit_string P_ ((int));
|
|
20625
|
2571 extern Lisp_Object make_uninit_multibyte_string P_ ((int, int));
|
|
50276
|
2572 extern Lisp_Object make_string_from_bytes P_ ((const char *, int, int));
|
|
|
2573 extern Lisp_Object make_specified_string P_ ((const char *, int, int, int));
|
|
18732
|
2574 EXFUN (Fpurecopy, 1);
|
|
21276
|
2575 extern Lisp_Object make_pure_string P_ ((char *, int, int, int));
|
|
18732
|
2576 extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
|
|
|
2577 extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
|
|
|
2578 EXFUN (Fgarbage_collect, 0);
|
|
|
2579 EXFUN (Fmake_byte_code, MANY);
|
|
|
2580 EXFUN (Fmake_bool_vector, 2);
|
|
|
2581 EXFUN (Fmake_char_table, 2);
|
|
|
2582 extern Lisp_Object make_sub_char_table P_ ((Lisp_Object));
|
|
13202
|
2583 extern Lisp_Object Qchar_table_extra_slots;
|
|
36430
|
2584 extern struct Lisp_Vector *allocate_vector P_ ((EMACS_INT));
|
|
|
2585 extern struct Lisp_Vector *allocate_other_vector P_ ((EMACS_INT));
|
|
|
2586 extern struct Lisp_Hash_Table *allocate_hash_table P_ ((void));
|
|
|
2587 extern struct window *allocate_window P_ ((void));
|
|
|
2588 extern struct frame *allocate_frame P_ ((void));
|
|
|
2589 extern struct Lisp_Process *allocate_process P_ ((void));
|
|
84763
|
2590 extern struct terminal *allocate_terminal P_ ((void));
|
|
6657
|
2591 extern int gc_in_progress;
|
|
50748
|
2592 extern int abort_on_gc;
|
|
18732
|
2593 extern Lisp_Object make_float P_ ((double));
|
|
20297
|
2594 extern void display_malloc_warning P_ ((void));
|
|
|
2595 extern int inhibit_garbage_collection P_ ((void));
|
|
49056
|
2596 extern Lisp_Object make_save_value P_ ((void *, int));
|
|
56242
|
2597 extern void free_misc P_ ((Lisp_Object));
|
|
20297
|
2598 extern void free_marker P_ ((Lisp_Object));
|
|
|
2599 extern void free_cons P_ ((struct Lisp_Cons *));
|
|
21931
|
2600 extern void init_alloc_once P_ ((void));
|
|
|
2601 extern void init_alloc P_ ((void));
|
|
|
2602 extern void syms_of_alloc P_ ((void));
|
|
27885
|
2603 extern struct buffer * allocate_buffer P_ ((void));
|
|
66778
|
2604 extern int valid_lisp_object_p P_ ((Lisp_Object));
|
|
302
|
2605
|
|
|
2606 /* Defined in print.c */
|
|
|
2607 extern Lisp_Object Vprin1_to_string_buffer;
|
|
25712
|
2608 extern void debug_print P_ ((Lisp_Object));
|
|
18732
|
2609 EXFUN (Fprin1, 2);
|
|
|
2610 EXFUN (Fprin1_to_string, 2);
|
|
|
2611 EXFUN (Fprinc, 2);
|
|
|
2612 EXFUN (Fterpri, 1);
|
|
|
2613 EXFUN (Fprint, 2);
|
|
|
2614 EXFUN (Ferror_message_string, 1);
|
|
302
|
2615 extern Lisp_Object Vstandard_output, Qstandard_output;
|
|
439
|
2616 extern Lisp_Object Qexternal_debugging_output;
|
|
46552
|
2617 extern void temp_output_buffer_setup P_ ((const char *));
|
|
302
|
2618 extern int print_level, print_escape_newlines;
|
|
|
2619 extern Lisp_Object Qprint_escape_newlines;
|
|
20297
|
2620 extern void write_string P_ ((char *, int));
|
|
|
2621 extern void write_string_1 P_ ((char *, int, Lisp_Object));
|
|
46573
|
2622 extern void print_error_message P_ ((Lisp_Object, Lisp_Object, char *, Lisp_Object));
|
|
20297
|
2623 extern Lisp_Object internal_with_output_to_temp_buffer
|
|
46552
|
2624 P_ ((const char *, Lisp_Object (*) (Lisp_Object), Lisp_Object));
|
|
20297
|
2625 extern void float_to_string P_ ((unsigned char *, double));
|
|
21931
|
2626 extern void syms_of_print P_ ((void));
|
|
20297
|
2627
|
|
|
2628 /* Defined in doprnt.c */
|
|
|
2629 extern int doprnt P_ ((char *, int, char *, char *, int, char **));
|
|
|
2630 extern int doprnt_lisp P_ ((char *, int, char *, char *, int, char **));
|
|
302
|
2631
|
|
|
2632 /* Defined in lread.c */
|
|
|
2633 extern Lisp_Object Qvariable_documentation, Qstandard_input;
|
|
21774
|
2634 extern Lisp_Object Vobarray, initial_obarray, Vstandard_input;
|
|
18732
|
2635 EXFUN (Fread, 1);
|
|
|
2636 EXFUN (Fread_from_string, 3);
|
|
|
2637 EXFUN (Fintern, 2);
|
|
|
2638 EXFUN (Fintern_soft, 2);
|
|
19119
|
2639 EXFUN (Fload, 5);
|
|
69171
|
2640 EXFUN (Fget_load_suffixes, 0);
|
|
18732
|
2641 EXFUN (Fget_file_char, 0);
|
72133
995e57f32746
* lisp.h: Update read-char, read-event, and read_filtered_event
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
2642 EXFUN (Fread_char, 3);
|
995e57f32746
* lisp.h: Update read-char, read-event, and read_filtered_event
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
2643 EXFUN (Fread_event, 3);
|
995e57f32746
* lisp.h: Update read-char, read-event, and read_filtered_event
Chong Yidong <cyd@stupidchicken.com>
diff
changeset
|
2644 extern Lisp_Object read_filtered_event P_ ((int, int, int, int, Lisp_Object));
|
|
22418
|
2645 EXFUN (Feval_region, 4);
|
|
76496
|
2646 extern Lisp_Object check_obarray P_ ((Lisp_Object));
|
|
46471
|
2647 extern Lisp_Object intern P_ ((const char *));
|
|
18732
|
2648 extern Lisp_Object make_symbol P_ ((char *));
|
|
46471
|
2649 extern Lisp_Object oblookup P_ ((Lisp_Object, const char *, int, int));
|
|
2605
|
2650 #define LOADHIST_ATTACH(x) \
|
|
|
2651 if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
|
|
|
2652 extern Lisp_Object Vcurrent_load_list;
|
|
69171
|
2653 extern Lisp_Object Vload_history, Vload_suffixes, Vload_file_rep_suffixes;
|
|
39810
|
2654 extern int openp P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
|
|
45000
|
2655 Lisp_Object *, Lisp_Object));
|
|
20297
|
2656 extern int isfloat_string P_ ((char *));
|
|
|
2657 extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
|
|
|
2658 Lisp_Object));
|
|
|
2659 extern void dir_warning P_ ((char *, Lisp_Object));
|
|
|
2660 extern void close_load_descs P_ ((void));
|
|
21931
|
2661 extern void init_obarray P_ ((void));
|
|
|
2662 extern void init_lread P_ ((void));
|
|
|
2663 extern void syms_of_lread P_ ((void));
|
|
302
|
2664
|
|
|
2665 /* Defined in eval.c */
|
|
|
2666 extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
|
|
381
|
2667 extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
|
|
302
|
2668 extern Lisp_Object Vautoload_queue;
|
|
8995
|
2669 extern Lisp_Object Vdebug_on_error;
|
|
30072
|
2670 extern Lisp_Object Vsignaling_function;
|
|
30081
|
2671 extern int handling_signal;
|
|
35773
|
2672 extern int interactive_p P_ ((int));
|
|
30072
|
2673
|
|
12731
|
2674 /* To run a normal hook, use the appropriate function from the list below.
|
|
|
2675 The calling convention:
|
|
|
2676
|
|
6216
|
2677 if (!NILP (Vrun_hooks))
|
|
12731
|
2678 call1 (Vrun_hooks, Qmy_funny_hook);
|
|
|
2679
|
|
|
2680 should no longer be used. */
|
|
302
|
2681 extern Lisp_Object Vrun_hooks;
|
|
18732
|
2682 EXFUN (Frun_hooks, MANY);
|
|
|
2683 EXFUN (Frun_hook_with_args, MANY);
|
|
|
2684 EXFUN (Frun_hook_with_args_until_success, MANY);
|
|
|
2685 EXFUN (Frun_hook_with_args_until_failure, MANY);
|
|
41751
|
2686 extern Lisp_Object run_hook_list_with_args P_ ((Lisp_Object, int, Lisp_Object *));
|
|
20297
|
2687 extern void run_hook_with_args_2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
|
|
18732
|
2688 EXFUN (Fand, UNEVALLED);
|
|
|
2689 EXFUN (For, UNEVALLED);
|
|
|
2690 EXFUN (Fif, UNEVALLED);
|
|
|
2691 EXFUN (Fprogn, UNEVALLED);
|
|
|
2692 EXFUN (Fprog1, UNEVALLED);
|
|
|
2693 EXFUN (Fprog2, UNEVALLED);
|
|
|
2694 EXFUN (Fsetq, UNEVALLED);
|
|
|
2695 EXFUN (Fquote, UNEVALLED);
|
|
|
2696 EXFUN (Fuser_variable_p, 1);
|
|
|
2697 EXFUN (Finteractive_p, 0);
|
|
|
2698 EXFUN (Fdefun, UNEVALLED);
|
|
|
2699 EXFUN (Flet, UNEVALLED);
|
|
|
2700 EXFUN (FletX, UNEVALLED);
|
|
|
2701 EXFUN (Fwhile, UNEVALLED);
|
|
|
2702 EXFUN (Fcatch, UNEVALLED);
|
|
31833
|
2703 EXFUN (Fthrow, 2) NO_RETURN;
|
|
18732
|
2704 EXFUN (Funwind_protect, UNEVALLED);
|
|
|
2705 EXFUN (Fcondition_case, UNEVALLED);
|
|
32065
|
2706 EXFUN (Fsignal, 2);
|
|
71983
|
2707 extern void xsignal P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
|
|
|
2708 extern void xsignal0 P_ ((Lisp_Object)) NO_RETURN;
|
|
|
2709 extern void xsignal1 P_ ((Lisp_Object, Lisp_Object)) NO_RETURN;
|
|
|
2710 extern void xsignal2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object)) NO_RETURN;
|
|
|
2711 extern void xsignal3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)) NO_RETURN;
|
|
|
2712 extern void signal_error P_ ((char *, Lisp_Object)) NO_RETURN;
|
|
18732
|
2713 EXFUN (Fautoload, 5);
|
|
44940
|
2714 EXFUN (Fcommandp, 2);
|
|
18732
|
2715 EXFUN (Feval, 1);
|
|
|
2716 EXFUN (Fapply, MANY);
|
|
|
2717 EXFUN (Ffuncall, MANY);
|
|
|
2718 EXFUN (Fbacktrace, 0);
|
|
|
2719 extern Lisp_Object apply1 P_ ((Lisp_Object, Lisp_Object));
|
|
|
2720 extern Lisp_Object call0 P_ ((Lisp_Object));
|
|
|
2721 extern Lisp_Object call1 P_ ((Lisp_Object, Lisp_Object));
|
|
|
2722 extern Lisp_Object call2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
|
|
|
2723 extern Lisp_Object call3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
|
|
|
2724 extern Lisp_Object call4 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
|
|
|
2725 extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
|
|
|
2726 extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
|
|
|
2727 EXFUN (Fdo_auto_save, 2);
|
|
|
2728 extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
|
|
|
2729 extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
|
|
66531
|
2730 extern Lisp_Object internal_lisp_condition_case P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
|
|
18732
|
2731 extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
|
|
|
2732 extern Lisp_Object internal_condition_case_1 P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
|
|
30218
|
2733 extern Lisp_Object internal_condition_case_2 P_ ((Lisp_Object (*) (int, Lisp_Object *), int, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
|
|
20297
|
2734 extern void specbind P_ ((Lisp_Object, Lisp_Object));
|
|
|
2735 extern void record_unwind_protect P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object));
|
|
18732
|
2736 extern Lisp_Object unbind_to P_ ((int, Lisp_Object));
|
|
31833
|
2737 extern void error P_ ((/* char *, ... */)) NO_RETURN;
|
|
20297
|
2738 extern void do_autoload P_ ((Lisp_Object, Lisp_Object));
|
|
18732
|
2739 extern Lisp_Object un_autoload P_ ((Lisp_Object));
|
|
|
2740 EXFUN (Ffetch_bytecode, 1);
|
|
21931
|
2741 extern void init_eval_once P_ ((void));
|
|
32173
|
2742 extern Lisp_Object safe_call P_ ((int, Lisp_Object *));
|
|
|
2743 extern Lisp_Object safe_call1 P_ ((Lisp_Object, Lisp_Object));
|
|
21931
|
2744 extern void init_eval P_ ((void));
|
|
|
2745 extern void syms_of_eval P_ ((void));
|
|
302
|
2746
|
|
|
2747 /* Defined in editfns.c */
|
|
44522
|
2748 EXFUN (Fpropertize, MANY);
|
|
25353
|
2749 EXFUN (Fcurrent_message, 0);
|
|
18732
|
2750 EXFUN (Fgoto_char, 1);
|
|
|
2751 EXFUN (Fpoint_min_marker, 0);
|
|
|
2752 EXFUN (Fpoint_max_marker, 0);
|
|
|
2753 EXFUN (Fpoint_min, 0);
|
|
|
2754 EXFUN (Fpoint_max, 0);
|
|
|
2755 EXFUN (Fpoint, 0);
|
|
|
2756 EXFUN (Fpoint_marker, 0);
|
|
|
2757 EXFUN (Fmark_marker, 0);
|
|
|
2758 EXFUN (Fline_beginning_position, 1);
|
|
|
2759 EXFUN (Fline_end_position, 1);
|
|
|
2760 EXFUN (Ffollowing_char, 0);
|
|
|
2761 EXFUN (Fprevious_char, 0);
|
|
|
2762 EXFUN (Fchar_after, 1);
|
|
|
2763 EXFUN (Finsert, MANY);
|
|
|
2764 EXFUN (Finsert_and_inherit, MANY);
|
|
|
2765 EXFUN (Finsert_before_markers, MANY);
|
|
|
2766 EXFUN (Finsert_buffer_substring, 3);
|
|
|
2767 EXFUN (Finsert_char, 3);
|
|
20297
|
2768 extern void insert1 P_ ((Lisp_Object));
|
|
18732
|
2769 EXFUN (Feolp, 0);
|
|
|
2770 EXFUN (Feobp, 0);
|
|
|
2771 EXFUN (Fbolp, 0);
|
|
|
2772 EXFUN (Fbobp, 0);
|
|
|
2773 EXFUN (Fformat, MANY);
|
|
25017
|
2774 EXFUN (Fmessage, MANY);
|
|
49446
|
2775 extern Lisp_Object format2 P_ ((char *, Lisp_Object, Lisp_Object));
|
|
18732
|
2776 EXFUN (Fbuffer_substring, 2);
|
|
|
2777 EXFUN (Fbuffer_string, 0);
|
|
|
2778 extern Lisp_Object save_excursion_save P_ ((void));
|
|
|
2779 extern Lisp_Object save_restriction_save P_ ((void));
|
|
|
2780 extern Lisp_Object save_excursion_restore P_ ((Lisp_Object));
|
|
|
2781 extern Lisp_Object save_restriction_restore P_ ((Lisp_Object));
|
|
|
2782 EXFUN (Fchar_to_string, 1);
|
|
|
2783 EXFUN (Fdelete_region, 2);
|
|
|
2784 EXFUN (Fnarrow_to_region, 2);
|
|
|
2785 EXFUN (Fwiden, 0);
|
|
|
2786 EXFUN (Fuser_login_name, 1);
|
|
|
2787 EXFUN (Fsystem_name, 0);
|
|
25450
|
2788 EXFUN (Fcurrent_time, 0);
|
|
20297
|
2789 extern int clip_to_bounds P_ ((int, int, int));
|
|
21282
|
2790 extern Lisp_Object make_buffer_string P_ ((int, int, int));
|
|
|
2791 extern Lisp_Object make_buffer_string_both P_ ((int, int, int, int, int));
|
|
21931
|
2792 extern void init_editfns P_ ((void));
|
|
|
2793 extern void syms_of_editfns P_ ((void));
|
|
27078
|
2794 extern Lisp_Object Vinhibit_field_text_motion;
|
|
30440
|
2795 EXFUN (Fconstrain_to_field, 5);
|
|
27885
|
2796 EXFUN (Ffield_string, 1);
|
|
|
2797 EXFUN (Fdelete_field, 1);
|
|
41067
|
2798 EXFUN (Ffield_beginning, 3);
|
|
|
2799 EXFUN (Ffield_end, 3);
|
|
27885
|
2800 EXFUN (Ffield_string_no_properties, 1);
|
|
31015
|
2801 extern void set_time_zone_rule P_ ((char *));
|
|
302
|
2802
|
|
|
2803 /* defined in buffer.c */
|
|
36585
|
2804 extern int mouse_face_overlay_overlaps P_ ((Lisp_Object));
|
|
71063
|
2805 extern void nsberror P_ ((Lisp_Object)) NO_RETURN;
|
|
25737
|
2806 extern char *no_switch_window P_ ((Lisp_Object window));
|
|
25353
|
2807 EXFUN (Fset_buffer_multibyte, 1);
|
|
18732
|
2808 EXFUN (Foverlay_start, 1);
|
|
|
2809 EXFUN (Foverlay_end, 1);
|
51868
6806fc84a58f
(adjust_overlays_for_insert, adjust_overlays_for_delete): Update prototype.
Andreas Schwab <schwab@suse.de>
diff
changeset
|
2810 extern void adjust_overlays_for_insert P_ ((EMACS_INT, EMACS_INT));
|
6806fc84a58f
(adjust_overlays_for_insert, adjust_overlays_for_delete): Update prototype.
Andreas Schwab <schwab@suse.de>
diff
changeset
|
2811 extern void adjust_overlays_for_delete P_ ((EMACS_INT, EMACS_INT));
|
54555
b136a4512609
* insdel.c (adjust_markers_for_insert): Call fix_start_end_in_overlays.
Masatake YAMATO <jet@gyve.org>
diff
changeset
|
2812 extern void fix_start_end_in_overlays P_ ((int, int));
|
|
20297
|
2813 extern void report_overlay_modification P_ ((Lisp_Object, Lisp_Object, int,
|
|
|
2814 Lisp_Object, Lisp_Object, Lisp_Object));
|
|
18732
|
2815 extern int overlay_touches_p P_ ((int));
|
|
3539
|
2816 extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
|
|
18732
|
2817 EXFUN (Fget_buffer, 1);
|
|
|
2818 EXFUN (Fget_buffer_create, 1);
|
|
|
2819 EXFUN (Fset_buffer, 1);
|
|
20708
|
2820 EXFUN (set_buffer_if_live, 1);
|
|
18732
|
2821 EXFUN (Fbarf_if_buffer_read_only, 0);
|
|
|
2822 EXFUN (Fcurrent_buffer, 0);
|
|
|
2823 EXFUN (Fswitch_to_buffer, 2);
|
|
|
2824 EXFUN (Fpop_to_buffer, 3);
|
|
22190
|
2825 EXFUN (Fother_buffer, 3);
|
|
18732
|
2826 EXFUN (Foverlay_get, 2);
|
|
|
2827 EXFUN (Fbuffer_modified_p, 1);
|
|
|
2828 EXFUN (Fset_buffer_modified_p, 1);
|
|
|
2829 EXFUN (Fkill_buffer, 1);
|
|
|
2830 EXFUN (Fkill_all_local_variables, 0);
|
|
|
2831 EXFUN (Fbuffer_disable_undo, 1);
|
|
|
2832 EXFUN (Fbuffer_enable_undo, 1);
|
|
|
2833 EXFUN (Ferase_buffer, 0);
|
|
2780
|
2834 extern Lisp_Object Qoverlayp;
|
|
63146
|
2835 extern Lisp_Object Qevaporate;
|
|
18732
|
2836 extern Lisp_Object get_truename_buffer P_ ((Lisp_Object));
|
|
302
|
2837 extern struct buffer *all_buffers;
|
|
18732
|
2838 EXFUN (Fprevious_overlay_change, 1);
|
|
34154
|
2839 EXFUN (Fbuffer_file_name, 1);
|
|
21931
|
2840 extern void init_buffer_once P_ ((void));
|
|
|
2841 extern void init_buffer P_ ((void));
|
|
|
2842 extern void syms_of_buffer P_ ((void));
|
|
|
2843 extern void keys_of_buffer P_ ((void));
|
|
302
|
2844
|
|
|
2845 /* defined in marker.c */
|
|
|
2846
|
|
18732
|
2847 EXFUN (Fmarker_position, 1);
|
|
|
2848 EXFUN (Fmarker_buffer, 1);
|
|
|
2849 EXFUN (Fcopy_marker, 2);
|
|
|
2850 EXFUN (Fset_marker, 3);
|
|
20297
|
2851 extern int marker_position P_ ((Lisp_Object));
|
|
21515
|
2852 extern int marker_byte_position P_ ((Lisp_Object));
|
|
|
2853 extern void clear_charpos_cache P_ ((struct buffer *));
|
|
|
2854 extern int charpos_to_bytepos P_ ((int));
|
|
|
2855 extern int buf_charpos_to_bytepos P_ ((struct buffer *, int));
|
|
|
2856 extern int buf_bytepos_to_charpos P_ ((struct buffer *, int));
|
|
51666
|
2857 extern void unchain_marker P_ ((struct Lisp_Marker *marker));
|
|
20297
|
2858 extern Lisp_Object set_marker_restricted P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
|
|
20559
|
2859 extern Lisp_Object set_marker_both P_ ((Lisp_Object, Lisp_Object, int, int));
|
|
|
2860 extern Lisp_Object set_marker_restricted_both P_ ((Lisp_Object, Lisp_Object,
|
|
|
2861 int, int));
|
|
21931
|
2862 extern void syms_of_marker P_ ((void));
|
|
302
|
2863
|
|
|
2864 /* Defined in fileio.c */
|
|
|
2865
|
|
|
2866 extern Lisp_Object Qfile_error;
|
|
18732
|
2867 EXFUN (Ffind_file_name_handler, 2);
|
|
|
2868 EXFUN (Ffile_name_as_directory, 1);
|
|
25450
|
2869 EXFUN (Fmake_temp_name, 1);
|
|
18732
|
2870 EXFUN (Fexpand_file_name, 2);
|
|
|
2871 EXFUN (Ffile_name_nondirectory, 1);
|
|
|
2872 EXFUN (Fsubstitute_in_file_name, 1);
|
|
|
2873 EXFUN (Ffile_symlink_p, 1);
|
|
|
2874 EXFUN (Fverify_visited_file_modtime, 1);
|
|
|
2875 EXFUN (Ffile_exists_p, 1);
|
|
|
2876 EXFUN (Ffile_name_absolute_p, 1);
|
|
|
2877 EXFUN (Fdirectory_file_name, 1);
|
|
|
2878 EXFUN (Ffile_name_directory, 1);
|
|
|
2879 extern Lisp_Object expand_and_dir_to_file P_ ((Lisp_Object, Lisp_Object));
|
|
|
2880 EXFUN (Ffile_accessible_directory_p, 1);
|
|
|
2881 EXFUN (Funhandled_file_name_directory, 1);
|
|
|
2882 EXFUN (Ffile_directory_p, 1);
|
|
21038
|
2883 EXFUN (Fwrite_region, 7);
|
|
18732
|
2884 EXFUN (Ffile_readable_p, 1);
|
|
|
2885 EXFUN (Ffile_executable_p, 1);
|
|
45545
|
2886 EXFUN (Fread_file_name, 6);
|
|
25704
|
2887 extern Lisp_Object close_file_unwind P_ ((Lisp_Object));
|
|
69878
|
2888 extern void report_file_error P_ ((const char *, Lisp_Object)) NO_RETURN;
|
|
20297
|
2889 extern int internal_delete_file P_ ((Lisp_Object));
|
|
21931
|
2890 extern void syms_of_fileio P_ ((void));
|
|
25748
|
2891 extern void init_fileio_once P_ ((void));
|
|
29443
|
2892 extern Lisp_Object make_temp_name P_ ((Lisp_Object, int));
|
|
55487
|
2893 EXFUN (Fmake_symbolic_link, 3);
|
|
302
|
2894
|
|
|
2895 /* Defined in abbrev.c */
|
|
|
2896
|
|
21931
|
2897 extern void syms_of_abbrev P_ ((void));
|
|
302
|
2898
|
|
|
2899 /* defined in search.c */
|
|
25765
|
2900 extern void shrink_regexp_cache P_ ((void));
|
|
18732
|
2901 EXFUN (Fstring_match, 3);
|
|
63146
|
2902 extern void restore_search_regs P_ ((void));
|
|
|
2903 EXFUN (Fmatch_data, 3);
|
|
|
2904 EXFUN (Fset_match_data, 2);
|
|
18732
|
2905 EXFUN (Fmatch_beginning, 1);
|
|
|
2906 EXFUN (Fmatch_end, 1);
|
|
63146
|
2907 extern void record_unwind_save_match_data P_ ((void));
|
|
33351
|
2908 EXFUN (Flooking_at, 1);
|
|
20297
|
2909 extern int fast_string_match P_ ((Lisp_Object, Lisp_Object));
|
|
46471
|
2910 extern int fast_c_string_match_ignore_case P_ ((Lisp_Object, const char *));
|
|
57571
|
2911 extern int fast_string_match_ignore_case P_ ((Lisp_Object, Lisp_Object));
|
|
20297
|
2912 extern int scan_buffer P_ ((int, int, int, int, int *, int));
|
|
20559
|
2913 extern int scan_newline P_ ((int, int, int, int, int, int));
|
|
20297
|
2914 extern int find_next_newline P_ ((int, int));
|
|
|
2915 extern int find_next_newline_no_quit P_ ((int, int));
|
|
|
2916 extern int find_before_next_newline P_ ((int, int, int));
|
|
21931
|
2917 extern void syms_of_search P_ ((void));
|
|
73231
|
2918 extern void clear_regexp_cache P_ ((void));
|
|
302
|
2919
|
|
|
2920 /* defined in minibuf.c */
|
|
|
2921
|
|
|
2922 extern Lisp_Object last_minibuf_string;
|
|
20297
|
2923 extern void choose_minibuf_frame P_ ((void));
|
|
19547
|
2924 EXFUN (Fcompleting_read, 8);
|
|
70929
|
2925 EXFUN (Fread_from_minibuffer, 7);
|
|
18732
|
2926 EXFUN (Fread_variable, 2);
|
|
|
2927 EXFUN (Fread_buffer, 3);
|
|
|
2928 EXFUN (Fread_minibuffer, 2);
|
|
|
2929 EXFUN (Feval_minibuffer, 2);
|
|
19547
|
2930 EXFUN (Fread_string, 5);
|
|
|
2931 EXFUN (Fread_no_blanks_input, 3);
|
|
18732
|
2932 extern Lisp_Object get_minibuffer P_ ((int));
|
|
50539
|
2933 extern void temp_echo_area_glyphs P_ ((Lisp_Object));
|
|
21931
|
2934 extern void init_minibuf_once P_ ((void));
|
|
|
2935 extern void syms_of_minibuf P_ ((void));
|
|
|
2936 extern void keys_of_minibuf P_ ((void));
|
|
302
|
2937
|
|
|
2938 /* Defined in callint.c */
|
|
|
2939
|
|
12114
|
2940 extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
|
|
302
|
2941 extern Lisp_Object Vcommand_history;
|
|
15695
|
2942 extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
|
|
18732
|
2943 EXFUN (Fcall_interactively, 3);
|
|
|
2944 EXFUN (Fprefix_numeric_value, 1);
|
|
21931
|
2945 extern void syms_of_callint P_ ((void));
|
|
302
|
2946
|
|
|
2947 /* defined in casefiddle.c */
|
|
|
2948
|
|
18732
|
2949 EXFUN (Fdowncase, 1);
|
|
|
2950 EXFUN (Fupcase, 1);
|
|
|
2951 EXFUN (Fcapitalize, 1);
|
|
|
2952 EXFUN (Fupcase_region, 2);
|
|
|
2953 EXFUN (Fupcase_initials, 1);
|
|
|
2954 EXFUN (Fupcase_initials_region, 2);
|
|
21931
|
2955 extern void syms_of_casefiddle P_ ((void));
|
|
|
2956 extern void keys_of_casefiddle P_ ((void));
|
|
302
|
2957
|
|
16133
|
2958 /* defined in casetab.c */
|
|
|
2959
|
|
18732
|
2960 EXFUN (Fset_case_table, 1);
|
|
|
2961 EXFUN (Fset_standard_case_table, 1);
|
|
21931
|
2962 extern void init_casetab_once P_ ((void));
|
|
|
2963 extern void syms_of_casetab P_ ((void));
|
|
16133
|
2964
|
|
302
|
2965 /* defined in keyboard.c */
|
|
|
2966
|
|
37188
|
2967 extern int echoing;
|
|
|
2968 extern Lisp_Object echo_message_buffer;
|
|
39451
|
2969 extern struct kboard *echo_kboard;
|
|
37188
|
2970 extern void cancel_echoing P_ ((void));
|
|
29940
|
2971 extern Lisp_Object Qdisabled, QCfilter;
|
|
17871
|
2972 extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
|
|
58932
|
2973 extern Lisp_Object Vthrow_on_input;
|
|
30723
|
2974 extern int input_pending;
|
|
18732
|
2975 EXFUN (Fdiscard_input, 0);
|
|
|
2976 EXFUN (Frecursive_edit, 0);
|
|
39924
|
2977 EXFUN (Ftop_level, 0);
|
|
18732
|
2978 EXFUN (Fcommand_execute, 4);
|
|
|
2979 EXFUN (Finput_pending_p, 0);
|
|
|
2980 extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
|
|
25544
|
2981 extern Lisp_Object tool_bar_items P_ ((Lisp_Object, int *));
|
|
1990
|
2982 extern Lisp_Object Qvertical_scroll_bar;
|
|
27885
|
2983 extern void discard_mouse_events P_ ((void));
|
|
18732
|
2984 EXFUN (Fevent_convert_list, 1);
|
|
22925
|
2985 EXFUN (Fread_key_sequence, 5);
|
83417
fe870a866ce7
Don't let x_initialize break 8-bit input on ttys. (Reported by Joakim Verona.) Split `set-input-mode'.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
2986 EXFUN (Fset_input_interrupt_mode, 1);
|
fe870a866ce7
Don't let x_initialize break 8-bit input on ttys. (Reported by Joakim Verona.) Split `set-input-mode'.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
2987 EXFUN (Fset_output_flow_control, 2);
|
fe870a866ce7
Don't let x_initialize break 8-bit input on ttys. (Reported by Joakim Verona.) Split `set-input-mode'.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
2988 EXFUN (Fset_input_meta_mode, 2);
|
fe870a866ce7
Don't let x_initialize break 8-bit input on ttys. (Reported by Joakim Verona.) Split `set-input-mode'.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
2989 EXFUN (Fset_quit_char, 1);
|
|
20297
|
2990 EXFUN (Fset_input_mode, 4);
|
|
|
2991 extern int detect_input_pending P_ ((void));
|
|
59580
|
2992 extern int detect_input_pending_ignore_squeezables P_ ((void));
|
|
20297
|
2993 extern int detect_input_pending_run_timers P_ ((int));
|
|
|
2994 extern void safe_run_hooks P_ ((Lisp_Object));
|
|
|
2995 extern void cmd_error_internal P_ ((Lisp_Object, char *));
|
|
|
2996 extern Lisp_Object command_loop_1 P_ ((void));
|
|
|
2997 extern Lisp_Object recursive_edit_1 P_ ((void));
|
|
|
2998 extern void record_auto_save P_ ((void));
|
|
21931
|
2999 extern void init_keyboard P_ ((void));
|
|
|
3000 extern void syms_of_keyboard P_ ((void));
|
|
|
3001 extern void keys_of_keyboard P_ ((void));
|
|
34907
|
3002 extern char *push_key_description P_ ((unsigned int, char *, int));
|
83766
77882096d1d7
(set_initial_environment): Rename from set_global_environment.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
3003 extern void add_user_signal P_ ((int sig, const char *name));
|
|
302
|
3004
|
|
|
3005
|
|
|
3006 /* defined in indent.c */
|
|
18732
|
3007 EXFUN (Fvertical_motion, 2);
|
|
|
3008 EXFUN (Findent_to, 2);
|
|
|
3009 EXFUN (Fcurrent_column, 0);
|
|
|
3010 EXFUN (Fmove_to_column, 2);
|
|
46304
|
3011 extern double current_column P_ ((void));
|
|
20297
|
3012 extern void invalidate_current_column P_ ((void));
|
|
46304
|
3013 extern int indented_beyond_p P_ ((int, int, double));
|
|
21931
|
3014 extern void syms_of_indent P_ ((void));
|
|
302
|
3015
|
|
765
|
3016 /* defined in frame.c */
|
55583
21f88361795c
Various fixes to support USE_LSB_TAG with carbon emacs. Mostly fixing
Steven Tamm <steventamm@mac.com>
diff
changeset
|
3017 #ifdef HAVE_WINDOW_SYSTEM
|
21f88361795c
Various fixes to support USE_LSB_TAG with carbon emacs. Mostly fixing
Steven Tamm <steventamm@mac.com>
diff
changeset
|
3018 extern Lisp_Object Vx_resource_name;
|
21f88361795c
Various fixes to support USE_LSB_TAG with carbon emacs. Mostly fixing
Steven Tamm <steventamm@mac.com>
diff
changeset
|
3019 extern Lisp_Object Vx_resource_class;
|
21f88361795c
Various fixes to support USE_LSB_TAG with carbon emacs. Mostly fixing
Steven Tamm <steventamm@mac.com>
diff
changeset
|
3020 #endif /* HAVE_WINDOW_SYSTEM */
|
|
6243
|
3021 extern Lisp_Object Qvisible;
|
|
20297
|
3022 extern void store_frame_param P_ ((struct frame *, Lisp_Object, Lisp_Object));
|
|
18732
|
3023 extern void store_in_alist P_ ((Lisp_Object *, Lisp_Object, Lisp_Object));
|
|
36807
|
3024 extern Lisp_Object do_switch_frame P_ ((Lisp_Object, int, int));
|
|
20297
|
3025 extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
|
|
22190
|
3026 extern Lisp_Object frame_buffer_predicate P_ ((Lisp_Object));
|
|
18732
|
3027 EXFUN (Fframep, 1);
|
|
63186
|
3028 EXFUN (Fselect_frame, 1);
|
|
18732
|
3029 EXFUN (Fselected_frame, 0);
|
|
|
3030 EXFUN (Fwindow_frame, 1);
|
|
|
3031 EXFUN (Fframe_root_window, 1);
|
|
|
3032 EXFUN (Fframe_first_window, 1);
|
|
|
3033 EXFUN (Fframe_selected_window, 1);
|
|
|
3034 EXFUN (Fframe_list, 0);
|
|
|
3035 EXFUN (Fnext_frame, 2);
|
|
|
3036 EXFUN (Fdelete_frame, 2);
|
|
|
3037 EXFUN (Fset_mouse_position, 3);
|
|
|
3038 EXFUN (Fmake_frame_visible, 1);
|
|
|
3039 EXFUN (Fmake_frame_invisible, 2);
|
|
|
3040 EXFUN (Ficonify_frame, 1);
|
|
|
3041 EXFUN (Fframe_visible_p, 1);
|
|
|
3042 EXFUN (Fvisible_frame_list, 0);
|
|
36445
|
3043 EXFUN (Fframe_parameter, 2);
|
|
18732
|
3044 EXFUN (Fframe_parameters, 1);
|
|
|
3045 EXFUN (Fmodify_frame_parameters, 2);
|
|
|
3046 EXFUN (Fset_frame_height, 3);
|
|
|
3047 EXFUN (Fset_frame_width, 3);
|
|
|
3048 EXFUN (Fset_frame_size, 3);
|
|
|
3049 EXFUN (Fset_frame_position, 3);
|
|
|
3050 EXFUN (Fraise_frame, 1);
|
|
|
3051 EXFUN (Fredirect_frame_focus, 2);
|
|
20297
|
3052 EXFUN (Fset_frame_selected_window, 2);
|
|
22190
|
3053 extern Lisp_Object frame_buffer_list P_ ((Lisp_Object));
|
|
20297
|
3054 extern void frames_discard_buffer P_ ((Lisp_Object));
|
|
22190
|
3055 extern void set_frame_buffer_list P_ ((Lisp_Object, Lisp_Object));
|
|
20297
|
3056 extern void frames_bury_buffer P_ ((Lisp_Object));
|
|
21931
|
3057 extern void syms_of_frame P_ ((void));
|
|
302
|
3058
|
|
|
3059 /* defined in emacs.c */
|
|
18732
|
3060 extern Lisp_Object decode_env_path P_ ((char *, char *));
|
|
4528
|
3061 extern Lisp_Object Vinvocation_name, Vinvocation_directory;
|
81269
5e310b8be81d
(STRING_SET_UNIBYTE): Return the canonical empty unibyte string, if appropriate.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
3062 extern Lisp_Object Vinstallation_directory;
|
5e310b8be81d
(STRING_SET_UNIBYTE): Return the canonical empty unibyte string, if appropriate.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
3063 extern Lisp_Object empty_unibyte_string, empty_multibyte_string;
|
|
69896
|
3064 EXFUN (Fkill_emacs, 1);
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3065 #if HAVE_SETLOCALE
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3066 void fixup_locale P_ ((void));
|
|
26526
|
3067 void synchronize_system_messages_locale P_ ((void));
|
|
|
3068 void synchronize_system_time_locale P_ ((void));
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3069 #else
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3070 #define setlocale(category, locale)
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3071 #define fixup_locale()
|
|
26526
|
3072 #define synchronize_system_messages_locale()
|
|
|
3073 #define synchronize_system_time_locale()
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3074 #endif
|
|
18732
|
3075 void shut_down_emacs P_ ((int, int, Lisp_Object));
|
|
302
|
3076 /* Nonzero means don't do interactive redisplay and don't change tty modes */
|
|
|
3077 extern int noninteractive;
|
|
|
3078 /* Nonzero means don't do use window-system-specific display code */
|
|
|
3079 extern int inhibit_window_system;
|
|
10316
|
3080 /* Nonzero means that a filter or a sentinel is running. */
|
|
10032
|
3081 extern int running_asynch_code;
|
|
302
|
3082
|
|
|
3083 /* defined in process.c */
|
|
18732
|
3084 EXFUN (Fget_process, 1);
|
|
|
3085 EXFUN (Fget_buffer_process, 1);
|
|
|
3086 EXFUN (Fprocessp, 1);
|
|
|
3087 EXFUN (Fprocess_status, 1);
|
|
|
3088 EXFUN (Fkill_process, 2);
|
|
|
3089 EXFUN (Fprocess_send_eof, 1);
|
|
|
3090 EXFUN (Fwaiting_for_user_input_p, 0);
|
|
10727
|
3091 extern Lisp_Object Qprocessp;
|
|
20297
|
3092 extern void kill_buffer_processes P_ ((Lisp_Object));
|
|
56729
|
3093 extern int wait_reading_process_output P_ ((int, int, int, int,
|
|
|
3094 Lisp_Object,
|
|
|
3095 struct Lisp_Process *,
|
|
|
3096 int));
|
|
20297
|
3097 extern void add_keyboard_wait_descriptor P_ ((int));
|
|
|
3098 extern void delete_keyboard_wait_descriptor P_ ((int));
|
|
80985
|
3099 extern void add_gpm_wait_descriptor P_ ((int));
|
|
|
3100 extern void delete_gpm_wait_descriptor P_ ((int));
|
|
20297
|
3101 extern void close_process_descs P_ ((void));
|
|
21931
|
3102 extern void init_process P_ ((void));
|
|
|
3103 extern void syms_of_process P_ ((void));
|
|
49665
|
3104 extern void setup_process_coding_systems P_ ((Lisp_Object));
|
|
302
|
3105
|
|
|
3106 /* defined in callproc.c */
|
|
39810
|
3107 extern Lisp_Object Vexec_path, Vexec_suffixes,
|
|
|
3108 Vexec_directory, Vdata_directory;
|
|
6029
|
3109 extern Lisp_Object Vdoc_directory;
|
|
25450
|
3110 EXFUN (Fcall_process, MANY);
|
|
20297
|
3111 extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
|
|
21931
|
3112 extern void init_callproc_1 P_ ((void));
|
|
|
3113 extern void init_callproc P_ ((void));
|
83766
77882096d1d7
(set_initial_environment): Rename from set_global_environment.
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
3114 extern void set_initial_environment P_ ((void));
|
|
21931
|
3115 extern void syms_of_callproc P_ ((void));
|
|
302
|
3116
|
|
|
3117 /* defined in doc.c */
|
|
|
3118 extern Lisp_Object Vdoc_file_name;
|
|
18732
|
3119 EXFUN (Fsubstitute_command_keys, 1);
|
|
|
3120 EXFUN (Fdocumentation, 2);
|
|
|
3121 EXFUN (Fdocumentation_property, 3);
|
|
|
3122 extern Lisp_Object read_doc_string P_ ((Lisp_Object));
|
|
22604
|
3123 extern Lisp_Object get_doc_string P_ ((Lisp_Object, int, int));
|
|
21931
|
3124 extern void syms_of_doc P_ ((void));
|
|
25759
|
3125 extern int read_bytecode_char P_ ((int));
|
|
302
|
3126
|
|
|
3127 /* defined in bytecode.c */
|
|
|
3128 extern Lisp_Object Qbytecode;
|
|
18732
|
3129 EXFUN (Fbyte_code, 3);
|
|
21931
|
3130 extern void syms_of_bytecode P_ ((void));
|
|
26367
|
3131 extern struct byte_stack *byte_stack_list;
|
|
|
3132 extern void mark_byte_stack P_ ((void));
|
|
26377
|
3133 extern void unmark_byte_stack P_ ((void));
|
|
302
|
3134
|
|
|
3135 /* defined in macros.c */
|
|
|
3136 extern Lisp_Object Qexecute_kbd_macro;
|
|
46886
|
3137 EXFUN (Fexecute_kbd_macro, 3);
|
|
49866
|
3138 EXFUN (Fcancel_kbd_macro_events, 0);
|
|
21931
|
3139 extern void init_macros P_ ((void));
|
|
|
3140 extern void syms_of_macros P_ ((void));
|
|
302
|
3141
|
|
1518
|
3142 /* defined in undo.c */
|
|
14665
|
3143 extern Lisp_Object Qinhibit_read_only;
|
|
18732
|
3144 EXFUN (Fundo_boundary, 0);
|
|
59049
|
3145 extern void truncate_undo_list P_ ((struct buffer *));
|
|
20297
|
3146 extern void record_marker_adjustment P_ ((Lisp_Object, int));
|
|
|
3147 extern void record_insert P_ ((int, int));
|
|
21277
|
3148 extern void record_delete P_ ((int, Lisp_Object));
|
|
20297
|
3149 extern void record_first_change P_ ((void));
|
|
|
3150 extern void record_change P_ ((int, int));
|
|
|
3151 extern void record_property_change P_ ((int, int, Lisp_Object, Lisp_Object,
|
|
|
3152 Lisp_Object));
|
|
21931
|
3153 extern void syms_of_undo P_ ((void));
|
|
59070
|
3154 extern Lisp_Object Vundo_outer_limit;
|
|
1518
|
3155
|
|
4067
|
3156 /* defined in textprop.c */
|
|
51858
|
3157 extern Lisp_Object Qfont, Qmouse_face;
|
|
4079
|
3158 extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
|
|
18732
|
3159 EXFUN (Fnext_single_property_change, 4);
|
|
30322
|
3160 EXFUN (Fnext_single_char_property_change, 4);
|
|
18732
|
3161 EXFUN (Fprevious_single_property_change, 4);
|
|
|
3162 EXFUN (Fput_text_property, 5);
|
|
|
3163 EXFUN (Fprevious_char_property_change, 2);
|
|
|
3164 EXFUN (Fnext_char_property_change, 2);
|
|
20297
|
3165 extern void report_interval_modification P_ ((Lisp_Object, Lisp_Object));
|
|
25818
|
3166 extern Lisp_Object next_single_char_property_change P_ ((Lisp_Object,
|
|
|
3167 Lisp_Object,
|
|
|
3168 Lisp_Object,
|
|
|
3169 Lisp_Object));
|
|
4067
|
3170
|
|
12093
|
3171 /* defined in xmenu.c */
|
|
18732
|
3172 EXFUN (Fx_popup_menu, 2);
|
|
62660
|
3173 EXFUN (Fx_popup_dialog, 3);
|
|
21931
|
3174 extern void syms_of_xmenu P_ ((void));
|
|
20297
|
3175
|
|
53226
|
3176 /* defined in termchar.h */
|
82989
f3845715a5f6
Separate frame-local, tty-dependent parameters from tty-local parameters.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3177 struct tty_display_info;
|
f3845715a5f6
Separate frame-local, tty-dependent parameters from tty-local parameters.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3178
|
f3845715a5f6
Separate frame-local, tty-dependent parameters from tty-local parameters.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3179 /* defined in termhooks.h */
|
83431
76396de7f50a
Rename `struct device' to `struct terminal'. Rename some terminal-related functions similarly.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3180 struct terminal;
|
|
53226
|
3181
|
|
20297
|
3182 /* defined in sysdep.c */
|
|
65424
|
3183 #ifndef HAVE_GET_CURRENT_DIR_NAME
|
|
65420
|
3184 extern char *get_current_dir_name P_ ((void));
|
|
|
3185 #endif
|
|
25769
|
3186 extern void stuff_char P_ ((char c));
|
|
20297
|
3187 extern void init_sigio P_ ((int));
|
|
|
3188 extern void sys_subshell P_ ((void));
|
|
|
3189 extern void sys_suspend P_ ((void));
|
|
|
3190 extern void discard_tty_input P_ ((void));
|
82989
f3845715a5f6
Separate frame-local, tty-dependent parameters from tty-local parameters.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3191 extern void init_sys_modes P_ ((struct tty_display_info *));
|
f3845715a5f6
Separate frame-local, tty-dependent parameters from tty-local parameters.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3192 extern void reset_sys_modes P_ ((struct tty_display_info *));
|
|
53226
|
3193 extern void init_all_sys_modes P_ ((void));
|
|
|
3194 extern void reset_all_sys_modes P_ ((void));
|
|
20297
|
3195 extern void wait_for_termination P_ ((int));
|
|
|
3196 extern void flush_pending_output P_ ((int));
|
|
|
3197 extern void child_setup_tty P_ ((int));
|
|
|
3198 extern void setup_pty P_ ((int));
|
|
|
3199 extern int set_window_size P_ ((int, int, int));
|
|
|
3200 extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
|
|
46471
|
3201 extern int emacs_open P_ ((const char *, int, int));
|
26088
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3202 extern int emacs_close P_ ((int));
|
b7aa6ac26872
Add support for large files, 64-bit Solaris, system locale codings.
Paul Eggert <eggert@twinsun.com>
diff
changeset
|
3203 extern int emacs_read P_ ((int, char *, unsigned int));
|
|
46552
|
3204 extern int emacs_write P_ ((int, const char *, unsigned int));
|
|
20297
|
3205
|
|
|
3206 /* defined in filelock.c */
|
|
|
3207 EXFUN (Funlock_buffer, 0);
|
|
21711
|
3208 EXFUN (Ffile_locked_p, 1);
|
|
20297
|
3209 extern void unlock_all_files P_ ((void));
|
|
|
3210 extern void lock_file P_ ((Lisp_Object));
|
|
|
3211 extern void unlock_file P_ ((Lisp_Object));
|
|
|
3212 extern void unlock_buffer P_ ((struct buffer *));
|
|
21931
|
3213 extern void syms_of_filelock P_ ((void));
|
|
25748
|
3214 extern void init_filelock P_ ((void));
|
|
|
3215
|
|
|
3216 /* Defined in sound.c */
|
|
|
3217 extern void syms_of_sound P_ ((void));
|
|
|
3218 extern void init_sound P_ ((void));
|
|
21931
|
3219
|
|
|
3220 /* Defined in category.c */
|
|
|
3221 extern void init_category_once P_ ((void));
|
|
|
3222 extern void syms_of_category P_ ((void));
|
|
|
3223
|
|
|
3224 /* Defined in ccl.c */
|
|
|
3225 extern void syms_of_ccl P_ ((void));
|
|
|
3226
|
|
|
3227 /* Defined in dired.c */
|
|
53111
|
3228 EXFUN (Ffile_attributes, 2);
|
|
21931
|
3229 extern void syms_of_dired P_ ((void));
|
|
|
3230
|
|
|
3231 /* Defined in term.c */
|
|
|
3232 extern void syms_of_term P_ ((void));
|
|
65795
|
3233 extern void fatal () NO_RETURN;
|
|
21931
|
3234
|
83420
521d3f18b3d1
Reimplement terminal parameters in C; clean up term.c, create terminal.c.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3235 /* Defined in terminal.c */
|
521d3f18b3d1
Reimplement terminal parameters in C; clean up term.c, create terminal.c.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3236 extern void syms_of_terminal P_ ((void));
|
521d3f18b3d1
Reimplement terminal parameters in C; clean up term.c, create terminal.c.
Karoly Lorentey <lorentey@elte.hu>
diff
changeset
|
3237
|
69959
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3238 #ifdef HAVE_WINDOW_SYSTEM
|
|
21931
|
3239 /* Defined in fontset.c */
|
|
|
3240 extern void syms_of_fontset P_ ((void));
|
|
25017
|
3241 EXFUN (Fset_fontset_font, 4);
|
69959
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3242
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3243 /* Defined in xfns.c, w32fns.c, or macfns.c */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3244 EXFUN (Fxw_display_color_p, 1);
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3245 EXFUN (Fx_file_dialog, 5);
|
|
21931
|
3246 #endif
|
|
|
3247
|
|
|
3248 /* Defined in xfaces.c */
|
81794
c1184a3d99c9
(map_char_table): Use an array of int for `indices' rather than
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
3249 EXFUN (Fclear_face_cache, 1);
|
|
21931
|
3250 extern void syms_of_xfaces P_ ((void));
|
|
|
3251
|
69374
c65249b41906
Remove duplicate prototypes. Make the prototype of getloadavg be conditioned
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
3252 #ifndef HAVE_GETLOADAVG
|
|
25712
|
3253 /* Defined in getloadavg.c */
|
|
|
3254 extern int getloadavg P_ ((double *, int));
|
69374
c65249b41906
Remove duplicate prototypes. Make the prototype of getloadavg be conditioned
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
3255 #endif
|
|
25712
|
3256
|
|
21931
|
3257 #ifdef HAVE_X_WINDOWS
|
|
|
3258 /* Defined in xfns.c */
|
|
|
3259 extern void syms_of_xfns P_ ((void));
|
|
|
3260
|
|
43816
|
3261 /* Defined in xsmfns.c */
|
|
|
3262 extern void syms_of_xsmfns P_ ((void));
|
|
|
3263
|
|
21931
|
3264 /* Defined in xselect.c */
|
81794
c1184a3d99c9
(map_char_table): Use an array of int for `indices' rather than
Stefan Monnier <monnier@iro.umontreal.ca>
diff
changeset
|
3265 EXFUN (Fx_send_client_event, 6);
|
|
21931
|
3266 extern void syms_of_xselect P_ ((void));
|
|
|
3267
|
|
|
3268 /* Defined in xterm.c */
|
|
|
3269 extern void syms_of_xterm P_ ((void));
|
69959
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3270 #endif /* HAVE_X_WINDOWS */
|
|
25759
|
3271
|
|
58013
|
3272 #ifdef MSDOS
|
|
|
3273 /* Defined in msdos.c */
|
|
|
3274 EXFUN (Fmsdos_downcase_filename, 1);
|
|
|
3275 #endif
|
69959
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3276
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3277 #ifdef MAC_OS
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3278 /* Defined in macfns.c */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3279 extern void syms_of_macfns P_ ((void));
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3280
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3281 /* Defined in macselect.c */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3282 extern void syms_of_macselect P_ ((void));
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3283
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3284 /* Defined in macterm.c */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3285 extern void syms_of_macterm P_ ((void));
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3286
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3287 /* Defined in macmenu.c */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3288 extern void syms_of_macmenu P_ ((void));
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3289
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3290 /* Defined in mac.c */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3291 extern void syms_of_mac P_ ((void));
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3292 #ifdef MAC_OSX
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3293 extern void init_mac_osx_environment P_ ((void));
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3294 #endif /* MAC_OSX */
|
d1856dc3952f
(syms_of_fontset, Fset_fontset_font): Put extern and
YAMAMOTO Mitsuharu <mituharu@math.s.chiba-u.ac.jp>
diff
changeset
|
3295 #endif /* MAC_OS */
|
|
29779
|
3296
|
|
302
|
3297 /* Nonzero means Emacs has already been initialized.
|
|
|
3298 Used during startup to detect startup of dumped Emacs. */
|
|
|
3299 extern int initialized;
|
|
|
3300
|
|
|
3301 extern int immediate_quit; /* Nonzero means ^G can quit instantly */
|
|
|
3302
|
|
30556
|
3303 extern POINTER_TYPE *xmalloc P_ ((size_t));
|
|
|
3304 extern POINTER_TYPE *xrealloc P_ ((POINTER_TYPE *, size_t));
|
|
29785
|
3305 extern void xfree P_ ((POINTER_TYPE *));
|
|
|
3306
|
|
46471
|
3307 extern char *xstrdup P_ ((const char *));
|
|
302
|
3308
|
|
20297
|
3309 extern char *egetenv P_ ((char *));
|
|
17404
|
3310
|
|
7906
|
3311 /* Set up the name of the machine we're running on. */
|
|
20297
|
3312 extern void init_system_name P_ ((void));
|
|
9799
|
3313
|
|
|
3314 /* Some systems (e.g., NT) use a different path separator than Unix,
|
|
|
3315 in addition to a device separator. Default the path separator
|
|
|
3316 to '/', and don't test for a device separator in IS_ANY_SEP. */
|
|
|
3317
|
|
15090
|
3318 #ifdef WINDOWSNT
|
|
|
3319 extern Lisp_Object Vdirectory_sep_char;
|
|
|
3320 #endif
|
|
|
3321
|
|
9799
|
3322 #ifndef DIRECTORY_SEP
|
|
|
3323 #define DIRECTORY_SEP '/'
|
|
|
3324 #endif
|
|
|
3325 #ifndef IS_DIRECTORY_SEP
|
|
|
3326 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
|
|
|
3327 #endif
|
|
|
3328 #ifndef IS_DEVICE_SEP
|
|
|
3329 #ifndef DEVICE_SEP
|
|
|
3330 #define IS_DEVICE_SEP(_c_) 0
|
|
|
3331 #else
|
|
|
3332 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
|
|
|
3333 #endif
|
|
|
3334 #endif
|
|
|
3335 #ifndef IS_ANY_SEP
|
|
|
3336 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
|
|
|
3337 #endif
|
|
10455
|
3338
|
|
|
3339 #ifdef SWITCH_ENUM_BUG
|
|
|
3340 #define SWITCH_ENUM_CAST(x) ((int)(x))
|
|
|
3341 #else
|
|
|
3342 #define SWITCH_ENUM_CAST(x) (x)
|
|
|
3343 #endif
|
|
39579
|
3344
|
|
|
3345 /* Loop over Lisp list LIST. Signal an error if LIST is not a proper
|
|
|
3346 list, or if it contains circles.
|
|
45623
|
3347
|
|
39579
|
3348 HARE and TORTOISE should be the names of Lisp_Object variables, and
|
|
|
3349 N should be the name of an EMACS_INT variable declared in the
|
|
|
3350 function where the macro is used. Each nested loop should use
|
|
|
3351 its own variables.
|
|
|
3352
|
|
|
3353 In the loop body, HARE is set to each cons of LIST, and N is the
|
|
|
3354 length of the list processed so far. */
|
|
|
3355
|
|
|
3356 #define LIST_END_P(list, obj) \
|
|
|
3357 (NILP (obj) \
|
|
|
3358 ? 1 \
|
|
|
3359 : (CONSP (obj) \
|
|
|
3360 ? 0 \
|
|
41615
|
3361 : (wrong_type_argument (Qlistp, (list))), 1))
|
|
39579
|
3362
|
|
|
3363 #define FOREACH(hare, list, tortoise, n) \
|
|
|
3364 for (tortoise = hare = (list), n = 0; \
|
|
|
3365 !LIST_END_P (list, hare); \
|
|
|
3366 (hare = XCDR (hare), ++n, \
|
|
|
3367 ((n & 1) != 0 \
|
|
|
3368 ? (tortoise = XCDR (tortoise), \
|
|
|
3369 (EQ (hare, tortoise) \
|
|
|
3370 && (circular_list_error ((list)), 1))) \
|
|
|
3371 : 0)))
|
|
39681
|
3372
|
|
|
3373 /* The ubiquitous min and max macros. */
|
|
|
3374
|
|
39710
|
3375 #ifdef max
|
|
|
3376 #undef max
|
|
|
3377 #undef min
|
|
|
3378 #endif
|
|
39681
|
3379 #define min(a, b) ((a) < (b) ? (a) : (b))
|
|
|
3380 #define max(a, b) ((a) > (b) ? (a) : (b))
|
|
39773
|
3381
|
|
84804
|
3382 /* Make sure we have abs defined */
|
|
|
3383 #if !defined(abs)
|
|
|
3384 #define abs(x) ((x) < 0 ? -(x) : (x))
|
|
|
3385 #endif
|
|
|
3386
|
|
39773
|
3387 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
|
|
|
3388 fixnum. */
|
|
|
3389
|
|
|
3390 #define make_fixnum_or_float(val) \
|
|
41615
|
3391 (FIXNUM_OVERFLOW_P (val) \
|
|
|
3392 ? make_float (val) \
|
|
|
3393 : make_number ((EMACS_INT)(val)))
|
|
52274
|
3394
|
|
55142
|
3395
|
|
|
3396 /* Checks the `cycle check' variable CHECK to see if it indicates that
|
|
|
3397 EL is part of a cycle; CHECK must be either Qnil or a value returned
|
|
|
3398 by an earlier use of CYCLE_CHECK. SUSPICIOUS is the number of
|
|
|
3399 elements after which a cycle might be suspected; after that many
|
|
|
3400 elements, this macro begins consing in order to keep more precise
|
|
|
3401 track of elements.
|
|
|
3402
|
|
|
3403 Returns nil if a cycle was detected, otherwise a new value for CHECK
|
|
|
3404 that includes EL.
|
|
|
3405
|
|
|
3406 CHECK is evaluated multiple times, EL and SUSPICIOUS 0 or 1 times, so
|
|
|
3407 the caller should make sure that's ok. */
|
|
|
3408
|
|
|
3409 #define CYCLE_CHECK(check, el, suspicious) \
|
|
|
3410 (NILP (check) \
|
|
|
3411 ? make_number (0) \
|
|
|
3412 : (INTEGERP (check) \
|
|
|
3413 ? (XFASTINT (check) < (suspicious) \
|
|
|
3414 ? make_number (XFASTINT (check) + 1) \
|
|
|
3415 : Fcons (el, Qnil)) \
|
|
|
3416 : (!NILP (Fmemq ((el), (check))) \
|
|
|
3417 ? Qnil \
|
|
|
3418 : Fcons ((el), (check)))))
|
|
|
3419
|
|
|
3420
|
|
56186
|
3421 /* SAFE_ALLOCA normally allocates memory on the stack, but if size is
|
|
|
3422 larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */
|
|
|
3423
|
|
|
3424 #define MAX_ALLOCA 16*1024
|
|
|
3425
|
|
|
3426 extern Lisp_Object safe_alloca_unwind (Lisp_Object);
|
|
|
3427
|
|
|
3428 #define USE_SAFE_ALLOCA \
|
|
57724
|
3429 int sa_count = SPECPDL_INDEX (), sa_must_free = 0
|
|
56186
|
3430
|
|
56198
|
3431 /* SAFE_ALLOCA allocates a simple buffer. */
|
|
|
3432
|
|
56186
|
3433 #define SAFE_ALLOCA(buf, type, size) \
|
|
|
3434 do { \
|
|
|
3435 if ((size) < MAX_ALLOCA) \
|
|
|
3436 buf = (type) alloca (size); \
|
|
|
3437 else \
|
|
|
3438 { \
|
|
|
3439 buf = (type) xmalloc (size); \
|
|
57724
|
3440 sa_must_free++; \
|
|
56186
|
3441 record_unwind_protect (safe_alloca_unwind, \
|
|
|
3442 make_save_value (buf, 0)); \
|
|
|
3443 } \
|
|
|
3444 } while (0)
|
|
|
3445
|
|
56198
|
3446 /* SAFE_FREE frees xmalloced memory and enables GC as needed. */
|
|
|
3447
|
|
57724
|
3448 #define SAFE_FREE() \
|
|
56186
|
3449 do { \
|
|
57724
|
3450 if (sa_must_free) { \
|
|
|
3451 sa_must_free = 0; \
|
|
56186
|
3452 unbind_to (sa_count, Qnil); \
|
|
57724
|
3453 } \
|
|
56186
|
3454 } while (0)
|
|
|
3455
|
|
|
3456
|
|
56204
|
3457 /* SAFE_ALLOCA_LISP allocates an array of Lisp_Objects. */
|
|
|
3458
|
|
|
3459 #define SAFE_ALLOCA_LISP(buf, nelt) \
|
|
|
3460 do { \
|
|
|
3461 int size_ = (nelt) * sizeof (Lisp_Object); \
|
|
|
3462 if (size_ < MAX_ALLOCA) \
|
|
|
3463 buf = (Lisp_Object *) alloca (size_); \
|
|
|
3464 else \
|
|
|
3465 { \
|
|
|
3466 Lisp_Object arg_; \
|
|
|
3467 buf = (Lisp_Object *) xmalloc (size_); \
|
|
|
3468 arg_ = make_save_value (buf, nelt); \
|
|
|
3469 XSAVE_VALUE (arg_)->dogc = 1; \
|
|
57724
|
3470 sa_must_free++; \
|
|
56204
|
3471 record_unwind_protect (safe_alloca_unwind, arg_); \
|
|
|
3472 } \
|
|
|
3473 } while (0)
|
|
|
3474
|
|
56186
|
3475
|
|
52274
|
3476 #endif /* EMACS_LISP_H */
|
|
52401
|
3477
|
|
|
3478 /* arch-tag: 9b2ed020-70eb-47ac-94ee-e1c2a5107d5e
|
|
|
3479 (do not change this comment) */
|
