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